|
|
#pragma once |
|
|
#include <string> |
|
|
#include <vector> |
|
|
#include <sstream> |
|
|
#include <iomanip> |
|
|
#include <imgui.h> |
|
|
#include "uicontext.h" |
|
|
#include "stx.h" |
|
|
#include "utils.h" |
|
|
#include "cpp_parser.h" |
|
|
#include "binding_type.h" |
|
|
|
|
|
|
|
|
struct property_base |
|
|
{ |
|
|
virtual std::string to_arg(std::string_view a = "", std::string_view b = "") const = 0; |
|
|
virtual bool set_from_arg(std::string_view s) = 0; |
|
|
virtual const char* c_str() const = 0; |
|
|
virtual std::vector<std::string> used_variables() const = 0; |
|
|
virtual void rename_variable(const std::string& oldn, const std::string& newn) = 0; |
|
|
}; |
|
|
|
|
|
|
|
|
template <class T = void> |
|
|
struct field_ref : property_base |
|
|
{ |
|
|
using type = T; |
|
|
|
|
|
bool empty() const { |
|
|
return str.empty(); |
|
|
} |
|
|
const std::string& value() const { |
|
|
return str; |
|
|
} |
|
|
bool has_single_variable() const { |
|
|
if (empty()) |
|
|
return false; |
|
|
return cpp::is_id(str); |
|
|
} |
|
|
|
|
|
T eval(const UIContext& ctx) const; |
|
|
|
|
|
bool set_from_arg(std::string_view s) { |
|
|
str = s; |
|
|
return true; |
|
|
} |
|
|
std::string to_arg(std::string_view = "", std::string_view = "") const { |
|
|
return str; |
|
|
} |
|
|
std::vector<std::string> used_variables() const { |
|
|
size_t i = 0; |
|
|
auto id = cpp::find_id(str, i); |
|
|
if (id == "") |
|
|
return {}; |
|
|
return { std::string(id.data(), id.size()) }; |
|
|
}; |
|
|
void rename_variable(const std::string& oldn, const std::string& newn) |
|
|
{ |
|
|
size_t i = 0; |
|
|
auto id = cpp::find_id(str, i); |
|
|
if (id == oldn) |
|
|
str.replace(id.data() - str.data(), id.size(), newn); |
|
|
} |
|
|
const char* c_str() const { return str.c_str(); } |
|
|
std::string* access() { return &str; } |
|
|
private: |
|
|
std::string str; |
|
|
}; |
|
|
|
|
|
|
|
|
template <class FuncSig = void()> |
|
|
struct event : property_base |
|
|
{ |
|
|
bool empty() const { |
|
|
return str.empty(); |
|
|
} |
|
|
bool set_from_arg(std::string_view s) { |
|
|
str = s; |
|
|
return true; |
|
|
} |
|
|
std::string to_arg(std::string_view = "", std::string_view = "") const { |
|
|
return str; |
|
|
} |
|
|
std::vector<std::string> used_variables() const { |
|
|
if (empty()) |
|
|
return {}; |
|
|
return { str }; |
|
|
}; |
|
|
void rename_variable(const std::string& oldn, const std::string& newn) |
|
|
{ |
|
|
if (str == oldn) |
|
|
str = newn; |
|
|
} |
|
|
const char* c_str() const { return str.c_str(); } |
|
|
std::string* access() { return &str; } |
|
|
private: |
|
|
std::string str; |
|
|
}; |
|
|
|
|
|
|
|
|
|
|
|
template <class T, bool E = std::is_enum_v<T>> |
|
|
struct direct_val; |
|
|
|
|
|
template <class T> |
|
|
struct direct_val<T, false> : property_base |
|
|
{ |
|
|
direct_val(T v) : val(v) {} |
|
|
|
|
|
operator T&() { return val; } |
|
|
operator const T&() const { return val; } |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
direct_val& operator= (const T& v) { |
|
|
val = v; |
|
|
return *this; |
|
|
} |
|
|
bool set_from_arg(std::string_view str) { |
|
|
std::istringstream is; |
|
|
is.str(std::string(str)); |
|
|
if constexpr (std::is_enum_v<T>) { |
|
|
int tmp; |
|
|
is >> tmp; |
|
|
val = (T)tmp; |
|
|
} |
|
|
else { |
|
|
is >> std::boolalpha >> val; |
|
|
} |
|
|
return is.good(); |
|
|
} |
|
|
std::string to_arg(std::string_view = "", std::string_view = "") const { |
|
|
std::ostringstream os; |
|
|
os << std::boolalpha << val; |
|
|
return os.str(); |
|
|
} |
|
|
std::vector<std::string> used_variables() const { |
|
|
return {}; |
|
|
} |
|
|
void rename_variable(const std::string& oldn, const std::string& newn) |
|
|
{} |
|
|
T* access() { return &val; } |
|
|
const char* c_str() const { return nullptr; } |
|
|
|
|
|
private: |
|
|
T val; |
|
|
}; |
|
|
|
|
|
#define add$(f) add(#f, f) |
|
|
template <class T> |
|
|
struct direct_val<T, true> : property_base |
|
|
{ |
|
|
direct_val(int v = 0) : val(v) {} |
|
|
|
|
|
void clear() { |
|
|
ids.clear(); |
|
|
} |
|
|
direct_val& add(const char* id, int v) { |
|
|
ids.push_back({ id, v }); |
|
|
return *this; |
|
|
} |
|
|
direct_val& separator() { |
|
|
ids.push_back({ "", 0 }); |
|
|
return *this; |
|
|
} |
|
|
auto find_id(int fl) const { |
|
|
return stx::find_if(ids, [this,fl](const auto& id) { |
|
|
return id.first != "" && id.second == fl; |
|
|
}); |
|
|
} |
|
|
const auto& get_ids() const { return ids; } |
|
|
const std::string& get_id() const { |
|
|
static std::string none; |
|
|
auto it = find_id(val); |
|
|
return it != ids.end() ? it->first : none; |
|
|
} |
|
|
void set_id(const std::string& v) { |
|
|
auto it = stx::find_if(ids, [&v](const auto& id) { return id.first == v; }); |
|
|
if (it != ids.end()) |
|
|
val = it->second; |
|
|
} |
|
|
|
|
|
operator T() const { return (T)val; } |
|
|
|
|
|
direct_val& operator= (int v) { |
|
|
val = v; |
|
|
return *this; |
|
|
} |
|
|
direct_val& operator|= (int v) { |
|
|
val |= v; |
|
|
return *this; |
|
|
} |
|
|
direct_val& operator&= (int v) { |
|
|
val &= v; |
|
|
return *this; |
|
|
} |
|
|
bool set_from_arg(std::string_view str) { |
|
|
bool ok = true; |
|
|
val = {}; |
|
|
size_t i = 0; |
|
|
while (true) { |
|
|
std::string s; |
|
|
size_t j = str.find('|', i); |
|
|
if (j == std::string::npos) |
|
|
s = str.substr(i); |
|
|
else |
|
|
s = str.substr(i, j - i); |
|
|
auto id = stx::find_if(ids, [&](const auto& id) { return id.first == s; }); |
|
|
|
|
|
if (s == "0" || |
|
|
(!s.compare(0, 5, "ImGui") && !s.compare(s.size() - 5, 5, "_None"))) |
|
|
val; |
|
|
else if (id != ids.end()) |
|
|
val |= id->second; |
|
|
else |
|
|
ok = false; |
|
|
if (j == std::string::npos) |
|
|
break; |
|
|
i = j + 1; |
|
|
} |
|
|
return ok; |
|
|
} |
|
|
std::string to_arg(std::string_view = "", std::string_view = "") const { |
|
|
std::string str; |
|
|
bool simpleEnum = false; |
|
|
for (const auto& id : ids) { |
|
|
if (id.first != "" && !id.second) |
|
|
simpleEnum = true; |
|
|
} |
|
|
if (simpleEnum) { |
|
|
auto it = stx::find_if(ids, [this](const auto& id) { return id.second == val; }); |
|
|
str = it == ids.end() ? "0" : it->first; |
|
|
} |
|
|
else { |
|
|
for (const auto& id : ids) |
|
|
if ((val & id.second) == id.second && id.first != "") |
|
|
str += id.first + " | "; |
|
|
if (str != "") |
|
|
str.resize(str.size() - 3); |
|
|
else |
|
|
str = "0"; |
|
|
} |
|
|
return str; |
|
|
} |
|
|
std::vector<std::string> used_variables() const { |
|
|
return {}; |
|
|
} |
|
|
void rename_variable(const std::string& oldn, const std::string& newn) |
|
|
{} |
|
|
int* access() { return &val; } |
|
|
const char* c_str() const { return nullptr; } |
|
|
|
|
|
private: |
|
|
int val; |
|
|
std::vector<std::pair<std::string, int>> ids; |
|
|
}; |
|
|
|
|
|
template <> |
|
|
struct direct_val<dimension_t> : property_base |
|
|
{ |
|
|
direct_val(float v) : val(v) {} |
|
|
|
|
|
operator float&() { return val; } |
|
|
operator const float() const { return val; } |
|
|
bool operator== (float dv) const { |
|
|
return val == dv; |
|
|
} |
|
|
bool operator!= (float dv) const { |
|
|
return val != dv; |
|
|
} |
|
|
direct_val& operator= (float v) { |
|
|
val = v; |
|
|
return *this; |
|
|
} |
|
|
float eval_px(const UIContext& ctx) const; |
|
|
|
|
|
bool set_from_arg(std::string_view s) { |
|
|
std::istringstream is; |
|
|
is.str(std::string(s)); |
|
|
is >> val; |
|
|
|
|
|
std::string_view factor = s.size() > 3 ? s.substr(s.size() - 3) : ""; |
|
|
if (factor == "*dp") |
|
|
{ |
|
|
std::istringstream is(std::string(s.substr(0, s.size() - 3))); |
|
|
float v; |
|
|
if ((is >> v) && is.eof()) |
|
|
val = v; |
|
|
} |
|
|
return true; |
|
|
} |
|
|
std::string to_arg(std::string_view unit, std::string_view = "") const { |
|
|
std::ostringstream os; |
|
|
os << val; |
|
|
if (unit != "") |
|
|
os << "*" << unit; |
|
|
return os.str(); |
|
|
} |
|
|
std::vector<std::string> used_variables() const { |
|
|
return {}; |
|
|
} |
|
|
void rename_variable(const std::string& oldn, const std::string& newn) |
|
|
{} |
|
|
float* access() { return &val; } |
|
|
const char* c_str() const { return nullptr; } |
|
|
|
|
|
private: |
|
|
float val; |
|
|
}; |
|
|
|
|
|
template <> |
|
|
struct direct_val<pzdimension_t> : property_base |
|
|
{ |
|
|
direct_val(float v = -1) : val(v) {} |
|
|
|
|
|
operator float&() { return val; } |
|
|
operator const float() const { return val; } |
|
|
bool empty() const { return val == -1; } |
|
|
void clear() { val = -1; } |
|
|
bool has_value() const { return !empty(); } |
|
|
bool operator== (float dv) const { |
|
|
return val == dv; |
|
|
} |
|
|
bool operator!= (float dv) const { |
|
|
return val != dv; |
|
|
} |
|
|
direct_val& operator= (float v) { |
|
|
val = v; |
|
|
return *this; |
|
|
} |
|
|
float eval_px(const UIContext& ctx) const; |
|
|
|
|
|
bool set_from_arg(std::string_view s) { |
|
|
std::istringstream is; |
|
|
is.str(std::string(s)); |
|
|
is >> val; |
|
|
|
|
|
std::string_view factor = s.size() > 3 ? s.substr(s.size() - 3) : ""; |
|
|
if (factor == "*dp") |
|
|
{ |
|
|
std::istringstream is(std::string(s.substr(0, s.size() - 3))); |
|
|
float v; |
|
|
if ((is >> v) && is.eof()) |
|
|
val = v; |
|
|
} |
|
|
return true; |
|
|
} |
|
|
std::string to_arg(std::string_view unit, std::string_view = "") const { |
|
|
std::ostringstream os; |
|
|
os << val; |
|
|
if (unit != "") |
|
|
os << "*" << unit; |
|
|
return os.str(); |
|
|
} |
|
|
std::vector<std::string> used_variables() const { |
|
|
return {}; |
|
|
} |
|
|
void rename_variable(const std::string& oldn, const std::string& newn) |
|
|
{} |
|
|
float* access() { return &val; } |
|
|
const char* c_str() const { return nullptr; } |
|
|
|
|
|
private: |
|
|
float val; |
|
|
}; |
|
|
|
|
|
template <> |
|
|
struct direct_val<pzdimension2_t> : property_base |
|
|
{ |
|
|
direct_val(ImVec2 dim = { -1, -1 }) : val(dim) {} |
|
|
|
|
|
operator ImVec2&() { return val; } |
|
|
operator const ImVec2() const { return val; } |
|
|
float& operator[] (int i) { return val[i]; } |
|
|
float operator[] (int i) const { return val[i]; } |
|
|
|
|
|
bool operator== (ImVec2 dv) const { |
|
|
return val[0] == dv[0] && val[1] == dv[1]; |
|
|
} |
|
|
bool operator!= (ImVec2 dv) const { |
|
|
return val[0] != dv[0] && val[1] != dv[1]; |
|
|
} |
|
|
direct_val& operator= (ImVec2 v) { |
|
|
val = v; |
|
|
return *this; |
|
|
} |
|
|
void clear() { val[0] = val[1] = -1; } |
|
|
bool empty() const { return val[0] == -1 && val[1] == -1; } |
|
|
bool has_value() const { return !empty(); } |
|
|
ImVec2 eval_px(const UIContext& ctx) const; |
|
|
|
|
|
bool set_from_arg(std::string_view s) { |
|
|
val = cpp::parse_fsize(std::string(s)); |
|
|
return true; |
|
|
} |
|
|
std::string to_arg(std::string_view unit, std::string_view = "") const { |
|
|
bool hasv = has_value(); |
|
|
std::ostringstream os; |
|
|
os << "{ " << val[0]; |
|
|
if (unit != "" && hasv && val[0]) |
|
|
os << "*" << unit; |
|
|
os << ", " << val[1]; |
|
|
if (unit != "" && hasv && val[1]) |
|
|
os << "*" << unit; |
|
|
os << " }"; |
|
|
return os.str(); |
|
|
} |
|
|
std::vector<std::string> used_variables() const { |
|
|
return {}; |
|
|
} |
|
|
void rename_variable(const std::string& oldn, const std::string& newn) |
|
|
{} |
|
|
ImVec2* access() { return &val; } |
|
|
const char* c_str() const { return nullptr; } |
|
|
|
|
|
private: |
|
|
ImVec2 val; |
|
|
}; |
|
|
|
|
|
template <> |
|
|
struct direct_val<std::string> : property_base |
|
|
{ |
|
|
direct_val(const std::string& v) : val(v) {} |
|
|
direct_val(const char* v) : val(v) {} |
|
|
|
|
|
operator std::string&() { return val; } |
|
|
operator const std::string&() const { return val; } |
|
|
|
|
|
const std::string& value() const { return val; } |
|
|
|
|
|
bool set_from_arg(std::string_view s) { |
|
|
val = cpp::parse_str_arg(s); |
|
|
return val != cpp::INVALID_TEXT; |
|
|
} |
|
|
std::string to_arg(std::string_view = "", std::string_view = "") const { |
|
|
return "\"" + cpp::escape(val) + "\""; |
|
|
} |
|
|
std::vector<std::string> used_variables() const { |
|
|
return {}; |
|
|
} |
|
|
void rename_variable(const std::string& oldn, const std::string& newn) |
|
|
{} |
|
|
std::string* access() { return &val; } |
|
|
const char* c_str() const { return val.c_str(); } |
|
|
bool empty() const { return val.empty(); } |
|
|
bool operator== (const std::string& dv) const { |
|
|
return val == dv; |
|
|
} |
|
|
bool operator!= (const std::string& dv) const { |
|
|
return val != dv; |
|
|
} |
|
|
private: |
|
|
std::string val; |
|
|
}; |
|
|
|
|
|
template <> |
|
|
struct direct_val<shortcut_t> : property_base |
|
|
{ |
|
|
direct_val(const std::string& v) : sh(v) {} |
|
|
direct_val(const char* v) : sh(v) {} |
|
|
|
|
|
int flags() const { return flags_; } |
|
|
void set_flags(int f) { flags_ = f; } |
|
|
|
|
|
|
|
|
bool set_from_arg(std::string_view s) { |
|
|
sh = ParseShortcut(s); |
|
|
flags_ = 0; |
|
|
if (s.find("ImGuiInputFlags_RouteGlobal") != std::string::npos) |
|
|
flags_ |= ImGuiInputFlags_RouteGlobal; |
|
|
if (s.find("ImGuiInputFlags_Repat") != std::string::npos) |
|
|
flags_ |= ImGuiInputFlags_Repeat; |
|
|
return true; |
|
|
} |
|
|
std::string to_arg(std::string_view = "", std::string_view = "") const { |
|
|
std::ostringstream os; |
|
|
os << CodeShortcut(sh); |
|
|
std::vector<std::string> fl; |
|
|
if (flags_ & ImGuiInputFlags_RouteGlobal) |
|
|
fl.push_back("ImGuiInputFlags_RouteGlobal"); |
|
|
if (flags_ & ImGuiInputFlags_Repeat) |
|
|
fl.push_back("ImGuiInputFlags_Repeat"); |
|
|
if (fl.size()) |
|
|
os << ", " << stx::join(fl, " | "); |
|
|
return os.str(); |
|
|
} |
|
|
std::vector<std::string> used_variables() const { |
|
|
return {}; |
|
|
} |
|
|
void rename_variable(const std::string& oldn, const std::string& newn) |
|
|
{} |
|
|
std::string* access() { return &sh; } |
|
|
const char* c_str() const { return sh.c_str(); } |
|
|
bool empty() const { return sh.empty(); } |
|
|
private: |
|
|
std::string sh; |
|
|
int flags_; |
|
|
}; |
|
|
|
|
|
|
|
|
|
|
|
template <class T = void> |
|
|
struct bindable : property_base |
|
|
{ |
|
|
bindable() { |
|
|
} |
|
|
template <class U = std::conditional_t<std::is_same_v<T, void>, std::nullptr_t, T>> |
|
|
bindable(U val) { |
|
|
std::ostringstream os; |
|
|
os << std::boolalpha << val; |
|
|
str = os.str(); |
|
|
} |
|
|
bool operator== (const bindable& b) const { |
|
|
return str == b.str; |
|
|
} |
|
|
bool operator!= (const bindable& b) const { |
|
|
return str != b.str; |
|
|
} |
|
|
bool empty() const { return str.empty(); } |
|
|
bool has_value() const { |
|
|
return cpp::is_literal(str); |
|
|
} |
|
|
T value() const { |
|
|
if (!has_value()) |
|
|
return {}; |
|
|
std::istringstream is(str); |
|
|
T val{}; |
|
|
if (is >> std::boolalpha >> val) |
|
|
return val; |
|
|
if constexpr (std::is_convertible_v<bool, T>) { |
|
|
if (str == "true") |
|
|
return true; |
|
|
if (str == "false") |
|
|
return false; |
|
|
} |
|
|
return {}; |
|
|
} |
|
|
T eval(const UIContext& ctx) const; |
|
|
|
|
|
bool has_single_variable() const { |
|
|
return cpp::is_id(str); |
|
|
} |
|
|
bool is_reference() const { |
|
|
return cpp::is_lvalue(str); |
|
|
} |
|
|
|
|
|
bool set_from_arg(std::string_view s) { |
|
|
str = s; |
|
|
|
|
|
if (std::is_same_v<T, float> && str.size() >= 3 && !str.compare(str.size() - 2, 2, ".f")) { |
|
|
str.resize(str.size() - 2); |
|
|
if (!has_value()) |
|
|
str += ".f"; |
|
|
} |
|
|
else if (std::is_same_v<T, float> && str.size() && str.back() == 'f') { |
|
|
str.pop_back(); |
|
|
if (!has_value()) |
|
|
str.push_back('f'); |
|
|
} |
|
|
return true; |
|
|
} |
|
|
std::string to_arg(std::string_view = "", std::string_view = "") const { |
|
|
if (std::is_same_v<T, float> && has_value()) { |
|
|
std::string tmp = str; |
|
|
if (str.find('.') == std::string::npos) |
|
|
tmp += ".f"; |
|
|
else |
|
|
tmp += "f"; |
|
|
return tmp; |
|
|
} |
|
|
return str; |
|
|
} |
|
|
std::vector<std::string> used_variables() const { |
|
|
if (empty() || has_value()) |
|
|
return {}; |
|
|
std::vector<std::string> vars; |
|
|
size_t i = 0; |
|
|
while (true) { |
|
|
auto id = cpp::find_id(str, i); |
|
|
if (id == "") |
|
|
break; |
|
|
vars.push_back(std::string(id)); |
|
|
} |
|
|
return vars; |
|
|
}; |
|
|
void rename_variable(const std::string& oldn, const std::string& newn) |
|
|
{ |
|
|
if (empty() || has_value()) |
|
|
return; |
|
|
std::vector<std::string> vars; |
|
|
size_t i = 0; |
|
|
while (true) { |
|
|
auto id = cpp::find_id(str, i); |
|
|
if (id == "") |
|
|
break; |
|
|
if (id == oldn) |
|
|
str.replace(id.data() - str.data(), id.size(), newn); |
|
|
} |
|
|
} |
|
|
const char* c_str() const { return str.c_str(); } |
|
|
std::string* access() { return &str; } |
|
|
private: |
|
|
std::string str; |
|
|
}; |
|
|
|
|
|
template <> |
|
|
struct bindable<dimension_t> : property_base |
|
|
{ |
|
|
bindable() { |
|
|
} |
|
|
bindable(float val) |
|
|
{ |
|
|
std::ostringstream os; |
|
|
os << val; |
|
|
str = os.str(); |
|
|
} |
|
|
bool operator== (const bindable& b) const { |
|
|
return str == b.str && grow == b.grow; |
|
|
} |
|
|
bool operator!= (const bindable& b) const { |
|
|
return str != b.str || grow != b.grow; |
|
|
} |
|
|
bool empty() const { |
|
|
return str.empty(); |
|
|
} |
|
|
bool zero() const { |
|
|
if (empty()) |
|
|
return false; |
|
|
std::istringstream is(str); |
|
|
float val; |
|
|
if (!(is >> val) || val) |
|
|
return false; |
|
|
return is.eof() || is.tellg() == str.size(); |
|
|
} |
|
|
bool stretched() const { |
|
|
return grow; |
|
|
} |
|
|
bool has_value() const { |
|
|
return cpp::is_literal(str); |
|
|
} |
|
|
float value() const { |
|
|
if (!has_value()) |
|
|
return {}; |
|
|
std::istringstream is(str); |
|
|
float val{}; |
|
|
is >> val; |
|
|
return val; |
|
|
} |
|
|
float eval_px(int axis, const UIContext& ctx) const; |
|
|
|
|
|
bool set_from_arg(std::string_view s) { |
|
|
str = s; |
|
|
stretch(false); |
|
|
|
|
|
std::string_view factor = s.size() > 3 ? s.substr(s.size() - 3) : ""; |
|
|
if (factor == "*fs" || factor == "*dp") |
|
|
{ |
|
|
std::istringstream is(std::string(s.substr(0, s.size() - 3))); |
|
|
float val; |
|
|
if ((is >> val) && is.eof()) |
|
|
str = s.substr(0, s.size() - 3); |
|
|
} |
|
|
else if (s.size() && s.back() == 'x') |
|
|
{ |
|
|
std::istringstream is(std::string(s.substr(0, s.size() - 1))); |
|
|
float val; |
|
|
if ((is >> val) && is.eof()) |
|
|
str.pop_back(); |
|
|
stretch(true); |
|
|
} |
|
|
return true; |
|
|
} |
|
|
std::string to_arg(std::string_view unit, std::string_view stretchCode = "") const { |
|
|
if (stretched()) |
|
|
{ |
|
|
if (stretchCode != "") |
|
|
return std::string(stretchCode); |
|
|
return str + "x"; |
|
|
} |
|
|
if (unit != "" && has_value() && |
|
|
str != "0" && str != "-1") |
|
|
{ |
|
|
return str + "*" + unit; |
|
|
} |
|
|
return str; |
|
|
} |
|
|
std::vector<std::string> used_variables() const { |
|
|
if (empty() || has_value()) |
|
|
return {}; |
|
|
std::vector<std::string> vars; |
|
|
size_t i = 0; |
|
|
while (true) { |
|
|
auto id = cpp::find_id(str, i); |
|
|
if (id == "") |
|
|
break; |
|
|
vars.push_back(std::string(id)); |
|
|
} |
|
|
return vars; |
|
|
}; |
|
|
void rename_variable(const std::string& oldn, const std::string& newn) |
|
|
{ |
|
|
if (empty() || has_value()) |
|
|
return; |
|
|
std::vector<std::string> vars; |
|
|
size_t i = 0; |
|
|
while (true) { |
|
|
auto id = cpp::find_id(str, i); |
|
|
if (id == "") |
|
|
break; |
|
|
if (id == oldn) |
|
|
str.replace(id.data() - str.data(), id.size(), newn); |
|
|
} |
|
|
} |
|
|
const char* c_str() const { return str.c_str(); } |
|
|
std::string* access() { return &str; } |
|
|
|
|
|
void stretch(bool s) { |
|
|
grow = s; |
|
|
std::ostringstream os; |
|
|
if (grow) { |
|
|
auto val = value(); |
|
|
os << std::fixed << std::setprecision(1) << val; |
|
|
str = os.str(); |
|
|
} |
|
|
else if (has_value()) { |
|
|
auto val = value(); |
|
|
os << std::defaultfloat << val; |
|
|
str = os.str(); |
|
|
} |
|
|
} |
|
|
|
|
|
private: |
|
|
std::string str; |
|
|
bool grow = false; |
|
|
}; |
|
|
|
|
|
|
|
|
template <> |
|
|
struct bindable<std::string> : property_base |
|
|
{ |
|
|
bindable() {} |
|
|
bindable(const char* val) { |
|
|
str = val; |
|
|
} |
|
|
bindable(const std::string& val) { |
|
|
str = val; |
|
|
} |
|
|
bool operator== (const bindable& b) const { |
|
|
return str == b.str; |
|
|
} |
|
|
bool operator!= (const bindable& b) const { |
|
|
return str != b.str; |
|
|
} |
|
|
bool empty() const { return str.empty(); } |
|
|
const std::string& value() const { return str; } |
|
|
bool set_from_arg(std::string_view s) |
|
|
{ |
|
|
str = cpp::parse_str_arg(s); |
|
|
return str != cpp::INVALID_TEXT; |
|
|
} |
|
|
std::string to_arg(std::string_view = "", std::string_view = "") const |
|
|
{ |
|
|
return cpp::to_str_arg(str); |
|
|
|
|
|
|
|
|
} |
|
|
bool has_single_variable() const { |
|
|
if (empty() || str[0] != '{' || str.back() != '}') |
|
|
return false; |
|
|
auto vars = used_variables(); |
|
|
if (vars.size() != 1 || str.compare(1, str.size() - 2, vars[0])) |
|
|
return false; |
|
|
return true; |
|
|
} |
|
|
std::vector<std::string> used_variables() const { |
|
|
std::vector<std::string> vars; |
|
|
size_t i = 0; |
|
|
while (true) { |
|
|
size_t j = str.find('{', i); |
|
|
if (j == std::string::npos) |
|
|
break; |
|
|
if (j + 1 < str.size() && str[j + 1] == '{') |
|
|
i = j + 2; |
|
|
else { |
|
|
i = j + 1; |
|
|
size_t e; |
|
|
for (e = i + 1; e < str.size(); ++e) |
|
|
if (str[e] == ':' || str[e] == '}') |
|
|
break; |
|
|
if (e >= str.size()) |
|
|
break; |
|
|
if (e > i) { |
|
|
auto s = str.substr(i, e - i); |
|
|
size_t k = 0; |
|
|
while (true) { |
|
|
auto id = cpp::find_id(s, k); |
|
|
if (id == "") |
|
|
break; |
|
|
vars.push_back(std::string(id)); |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
return vars; |
|
|
}; |
|
|
void rename_variable(const std::string& oldn, const std::string& newn) { |
|
|
std::vector<std::string> vars; |
|
|
size_t i = 0; |
|
|
while (true) { |
|
|
size_t j = str.find('{', i); |
|
|
if (j == std::string::npos) |
|
|
break; |
|
|
if (j + 1 < str.size() && str[j + 1] == '{') |
|
|
i = j + 2; |
|
|
else { |
|
|
i = j + 1; |
|
|
size_t e = std::min(str.find(':', i), str.find('}', i)); |
|
|
if (e == std::string::npos) |
|
|
break; |
|
|
auto s = str.substr(i, e - i); |
|
|
size_t k = 0; |
|
|
while (true) { |
|
|
auto id = cpp::find_id(s, k); |
|
|
if (id == "") |
|
|
break; |
|
|
if (id == oldn) |
|
|
str.replace(id.data() - s.data() + i, id.size(), newn); |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
const char* c_str() const { return str.c_str(); } |
|
|
std::string* access() { return &str; } |
|
|
protected: |
|
|
std::string str; |
|
|
}; |
|
|
|
|
|
|
|
|
template <> |
|
|
struct bindable<std::vector<std::string>> : bindable<std::string> |
|
|
{ |
|
|
bindable() {} |
|
|
bool has_single_variable() const |
|
|
{ |
|
|
return str.size() > 2 && str[0] == '{' && |
|
|
str.find('{', 1) == std::string::npos && |
|
|
str.back() == '}'; |
|
|
} |
|
|
std::string to_arg(std::string_view = "", std::string_view = "") const |
|
|
{ |
|
|
return cpp::to_str_arg(str, true); |
|
|
} |
|
|
}; |
|
|
|
|
|
template <> |
|
|
struct bindable<font_name_t> : property_base |
|
|
{ |
|
|
bindable() { |
|
|
} |
|
|
bindable(std::string_view fn) { |
|
|
set_font_name(fn); |
|
|
} |
|
|
bool operator== (const bindable& b) const { |
|
|
return str == b.str; |
|
|
} |
|
|
bool operator!= (const bindable& b) const { |
|
|
return str != b.str; |
|
|
} |
|
|
bool empty() const { return str.empty(); } |
|
|
bool has_value() const { |
|
|
return !str.compare(0, 22, "ImRad::GetFontByName(\""); |
|
|
} |
|
|
std::string eval(const UIContext& ctx) const; |
|
|
|
|
|
void set_font_name(std::string_view fn) { |
|
|
str = "ImRad::GetFontByName(\"" + std::string(fn) + "\")"; |
|
|
} |
|
|
bool set_from_arg(std::string_view s) { |
|
|
str = s; |
|
|
return true; |
|
|
} |
|
|
std::string to_arg(std::string_view = "", std::string_view = "") const { |
|
|
return str; |
|
|
} |
|
|
std::vector<std::string> used_variables() const { |
|
|
if (empty()) |
|
|
return {}; |
|
|
std::vector<std::string> vars; |
|
|
size_t i = 0; |
|
|
while (true) { |
|
|
auto id = cpp::find_id(str, i); |
|
|
if (id == "") |
|
|
break; |
|
|
vars.push_back(std::string(id)); |
|
|
} |
|
|
return vars; |
|
|
}; |
|
|
void rename_variable(const std::string& oldn, const std::string& newn) |
|
|
{ |
|
|
if (empty()) |
|
|
return; |
|
|
std::vector<std::string> vars; |
|
|
size_t i = 0; |
|
|
while (true) { |
|
|
auto id = cpp::find_id(str, i); |
|
|
if (id == "") |
|
|
break; |
|
|
if (id == oldn) |
|
|
str.replace(id.data() - str.data(), id.size(), newn); |
|
|
} |
|
|
} |
|
|
const char* c_str() const { return str.c_str(); } |
|
|
std::string* access() { return &str; } |
|
|
private: |
|
|
std::string str; |
|
|
}; |
|
|
|
|
|
template <> |
|
|
struct bindable<color_t> : property_base |
|
|
{ |
|
|
bindable() { |
|
|
} |
|
|
bindable(ImU32 c) { |
|
|
std::ostringstream os; |
|
|
if (c) |
|
|
os << "0x" << std::hex << std::setw(2 * 4) << std::setfill('0') << c; |
|
|
str = os.str(); |
|
|
} |
|
|
bool operator== (const bindable& b) const { |
|
|
return str == b.str; |
|
|
} |
|
|
bool operator!= (const bindable& b) const { |
|
|
return str != b.str; |
|
|
} |
|
|
bool empty() const { return str.empty(); } |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
ImU32 eval(int col, const UIContext& ctx) const; |
|
|
|
|
|
bool has_style_color() const { |
|
|
if (!str.compare(0, 34, "ImGui::GetStyle().Colors[ImGuiCol_") && str.back() == ']') |
|
|
return true; |
|
|
if (!str.compare(0, 34, "ImGui::GetStyleColorVec4(ImGuiCol_") && str.back() == ')') |
|
|
return true; |
|
|
return false; |
|
|
} |
|
|
int style_color() const { |
|
|
if (!has_style_color()) |
|
|
return -1; |
|
|
std::string code = str.substr(34, str.size() - 34 - 1); |
|
|
for (int i = 0; i < ImGuiCol_COUNT; ++i) |
|
|
if (code == ImGui::GetStyleColorName(i)) |
|
|
return i; |
|
|
return -1; |
|
|
} |
|
|
void set_style_color(int i) { |
|
|
std::ostringstream os; |
|
|
os << "ImGui::GetStyleColorVec4(ImGuiCol_" << ImGui::GetStyleColorName(i) << ")"; |
|
|
str = os.str(); |
|
|
} |
|
|
bool set_from_arg(std::string_view s) { |
|
|
str = s; |
|
|
return true; |
|
|
} |
|
|
std::string to_arg(std::string_view = "", std::string_view = "") const { |
|
|
return str; |
|
|
} |
|
|
std::vector<std::string> used_variables() const { |
|
|
if (empty()) |
|
|
return {}; |
|
|
std::vector<std::string> vars; |
|
|
size_t i = 0; |
|
|
while (true) { |
|
|
auto id = cpp::find_id(str, i); |
|
|
if (id == "") |
|
|
break; |
|
|
vars.push_back(std::string(id)); |
|
|
} |
|
|
return vars; |
|
|
}; |
|
|
void rename_variable(const std::string& oldn, const std::string& newn) |
|
|
{ |
|
|
if (empty()) |
|
|
return; |
|
|
std::vector<std::string> vars; |
|
|
size_t i = 0; |
|
|
while (true) { |
|
|
auto id = cpp::find_id(str, i); |
|
|
if (id == "") |
|
|
break; |
|
|
if (id == oldn) |
|
|
str.replace(id.data() - str.data(), id.size(), newn); |
|
|
} |
|
|
} |
|
|
const char* c_str() const { return str.c_str(); } |
|
|
std::string* access() { return &str; } |
|
|
private: |
|
|
std::string str; |
|
|
}; |
|
|
|
|
|
struct data_loop : property_base |
|
|
{ |
|
|
bindable<int> limit; |
|
|
field_ref<int> index; |
|
|
|
|
|
bool empty() const { |
|
|
return limit.empty(); |
|
|
} |
|
|
std::string index_name_or(std::string_view s) const { |
|
|
return index.empty() ? std::string(s) : index.to_arg(); |
|
|
} |
|
|
std::string container_var() const { |
|
|
auto vars = limit.used_variables(); |
|
|
if (vars.size()) |
|
|
return vars[0]; |
|
|
return ""; |
|
|
} |
|
|
std::string container_expr() { |
|
|
std::string var = container_var(); |
|
|
const std::string& str = *limit.access(); |
|
|
size_t i = str.find(var); |
|
|
if ((i && str[i - 1] == '*') || !str.compare(i + var.size(), 2, "->")) |
|
|
return "(*" + var + ")"; |
|
|
return var; |
|
|
} |
|
|
|
|
|
bool set_from_arg(std::string_view code) { |
|
|
if (code.compare(0, 4, "for(")) |
|
|
return false; |
|
|
bool local = !code.compare(4, 3, "int") || !code.compare(4, 6, "size_t"); |
|
|
auto i = code.find(";"); |
|
|
if (i == std::string::npos) |
|
|
return false; |
|
|
code.remove_prefix(i + 1); |
|
|
|
|
|
i = code.find(";"); |
|
|
if (i == std::string::npos) |
|
|
return false; |
|
|
code.remove_suffix(code.size() - i); |
|
|
|
|
|
i = code.find("<"); |
|
|
if (local) |
|
|
*index.access() = ""; |
|
|
else |
|
|
*index.access() = code.substr(0, i); |
|
|
|
|
|
limit.set_from_arg(code.substr(i + 1)); |
|
|
return true; |
|
|
} |
|
|
std::string to_arg(std::string_view forVarName, std::string_view = "") const { |
|
|
if (empty()) |
|
|
return ""; |
|
|
std::ostringstream os; |
|
|
std::string name = index_name_or(std::string(forVarName)); |
|
|
os << "for ("; |
|
|
if (index.empty()) |
|
|
os << "int "; |
|
|
os << name << " = 0; " << name << " < " << limit.to_arg() |
|
|
<< "; ++" << name << ")"; |
|
|
return os.str(); |
|
|
} |
|
|
std::vector<std::string> used_variables() const { |
|
|
auto vars = index.used_variables(); |
|
|
auto vars2 = limit.used_variables(); |
|
|
vars.insert(vars.end(), vars2.begin(), vars2.end()); |
|
|
return vars; |
|
|
}; |
|
|
void rename_variable(const std::string& oldn, const std::string& newn) |
|
|
{ |
|
|
limit.rename_variable(oldn, newn); |
|
|
index.rename_variable(oldn, newn); |
|
|
} |
|
|
const char* c_str() const { return limit.c_str(); } |
|
|
std::string* access() { return limit.access(); } |
|
|
}; |
|
|
|
|
|
|
