Hugging Face's logo

Datasets:
dlxjj
/
imradv3

Modalities:
Image
Text
Formats:
text
Size:
< 1K
Libraries:
Datasets
Dataset card Data Studio Files
xet
 Community
1
imradv3 / src /main.cpp
fasdfsa's picture
fasdfsa
wechat ocr 用于编辑器
6ef0bb6
Raw History Blame Contribute Delete
103 kB
#if WIN32
#define WIN32_LEAN_AND_MEAN
#include <Windows.h>
#undef min
#undef max
#undef MessageBox
#endif
#if defined(__APPLE__)
#include <mach-o/dyld.h>
#endif
#include <imgui.h>
#include <imgui_internal.h>
#include <misc/cpp/imgui_stdlib.h>
#include <IconsFontAwesome6.h>
//#include <misc/fonts/IconsMaterialDesign.h>
#include <backends/imgui_impl_glfw.h>
#include <backends/imgui_impl_opengl3.h>
#include <iostream>
#include <fstream>
#include <string>
#if defined(IMGUI_IMPL_OPENGL_ES2)
#include <GLES2/gl2.h>
#endif
#include <GLFW/glfw3.h> // Will drag system OpenGL headers
#include <nfd.h>
#include "glfw_cursor.h"
#include "node_standard.h"
#include "cppgen.h"
#include "utils.h"
#include "ui_new_field.h"
#include "ui_message_box.h"
#include "ui_error_box.h"
#include "ui_class_wizard.h"
#include "ui_table_cols.h"
#include "ui_about_dlg.h"
#include "ui_binding.h"
#include "ui_combo_dlg.h"
#include "ui_horiz_layout.h"
#include "ui_input_name.h"
#include "ui_settings_dlg.h"
#include "ui_explorer.h"
#include "SimpleLayout.h"
#include "ImGuiColorTextEdit/TextEditor.h"
#include "nlohmann_json/json.hpp"
#include "MD5/quickdigest5.h"
#include "Constant.h"
#include "global.h"
using json = nlohmann::json;
//must come last
#define STB_IMAGE_IMPLEMENTATION
#include <stb_image.h>
#include <d3d11.h>
//#pragma comment(lib, "E:\\huggingface\\ColorTextEditorV2\\build\\bin\\opencv_core4120.lib")
//#pragma comment(lib, "E:\\huggingface\\ColorTextEditorV2\\build\\bin\\opencv_highgui4120.lib")
std::filesystem::path g_currPath;
HINSTANCE g_wechatocr_dll = NULL;
typedef const char* (_cdecl* FunctionPtr) (const char* pth_img);
FunctionPtr rec;
std::pair<std::filesystem::path, std::filesystem::path> get_img_json_pth(const std::string& m5) {
#ifdef _DEBUG
// 这是工作目录
auto pth_img = g_currPath.parent_path().parent_path() / std::filesystem::path("data/img") / std::format("{}.txt", m5);
auto pth_json = g_currPath.parent_path().parent_path() / std::filesystem::path("data/json") / std::format("{}.json", m5);
#else
// 这是工作目录
auto pth_img = g_currPath / std::filesystem::path("data/img") / std::format("{}.txt", m5); // .parent_path().parent_path()
auto pth_json = g_currPath / std::filesystem::path("data/json") / std::format("{}.json", m5); // .parent_path().parent_path()
//// 这是可执行文件所在目录
//auto pth_img = g_currPath / std::filesystem::path("data/img") / std::format("{}.txt", m5);
//auto pth_json = g_currPath / std::filesystem::path("data/json") / std::format("{}.json", m5);
#endif // DEBUG
pth_img = pth_img.lexically_normal();
pth_json = pth_json.lexically_normal();
std::pair<std::filesystem::path, std::filesystem::path> pth_pair{ pth_img, pth_json };
return pth_pair;
}
std::string readFileToString(const std::string& filePath) {
std::ifstream file(filePath, std::ios::binary);
if (!file) return "";
std::ostringstream buffer;
buffer << file.rdbuf(); // 将文件流缓冲区内容写入字符串流
return buffer.str();
}
static void glfw_error_callback(int error, const char* description)
{
std::cerr << "Glfw Error: " << description;
}
const float TB_SIZE = 40;
const float TAB_SIZE = 25; //todo examine
const std::string UNTITLED = "Untitled";
const std::string DEFAULT_STYLE = "Dark";
const std::string DEFAULT_UNIT = "px";
const char* INI_FILE_NAME = "imgui.ini";
struct File
{
std::string fname;
CppGen codeGen;
std::unique_ptr<TopWindow> rootNode;
bool modified = false;
fs::file_time_type time[2];
std::string styleName;
std::string unit;
};
enum ProgramState { Run, Init, Shutdown };
ProgramState programState;
std::string rootPath;
std::string initErrors, showError;
std::string uiFontName = "Roboto-Regular.ttf";
std::string pgFontName = "Roboto-Regular.ttf";
std::string pgbFontName = "Roboto-Bold.ttf";
float uiFontSize = 19;
float pgFontSize = 20;
UIContext ctx;
std::unique_ptr<Widget> newNode;
std::vector<File> fileTabs;
int activeTab = -1;
std::vector<std::pair<std::string, std::string>> styleNames; //name, path
std::string styleName;
bool reloadStyle = true;
GLFWwindow* window = nullptr;
int addInputCharacter = 0;
std::string lastPropName;
std::string activeButton = "";
std::vector<std::unique_ptr<Widget>> clipboard;
GLFWcursor* curCross = nullptr;
GLFWcursor* curWait = nullptr;
float pgHeight = 0, pgeHeight = 0;
ImRad::IOUserData ioUserData;
struct TB_Button
{
std::string label;
std::string name;
};
std::vector<std::pair<std::string, std::vector<TB_Button>>> tbButtons{
{ "Standard", {
{ ICON_FA_ARROW_POINTER, "" },
{ ICON_FA_FONT, "Text" },
{ ICON_FA_AUDIO_DESCRIPTION, "Selectable" },
{ ICON_FA_CIRCLE_PLAY, "Button" }, //ICON_FA_SQUARE_PLUS
{ "[a_]", "Input" }, //ICON_FA_CLOSED_CAPTIONING
{ ICON_FA_SQUARE_CHECK, "CheckBox" },
{ ICON_FA_CIRCLE_DOT, "RadioButton" },
{ ICON_FA_SQUARE_CARET_DOWN, "Combo" },
{ ICON_FA_SLIDERS, "Slider" },
{ ICON_FA_CIRCLE_HALF_STROKE, "ColorEdit" },
{ ICON_FA_BATTERY_HALF, "ProgressBar" },
{ ICON_FA_IMAGE, "Image" },
{ ICON_FA_LEFT_RIGHT, "Spacer" },
{ ICON_FA_MINUS, "Separator" },
{ ICON_FA_EXPAND, "CustomWidget" },
}},
{ "Containers", {
{ ICON_FA_SQUARE_FULL, "Child" },
{ ICON_FA_TABLE_CELLS_LARGE, "Table" },
{ ICON_FA_ARROW_DOWN_WIDE_SHORT, "CollapsingHeader" },
{ ICON_FA_FOLDER_CLOSED, "TabBar" },
{ ICON_FA_SITEMAP, "TreeNode" },
{ ICON_FA_TABLE_COLUMNS, "Splitter" }, //ICON_FA_ARROWS_LEFT_RIGHT_TO_LINE
//{ ICON_FA_CLAPPERBOARD /*ELLIPSIS*/, "MenuBar" },
{ ICON_FA_TABLE, "DockSpace" },
{ ICON_FA_MESSAGE /*RECEIPT*/, "ContextMenu" },
}},
};
//CancelShutdown identifier is used in winuser.h
void DoCancelShutdown()
{
if (programState != Shutdown)
return;
glfwSetWindowShouldClose(window, false);
programState = Run;
ImGui::GetIO().IniFilename = INI_FILE_NAME;
}
void DoReloadFile()
{
if (activeTab < 0)
return;
auto& tab = fileTabs[activeTab];
if (tab.fname == "" || !fs::is_regular_file(u8path(tab.fname)))
return;
std::map<std::string, std::string> params;
std::string error;
tab.rootNode = tab.codeGen.Import(tab.fname, params, error);
auto pit = params.find("style");
tab.styleName = pit == params.end() ? DEFAULT_STYLE : pit->second;
pit = params.find("unit");
tab.unit = pit == params.end() ? DEFAULT_UNIT : pit->second;
bool styleFound = stx::count_if(styleNames, [&](const auto& st) {
return st.first == tab.styleName;
});
if (!styleFound) {
error = "Unknown style \"" + tab.styleName + "\" used\n" + error;
tab.styleName = DEFAULT_STYLE;
}
tab.modified = false;
ctx.mode = UIContext::NormalSelection;
ctx.selected = { tab.rootNode.get() };
if (error != "" && programState != Shutdown)
{
errorBox.title = "Reload";
errorBox.message = "Errors occured";
errorBox.error = error;
errorBox.OpenPopup();
}
}
void ReloadFile()
{
if (activeTab < 0)
return;
auto& tab = fileTabs[activeTab];
if (tab.fname == "" || !fs::is_regular_file(u8path(tab.fname)))
return;
auto time1 = fs::last_write_time(u8path(tab.fname));
std::error_code err;
auto time2 = fs::last_write_time(u8path(tab.codeGen.AltFName(tab.fname)), err);
if (time1 == tab.time[0] && time2 == tab.time[1])
return;
tab.time[0] = time1;
tab.time[1] = time2;
if (programState != Shutdown)
{
std::string fn = u8string(u8path(tab.fname).filename());
messageBox.title = "Reload";
messageBox.message = "File content of '" + fn + "' has changed. Reload?";
messageBox.buttons = ImRad::Yes | ImRad::No;
messageBox.OpenPopup([&](ImRad::ModalResult mr) {
if (mr == ImRad::Yes)
DoReloadFile();
});
}
else {
DoReloadFile();
}
}
void ActivateTab(int i)
{
/*doesn't work when activeTab is closed
std::string lastStyle;
if (activeTab >= 0)
lastStyle = fileTabs[activeTab].styleName;*/
if (i >= fileTabs.size())
i = (int)fileTabs.size() - 1;
if (i < 0) {
activeTab = -1;
ctx.selected.clear();
ctx.codeGen = nullptr;
return;
}
activeTab = i;
auto& tab = fileTabs[i];
ctx.selected = { tab.rootNode.get() };
ctx.codeGen = &tab.codeGen;
ReloadFile();
if (fileTabs[activeTab].styleName != styleName)
reloadStyle = true;
}
void NewFile(TopWindow::Kind k)
{
ctx.kind = k;
auto top = std::make_unique<TopWindow>(ctx);
File file;
file.rootNode = std::move(top);
file.styleName = DEFAULT_STYLE;
file.unit = k == TopWindow::Activity ? "dp" : DEFAULT_UNIT;
file.modified = true;
fileTabs.push_back(std::move(file));
ActivateTab((int)fileTabs.size() - 1);
}
void CopyFileReplace(const std::string& from, const std::string& to, std::vector<std::pair<std::string, std::string>>& repl)
{
std::ifstream fin(u8path(from));
if (!fin)
throw std::runtime_error("can't read from " + from);
std::ofstream fout(u8path(to));
if (!fout)
throw std::runtime_error("can't write to " + to);
std::string line;
while (std::getline(fin, line))
{
size_t i = 0;
while (true)
{
i = line.find("${", i);
if (i == std::string::npos)
break;
size_t j = line.find("}", i);
if (j == std::string::npos)
break;
for (const auto& r : repl)
if (!line.compare(i + 2, j - i - 2, r.first)) {
line.replace(line.begin() + i, line.begin() + j + 1, r.second);
j = i + r.second.size();
break;
}
i = j;
}
fout << line << "\n";
}
}
void DoNewTemplate(int type, const std::string& name)
{
nfdchar_t *outPath = NULL;
nfdfilteritem_t filterItem[1] = { { (const nfdchar_t *)"Source code", (const nfdchar_t *)"cpp" } };
nfdresult_t result = NFD_SaveDialog(&outPath, filterItem, 1, nullptr, "main.cpp");
if (result != NFD_OKAY)
return;
fs::path p = u8path(outPath);
NFD_FreePath(outPath);
if (!p.has_extension())
p.replace_extension(".cpp");
try {
switch (type)
{
case 0:
fs::copy_file(u8path(rootPath + "/template/glfw/main.cpp"), p, fs::copy_options::overwrite_existing);
break;
case 1: {
std::string jni = name;
stx::replace(jni, '.', '_');
if (name.find('.') == std::string::npos)
throw std::runtime_error("invalid package name");
std::string lib = name.substr(name.rfind('.') + 1);
std::vector<std::pair<std::string, std::string>> repl{
{ "JAVA_PACKAGE", name },
{ "JNI_PACKAGE", jni },
{ "LIB_NAME", lib },
{ "IMRAD_INCLUDE", rootPath + "/include" },
};
CopyFileReplace(rootPath + "/template/android/main.cpp", u8string(p), repl);
CopyFileReplace(rootPath + "/template/android/CMakeLists.txt", u8string(p.replace_filename("CMakeLists.txt")), repl);
CopyFileReplace(rootPath + "/template/android/MainActivity.java", u8string(p.replace_filename("MainActivity.java")), repl);
CopyFileReplace(rootPath + "/template/android/AndroidManifest.xml", u8string(p.replace_filename("AndroidManifest.xml")), repl);
break;
}
}
}
catch (std::exception& e) {
messageBox.title = "error";
messageBox.message = e.what();
messageBox.buttons = ImRad::Ok;
messageBox.OpenPopup();
}
}
void NewTemplate(int type)
{
if (type == 1)
{
//android template
inputName.title = "Java package name";
inputName.hint = "com.example.test";
inputName.OpenPopup([type](ImRad::ModalResult mr) {
DoNewTemplate(type, inputName.name);
});
}
else
DoNewTemplate(type, "");
}
bool DoOpenFile(const std::string& path, std::string* errs = nullptr)
{
File file;
file.fname = path;
if (u8string(u8path(file.fname).extension()).compare(0, 2, ".h")) {
file.fname = file.codeGen.AltFName(file.fname);
}
if (!fs::is_regular_file(u8path(path))) {
if (errs)
*errs += "Can't read '" + path + "'\n";
else {
messageBox.title = "ImRAD";
messageBox.message = "Can't read '" + path + "'";
messageBox.buttons = ImRad::Ok;
messageBox.OpenPopup();
}
return false;
}
std::error_code err;
file.time[0] = fs::last_write_time(u8path(file.fname), err);
file.time[1] = fs::last_write_time(u8path(file.codeGen.AltFName(file.fname)), err);
std::map<std::string, std::string> params;
std::string error;
file.rootNode = file.codeGen.Import(file.fname, params, error);
auto pit = params.find("style");
file.styleName = pit == params.end() ? DEFAULT_STYLE : pit->second;
pit = params.find("unit");
file.unit = pit == params.end() ? DEFAULT_UNIT : pit->second;
if (!file.rootNode) {
if (errs)
*errs += "Unsuccessful import of '" + path + "'\n";
else {
errorBox.title = "CodeGen";
errorBox.message = "Unsuccessful import because of errors";
errorBox.error = error;
errorBox.OpenPopup();
}
return false;
}
bool styleFound = stx::count_if(styleNames, [&](const auto& st) {
return st.first == file.styleName;
});
if (!styleFound) {
if (errs)
*errs += "Uknown style \"" + file.styleName + "\" used\n";
else
error = "Unknown style \"" + file.styleName + "\" used\n" + error;
file.styleName = DEFAULT_STYLE;
}
auto it = stx::find_if(fileTabs, [&](const File& f) { return f.fname == file.fname; });
if (it == fileTabs.end()) {
fileTabs.push_back({});
it = fileTabs.begin() + fileTabs.size() - 1;
}
int idx = int(it - fileTabs.begin());
fileTabs[idx] = std::move(file);
ActivateTab(idx);
if (error != "") {
if (errs)
*errs += error;
else {
errorBox.title = "CodeGen";
errorBox.message = "Import finished with errors";
errorBox.error = error;
errorBox.OpenPopup();
}
}
return true;
}
void OpenFile()
{
nfdchar_t *outPath = NULL;
nfdfilteritem_t filterItem[1] = { { "Headers", "h,hpp" } };
nfdresult_t result = NFD_OpenDialog(&outPath, filterItem, 1, nullptr);
if (result != NFD_OKAY)
return;
ctx.mode = UIContext::NormalSelection;
ctx.selected.clear();
auto it = stx::find_if(fileTabs, [&](const File& f) { return f.fname == outPath; });
if (it != fileTabs.end())
{
ActivateTab(int(it - fileTabs.begin()));
if (it->modified) {
messageBox.title = "Open File";
messageBox.message = "Reload and lose unsaved changes?";
messageBox.buttons = ImRad::Yes | ImRad::No;
messageBox.OpenPopup([=](ImRad::ModalResult mr) {
if (mr == ImRad::Yes)
DoOpenFile(outPath);
});
}
else {
DoOpenFile(outPath);
}
}
else {
DoOpenFile(outPath);
}
NFD_FreePath(outPath);
}
enum {
CLOSE_ACTIVE = 0x1,
CLOSE_ALL = 0x2,
CLOSE_ALL_BUT_PREVIOUS = 0x4,
};
void CloseFile(int flags = CLOSE_ACTIVE);
bool SaveFile(int flags = 0);
bool SaveFileAs(int flags = 0);
void DoCloseFile(int flags)
{
if (activeTab < 0)
return;
ctx.root = nullptr;
ctx.selected.clear();
fileTabs.erase(fileTabs.begin() + activeTab);
if ((flags & CLOSE_ALL_BUT_PREVIOUS) && fileTabs.size() >= 2) {
ActivateTab(activeTab >= fileTabs.size() ? 0 : activeTab); //cycle from first tab
CloseFile(flags);
}
else if (flags & CLOSE_ALL) {
ActivateTab(activeTab);
CloseFile(flags);
}
else {
ActivateTab(activeTab);
}
}
void CloseFile(int flags)
{
if (activeTab < 0)
return;
if (fileTabs[activeTab].modified) {
messageBox.title = "Confirmation";
std::string fname = u8string(u8path(fileTabs[activeTab].fname).filename());
if (fname.empty())
fname = UNTITLED;
messageBox.message = "Save changes to " + fname + "?";
messageBox.buttons = ImRad::Yes | ImRad::No | ImRad::Cancel;
messageBox.OpenPopup([=](ImRad::ModalResult mr) {
if (mr == ImRad::Yes)
SaveFile(flags);
else if (mr == ImRad::No)
DoCloseFile(flags);
else
DoCancelShutdown();
});
}
else {
DoCloseFile(flags);
}
}
void DoSaveFile(int flags)
{
auto& tab = fileTabs[activeTab];
std::map<std::string, std::string> params{
{ "style", tab.styleName },
{ "unit", tab.unit },
};
std::string error;
if (!tab.codeGen.ExportUpdate(tab.fname, tab.rootNode.get(), params, error))
{
DoCancelShutdown();
errorBox.title = "CodeGen";
errorBox.message = "Unsuccessful export due to errors";
errorBox.error = error;
errorBox.OpenPopup();
return;
}
std::error_code err;
tab.modified = false;
tab.time[0] = fs::last_write_time(u8path(tab.fname), err);
tab.time[1] = fs::last_write_time(u8path(tab.codeGen.AltFName(tab.fname)), err);
if (error != "" && programState != Shutdown)
{
errorBox.title = "CodeGen";
errorBox.message = "Export finished with errors";
errorBox.error = error;
errorBox.OpenPopup([=](ImRad::ModalResult) {
if (flags)
DoCloseFile(flags);
});
return;
}
if (flags)
DoCloseFile(flags);
}
bool SaveFileAs(int flags)
{
nfdchar_t *outPath = NULL;
nfdfilteritem_t filterItem[1] = { { (const nfdchar_t *)"Header File", (const nfdchar_t *)"h,hpp" } };
nfdresult_t result = NFD_SaveDialog(&outPath, filterItem, 1, nullptr, nullptr);
if (result != NFD_OKAY) {
DoCancelShutdown();
return false;
}
auto& tab = fileTabs[activeTab];
fs::path oldName = u8path(tab.fname);
fs::path newName = u8path(outPath).replace_extension(".h");
NFD_FreePath(outPath);
if (newName == oldName) {
DoSaveFile(flags);
return true;
}
try {
if (oldName != "") {
//copy files first so CppGen can parse it and preserve user content as with Save
fs::copy_file(oldName, newName, fs::copy_options::overwrite_existing);
fs::copy_file(
oldName.replace_extension(".cpp"),
newName.replace_extension(".cpp"),
fs::copy_options::overwrite_existing);
}
else {
fs::remove(newName);
fs::remove(newName.replace_extension(".cpp"));
}
}
catch (std::exception& e)
{
DoCancelShutdown();
messageBox.title = "error";
messageBox.message = e.what();
messageBox.buttons = ImRad::Ok;
messageBox.OpenPopup();
return false;
}
if (oldName == "") {
tab.codeGen.SetNamesFromId(u8string(newName.stem()));
tab.fname = u8string(newName.replace_extension(".h"));
DoSaveFile(flags);
}
else {
messageBox.title = "codegen";
messageBox.message = "Rename window class?";
messageBox.buttons = ImRad::Yes | ImRad::No | ImRad::Cancel;
messageBox.OpenPopup([&tab,newName,flags](ImRad::ModalResult mr) mutable {
if (mr == ImRad::ModalResult::Cancel)
return;
if (mr == ImRad::ModalResult::Yes)
tab.codeGen.SetNamesFromId(u8string(newName.stem()));
tab.fname = u8string(newName.replace_extension(".h"));
DoSaveFile(flags);
});
}
return true;
}
bool SaveFile(int flags)
{
auto& tab = fileTabs[activeTab];
if (tab.fname == "") {
return SaveFileAs(flags);
}
else {
DoSaveFile(flags);
return true;
}
}
//todo: dangerous because of no reloading
void SaveAll()
{
int tmp = activeTab;
for (activeTab = 0; activeTab < fileTabs.size(); ++activeTab)
{
if (!SaveFile())
break;
}
activeTab = tmp;
}
void ShowCode()
{
if (activeTab < 0)
return;
fs::path path = fs::temp_directory_path() / "imrad-preview.cpp";
std::ofstream fout(path);
fout << "// NOTE: This is just a preview of the Draw() method. To see the complete code\n"
<< "// including class definition and event handlers inspect generated .h/cpp files\n\n";
ctx.ind = "";
auto* root = fileTabs[activeTab].rootNode.get();
root->Export(fout, ctx);
if (ctx.errors.size()) {
fout << "\n// Export finished with errors:\n";
for (const std::string& e : ctx.errors)
fout << "// " << e << "\n";
}
fout.close();
ShellExec(u8string(path));
}
void NewWidget(const std::string& name)
{
if (name == "")
{
activeButton = "";
ctx.selected.clear();
ctx.mode = UIContext::NormalSelection;
}
else if (name == "MenuBar")
{
if (ctx.root->children.empty() ||
!dynamic_cast<MenuBar*>(ctx.root->children[0].get()))
{
dynamic_cast<TopWindow*>(ctx.root)->flags |= ImGuiWindowFlags_MenuBar;
ctx.root->children.insert(ctx.root->children.begin(), std::make_unique<MenuBar>(ctx));
ctx.selected = { ctx.root->children[0]->children[0].get() };
}
ctx.mode = UIContext::NormalSelection;
}
else if (name == "ContextMenu")
{
activeButton = "";
auto popup = std::make_unique<ContextMenu>(ctx);
auto item = std::make_unique<MenuIt>(ctx);
item->label = "Item";
popup->children.push_back(std::move(item));
size_t i = 0;
for (; i < ctx.root->children.size(); ++i)
{
if (ctx.root->children[i]->Behavior() & Widget::SnapSides)
break;
}
popup->label = "ContextMenu" + std::to_string(i + 1);
ctx.root->children.insert(ctx.root->children.begin() + i, std::move(popup));
ctx.mode = UIContext::NormalSelection;
ctx.selected = { ctx.root->children[i]->children[0].get() };
}
else
{
activeButton = name;
ctx.selected.clear();
ctx.mode = UIContext::SnapInsert;
newNode = Widget::Create(name, ctx);
}
}
void StyleColors()
{
ImGui::StyleColorsLight();
ImGuiStyle& style = ImGui::GetStyle();
style.Alpha = 1.0f;
style.FrameRounding = 3.0f;
style.WindowRounding = 3.f;
style.Colors[ImGuiCol_Text] = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
style.Colors[ImGuiCol_TextDisabled] = ImVec4(0.40f, 0.40f, 0.40f, 1.00f);
style.Colors[ImGuiCol_WindowBg] = ImVec4(0.94f, 0.94f, 0.94f, 0.94f);
style.Colors[ImGuiCol_ChildBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
style.Colors[ImGuiCol_PopupBg] = ImVec4(1.00f, 1.00f, 1.00f, 0.94f);
style.Colors[ImGuiCol_Border] = ImVec4(0.00f, 0.00f, 0.00f, 0.39f);
style.Colors[ImGuiCol_BorderShadow] = ImVec4(1.00f, 1.00f, 1.00f, 0.10f);
style.Colors[ImGuiCol_FrameBg] = ImVec4(1.00f, 1.00f, 1.00f, 0.94f);
style.Colors[ImGuiCol_FrameBgHovered] = ImVec4(0.26f, 0.59f, 0.98f, 0.40f);
style.Colors[ImGuiCol_FrameBgActive] = ImVec4(0.26f, 0.59f, 0.98f, 0.67f);
style.Colors[ImGuiCol_TitleBg] = ImVec4(0.96f, 0.96f, 0.96f, 1.00f);
style.Colors[ImGuiCol_TitleBgCollapsed] = ImVec4(1.00f, 1.00f, 1.00f, 0.51f);
style.Colors[ImGuiCol_TitleBgActive] = ImVec4(0.82f, 0.82f, 0.82f, 1.00f);
style.Colors[ImGuiCol_MenuBarBg] = ImVec4(0.86f, 0.86f, 0.86f, 1.00f);
style.Colors[ImGuiCol_ScrollbarBg] = ImVec4(0.98f, 0.98f, 0.98f, 0.53f);
style.Colors[ImGuiCol_ScrollbarGrab] = ImVec4(0.69f, 0.69f, 0.69f, 1.00f);
style.Colors[ImGuiCol_ScrollbarGrabHovered] = ImVec4(0.59f, 0.59f, 0.59f, 1.00f);
style.Colors[ImGuiCol_ScrollbarGrabActive] = ImVec4(0.49f, 0.49f, 0.49f, 1.00f);
style.Colors[ImGuiCol_CheckMark] = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
style.Colors[ImGuiCol_SliderGrab] = ImVec4(0.24f, 0.52f, 0.88f, 1.00f);
style.Colors[ImGuiCol_SliderGrabActive] = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
style.Colors[ImGuiCol_Header] = ImVec4(0.26f, 0.59f, 0.98f, 0.31f);
style.Colors[ImGuiCol_HeaderHovered] = ImVec4(0.26f, 0.59f, 0.98f, 0.80f);
style.Colors[ImGuiCol_HeaderActive] = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
style.Colors[ImGuiCol_HeaderHovered] = ImVec4(0.26f, 0.59f, 0.98f, 0.78f);
style.Colors[ImGuiCol_ResizeGrip] = ImVec4(1.00f, 1.00f, 1.00f, 0.50f);
style.Colors[ImGuiCol_ResizeGripHovered] = ImVec4(0.26f, 0.59f, 0.98f, 0.67f);
style.Colors[ImGuiCol_ResizeGripActive] = ImVec4(0.26f, 0.59f, 0.98f, 0.95f);
style.Colors[ImGuiCol_Button] = ImVec4(0.59f, 0.59f, 0.59f, 0.50f);
style.Colors[ImGuiCol_ButtonHovered] = ImVec4(0.98f, 0.39f, 0.36f, 1.00f);
style.Colors[ImGuiCol_ButtonActive] = ImVec4(0.86f, 0.59f, 0.59f, 1.00f);
style.Colors[ImGuiCol_PlotLines] = ImVec4(0.39f, 0.39f, 0.39f, 1.00f);
style.Colors[ImGuiCol_PlotLinesHovered] = ImVec4(1.00f, 0.43f, 0.35f, 1.00f);
style.Colors[ImGuiCol_PlotHistogram] = ImVec4(0.90f, 0.70f, 0.00f, 1.00f);
style.Colors[ImGuiCol_PlotHistogramHovered] = ImVec4(1.00f, 0.60f, 0.00f, 1.00f);
style.Colors[ImGuiCol_TextSelectedBg] = ImVec4(0.26f, 0.59f, 0.98f, 0.35f);
style.Colors[ImGuiCol_TabSelectedOverline].w = 0;
style.Colors[ImGuiCol_TabDimmedSelectedOverline].w = 0;
style.Colors[ImGuiCol_ModalWindowDimBg] = ImVec4(0.20f, 0.20f, 0.20f, 0.35f);
float alpha_ = 0.95f;
if (false) //dark
{
for (int i = 0; i < ImGuiCol_COUNT; i++)
{
ImVec4& col = style.Colors[i];
float H, S, V;
ImGui::ColorConvertRGBtoHSV(col.x, col.y, col.z, H, S, V);
if (S < 0.1f)
{
V = 1.0f - V;
}
ImGui::ColorConvertHSVtoRGB(H, S, V, col.x, col.y, col.z);
if (col.w < 1.00f)
{
col.w *= alpha_;
}
}
}
else
{
for (int i = 0; i < ImGuiCol_COUNT; i++)
{
ImVec4& col = style.Colors[i];
if (col.w < 1.00f)
{
col.x *= alpha_;
col.y *= alpha_;
col.z *= alpha_;
col.w *= alpha_;
}
}
}
//ImRad::SaveStyle(rootPath + "/style/debug.ini");
}
void GetStyles()
{
styleNames = {
{ "Classic", "" },
{ "Light", "" },
{ "Dark", "" }
};
for (fs::directory_iterator it(u8path(rootPath + "/style/")); it != fs::directory_iterator(); ++it)
{
if (it->path().extension() != ".ini")
continue;
styleNames.push_back({ u8string(it->path().stem()), u8string(it->path()) });
}
}
const std::array<ImU32, UIContext::Color::COUNT>&
GetCtxColors(const std::string& styleName)
{
static const std::array<ImU32, UIContext::Color::COUNT> classic{
IM_COL32(255, 255, 0, 128),
IM_COL32(255, 0, 0, 255),
IM_COL32(128, 128, 255, 255),
IM_COL32(255, 0, 255, 255),
IM_COL32(0, 255, 255, 255),
IM_COL32(0, 255, 0, 255),
};
static const std::array<ImU32, UIContext::Color::COUNT> light {
IM_COL32(0, 0, 255, 128),
IM_COL32(255, 96, 96, 255),
IM_COL32(128, 128, 255, 255),
IM_COL32(255, 0, 255, 255),
IM_COL32(0, 128, 128, 255),
IM_COL32(0, 255, 0, 255),
};
static const std::array<ImU32, UIContext::Color::COUNT> dark{
IM_COL32(255, 255, 0, 128),
IM_COL32(255, 0, 0, 255),
IM_COL32(128, 128, 255, 255),
IM_COL32(255, 0, 255, 255),
IM_COL32(0, 255, 255, 255),
IM_COL32(0, 255, 0, 255),
};
if (styleName == "Light")
return light;
else if (styleName == "Dark")
return dark;
else
return classic;
}
void LoadStyle()
{
if (!reloadStyle)
return;
reloadStyle = false;
auto& io = ImGui::GetIO();
std::string stylePath = rootPath + "/style/";
glfwSetCursor(window, curWait);
io.Fonts->Clear();
//reload ImRAD UI first
StyleColors();
io.Fonts->AddFontFromFileTTF((stylePath + uiFontName).c_str(), uiFontSize);
static ImWchar icons_ranges[] = { ICON_MIN_FA, ICON_MAX_16_FA, 0 };
ImFontConfig cfg;
cfg.MergeMode = true;
//icons_config.PixelSnapH = true;
const float faSize = uiFontSize * 18.f / 20.f;
io.Fonts->AddFontFromFileTTF((stylePath + FONT_ICON_FILE_NAME_FAR).c_str(), faSize, &cfg, icons_ranges);
io.Fonts->AddFontFromFileTTF((stylePath + FONT_ICON_FILE_NAME_FAS).c_str(), faSize, &cfg, icons_ranges);
cfg.MergeMode = false;
strcpy(cfg.Name, "imrad.H1");
io.Fonts->AddFontFromFileTTF((stylePath + uiFontName).c_str(), uiFontSize * 1.5f, &cfg);
strcpy(cfg.Name, "imrad.H3");
io.Fonts->AddFontFromFileTTF((stylePath + uiFontName).c_str(), uiFontSize * 1.1f, &cfg);
strcpy(cfg.Name, "imrad.pg");
ctx.pgFont = io.Fonts->AddFontFromFileTTF((stylePath + pgFontName).c_str(), pgFontSize, &cfg);
strcpy(cfg.Name, "imrad.pgb");
ctx.pgbFont = io.Fonts->AddFontFromFileTTF((stylePath + pgbFontName).c_str(), pgFontSize, &cfg);
strcpy(cfg.Name, "imrad.explorer");
io.Fonts->AddFontFromFileTTF((stylePath + "Roboto-Regular.ttf").c_str(), uiFontSize, &cfg);
cfg.MergeMode = false;
strcpy(cfg.Name, "simhei");
ImFont *font = io.Fonts->AddFontFromFileTTF("c:/windows/fonts/simhei.ttf", 23.0f, &cfg, io.Fonts->GetGlyphRangesChineseFull());
IM_ASSERT(font != nullptr);
// io.FontDefault = font; // 设置默认字体，成功显示中文
//ImGui::PushFont(font);
ctx.defaultStyleFont = nullptr;
ctx.fontNames.clear();
stx::fill(ctx.colors, IM_COL32(0, 0, 0, 255));
ctx.style = ImGuiStyle();
if (activeTab >= 0)
{
std::string styleName = fileTabs[activeTab].styleName;
std::string defaultFont = stylePath + "Roboto-Regular.ttf";
if (styleName == "Classic")
{
ImGui::StyleColorsClassic(&ctx.style);
ctx.defaultStyleFont = io.Fonts->AddFontFromFileTTF(defaultFont.c_str(), uiFontSize);
ctx.defaultStyleFont->FallbackChar = '#';
ctx.fontNames = { "" };
ctx.colors = GetCtxColors(styleName);
}
else if (styleName == "Light")
{
ImGui::StyleColorsLight(&ctx.style);
ctx.defaultStyleFont = io.Fonts->AddFontFromFileTTF(defaultFont.c_str(), uiFontSize);
ctx.defaultStyleFont->FallbackChar = '#';
ctx.fontNames = { "" };
ctx.colors = GetCtxColors(styleName);
}
else if (styleName == "Dark")
{
ImGui::StyleColorsDark(&ctx.style);
ctx.defaultStyleFont = io.Fonts->AddFontFromFileTTF(defaultFont.c_str(), uiFontSize);
ctx.defaultStyleFont->FallbackChar = '#';
ctx.fontNames = { "" };
ctx.colors = GetCtxColors(styleName);
}
else
{
std::map<std::string, ImFont*> fontMap;
std::map<std::string, std::string> extra;
try {
auto it = stx::find_if(styleNames, [&](const auto& s) { return s.first == styleName; });
ImRad::LoadStyle(it->second, 1.f, &ctx.style, &fontMap, &extra);
ctx.defaultStyleFont = fontMap[""];
for (const auto& f : fontMap) {
ctx.fontNames.push_back(f.first);
}
for (const auto& ex : extra) {
if (ex.first.compare(0, 13, "imrad.colors."))
continue;
std::istringstream is(ex.second);
int r, g, b, a;
is >> r >> g >> b >> a;
auto clr = IM_COL32(r, g, b, a);
std::string key = ex.first.substr(13);
#define SET_CLR(a) if (key == #a) ctx.colors[UIContext::a] = clr;
SET_CLR(Selected);
SET_CLR(Hovered);
SET_CLR(Snap1);
SET_CLR(Snap2);
SET_CLR(Snap3);
SET_CLR(Snap4);
SET_CLR(Snap5);
#undef SET_CLR
}
}
catch (std::exception& e)
{
//can't OpenPopup here, there is no window parent
showError = e.what();
}
}
}
ImGui_ImplOpenGL3_DestroyFontsTexture();
ImGui_ImplOpenGL3_CreateFontsTexture();
}
void DoCloneStyle(const std::string& name)
{
auto FormatClr = [](ImU32 c) {
std::ostringstream os;
os << (c & 0xff) << " " <<
((c >> 8) & 0xff) << " " <<
((c >> 16) & 0xff) << " " <<
((c >> 24) & 0xff);
return os.str();
};
std::string from = fileTabs[activeTab].styleName;
std::string path = rootPath + "/style/" + name + ".ini";
try
{
if (from == "Classic" || from == "Dark" || from == "Light")
{
ImGuiStyle style;
if (from == "Dark")
ImGui::StyleColorsDark(&style);
else if (from == "Light")
ImGui::StyleColorsLight(&style);
else
ImGui::StyleColorsClassic(&style);
std::map<std::string, std::string> extra;
const auto& colors = GetCtxColors(from);
#define SET_CLR(a) extra[std::string("imrad.colors.") + #a] = FormatClr(colors[UIContext::Color::a]);
SET_CLR(Selected);
SET_CLR(Hovered);
SET_CLR(Snap1);
SET_CLR(Snap2);
SET_CLR(Snap3);
SET_CLR(Snap4);
SET_CLR(Snap5);
#undef SET_CLR
ImRad::SaveStyle(path, &style, extra);
}
else
{
fs::copy_file(u8path(rootPath + "/style/" + from + ".ini"), u8path(path), fs::copy_options::overwrite_existing);
}
fileTabs[activeTab].styleName = name;
if (!stx::count_if(styleNames, [&](const auto& s) { return s.first == name; }))
styleNames.push_back({ name, path });
messageBox.title = "Style saved";
messageBox.message = "New style was saved as '" + path + "'";
messageBox.buttons = ImRad::Ok;
messageBox.OpenPopup();
}
catch (std::exception& e)
{
messageBox.title = "error";
messageBox.message = e.what();
messageBox.buttons = ImRad::Ok;
messageBox.OpenPopup();
}
}
void CloneStyle()
{
inputName.title = "Clone Style";
inputName.hint = "Enter new style name";
inputName.OpenPopup([](ImRad::ModalResult mr)
{
std::string path = rootPath + "/style/" + inputName.name + ".ini";
if (fs::exists(u8string(path))) {
messageBox.title = "Confirmation";
messageBox.message = "Overwrite existing style?";
messageBox.buttons = ImRad::Yes | ImRad::No;
messageBox.OpenPopup([=](ImRad::ModalResult mr) {
if (mr == ImRad::Yes)
DoCloneStyle(inputName.name);
});
}
else
DoCloneStyle(inputName.name);
});
}
void DockspaceUI()
{
// We are using the ImGuiWindowFlags_NoDocking flag to make the parent window not dockable into,
// because it would be confusing to have two docking targets within each others.
ImGuiWindowFlags window_flags = /*ImGuiWindowFlags_MenuBar |*/ ImGuiWindowFlags_NoDocking;
ImGuiViewport* viewport = ImGui::GetMainViewport();
ImGui::SetNextWindowPos(viewport->Pos + ImVec2(0, TB_SIZE + 0));
ImGui::SetNextWindowSize(viewport->Size - ImVec2(0, TB_SIZE + 0));
ImGui::SetNextWindowViewport(viewport->ID);
ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
window_flags |= ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove;
window_flags |= ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoNavFocus;
window_flags |= ImGuiWindowFlags_NoBackground;
ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));
ImGui::Begin("DockSpace", nullptr, window_flags);
ImGui::PopStyleVar();
ImGui::PopStyleVar(2);
ImGuiID dockspace_id = ImGui::GetID("MyDockSpace");
ImGui::DockSpace(dockspace_id, ImVec2(0.0f, 0.0f), ImGuiDockNodeFlags_PassthruCentralNode | ImGuiDockNodeFlags_NoDockingOverCentralNode);
if (programState == Init)
{
ImGui::DockBuilderRemoveNode(dockspace_id); // clear any previous layout
ImGui::DockBuilderAddNode(dockspace_id, ImGuiDockNodeFlags_PassthruCentralNode | ImGuiDockNodeFlags_DockSpace);
ImGui::DockBuilderSetNodeSize(dockspace_id, viewport->Size);
ImGuiID dock_id_right = ImGui::DockBuilderSplitNode(dockspace_id, ImGuiDir_Right, 350.f / viewport->Size.x, nullptr, &dockspace_id);
ImGuiID dock_id_left = ImGui::DockBuilderSplitNode(dockspace_id, ImGuiDir_Left, 300.f / (viewport->Size.x - 350), nullptr, &dockspace_id);
ImGuiID dock_id_right1, dock_id_right2;
ImGui::DockBuilderSplitNode(dock_id_right, ImGuiDir_Up, 230.f / (viewport->Size.y - TB_SIZE), &dock_id_right1, &dock_id_right2);
float vh = viewport->Size.y - TB_SIZE;
ImGuiID dock_id_top = ImGui::DockBuilderSplitNode(dockspace_id, ImGuiDir_Up, TAB_SIZE / vh, nullptr, &dockspace_id);
ImGui::DockBuilderDockWindow("FileTabs", dock_id_top);
ImGui::DockBuilderDockWindow("Hierarchy", dock_id_left);
ImGui::DockBuilderDockWindow("Explorer", dock_id_left);
ImGui::DockBuilderDockWindow("Widgets", dock_id_right1);
ImGui::DockBuilderDockWindow("Properties", dock_id_right2);
ImGui::DockBuilderDockWindow("Events", dock_id_right2);
ImGui::DockBuilderFinish(dockspace_id);
}
ImGuiDockNode* cn = ImGui::DockBuilderGetCentralNode(dockspace_id);
ctx.designAreaMin = cn->Pos;
ctx.designAreaMax = cn->Pos + cn->Size;
if (fileTabs.empty())
{
std::pair<std::string, std::string> help[]{
{ "Create a New File", "Ctrl+N" },
{ "Open File", "Ctrl+O" }
};
float lh = 2 * ImGui::GetTextLineHeight();
for (size_t i = 0; i < std::size(help); ++i)
{
ImVec2 size = ImGui::CalcTextSize((help[i].first + help[i].second).c_str());
ImGui::SetCursorScreenPos({
viewport->WorkSize.x / 2.5f,
(viewport->WorkSize.y - (std::size(help) - 1) * lh) / 2 + i * lh
});
ImVec4 clr = ImGui::GetStyleColorVec4(ImGuiCol_Text);
clr.w = 0.75f;
ImGui::PushStyleColor(ImGuiCol_Text, clr);
ImGui::Selectable(help[i].first.c_str(), false, 0, { 150, 0 });
ImGui::PopStyleColor();
clr.w = 1.f;
ImGui::PushStyleColor(ImGuiCol_Text, clr);
for (size_t c = 0; c < help[i].second.size(); )
{
bool first = !c;
std::string sub;
size_t j = help[i].second.find('+', c);
if (j != std::string::npos) {
sub = help[i].second.substr(c, j - c);
c = j + 1;
}
else {
sub = help[i].second.substr(c);
c = j;
}
ImGui::SameLine(0, 0);
if (!first) {
ImGui::Text(" + ");
ImGui::SameLine(0, 0);
}
ImGui::Selectable(sub.c_str(), true, 0, { ImGui::CalcTextSize(sub.c_str()).x, 0 });
}
ImGui::PopStyleColor();
}
}
else
{
float sp = ImGui::GetStyle().ItemSpacing.x;
ImGui::SetCursorScreenPos({
ctx.designAreaMin.x + sp,
ctx.designAreaMax.y - ImGui::GetTextLineHeight() - sp
});
ImVec4 clr = ImGui::GetStyleColorVec4(ImGuiCol_Text);
clr.w = 0.5f;
ImGui::PushStyleColor(ImGuiCol_Text, clr);
ImGui::Text("Zoom: %d%%", (int)(ctx.zoomFactor * 100));
ImGui::PopStyleColor();
}
ImGui::End();
}
void ToolbarUI()
{
ImGuiViewport* viewport = ImGui::GetMainViewport();
ImGui::SetNextWindowPos(ImVec2(viewport->Pos.x, viewport->Pos.y + 0));
ImGui::SetNextWindowSize(ImVec2(viewport->Size.x, TB_SIZE));
ImGui::SetNextWindowViewport(viewport->ID);
ImGuiWindowFlags window_flags = 0
| ImGuiWindowFlags_NoDocking
| ImGuiWindowFlags_NoTitleBar
| ImGuiWindowFlags_NoResize
| ImGuiWindowFlags_NoMove
| ImGuiWindowFlags_NoScrollbar
| ImGuiWindowFlags_NoNavInputs
| ImGuiWindowFlags_NoSavedSettings
;
ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0);
ImGui::Begin("TOOLBAR", nullptr, window_flags);
ImGui::PopStyleVar();
const float BTN_SIZE = 30;
const auto& io = ImGui::GetIO();
if (ImGui::Button(ICON_FA_FILE " " ICON_FA_CARET_DOWN) ||
ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiKey_N, ImGuiInputFlags_RouteGlobal))
ImGui::OpenPopup("NewMenu");
if (ImGui::IsItemHovered(ImGuiHoveredFlags_DelayNormal))
ImGui::SetTooltip("New File (Ctrl+N)");
ImGui::SetNextWindowPos(ImGui::GetCursorPos());
ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, { 0, 10 });
if (ImGui::BeginPopup("NewMenu"))
{
if (ImGui::MenuItem(ICON_FA_TV " Main Window", "\tGLFW"))
NewFile(TopWindow::MainWindow);
if (ImGui::IsItemHovered(ImGuiHoveredFlags_DelayNormal))
ImGui::SetTooltip("ImGui window integrated into OS window (GLFW)");
if (ImGui::MenuItem(ICON_FA_WINDOW_MAXIMIZE " Window", ""))
NewFile(TopWindow::Window);
if (ImGui::IsItemHovered(ImGuiHoveredFlags_DelayNormal))
ImGui::SetTooltip("Floating ImGui window");
if (ImGui::MenuItem(ICON_FA_CLONE " Popup", ""))
NewFile(TopWindow::Popup);
if (ImGui::MenuItem(ICON_FA_WINDOW_RESTORE " Modal Popup", ""))
NewFile(TopWindow::ModalPopup);
if (ImGui::MenuItem(ICON_FA_MOBILE_SCREEN " Activity", "\tAndroid"))
NewFile(TopWindow::Activity);
ImGui::Separator();
if (ImGui::MenuItem(ICON_FA_FILE_PEN " main.cpp", "\tGLFW"))
NewTemplate(0);
if (ImGui::MenuItem(ICON_FA_FILE_PEN " main+java+manifest", "\tAndroid"))
NewTemplate(1);
ImGui::EndPopup();
}
ImGui::PopStyleVar();
ImGui::SameLine();
if (ImGui::Button(ICON_FA_FOLDER_OPEN) ||
ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiKey_O, ImGuiInputFlags_RouteGlobal))
OpenFile();
if (ImGui::IsItemHovered(ImGuiHoveredFlags_DelayNormal))
ImGui::SetTooltip("Open File (Ctrl+O)");
ImGui::BeginDisabled(activeTab < 0);
ImGui::SameLine();
float cx = ImGui::GetCursorPosX();
//ImGui::BeginDisabled(activeTab >= 0 && !fileTabs[activeTab].modified);
if (ImGui::Button(ICON_FA_FLOPPY_DISK) ||
ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiKey_S, ImGuiInputFlags_RouteGlobal))
SaveFile();
//ImGui::EndDisabled();
if (ImGui::IsItemHovered(ImGuiHoveredFlags_DelayNormal))
ImGui::SetTooltip("Save File (Ctrl+S)");
ImGui::SameLine(0, 0);
ImGui::SeparatorEx(ImGuiSeparatorFlags_Vertical);
ImGui::SameLine(0, 0);
ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, { 2, ImGui::GetStyle().FramePadding.y });
if (ImGui::Button(ICON_FA_CARET_DOWN))
ImGui::OpenPopup("SaveMenu");
ImGui::PopStyleVar();
ImGui::SetNextWindowPos({ cx, ImGui::GetCursorPosY() });
ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, { 0, 10 });
if (ImGui::BeginPopup("SaveMenu"))
{
if (ImGui::MenuItem("Save As..."))
SaveFileAs();
if (ImGui::MenuItem("Save All", "\tCtrl+Shift+S"))
SaveAll();
ImGui::EndPopup();
}
ImGui::PopStyleVar();
if (ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiMod_Shift | ImGuiKey_S, ImGuiInputFlags_RouteGlobal))
SaveAll();
ImGui::SameLine();
ImGui::SeparatorEx(ImGuiSeparatorFlags_Vertical);
ImGui::SameLine();
ImGui::Text("Style");
ImGui::SameLine();
ImGui::SetNextItemWidth(100);
styleName = "";
if (activeTab >= 0)
styleName = fileTabs[activeTab].styleName;
if (ImGui::BeginCombo("##style", styleName.c_str()))
{
for (size_t i = 0; i < styleNames.size(); ++i)
{
if (ImGui::Selectable(styleNames[i].first.c_str(), styleNames[i].first == styleName))
{
reloadStyle = true;
assert(activeTab >= 0);
fileTabs[activeTab].modified = true;
fileTabs[activeTab].styleName = styleNames[i].first;
}
if (i == 2 && i + 1 < styleNames.size())
ImGui::Separator();
}
ImGui::EndCombo();
}
ImGui::SameLine();
if (ImGui::Button(ICON_FA_CLONE))
CloneStyle();
if (ImGui::IsItemHovered(ImGuiHoveredFlags_DelayNormal))
ImGui::SetTooltip("Clone Style");
ImGui::SameLine();
ImGui::Text("Units");
ImGui::SameLine();
ImGui::SetNextItemWidth(100);
const std::string unit = activeTab >= 0 ? fileTabs[activeTab].unit : "";
std::array<const char*, 2> UNITS{ "px", /*"fs",*/ "dp" };
int usel = 0;
if (unit != "")
usel = (int)(stx::find(UNITS, unit) - UNITS.begin());
if (ImGui::Combo("##units", &usel, stx::join(UNITS, std::string_view("\0", 1)).c_str())) // "px\0fs\0dp\0"))
{
auto& tab = fileTabs[activeTab];
tab.unit = UNITS[usel];
tab.modified = true;
}
ImGui::SameLine();
ImGui::SeparatorEx(ImGuiSeparatorFlags_Vertical);
ImGui::SameLine();
ImGui::BeginDisabled(activeTab < 0);
if (ImGui::Button(ICON_FA_BOLT) || // ICON_FA_BOLT, ICON_FA_RIGHT_TO_BRACKET) ||
ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiKey_P, ImGuiInputFlags_RouteGlobal))
ShowCode();
if (ImGui::IsItemHovered(ImGuiHoveredFlags_DelayNormal))
ImGui::SetTooltip("Preview Code (Ctrl+P)");
ImGui::EndDisabled();
ImGui::SameLine();
if (ImGui::Button(ICON_FA_CUBES))
{
classWizard.codeGen = ctx.codeGen;
classWizard.root = fileTabs[activeTab].rootNode.get();
classWizard.modified = &fileTabs[activeTab].modified;
classWizard.OpenPopup();
}
if (ImGui::IsItemHovered(ImGuiHoveredFlags_DelayNormal))
ImGui::SetTooltip("Class Wizard");
ImGui::SameLine();
bool showHelper = activeTab >= 0 &&
ctx.selected.size() >= 1 &&
(ctx.selected[0]->Behavior() & UINode::SnapSides);
if (showHelper)
{
auto pinfo = ctx.root->FindChild(ctx.selected[0]);
if (!pinfo || (pinfo->first->Behavior() & UINode::SnapItemInterior))
showHelper = false;
}
ImGui::BeginDisabled(!showHelper);
if (ImGui::Button(ICON_FA_BORDER_NONE))
{
horizLayout.root = fileTabs[activeTab].rootNode.get();
HorizLayout::ExpandSelection(ctx.selected, horizLayout.root);
horizLayout.selected = ctx.selected;
horizLayout.ctx = &ctx;
horizLayout.OpenPopup();
}
ImGui::EndDisabled();
if (ImGui::IsItemHovered(ImGuiHoveredFlags_DelayNormal))
ImGui::SetTooltip("Table Layout Helper");
ImGui::SameLine();
ImGui::EndDisabled();
ImGui::SameLine();
ImGui::SeparatorEx(ImGuiSeparatorFlags_Vertical);
ImGui::SameLine();
if (ImGui::Button(ICON_FA_GEAR))
{
std::vector<std::string> fontNames;
for (const auto& entry : fs::directory_iterator(u8path(rootPath + "/style/")))
{
if (entry.is_regular_file() && entry.path().extension() == ".ttf")
fontNames.push_back(u8string(entry.path().stem()));
}
settingsDlg.fontNames = std::move(fontNames);
settingsDlg.uiFontName = uiFontName.substr(0, uiFontName.size() - 4);
settingsDlg.uiFontSize = std::to_string((int)uiFontSize);
settingsDlg.pgFontName = pgFontName.substr(0, pgFontName.size() - 4);
settingsDlg.pgbFontName = pgbFontName.substr(0, pgbFontName.size() - 4);
settingsDlg.pgFontSize = std::to_string((int)pgFontSize);
settingsDlg.OpenPopup([](ImRad::ModalResult)
{
uiFontName = settingsDlg.uiFontName + ".ttf";
uiFontSize = std::stof(settingsDlg.uiFontSize);
pgFontName = settingsDlg.pgFontName + ".ttf";
pgbFontName = settingsDlg.pgbFontName + ".ttf";
pgFontSize = std::stof(settingsDlg.pgFontSize);
ImGui::SaveIniSettingsToDisk(ImGui::GetIO().IniFilename);
reloadStyle = true;
});
}
ImGui::SameLine();
float defHeight = ImGui::GetFrameHeightWithSpacing();
ImGui::Dummy(ImGui::CalcItemSize({ -defHeight, 1 }, 0, 0));
ImGui::SameLine();
if (ImGui::Button(ICON_FA_CIRCLE_INFO))
{
aboutDlg.OpenPopup();
}
ImGui::End();
float sp = ImGui::GetStyle().ItemSpacing.x;
ImGui::SetNextWindowPos({ viewport->Size.x - 520, 100 }, ImGuiCond_FirstUseEver);
ImGui::SetNextWindowSize({ 140, 260 }, ImGuiCond_FirstUseEver);
ImGui::Begin("Widgets", nullptr, ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoScrollbar);
int n = (int)std::max(1.f, ImGui::GetContentRegionAvail().x / (BTN_SIZE + sp));
ImGui::PushStyleVar(ImGuiStyleVar_SelectableTextAlign, { 0.5f, 0.5f });
for (const auto& cat : tbButtons)
{
ImGui::SetNextItemOpen(true, ImGuiCond_Appearing);
if (ImGui::CollapsingHeader(cat.first.c_str()))
{
int rows = (stx::ssize(cat.second) + n - 1) / n;
float h = rows * BTN_SIZE + (rows - 1) * 5;
ImGui::BeginChild(("cat" + cat.first).c_str(), { 0, h }, ImGuiChildFlags_NavFlattened, 0);
ImGui::Columns(n, nullptr, false);
for (const auto& tb : cat.second)
{
if (ImGui::Selectable(tb.label.c_str(), activeButton == tb.name, 0, ImVec2(BTN_SIZE, BTN_SIZE)))
NewWidget(tb.name);
if (ImGui::IsItemHovered(ImGuiHoveredFlags_DelayNormal) && tb.name != "")
ImGui::SetTooltip("%s", tb.name.c_str());
ImGui::NextColumn();
}
ImGui::EndChild();
}
}
ImGui::PopStyleVar();
ImGui::End();
}
void TabsUI()
{
ImGuiWindowFlags window_flags = 0
//| ImGuiWindowFlags_NoDocking
| ImGuiWindowFlags_NoTitleBar
| ImGuiWindowFlags_NoResize
| ImGuiWindowFlags_NoCollapse
| ImGuiWindowFlags_NoMove
| ImGuiWindowFlags_NoScrollbar
//| ImGuiWindowFlags_NoSavedSettings
;
ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(4, 0.0f));
ImGuiWindowClass window_class;
window_class.DockNodeFlagsOverrideSet = ImGuiDockNodeFlags_NoTabBar | ImGuiDockNodeFlags_NoResize;
ImGui::SetNextWindowClass(&window_class);
ImGui::Begin("FileTabs", 0, window_flags);
if (ImGui::BeginTabBar(".Tabs", ImGuiTabBarFlags_NoTabListScrollingButtons | ImGuiTabBarFlags_Reorderable))
{
ImGui::PopStyleVar();
int untitled = 0;
for (int i = 0; i < (int)fileTabs.size(); ++i)
{
ImGui::PushID(i);
const auto& tab = fileTabs[i];
std::string fname = u8string(u8path(tab.fname).filename());
if (fname == "")
fname = UNTITLED + std::to_string(++untitled);
if (tab.modified)
fname += " *";
bool notClosed = true;
if (ImGui::BeginTabItem(fname.c_str(), &notClosed, i == activeTab ? ImGuiTabItemFlags_SetSelected : 0))
ImGui::EndTabItem();
if (ImGui::IsItemHovered(ImGuiHoveredFlags_DelayNormal) && tab.fname != "")
ImGui::SetTooltip("%s", tab.fname.c_str());
std::string popupId = "TabPopup" + std::to_string(i);
ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, { 0, 10 });
if (ImGui::BeginPopup(popupId.c_str()))
{
/*if (ImGui::MenuItem("Save", "Ctrl+S"))
{
ActivateTab(i);
SaveFile();
}*/
if (ImGui::MenuItem("Close", "Ctrl+F4"))
{
ActivateTab(i);
CloseFile();
}
if (ImGui::MenuItem("Close All"))
CloseFile(CLOSE_ALL);
if (ImGui::MenuItem("Close All But This") && fileTabs.size() >= 2) {
ActivateTab(i + 1 == fileTabs.size() ? 0 : i + 1); //cycle from beginning
CloseFile(CLOSE_ALL_BUT_PREVIOUS);
}
ImGui::Separator();
if (ImGui::MenuItem("Copy Full Path"))
ImGui::SetClipboardText(("\"" + tab.fname + "\"").c_str());
if (ImGui::MenuItem("Open Containing Folder"))
ShellExec(u8string(u8path(tab.fname).parent_path()));
ImGui::EndPopup();
}
ImGui::PopStyleVar();
if (!notClosed ||
(i == activeTab && ImGui::Shortcut(ImGuiKey_F4 | ImGuiMod_Ctrl, ImGuiInputFlags_RouteGlobal))) //ImGui::IsKeyPressed(ImGuiKey_F4, false) && ImGui::GetIO().KeyCtrl))
{
ActivateTab(i);
CloseFile();
}
else if (ImGui::IsItemActivated() && i != activeTab)
{
ActivateTab(i);
}
else if (ImRad::IsItemContextMenuClicked())
{
ActivateTab(i);
ImGui::OpenPopup(popupId.c_str());
}
ImGui::PopID();
}
ImGui::EndTabBar();
}
else
ImGui::PopStyleVar();
ImGui::End();
}
void HierarchyUI()
{
//ImGui::PushFont(ctx.defaultFont); icons are FA
ImGui::PushStyleVarX(ImGuiStyleVar_WindowPadding, 0);
ImGui::Begin("Hierarchy");
if (activeTab >= 0 && fileTabs[activeTab].rootNode)
fileTabs[activeTab].rootNode->TreeUI(ctx);
ImGui::End();
ImGui::PopStyleVar();
}
void ExplorerUI(TextEditor* editor)
{
ExplorerUI(*ctx.codeGen, [&editor](const std::string& fpath) {
auto m5 = QuickDigest5::fileToHash(fpath);
auto [pth_img, pth_json] = get_img_json_pth(m5);
if (!std::filesystem::exists(pth_json)) {
// 文件不存在，调用 wechat ocr 识别
std::string result = rec(fpath.c_str());
std::string b64_str = base64_encode(fpath);
std::ofstream f_json(pth_json, std::ios::out | std::ios::binary);
f_json.write(result.c_str(), result.size());
f_json.close();
std::ofstream f_b64(pth_img, std::ios::out | std::ios::binary);
f_b64.write(b64_str.c_str(), b64_str.size());
f_b64.close();
json jsn = json::parse(result);
std::string jsn_str = jsn.dump(4);
if (!std::filesystem::exists(pth_json) || !std::filesystem::exists(pth_img)) {
return 1;
}
}
std::ifstream f(pth_json);
if (!f.is_open()) {
return 1;
}
json jsn = json::parse(f);
editor->SetText(jsn, m5);
//DoOpenFile(fpath);
});
}
bool BeginPropGroup(const std::string& cat, bool forceOpen, bool& forceSameRow)
{
bool topLevel = cat.find('.') == std::string::npos;
forceSameRow = !topLevel;
ImVec2 pad = ImGui::GetStyle().FramePadding;
ImGui::TableNextRow();
ImGui::TableSetColumnIndex(0);
ImGui::AlignTextToFramePadding();
ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, { 0.0f, pad.y });
ImGui::PushFont(topLevel ? ctx.pgbFont : ctx.pgFont);
int flags = ImGuiTreeNodeFlags_SpanAllColumns /*| ImGuiTreeNodeFlags_NoNavFocus*/;
std::string str;
if (topLevel)
{
ImGui::TableSetBgColor(ImGuiTableBgTarget_RowBg0,
ImGui::ColorConvertFloat4ToU32(ImGui::GetStyleColorVec4(ImGuiCol_TableBorderLight)));
str = std::string(1, std::toupper(cat[0])) + cat.substr(1);
if (str != "Appearance" & str != "Common")
flags |= ImGuiTreeNodeFlags_DefaultOpen;
}
else
{
size_t i1 = cat.rfind('.');
if (i1 == std::string::npos || i1 + 1 == cat.size())
str = cat;
else
str = cat.substr(i1 + 1);
}
if (!topLevel)
ImGui::Unindent();
ImGui::SetNextItemAllowOverlap();
if (forceOpen)
ImGui::SetNextItemOpen(true);
//see https://github.com/ocornut/imgui/issues/8551
//ImGui::PushItemFlag(ImGuiItemFlags_NoNav, true);
bool open;
if (!forceSameRow)
open = ImGui::TreeNodeEx(str.c_str(), flags);
else {
open = ImGui::TreeNodeEx(("###TreeNode." + cat).c_str(), flags);
ImGui::SameLine(0, 0);
}
//ImGui::PopItemFlag();
if (!topLevel && !forceSameRow)
ImGui::Indent();
ImGui::PopFont();
ImGui::PopStyleVar();
if (!open && !forceSameRow)
ImGui::TableNextColumn();
return open;
}
void EndPropGroup(const std::string& cat, bool open)
{
bool topLevel = cat.find('.') == std::string::npos;
if (open)
ImGui::TreePop();
}
std::vector<std::string_view> GetCat(std::string_view pname)
{
std::vector<std::string_view> cat;
size_t i1 = 0;
while (1) {
size_t i2 = pname.find_first_of(".#", i1);
if (i2 == std::string::npos || pname[i2] == '#')
break;
cat.push_back(pname.substr(i1, i2 - i1));
i1 = i2 + 1;
}
return cat;
}
void PropertyRowsUI(bool pr)
{
int keyPressed = 0;
if (addInputCharacter)
{
//select all text when activating
auto* g = ImGui::GetCurrentContext();
g->NavNextActivateFlags &= ~ImGuiActivateFlags_TryToPreserveState;
g->NavActivateFlags &= ~ImGuiActivateFlags_TryToPreserveState;
//and send a character to overwrite it
ImGui::GetIO().AddInputCharacter(addInputCharacter);
addInputCharacter = 0;
}
//detect keypress when Input is inactive
if (!ImGui::GetIO().WantTextInput &&
!(ImGui::GetIO().KeyMods & ~ImGuiMod_Shift) &&
!ImGui::GetTopMostPopupModal()) //TopMostAndVisible doesn't work with ClassWizard open??
{
for (int key = ImGuiKey_A; key <= ImGuiKey_Z; ++key)
if (ImGui::IsKeyPressed((ImGuiKey)key)) {
keyPressed = key - ImGuiKey_A + (ImGui::GetIO().KeyShift ? 'A' : 'a');
break;
}
for (int key = ImGuiKey_Keypad0; key <= ImGuiKey_Keypad9; ++key)
if (ImGui::IsKeyPressed((ImGuiKey)key)) {
keyPressed = key - ImGuiKey_Keypad0 + '0';
break;
}
if (ImGui::IsKeyPressed(ImGuiKey_KeypadSubtract))
keyPressed = '-';
if (ImGui::IsKeyPressed(ImGuiKey_KeypadDecimal))
keyPressed = '.';
}
//header
/*if (pr)
{
std::string header;
if (ctx.selected.size() == 1)
header = ctx.selected[0]->GetTypeName();
else
header = std::to_string(ctx.selected.size()) + " selected";
ImGui::PushStyleColor(ImGuiCol_ChildBg, 0xffeafafa); // ImGui::GetStyleColorVec4(ImGuiCol_TabUnfocusedActive)); // 0xffc0c0c0);
ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, { 10, 4 });
if (ImGui::BeginChild("##typeChld", { -1, 0 }, ImGuiChildFlags_AlwaysAutoResize | ImGuiChildFlags_AutoResizeY | ImGuiChildFlags_AlwaysUseWindowPadding, 0)) {
ImGui::Text("%s", header.c_str());
ImGui::EndChild();
}
ImGui::PopStyleVar();
ImGui::PopStyleColor();
ImGui::SetCursorPosY(ImGui::GetCursorPosY() - ImGui::GetStyle().ItemSpacing.y);
}*/
//clear bg
ImVec2 pgMin = ImGui::GetCursorScreenPos();
ImGui::GetWindowDrawList()->AddRectFilled(
{ pgMin.x + ImGui::GetStyle().IndentSpacing + 1, pgMin.y },
ImGui::GetCurrentWindow()->InnerRect.Max,
0xfffafafa
);
ImGui::GetWindowDrawList()->AddRectFilled(
{ pgMin.x, pgMin.y + (pr ? pgHeight : pgeHeight) },
{ pgMin.x + ImGui::GetStyle().IndentSpacing + 1, ImGui::GetCurrentWindow()->InnerRect.Max.y },
0xfffafafa
);
ImGui::PushItemFlag(ImGuiItemFlags_NoNav, true); //ImGuiChildFlags_NavFlattened emulation
ImGuiTableFlags flags = ImGuiTableFlags_BordersOuter | ImGuiTableFlags_BordersInnerH | ImGuiTableFlags_Resizable | ImGuiTableFlags_ScrollY;
if (ImGui::BeginTable(pr ? "pg" : "pge", 2, flags))
{
ImGui::TableSetupColumn("name", ImGuiTableColumnFlags_WidthStretch);
ImGui::TableSetupColumn("value", ImGuiTableColumnFlags_WidthStretch);
ImGui::PushItemFlag(ImGuiItemFlags_NoNav, false); //Pop+Push doesn't work here
//find parents for widget::PropertyUI and BindingButton
if (ctx.selected.size() && ctx.root) {
UINode* cur = ctx.selected[0];
ctx.parents = { cur };
while (auto pinfo = ctx.root->FindChild(cur)) {
cur = pinfo->first;
ctx.parents.insert(ctx.parents.begin(), cur);
}
}
//determine common properties for a selection set
//todo: remember to clear out differing values
//todo: combine enabled state
std::vector<std::string_view> pnames;
for (auto* node : ctx.selected)
{
std::vector<std::string_view> pn;
auto props = pr ? node->Properties() : node->Events();
for (auto& p : props) {
if (ctx.selected.size() == 1 ||
(p.name.size() > 3 && p.name.compare(p.name.size() - 3, 3, "##1")))
{
pn.push_back(p.name);
}
}
stx::sort(pn);
if (node == ctx.selected[0])
pnames = std::move(pn);
else {
std::vector<std::string_view> pres;
stx::set_intersection(pnames, pn, std::back_inserter(pres));
pnames = std::move(pres);
}
}
std::vector<std::string_view> forceCatOpen;
if (pr && keyPressed)
{
if (stx::count(pnames, lastPropName))
forceCatOpen = GetCat(lastPropName);
}
ImGui::PushFont(ctx.pgFont);
ImVec2 framePad = ImGui::GetStyle().FramePadding;
ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, { framePad.x * 0.5f, framePad.y * 0.5f });
//when selecting other widget of same kind from Tree, value from previous widget
//wants to be sent to the new widget because input IDs are the same
//PushID widget ptr to prevent it
//We PopID/PushID before a category treeNode to keep them open/close across all widgets
//having same property
ImGui::PushID(ctx.selected[0]);
//edit first widget
auto props = pr ? ctx.selected[0]->Properties() : ctx.selected[0]->Events();
std::string pval;
std::vector<std::string_view> lastCat;
std::vector<bool> catOpen;
for (int i = 0; i < (int)props.size(); ++i)
{
const auto& prop = props[i];
if (!stx::count(pnames, prop.name))
continue;
std::vector<std::string_view> cat = GetCat(prop.name);
bool forceSameRow = false;
if (cat != lastCat)
{
while (lastCat.size() &&
(lastCat.size() > cat.size() ||
!std::equal(lastCat.begin(), lastCat.end(), cat.begin(), cat.begin() + lastCat.size())))
{
EndPropGroup(stx::join(lastCat, "."), catOpen.back());
lastCat.pop_back();
catOpen.pop_back();
}
bool forceOpen = cat.size() <= forceCatOpen.size() &&
std::equal(cat.begin(), cat.end(), forceCatOpen.begin(), forceCatOpen.begin() + cat.size());
while (lastCat.size() < cat.size())
{
lastCat.push_back(cat[lastCat.size()]);
bool open = false;
if (!stx::count(catOpen, false))
{
ImGui::PopID();
open = BeginPropGroup(stx::join(lastCat, "."), forceOpen, forceSameRow);
ImGui::PushID(ctx.selected[0]);
}
catOpen.push_back(open);
}
}
if (lastCat.size() && stx::count(catOpen, false) && !forceSameRow)
continue;
if (keyPressed && props[i].name == lastPropName) {
//todo: don't if property is disabled
addInputCharacter = keyPressed;
ImGui::SetKeyboardFocusHere();
}
if (!forceSameRow) {
ImGui::TableNextRow();
ImGui::TableSetColumnIndex(0);
ImGui::AlignTextToFramePadding();
}
bool change = pr ? ctx.selected[0]->PropertyUI(i, ctx) : ctx.selected[0]->EventUI(i, ctx);
if (change) {
fileTabs[activeTab].modified = true;
if (props[i].property) {
lastPropName = props[i].name; //todo: set lastPropName upon input focus as well
pval = props[i].property->to_arg();
}
}
if (forceSameRow) {
ImGui::TableSetColumnIndex(0);
ImGui::Indent();
ImGui::TableNextColumn();
}
}
while (lastCat.size())
{
EndPropGroup(stx::join(lastCat, "."), catOpen.back());
lastCat.pop_back();
catOpen.pop_back();
}
ImGui::PopItemFlag();
ImGui::PopID();
ImGui::PopFont();
ImGui::PopStyleVar();
ImGui::EndTable();
if (pr)
pgHeight = ImGui::GetItemRectSize().y;
else
pgeHeight = ImGui::GetItemRectSize().y;
if (props.empty()) {
ImGui::Spacing();
ImGui::Indent();
ImGui::TextDisabled("%s", "Not available");
}
//copy changes to other widgets
for (size_t i = 1; i < ctx.selected.size(); ++i)
{
auto props = pr ? ctx.selected[i]->Properties() : ctx.selected[i]->Events();
for (auto& p : props)
{
if (p.name == lastPropName) {
auto prop = const_cast<property_base*>(p.property);
prop->set_from_arg(pval);
}
}
}
}
ImGui::PopItemFlag();
}
void PropertyUI()
{
ImGui::PushStyleColor(ImGuiCol_TableBorderLight, 0xffe5e5e5);
ImGui::PushStyleColor(ImGuiCol_TableBorderStrong, 0xfffafafa);
ImVec4 clr = ImGui::GetStyleColorVec4(ImGuiCol_Button);
clr.w *= 0.5f;
ImGui::PushStyleColor(ImGuiCol_Button, clr);
ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, { 0, 0 });
ImGui::Begin("Events");
if (!ctx.selected.empty())
{
PropertyRowsUI(0);
}
ImGui::End();
ImGui::Begin("Properties");
if (!ctx.selected.empty())
{
PropertyRowsUI(1);
}
ImGui::End();
ImGui::PopStyleVar();
ImGui::PopStyleColor(3);
}
void PopupUI()
{
newFieldPopup.Draw();
tableCols.Draw();
comboDlg.Draw();
messageBox.Draw();
errorBox.Draw();
classWizard.Draw();
settingsDlg.Draw();
aboutDlg.Draw();
bindingDlg.Draw();
horizLayout.Draw();
inputName.Draw();
}
void Draw()
{
if (activeTab < 0 || !fileTabs[activeTab].rootNode)
return;
if (reloadStyle) //eliminates flicker
return;
auto& tab = fileTabs[activeTab];
auto tmpStyle = ImGui::GetStyle();
ImGui::GetStyle() = ctx.style;
ImGui::GetStyle().Colors[ImGuiCol_TitleBg] = ImGui::GetStyle().Colors[ImGuiCol_TitleBgActive];
ImGui::GetStyle().ScaleAllSizes(ctx.zoomFactor);
ImGui::PushFont(ctx.defaultStyleFont);
ctx.appStyle = &tmpStyle;
ctx.workingDir = u8string(u8path(tab.fname).parent_path());
ctx.unit = tab.unit;
ctx.modified = &tab.modified;
tab.rootNode->Draw(ctx);
if (ctx.isAutoSize && ctx.layoutHash != ctx.prevLayoutHash)
{
ctx.root->ResetLayout();
if (ctx.rootWin)
ctx.rootWin->HiddenFramesCannotSkipItems = 2; //flicker removal
}
ImGui::PopFont();
ImGui::GetStyle() = tmpStyle;
}
std::vector<UINode*> SortSelection(const std::vector<UINode*>& sel)
{
auto& tab = fileTabs[activeTab];
std::vector<UINode*> allNodes = tab.rootNode->GetAllChildren();
std::vector<UINode*> children;
for (UINode* node : sel)
{
if (node == tab.rootNode.get())
continue;
auto it = stx::find(allNodes, node);
if (it == allNodes.end())
continue;
auto ch = node->GetAllChildren();
assert(ch.size() && ch[0] == node);
children.insert(children.end(), ch.begin() + 1, ch.end());
}
std::vector<std::pair<int, UINode*>> sortedSel;
for (UINode* node : sel)
{
if (node == tab.rootNode.get())
continue;
auto it = stx::find(allNodes, node);
if (it == allNodes.end() || stx::find(children, node) != children.end())
continue;
sortedSel.push_back({ int(it - allNodes.begin()), node });
auto ch = node->GetAllChildren();
children.insert(children.end(), ch.begin(), ch.end());
}
stx::sort(sortedSel);
allNodes.clear();
for (const auto& sel : sortedSel)
allNodes.push_back(sel.second);
return allNodes;
}
//discarding result will delete widgets permanently
std::vector<std::unique_ptr<Widget>>
RemoveSelected()
{
auto& tab = fileTabs[activeTab];
std::vector<UINode*> sortedSel = SortSelection(ctx.selected);
if (sortedSel.empty())
return {};
std::vector<std::unique_ptr<Widget>> remove;
tab.modified = true;
auto pi1 = tab.rootNode->FindChild(sortedSel[0]);
for (UINode* node : sortedSel)
{
auto pi = tab.rootNode->FindChild(node);
UINode* parent = pi->first;
remove.push_back(std::move(parent->children[pi->second]));
parent->children.erase(parent->children.begin() + pi->second);
if (pi->second < parent->children.size() &&
!stx::count(ctx.selected, parent->children[pi->second].get()) &&
(parent->children[pi->second]->Behavior() & UINode::SnapSides))
{
Widget* child = dynamic_cast<Widget*>(remove.back().get());
Widget* next = dynamic_cast<Widget*>(parent->children[pi->second].get());
if (!child->sameLine && !next->nextColumn) {
next->sameLine = false;
next->spacing = child->spacing;
next->indent = child->indent;
}
next->nextColumn += child->nextColumn;
}
}
//move selection. Useful for things like menu items
if (sortedSel.size() == 1 && pi1)
{
UINode* parent1 = pi1->first;
if (pi1->second < parent1->children.size())
ctx.selected = { parent1->children[pi1->second].get() };
else if (pi1->second)
ctx.selected = { parent1->children[pi1->second - 1].get() };
else
ctx.selected = { parent1 };
}
else
{
ctx.selected.clear();
}
return remove;
}
void Work()
{
if (ImGui::GetTopMostAndVisiblePopupModal())
return;
if (initErrors != "")
{
errorBox.title = "Startup";
errorBox.message = "Errors occured";
errorBox.error = initErrors;
errorBox.OpenPopup();
initErrors = "";
}
else if (showError != "")
{
messageBox.title = "Error";
messageBox.message = showError;
messageBox.buttons = ImRad::Ok;
messageBox.OpenPopup();
showError = "";
}
if (programState == Shutdown)
{
CloseFile();
}
if (ctx.mode == UIContext::PickPoint)
{
ImGui::SetMouseCursor(ImGuiMouseCursor_Hand);
glfwSetCursor(window, curCross);
if (ImGui::IsKeyPressed(ImGuiKey_Escape))
{
ctx.mode = UIContext::NormalSelection;
activeButton = "";
}
else if (!ImGui::GetIO().KeyCtrl)
{
ctx.mode = UIContext::SnapInsert;
}
else if (ImGui::IsMouseReleased(ImGuiMouseButton_Left) &&
ctx.snapParent)
{
if (activeButton == "") {
newNode = std::move(clipboard.back());
clipboard.pop_back();
}
newNode->hasPos = 0;
ImVec2 pos = ImGui::GetMousePos() - ctx.snapParent->cached_pos;
if (pos.x < ctx.snapParent->cached_size.x / 2) {
newNode->hasPos |= ImRad::AlignLeft;
newNode->pos_x = pos.x / ctx.zoomFactor;
}
else {
newNode->hasPos |= ImRad::AlignRight;
newNode->pos_x = (pos.x - ctx.snapParent->cached_size.x) / ctx.zoomFactor;
}
if (pos.y < ctx.snapParent->cached_size.y / 2) {
newNode->hasPos |= ImRad::AlignTop;
newNode->pos_y = pos.y / ctx.zoomFactor;
}
else {
newNode->hasPos |= ImRad::AlignBottom;
newNode->pos_y = (pos.y - ctx.snapParent->cached_size.y) / ctx.zoomFactor;
}
ctx.selected = { newNode.get() };
ctx.snapParent->children.push_back(std::move(newNode));
ctx.mode = UIContext::NormalSelection;
if (activeButton == "") {
//push pasted widget copy to clipboard (vars may change)
auto clone = ctx.snapParent->children.back()->Clone(ctx);
clipboard.push_back(std::move(clone));
}
activeButton = "";
fileTabs[activeTab].modified = true;
ImGui::GetIO().MouseReleased[ImGuiMouseButton_Left] = false; //eat event
}
}
else if (ctx.mode == UIContext::SnapInsert || ctx.mode == UIContext::SnapMove)
{
if (ImGui::IsKeyPressed(ImGuiKey_Escape))
{
ctx.mode = UIContext::NormalSelection;
activeButton = "";
}
else if (ctx.mode == UIContext::SnapInsert && //todo: SnapMove
ImGui::GetIO().KeyCtrl &&
(activeButton == "" || (newNode->Behavior() & UINode::SnapSides)))
{
ctx.mode = UIContext::PickPoint;
}
else if (ImGui::IsMouseReleased(ImGuiMouseButton_Left)) //MouseReleased to avoid confusing RectSelection
{
if (!ctx.snapParent && ctx.mode == UIContext::SnapMove)
{
ctx.mode = UIContext::NormalSelection;
ImGui::GetIO().MouseReleased[ImGuiMouseButton_Left] = false; //eat event
return;
}
else if (!ctx.snapParent)
{
return;
}
int n;
std::unique_ptr<Widget>* newNodes;
std::vector<std::unique_ptr<Widget>> tmpMoved;
if (ctx.mode == UIContext::SnapMove)
{
assert(ctx.selected.size() == 1);
auto pinfo = fileTabs[activeTab].rootNode->FindChild(ctx.selected[0]);
auto chinfo = ctx.selected[0]->FindChild(ctx.snapParent);
if (chinfo) {
//disallow moving into its child
ctx.mode = UIContext::NormalSelection;
ImGui::GetIO().MouseReleased[ImGuiMouseButton_Left] = false; //eat event
return;
}
if (pinfo->first == ctx.snapParent && ctx.snapIndex > pinfo->second) {
//compensate removeSelected operation
--ctx.snapIndex;
}
tmpMoved = RemoveSelected();
n = (int)tmpMoved.size();
newNodes = tmpMoved.data();
}
else if (activeButton != "")
{
n = 1;
newNodes = &newNode;
}
else
{
n = (int)clipboard.size();
newNodes = clipboard.data();
}
if (n)
{
bool firstItem = true;
for (size_t i = 0; i < ctx.snapIndex; ++i)
{
auto* ch = ctx.snapParent->children[i].get();
if (!ch->hasPos && (ch->Behavior() & UINode::SnapSides))
firstItem = false;
}
newNodes[0]->sameLine = ctx.snapSameLine;
newNodes[0]->spacing = firstItem ? 0 : 1;
newNodes[0]->nextColumn = ctx.snapNextColumn;
//reset hasPos, nextColumn
for (size_t i = 0; i < n; ++i)
{
newNodes[i]->hasPos = ImRad::AlignNone;
}
if (ctx.snapParent->ColumnCount(ctx) <= 1)
{
for (size_t i = 1; i < n; ++i)
newNodes[i]->nextColumn = 0;
}
}
if (ctx.snapIndex < ctx.snapParent->children.size())
{
auto& next = ctx.snapParent->children[ctx.snapIndex];
if (ctx.snapUseNextSpacing) {
newNodes[0]->nextColumn = next->nextColumn;
newNodes[0]->spacing = next->spacing;
newNodes[0]->indent = next->indent;
next->nextColumn = 0;
next->spacing = 1;
next->indent = 0;
}
if (ctx.snapSetNextSameLine) {
next->sameLine = true;
}
if (next->sameLine)
next->indent = 0; //otherwise creates widgets overlaps
}
ctx.selected.clear();
if (ctx.mode == UIContext::SnapMove || activeButton != "")
{
ctx.selected.push_back(newNodes[0].get());
ctx.snapParent->children.insert(ctx.snapParent->children.begin() + ctx.snapIndex, std::move(newNodes[0]));
}
else
{
for (int i = 0; i < n; ++i)
{
//paste original widgets and push cloned widgets back to the clipboard
//so original variables will be used in a pasted widget
auto wdg = newNodes[i]->Clone(ctx);
ctx.selected.push_back(newNodes[i].get());
ctx.snapParent->children.insert(ctx.snapParent->children.begin() + ctx.snapIndex + i, std::move(newNodes[i]));
newNodes[i] = std::move(wdg);
}
}
ctx.mode = UIContext::NormalSelection;
activeButton = "";
fileTabs[activeTab].modified = true;
ImGui::GetIO().MouseReleased[ImGuiMouseButton_Left] = false; //eat event
}
}
else
{
if (ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiKey_KeypadAdd, ImGuiInputFlags_RouteGlobal | ImGuiInputFlags_Repeat) ||
ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiKey_Equal, ImGuiInputFlags_RouteGlobal | ImGuiInputFlags_Repeat))
{
if (ctx.zoomFactor < 2)
ctx.zoomFactor *= 1.2f;
}
if (ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiKey_KeypadSubtract, ImGuiInputFlags_RouteGlobal | ImGuiInputFlags_Repeat) ||
ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiKey_Minus, ImGuiInputFlags_RouteGlobal | ImGuiInputFlags_Repeat))
{
if (ctx.zoomFactor > 0.5)
ctx.zoomFactor /= 1.2f;
}
if (!ImGui::GetIO().WantTextInput)
{
if (ImGui::IsKeyPressed(ImGuiKey_Delete))
{
RemoveSelected();
}
if (ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiKey_C, ImGuiInputFlags_RouteGlobal) &&
!ctx.selected.empty() &&
ctx.selected[0] != fileTabs[activeTab].rootNode.get())
{
clipboard.clear();
bool tmp = ctx.createVars;
ctx.createVars = false;
auto sortedSel = SortSelection(ctx.selected);
for (UINode* node : sortedSel)
{
auto* wdg = dynamic_cast<Widget*>(node);
clipboard.push_back(wdg->Clone(ctx));
}
ctx.createVars = tmp;
}
if (ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiKey_X, ImGuiInputFlags_RouteGlobal) &&
!ctx.selected.empty() &&
ctx.selected[0] != fileTabs[activeTab].rootNode.get())
{
clipboard = RemoveSelected();
}
if (ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiKey_V, ImGuiInputFlags_RouteGlobal) &&
clipboard.size())
{
activeButton = "";
ctx.mode = UIContext::SnapInsert;
ctx.selected = {};
}
if (ImGui::Shortcut(ImGuiMod_Alt | ImGuiKey_LeftArrow, ImGuiInputFlags_RouteGlobal) &&
ctx.selected.size() == 1 &&
(ctx.selected[0]->Behavior() & UINode::SnapSides))
{
auto pos = ctx.root->FindChild(ctx.selected[0]);
if (!pos)
return;
UINode* parent = pos->first;
auto* child = parent->children[pos->second].get();
auto* left = pos->second ? parent->children[pos->second - 1].get() : nullptr;
auto* right = pos->second + 1 < parent->children.size() ? parent->children[pos->second + 1].get() : nullptr;
int ncols = parent->ColumnCount(ctx);
int col = 0;
if (ncols >= 2) {
for (size_t j = 0; j <= pos->second; ++j)
col = (col + parent->children[j]->nextColumn) % ncols;
}
if (left && (left->Behavior() & UINode::SnapSides))
{
if (ncols >= 2 && child->nextColumn) {
--child->nextColumn;
if (right) {
++right->nextColumn;
right->sameLine = false;
right->spacing = child->spacing;
}
if (!child->nextColumn) {
child->sameLine = false;
child->spacing = 1;
}
}
else if (!child->sameLine) { //move to the end of previous row (same pos)
if (right && (ncols < 2 || !right->nextColumn)) {
right->sameLine = false;
right->spacing = child->spacing;
}
child->sameLine = true;
child->spacing = 1;
}
else {
if (ncols >= 2 && left->nextColumn) {
child->nextColumn = left->nextColumn;
child->spacing = left->spacing;
child->sameLine = false;
left->nextColumn = 0;
left->spacing = 1;
left->sameLine = true;
}
else if (!left->sameLine) {
child->spacing = left->spacing;
left->spacing = 1;
std::swap(child->sameLine, left->sameLine);
}
else {
std::swap(child->sameLine, left->sameLine);
}
auto mv = std::move(parent->children[pos->second]);
parent->children.erase(parent->children.begin() + pos->second);
parent->children.insert(parent->children.begin() + pos->second - 1, std::move(mv));
}
}
}
if (ImGui::Shortcut(ImGuiMod_Alt | ImGuiKey_RightArrow, ImGuiInputFlags_RouteGlobal) &&
ctx.selected.size() == 1 &&
(ctx.selected[0]->Behavior() & UINode::SnapSides))
{
auto pos = ctx.root->FindChild(ctx.selected[0]);
if (!pos)
return;
UINode* parent = pos->first;
auto* child = parent->children[pos->second].get();
auto* right = pos->second + 1 < parent->children.size() ? parent->children[pos->second + 1].get() : nullptr;
int ncols = parent->ColumnCount(ctx);
int col = 0;
if (ncols >= 2) {
for (size_t j = 0; j <= pos->second; ++j)
col = (col + parent->children[j]->nextColumn) % ncols;
}
if (!right || !(right->Behavior() & UINode::SnapSides))
{
//just ensure a new row
if (child->sameLine) {
child->spacing = 1;
child->sameLine = false;
}
else if (col + 1 < ncols) {
child->sameLine = false;
child->spacing = 0;
++child->nextColumn;
}
}
else
{
if (child->sameLine && (ncols >= 2 && right->nextColumn)) {
//move to the beginning of next row (same pos)
child->sameLine = false;
child->spacing = 1;
}
else if (ncols >= 2 && right->nextColumn) {
++child->nextColumn;
child->sameLine = false;
if (child->nextColumn == right->nextColumn) {
child->spacing = right->spacing;
right->spacing = 1;
right->sameLine = true;
right->nextColumn = 0;
}
else {
child->spacing = 0;
--right->nextColumn;
}
}
else {
if (ncols >= 2 && child->nextColumn) {
right->nextColumn = child->nextColumn;
right->sameLine = false;
right->spacing = child->spacing;
child->nextColumn = 0;
child->sameLine = true;
child->spacing = 1;
}
else if (!child->sameLine) {
right->sameLine = false;
right->spacing = child->spacing;
child->sameLine = true;
child->spacing = 1;
}
else {
right->sameLine = child->sameLine;
child->sameLine = true;
}
auto mv = std::move(parent->children[pos->second]);
parent->children.erase(parent->children.begin() + pos->second);
parent->children.insert(parent->children.begin() + pos->second + 1, std::move(mv));
}
}
}
}
}
if (ImGui::Shortcut(ImGuiKey_F1, ImGuiInputFlags_RouteGlobal))
{
ShellExec(GITHUB_URL + "/wiki");
}
}
//This writes and reads records from [Recent] section
void AddINIHandler()
{
ImGuiSettingsHandler ini_handler;
ini_handler.TypeName = "ImRAD";
ini_handler.TypeHash = ImHashStr("ImRAD");
ini_handler.ReadOpenFn = [](ImGuiContext* ctx, ImGuiSettingsHandler* handler, const char* name) -> void*
{
return (void*)name;
};
ini_handler.ReadLineFn = [](ImGuiContext*, ImGuiSettingsHandler*, void* entry, const char* line)
{
if (programState != Init)
return;
if (!strcmp((const char*)entry, "Recent")) {
int i;
if (sscanf(line, "File%d=", &i) == 1) {
std::string fname = line + std::string_view(line).find('=') + 1;
if (i == 1) {
fileTabs.clear();
ActivateTab(-1);
}
std::string err;
DoOpenFile(fname, &err);
if (err != "") {
initErrors += u8string(u8path(fname).filename()) + "\n\t";
initErrors += Replace(Trim(err), "\n", "\n\t");
initErrors += "\n";
}
}
else if (sscanf(line, "ActiveTab=%d", &i) == 1) {
ActivateTab(i);
}
}
else if (!strcmp((const char*)entry, "Explorer")) {
int tmp;
if (!strncmp(line, "Path=", 5))
explorerPath = line + 5;
else if (sscanf(line, "Filter=%d", &explorerFilter) == 1)
line;
else if (sscanf(line, "SortColumn=%hd", &explorerSorting.ColumnIndex) == 1)
line;
else if (sscanf(line, "SortDir=%d", &tmp) == 1)
explorerSorting.SortDirection = (ImGuiSortDirection)tmp;
}
else if (!strcmp((const char*)entry, "UI")) {
if (!strncmp(line, "FontName=", 9))
uiFontName = line + 9;
else if (!strncmp(line, "FontSize=", 9))
uiFontSize = (float)std::atof(line + 9);
else if (!strncmp(line, "PgFontName=", 11))
pgFontName = line + 11;
else if (!strncmp(line, "PgbFontName=", 12))
pgbFontName = line + 12;
else if (!strncmp(line, "PgFontSize=", 11))
pgFontSize = (float)std::atof(line + 11);
}
};
ini_handler.ApplyAllFn = nullptr;
ini_handler.WriteAllFn = [](ImGuiContext* ctx, ImGuiSettingsHandler* handler, ImGuiTextBuffer* buf)
{
buf->append("[ImRAD][Recent]\n");
int active = activeTab;
int count = 0;
for (int i = 0; i < fileTabs.size(); ++i) {
if (fileTabs[i].fname != "") {
buf->appendf("File%d=%s\n", i + 1, fileTabs[i].fname.c_str());
++count;
}
else if (i < active)
--active;
}
if (active == count)
active = count - 1;
buf->appendf("ActiveTab=%d\n", active);
buf->append("\n");
buf->append("[ImRAD][Explorer]\n");
buf->appendf("Path=%s\n", explorerPath.c_str());
buf->appendf("Filter=%d\n", explorerFilter);
buf->appendf("SortColumn=%d\n", explorerSorting.ColumnIndex);
buf->appendf("SortDir=%d\n", explorerSorting.SortDirection);
buf->append("\n");
buf->append("[ImRAD][UI]\n");
buf->appendf("FontName=%s\n", uiFontName.c_str());
buf->appendf("FontSize=%f\n", uiFontSize);
buf->appendf("PgFontName=%s\n", pgFontName.c_str());
buf->appendf("PgbFontName=%s\n", pgbFontName.c_str());
buf->appendf("PgFontSize=%f\n", pgFontSize);
buf->append("\n");
};
ImGui::GetCurrentContext()->SettingsHandlers.push_back(ini_handler);
}
std::string GetRootPath()
{
#ifdef WIN32
wchar_t tmp[1024];
int n = GetModuleFileNameW(NULL, tmp, (int)std::size(tmp));
return generic_u8string(fs::path(tmp).parent_path()); //need generic for CMake template path substitutions
//test utf8 path: return u8string(L"c:/work/de�o/latest");
#elif __APPLE__
char executablePath[PATH_MAX];
uint32_t len = PATH_MAX;
if (_NSGetExecutablePath(executablePath, &len) != 0) {
std::cerr << "Error: _NSGetExecutablePath failed, fallback to current directory\n";
return u8string(fs::current_path());
}
try {
fs::path pexe = fs::canonical(u8path(executablePath));
return u8string(pexe.parent_path());
} catch (const std::exception& e) {
std::cerr << "Error: fs::canonical failed: " << e.what() << ", fallback to current directory\n";
return u8string(fs::current_path());
}
#else
fs::path pexe = fs::canonical("/proc/self/exe");
return u8string(pexe.parent_path());
#endif
}
#if (WIN32) && !(__MINGW32__)
int WINAPI wWinMain(
HINSTANCE hInstance,
HINSTANCE hPrevInstance,
PWSTR lpCmdLine,
int nCmdShow
)
{
#else
int main(int argc, const char* argv[])
{
#endif
rootPath = GetRootPath();
#ifdef _DEBUG
std::filesystem::path currPath = std::filesystem::current_path(); // 注意：这是工作目录
//auto pth_img = currPath.parent_path().parent_path() / std::filesystem::path("data/img") / std::format("{}.txt", m5);
//auto pth_json = currPath.parent_path().parent_path() / std::filesystem::path("data/json") / std::format("{}.json", m5);
#else
std::filesystem::path currPath = std::filesystem::current_path(); // 注意：这是可执行文件所在目录
#endif // DEBUG
SetConsoleCP(CP_UTF8);
SetConsoleOutputCP(CP_UTF8);
setlocale(LC_ALL, "en_US.UTF-8");
g_currPath = currPath;
//E:\huggingface\ColorTextEditorV2\build\x64\Release\WeChatOcrCpp.dll
g_wechatocr_dll = LoadLibrary(Constant::pth_wechatocr_dll.wstring().c_str()); // "E:\\huggingface\\ColorTextEditorV2\\build\\x64\\Release\\WeChatOcrCpp.dll"
rec = (FunctionPtr)GetProcAddress(g_wechatocr_dll, "rec");
std::string result = rec("E:\\huggingface\\imradv3\\data\\t2.jpg");
json jsn = json::parse(result);
std::string jsn_str = jsn.dump(4);
// Setup window
glfwSetErrorCallback(glfw_error_callback);
if (!glfwInit())
return 1;
// Decide GL+GLSL versions
#if defined(IMGUI_IMPL_OPENGL_ES2)
// GL ES 2.0 + GLSL 100
const char* glsl_version = "#version 100";
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API);
#elif defined(__APPLE__)
// GL 3.2 + GLSL 150
const char* glsl_version = "#version 150";
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); // 3.2+ only
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // Required on Mac
#else
// GL 3.0 + GLSL 130
const char* glsl_version = "#version 130";
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
//glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); // 3.2+ only
//glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // 3.0+ only
#endif
// Initialize the native file dialog
NFD_Init();
// Create window with graphics context
window = glfwCreateWindow(1280, 720, VER_STR.c_str(), NULL, NULL);
if (window == NULL)
return 1;
GLFWimage icons[2];
icons[0].pixels = stbi_load((rootPath + "/style/icon-40.png").c_str(), &icons[0].width, &icons[0].height, 0, 4);
icons[1].pixels = stbi_load((rootPath + "/style/icon-100.png").c_str(), &icons[1].width, &icons[1].height, 0, 4);
if (icons[0].pixels && icons[1].pixels)
glfwSetWindowIcon(window, 2, icons);
stbi_image_free(icons[0].pixels);
stbi_image_free(icons[1].pixels);
glfwMakeContextCurrent(window);
glfwSwapInterval(1); // Enable vsync
glfwMaximizeWindow(window);
curCross = glfwCreateStandardCursor(GLFW_CROSSHAIR_CURSOR);
//curWait = glfwCreateStandardCursor(GLFW_HAND_CURSOR);
curWait = glfwCreateCursor(CUSTOM_BUSY_CURSOR);
// Setup Dear ImGui context
IMGUI_CHECKVERSION();
ImGui::CreateContext();
auto& g = *ImGui::GetCurrentContext();
g.ConfigNavWindowingKeyNext = g.ConfigNavWindowingKeyPrev = ImGuiKey_None; //disable imgui ctrl+tab menu
ImGui::GetIO().IniFilename = INI_FILE_NAME;
AddINIHandler();
ImGuiIO& io = ImGui::GetIO();
io.UserData = &ioUserData;
io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
//io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad; // Enable Gamepad Controls
// Setup Platform/Renderer backends
ImGui_ImplGlfw_InitForOpenGL(window, true);
ImGui_ImplOpenGL3_Init(glsl_version);
const ImVec4 clear_color = ImVec4(0.45f, 0.55f, 0.60f, 1.00f);
ctx.dashTexId = ImRad::LoadTextureFromFile(
(rootPath + "/style/dash.png").c_str(), GL_NEAREST, GL_NEAREST, GL_REPEAT, GL_REPEAT).id;
GetStyles();
programState = (ProgramState)-1;
bool lastVisible = true;
// 创建布局，初始分割比例为0.5（中间）
SimpleLayout leftRightLayout(0.2f);
TextEditor editorr;
std::string s("A.磷酸戊糖位于螺旋外侧，碱基位于内侧");
//editorr.SetText(s);
while (true)
{
if (programState == -1)
{
programState = Init;
}
else if (programState == Init)
{
programState = Run;
}
else if (programState == Shutdown)
{
if (fileTabs.empty()) //Work() will close the tabs
break;
}
else if (programState == Run && glfwWindowShouldClose(window))
{
if (ImGui::GetTopMostAndVisiblePopupModal())
{
glfwSetWindowShouldClose(window, false);
}
else
{
programState = Shutdown;
ctx.mode = UIContext::NormalSelection;
//save state before files close
ImGui::SaveIniSettingsToDisk(ImGui::GetIO().IniFilename);
ImGui::GetIO().IniFilename = nullptr;
}
}
//font loading must be called before NewFrame
LoadStyle();
// Poll and handle events (inputs, window resize, etc.)
// You can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to tell if dear imgui wants to use your inputs.
// - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application, or clear/overwrite your copy of the mouse data.
// - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application, or clear/overwrite your copy of the keyboard data.
// Generally you may always pass all inputs to dear imgui, and hide them from your application based on those two flags.
glfwPollEvents();
// Start the Dear ImGui frame
ImGui_ImplOpenGL3_NewFrame();
ImGui_ImplGlfw_NewFrame();
ImGui::NewFrame();
bool visible = glfwGetWindowAttrib(window, GLFW_FOCUSED);
if (visible && !lastVisible)
ReloadFile();
lastVisible = visible;
// 设置左右窗口的内容
leftRightLayout.SetLeftWindow([&editorr]() {
//ImGui::Text("这是左窗口");
ExplorerUI(&editorr);
});
leftRightLayout.SetRightWindow([&editorr]() {
ImFont* font = NULL;
ImFontAtlas* atlas = ImGui::GetIO().Fonts;
for (ImFont* ft : atlas->Fonts) {
// font->ConfigData ? font->ConfigData[0].Name : "", font->FontSize, font->Glyphs.Size, font->ConfigDataCount
const char* fontName = ft->ConfigData ? ft->ConfigData[0].Name : "";
if (strcmp(fontName, "simhei") == 0) {
font = ft;
break;
}
}
ImGui::Button("\xef\x8b\xb9" "##ego"); // 默认是图标字体
ImGui::PushFont(font); // 切换中文字体
editorr.Render("Editor");
ImGui::PopFont();
});
leftRightLayout.Draw();
//DockspaceUI();
//ToolbarUI();
//TabsUI();
//HierarchyUI();
//ExplorerUI();
//PropertyUI();
//PopupUI();
//Work();
Draw(); //last
//ImGui::ShowDemoWindow();
// Rendering
ImGui::Render();
int display_w, display_h;
glfwGetFramebufferSize(window, &display_w, &display_h);
glViewport(0, 0, display_w, display_h);
glClearColor(clear_color.x * clear_color.w, clear_color.y * clear_color.w, clear_color.z * clear_color.w, clear_color.w);
glClear(GL_COLOR_BUFFER_BIT);
ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
glfwSwapBuffers(window);
}
// Cleanup
NFD_Quit();
ImGui_ImplOpenGL3_Shutdown();
ImGui_ImplGlfw_Shutdown();
ImGui::DestroyContext();
glfwDestroyCursor(curCross);
glfwDestroyCursor(curWait);
glfwDestroyWindow(window);
glfwTerminate();
return 0;
}