web_sender.h

// SPDX-FileCopyrightText: AC SOFTWARE SP. Z O.O.
// SPDX-License-Identifier: GPL-2.0-or-later
 
#ifndef SRC_SUPLA_NETWORK_WEB_SENDER_H_
#define SRC_SUPLA_NETWORK_WEB_SENDER_H_
 
#include <stddef.h>
#include <stdio.h>
#include <stdint.h>
#include <supla/network/html_generator.h>
 
#if defined(ARDUINO_ARCH_ESP8266)
#include <pgmspace.h>
#define SUPLA_WEB_PROGMEM PROGMEM
#define SUPLA_WEB_SNPRINTF(buffer, size, format, ...) \
  snprintf_P(buffer, size, PSTR(format), ##__VA_ARGS__)
#else
#define SUPLA_WEB_PROGMEM
#define SUPLA_WEB_SNPRINTF(buffer, size, format, ...) \
  snprintf(buffer, size, format, ##__VA_ARGS__)
#endif
 
namespace Supla {
 
class WebSender;
 
struct FixedValue {
  int raw = 0;
  int precision = 0;
 
  constexpr FixedValue() = default;
  // NOLINTNEXTLINE(runtime/explicit)
  constexpr FixedValue(int value) : raw(value), precision(0) {
  }
  constexpr FixedValue(int value, int prec) : raw(value), precision(prec) {
  }
};
 
constexpr FixedValue fixed(int value, int precision) {
  return FixedValue(value, precision);
}
 
struct NumericInputSpec {
  FixedValue min;
  FixedValue max;
  FixedValue value;
  FixedValue step;
};
 
class HtmlTag {
 public:
  HtmlTag(WebSender* sender, const char* tagName, bool paired = true);
  ~HtmlTag();
 
  HtmlTag(const HtmlTag&) = delete;
  HtmlTag& operator=(const HtmlTag&) = delete;
 
  HtmlTag(HtmlTag&& other) noexcept;
  HtmlTag& operator=(HtmlTag&& other) noexcept;
 
  HtmlTag& attr(const char* name, const char* value);
 
  // Static attribute value in SUPLA_WEB_PROGMEM, escaped as ordinary attr().
  HtmlTag& attrStatic(const char* name,
                      const char* value,
                      size_t size = static_cast<size_t>(-1));
 
  HtmlTag& attr(const char* name, int value);
 
  HtmlTag& attr(const char* name, int value, int precision);
 
  HtmlTag& attrIf(const char* name, bool enabled);
 
  HtmlTag& close();
 
  HtmlTag& finish();
 
  template <typename Fn>
  void body(Fn&& fn) {
    close();
    fn();
    end();
  }
 
  void body(char* text);
 
  template <size_t N>
  void body(const char (&text)[N]) {
    body(static_cast<const char*>(text));
  }
 
  void body(const char* text);
 
  void end();
 
 private:
  void release();
 
  WebSender* sender_ = nullptr;
  const char* tagName_ = nullptr;
  bool paired_ = true;
  bool closed_ = false;
  bool finished_ = false;
};
 
class WebSender {
 public:
  virtual ~WebSender();
  virtual void send(const char*, int size = -1) = 0;
 
  void sendStatic(const char* data,
                  size_t size = static_cast<size_t>(-1),
                  bool escape = false);
 
  virtual void sendSafe(const char*, int size = -1);
  virtual void send(int number);
  virtual void send(int number, int precision);
  virtual void sendNameAndId(const char* id);
  virtual void sendLabelFor(const char* id, const char* label);
  virtual void sendSelectItem(int value,
                              const char* label,
                              bool selected,
                              bool emptyValue = false);
  virtual void sendCsrfField();
  virtual void sendHidden(bool hidden);
  virtual void sendReadonly(bool readonly);
  virtual void sendDisabled(bool disabled);
  virtual void sendTimestamp(uint32_t timestamp);
 
  template <typename Fn>
  void formField(Fn&& fn, const char* className = "form-field") {
    auto field = tag("div");
    field.attr("class", className);
    field.body(fn);
  }
 
  template <typename Fn>
  void labeledField(const char* id,
                    const char* text,
                    Fn&& fn,
                    const char* className = "form-field") {
    formField(
        [&]() {
          labelFor(id, text);
          fn();
        },
        className);
  }
 
  template <typename Fn>
  void toggleBox(const char* id,
                 bool visible,
                 Fn&& fn,
                 const char* className = nullptr) {
    auto box = tag("div");
    if (id) {
      box.attr("id", id);
    }
    if (className) {
      box.attr("class", className);
    }
    box.attr("style", visible ? "display: block" : "display: none");
    box.body(fn);
  }
 
  template <typename Fn>
  void selectInput(const char* name, const char* id, Fn&& fn) {
    selectTag(name, id).body(fn);
  }
 
  HtmlTag selectTag(const char* name, const char* id) {
    auto select = tag("select");
    if (name) {
      select.attr("name", name);
    }
    if (id) {
      select.attr("id", id);
    }
    return select;
  }
 
  void labelFor(const char* id, const char* text);
 
  void textInput(const char* name,
                 const char* id,
                 const char* value = nullptr,
                 int maxLength = -1,
                 const char* listId = nullptr,
                 const char* onInput = nullptr,
                 const char* onChange = nullptr);
 
  void passwordInput(const char* name, const char* id);
 
  void checkboxInput(const char* name,
                     const char* id,
                     bool checked,
                     const char* value = "on");
 
  void numberInput(const char* key,
                   const NumericInputSpec& spec,
                   const char* cssClass = nullptr);
 
  void rangeInput(const char* key,
                  const NumericInputSpec& spec,
                  const char* cssClass = nullptr);
 
  void numberInput(const char* name,
                   const char* id,
                   const NumericInputSpec& spec,
                   const char* cssClass = nullptr);
 
  void rangeInput(const char* name,
                  const char* id,
                  const NumericInputSpec& spec,
                  const char* cssClass = nullptr);
 
  void selectOption(int value, int text, bool selected = false);
  void selectOption(int value, const char* text, bool selected = false);
  void selectOption(const char* value, int text, bool selected = false);
  void selectOption(const char* value, const char* text, bool selected = false);
 
  HtmlTag tag(const char* tagName, bool paired = true) {
    return HtmlTag(this, tagName, paired);
  }
 
  HtmlTag voidTag(const char* tagName) {
    return HtmlTag(this, tagName, false);
  }
};
};  // namespace Supla
 
#endif  // SRC_SUPLA_NETWORK_WEB_SENDER_H_