web_sender.h

/*
 Copyright (C) AC SOFTWARE SP. Z O.O.
 
 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation; either version 2
 of the License, or (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/
 
#ifndef SRC_SUPLA_NETWORK_WEB_SENDER_H_
#define SRC_SUPLA_NETWORK_WEB_SENDER_H_
 
#include <stddef.h>
#include <stdint.h>
#include <supla/network/html_generator.h>
 
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);

  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;
  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 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);

  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_