zeml.h

Go to the documentation of this file.

#ifndef YAZE_APP_GUI_ZEML_H
#define YAZE_APP_GUI_ZEML_H
 
#include "imgui/imgui.h"
 
#include <cctype>
#include <functional>
#include <map>
#include <memory>
#include <string>
#include <vector>
 
namespace yaze {
namespace gui {

namespace zeml {

enum class TokenType {
  Identifier,
  String,
  OpenBrace,
  CloseBrace,
  Comma,
  EndOfStream
};

struct Token {
  TokenType type;
  std::string value;
} typedef Token;

enum class WidgetType {
  Window,
  Button,
  Slider,
  Text,
  Table,
  TableSetupColumn,
  TableHeadersRow,
  TableNextColumn,
  CollapsingHeader,
  Columns,
  Checkbox,
  Selectable,
  Function,
  BeginChild,
  BeginMenuBar,
  BeginMenu,
  BeginTabBar,
  BeginTabItem,
  MenuItem,
  Separator,
  HexInputByte,
  HexInputWord,
  Canvas,
  Definition,
};

struct WidgetAttributes {
  std::string id;
  std::string title;                      // For Window, Button
  std::string text;                       // For Text, Button
  double min;                             // For Slider
  double max;                             // For Slider
  double value;                           // For Slidecar
  float width;                            // For Columns
  int count = 0;                          // For Columns
  ImVec2 size = ImVec2(0, 0);             // For BeginChild
  bool* selected = nullptr;               // For Selectable
  std::shared_ptr<void> flags = nullptr;  // For Various
  void* data = nullptr;                   // For Various
};

enum class ActionType { Click, Change, Run };

struct Action {
  ActionType type;
  std::function<void()> callback;
};

std::vector<Token> Tokenize(const std::string& input);

struct Node {
  WidgetType type;
  WidgetAttributes attributes;
  std::vector<Action> actions;
  std::vector<Node> children;
 
  Node* parent = nullptr;
 
  Node* GetNode(const std::string& searchId) {
    if (attributes.id == searchId) {
      return this;
    }
    for (Node& child : children) {
      Node* found = child.GetNode(searchId);
      if (found != nullptr) {
        return found;
      }
    }
    return nullptr;
  }
};

void Bind(Node* node, std::function<void()> callback);

void BindAction(Node* node, ActionType type, std::function<void()> callback);

void BindSelectable(Node* node, bool* selected, std::function<void()> callback);

WidgetType MapType(const std::string& type);

void ParseDefinitions(const std::vector<Token>& tokens, size_t& index,
                      std::map<std::string, Node>& definitions);
 
void ParseFlags(const WidgetType& type, const std::string& flags,
                WidgetAttributes& flags_ptr);

WidgetAttributes ParseAttributes(
    const std::vector<Token>& tokens, size_t& index, const WidgetType& type,
    const std::map<std::string, void*>& data_bindings = {});

Node ParseNode(const std::vector<Token>& tokens, size_t& index,
               const std::map<std::string, void*>& data_bindings = {},
               const std::map<std::string, Node>& definitions = {});

Node Parse(const std::string& yazon_input,
           const std::map<std::string, void*>& data_bindings = {});

void Render(Node& node);

void ExecuteActions(const std::vector<Action>& actions, ActionType type);
 
std::string LoadFile(const std::string& filename);
 
}  // namespace zeml
}  // namespace gui
 
}  // namespace yaze
 
#endif  // YAZE_APP_GUI_YAZON_H_