Datasets:

dlxjj
/

imradv3

#include "ui_explorer.h"
#include "ui_message_box.h"
#include "utils.h"
#include "stx.h"
#include "imrad.h"
#include "cppgen.h"
#include <sstream>
#include <chrono>
#include <IconsFontAwesome6.h>

struct ExplorerEntry
{
    std::string path;
    bool folder;
    bool generated;
    std::string fileName;
    std::time_t last_write_time;
    std::string modified;
};

std::string explorerPath;
int explorerFilter = 0;
ImGuiTableColumnSortSpecs explorerSorting;

static int pathSel = -1;
static std::vector<ExplorerEntry> data;
static std::vector<std::string> suggestions;
static int suggestionSel = -1;
static std::string lastPath;
static bool scrollBack = false;
static bool showSuggestions = false;
static bool autocompleted = false;
enum MoveFocus { None, PathInput, FirstEntry };
static MoveFocus moveFocus = None;

bool IsHeaderFile(const fs::path& p)
{
    auto ext = u8string(p.extension());
    return ext == ".h" || ext == ".hpp" || ext == ".hxx";
}

bool IsJsonFile(const fs::path& p)
{
    auto ext = u8string(p.extension());
    return ext == ".json" || ext == ".JSON";
}

bool IsImageFile(const fs::path& p)
{
    auto ext = u8string(p.extension());
    return ext == ".jpg" || ext == ".JPG" || ext == ".jpeg" || ext == ".JPEG" || ext == ".png" || ext == ".PNG" || ext == ".bmp" || ext == ".BMP";
}

bool IsCppFile(const fs::path& p)
{
    auto ext = u8string(p.extension());
    return ext == ".c" || ext == ".cpp" || ext == ".cxx";
}

void ReloadExplorer(const CppGen& codeGen)
{
    data.clear();
    auto path = u8path(explorerPath);
    //+= '/' so it works with paths like "c:"
    if (!path.has_root_directory())
        path = u8path(explorerPath + (char)fs::path::preferred_separator);
    path.make_preferred();
    explorerPath = u8string(path);

    if (!fs::is_directory(path)) {
        messageBox.title = "Error";
        messageBox.message = "Can't open \"" + explorerPath + "\"";
        messageBox.buttons = ImRad::Ok;
        messageBox.OpenPopup();
        return;
    }

    scrollBack = true;
    std::ostringstream os;
    auto fsnow = fs::file_time_type::clock::now();
    auto snow = std::chrono::system_clock::now();
    os.imbue(std::locale(""));
    std::error_code ec;
    for (fs::directory_iterator it(path, ec); it != fs::directory_iterator(); ++it)
    {
        if (u8string(it->path().stem())[0] == '.')
            continue;
        if (!it->is_directory() &&
            //(!explorerFilter && !IsHeaderFile(it->path())))
            (!explorerFilter && !IsImageFile(it->path())))
            continue;
        ExplorerEntry entry;
        entry.path = u8string(it->path());
        entry.folder = it->is_directory();
        entry.generated = (IsHeaderFile(it->path()) || IsCppFile(it->path())) &&
            codeGen.ReadGenVersion(entry.path);
        entry.fileName = u8string(it->path().filename());
        auto sctp = std::chrono::time_point_cast<std::chrono::system_clock::duration>(
            it->last_write_time() - fsnow + snow);
        entry.last_write_time = std::chrono::system_clock::to_time_t(sctp);
        auto* tm = std::localtime(&entry.last_write_time);
        os.str("");
        os << std::put_time(tm, "%x %X");
        entry.modified = os.str();
        data.push_back(std::move(entry));
    }
    stx::sort(data, [](const ExplorerEntry& a, const ExplorerEntry& b) {
        if (a.folder != b.folder)
            return a.folder;
        if (!explorerSorting.ColumnIndex) {
            if (explorerSorting.SortDirection == ImGuiSortDirection_Ascending)
                return path_cmp(a.fileName, b.fileName);
            else
                return path_cmp(b.fileName, a.fileName);
        }
        else {
            if (explorerSorting.SortDirection == ImGuiSortDirection_Ascending)
                return a.last_write_time < b.last_write_time;
            else
                return a.last_write_time > b.last_write_time;
        }
        });
    if (!u8path(explorerPath).relative_path().empty()) {
        std::string ppath = u8string(u8path(explorerPath).parent_path());
        ExplorerEntry e;
        e.path = ppath;
        e.folder = true;
        e.fileName = "..";
        data.insert(data.begin(), e);
    }
}

void GetSuggestions()
{
    suggestions.clear();
    std::error_code ec;
    auto path = u8path(explorerPath);
    //+= '/' so it works with paths like "c:"
    if (!path.has_root_directory())
        path = u8path(explorerPath + (char)fs::path::preferred_separator);
    std::string match = u8string(path.stem());
    for (fs::directory_iterator it(path.parent_path(), ec); it != fs::directory_iterator(); ++it)
    {
        std::string stem = u8string(it->path().stem());
        if (!it->is_directory() || stem[0] == '.')
            continue;
        if (stem.size() > match.size())
            stem.resize(match.size());
        if (path_cmp(stem, match) || path_cmp(match, stem))
            continue;
        std::string fileName = u8string(it->path().filename());
        suggestions.push_back(std::move(fileName));
    }
    stx::sort(suggestions, [](const std::string& a, const std::string& b) {
        return path_cmp(a, b);
        });
}

int ExplorerPathCallback(ImGuiInputTextCallbackData* data)
{
    if (data->EventFlag == ImGuiInputTextFlags_CallbackCharFilter) {
        return DefaultCharFilter(data);
    }
    else if (data->EventFlag == ImGuiInputTextFlags_CallbackHistory)
    {
        if (data->EventKey == ImGuiKey_UpArrow && suggestions.size()) {
            if (suggestionSel < 0) {
                suggestionSel = (int)suggestions.size() - 1;
                lastPath = explorerPath;
            }
            else if (--suggestionSel < 0)
                suggestionSel = -1;
        }
        else if (data->EventKey == ImGuiKey_DownArrow && suggestions.size()) {
            if (suggestionSel < 0) {
                suggestionSel = 0;
                lastPath = explorerPath;
            }
            else if (++suggestionSel == suggestions.size())
                suggestionSel = -1;
        }

        //commit suggestion
        std::string str = lastPath;
        if (suggestionSel >= 0) {
            size_t i = explorerPath.find_last_of("/\\");
            if (i == std::string::npos)
                str = explorerPath + (char)fs::path::preferred_separator;
            else
                str = explorerPath.substr(0, i + 1);
            str += suggestions[suggestionSel];
        }
        if (str.size() + 1 < data->BufSize) { //no reallocation occured
            autocompleted = true;
            data->BufDirty = true;
            strcpy(data->Buf, str.c_str());
            data->BufTextLen = (int)str.size();
            data->SelectionStart = data->SelectionEnd = data->CursorPos = data->BufTextLen;
        }
    }
    return 0;
}

void ExplorerUI(const CppGen& codeGen, std::function<void(const std::string& fpath)> openFileFunc)
{
    explorerPath.reserve(1024); //ImGuiInputText_HistoryCallback doesn't allow buffer reallocation??
    if (explorerPath == "")
        explorerPath = u8string(fs::current_path());

    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, { 4, 4 });
    ImGui::Begin("Explorer", 0, ImGuiWindowFlags_NoCollapse);
    if (ImGui::IsWindowAppearing()) {
        ReloadExplorer(codeGen);
        showSuggestions = false;
        autocompleted = false;
        moveFocus = FirstEntry;
    }

    //clickable path box
    const int sp = 4;
    const std::string ELIDE_STR = "...";
    std::string inputId = "##explorerCwd";
    if (ImGui::GetFocusID() != ImGui::GetID(inputId.c_str()))
    {
        ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImGui::GetStyle().FramePadding);
        ImGui::PushStyleVar(ImGuiStyleVar_ChildRounding, ImGui::GetStyle().FrameRounding);
        ImGui::PushStyleColor(ImGuiCol_ChildBg, 0xffd0d0d0);
        ImGui::PushStyleColor(ImGuiCol_Border, 0xffb0b0b0);
        if (ImGui::BeginChild("cwdChild", { -ImGui::GetFrameHeight() - sp, ImGui::GetFrameHeight() }, ImGuiChildFlags_Borders, ImGuiWindowFlags_NavFlattened | ImGuiWindowFlags_NoScrollbar))
        {
            fs::path path = u8path(explorerPath);
            char separator = (char)fs::path::preferred_separator;
            int elideStart = (int)path.has_root_name() + (int)path.has_root_directory();
            int elideN = 0;
            ImVec2 wpad = ImGui::GetStyle().WindowPadding;
            int n = 0;
            for (const auto& p : path)
                ++n;
            for (; elideStart + elideN < n; ++elideN) {
                std::string tmp;
                int i = 0;
                for (const auto& p : path) {
                    if (i < elideStart)
                        tmp += u8string(p);
                    else if (i == elideStart && elideN)
                        tmp += ELIDE_STR + separator;
                    else if (i >= elideStart + elideN)
                        tmp += u8string(p) + separator;
                    ++i;
                }
                if (tmp.back() == separator)
                    tmp.pop_back();
                if (elideStart + elideN + 1 == n ||
                    ImGui::CalcTextSize(tmp.c_str()).x + 2 * wpad.x < ImGui::GetWindowWidth())
                    break;
            }
            int i = 0;
            int rootDirIdx = path.has_root_directory() ? (int)path.has_root_name() : -1;
            int lastPathSel = pathSel;
            pathSel = -1;
            bool sepSel = false;
            fs::path subpath;
            for (const auto& p : path) {
                subpath /= p;
                if (i >= elideStart && i < elideStart + elideN) {
                    ++i;
                    continue;
                }
                if (p.has_root_directory()) {
                    ImGui::SameLine(0, 0);
                    ImGui::Text("%s", u8string(p).c_str());
                    if (ImGui::IsItemHovered())
                        sepSel = true;
                    ++i;
                    continue;
                }
                if (i && i != rootDirIdx + 1) {
                    ImGui::SameLine(0, 0);
                    std::string sep = elideN && i == elideStart + elideN ? ELIDE_STR : "";
                    sep += separator;
                    ImGui::Text("%s", sep.c_str());
                    if (ImGui::IsItemHovered())
                        sepSel = true;
                }
                ImGui::SameLine(0, 0);
                ImGui::PushStyleColor(ImGuiCol_Text, i == lastPathSel ? 0xff0000ff : 0xff000000);
                ImGui::Text("%s", u8string(p).c_str());
                ImGui::PopStyleColor();
                if (ImGui::IsItemHovered() && i + 1 != n)
                    pathSel = i;
                if (ImGui::IsItemClicked() && i + 1 != n) {
                    explorerPath = u8string(subpath);
                    ReloadExplorer(codeGen);
                    moveFocus = FirstEntry;
                }
                ++i;
            }
            if (ImGui::IsWindowHovered() && !sepSel && pathSel < 0)
            {
                ImGui::SetMouseCursor(ImGuiMouseCursor_TextInput);
                if (ImGui::IsMouseClicked(ImGuiMouseButton_Left))
                    moveFocus = PathInput;
            }
        }
        ImGui::EndChild();
        ImGui::PopStyleVar(2);
        ImGui::PopStyleColor(2);
    }

    ImGui::SameLine(0, 0);
    if (ImGui::GetContentRegionAvail().x - ImGui::GetFrameHeight() - sp <= 0)
        ImGui::SetNextItemWidth(0);
    else
        ImGui::SetNextItemWidth(-ImGui::GetFrameHeight() - sp);
    //ImGui::PushStyleColor(ImGuiCol_FrameBg, 0xffd0d0d0);
    //ImGui::PushStyleColor(ImGuiCol_Border, 0xffb0b0b0);
    ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 1);
    int fl = ImGuiInputTextFlags_ElideLeft | ImGuiInputTextFlags_CallbackHistory | ImGuiInputTextFlags_CallbackCharFilter;
    if (ImGui::InputText(inputId.c_str(), &explorerPath, fl, ExplorerPathCallback)) {
        if (autocompleted)
            autocompleted = false;
        else {
            GetSuggestions();
            showSuggestions = true;
            suggestionSel = -1;
        }
    }
    //ImGui::PopStyleColor(2);
    ImGui::PopStyleVar();
    if (moveFocus == PathInput)
    {
        ImGui::SetKeyboardFocusHere(-1);
        auto* state = ImGui::GetInputTextState(ImGui::GetItemID());
        if (state)
            state->ClearSelection();
        if (ImGui::IsItemFocused())
            moveFocus = None;
    }
    if (ImGui::IsItemDeactivated()) { //AfterEdit())
        ReloadExplorer(codeGen);
        showSuggestions = false;
        moveFocus = FirstEntry;
    }
    if (showSuggestions)
    {
        ImGui::PushFont(ImRad::GetFontByName("imrad.explorer"));
        ImGui::SetNextWindowPos({ ImGui::GetItemRectMin().x, ImGui::GetItemRectMax().y });
        float h = ImGui::GetTextLineHeight() + ImGui::GetStyle().ItemInnerSpacing.y;
        float pad = ImGui::GetStyle().WindowPadding.y;
        const int N = 7;
        ImGui::SetNextWindowSize({ ImGui::GetItemRectSize().x, std::min(N, (int)suggestions.size()) * h + 2 * pad });
        float selY = std::max(suggestionSel, 0) * h + pad;
        if (ImGui::BeginTooltip()) //Tooltip won't steal the focus as BeginPopup does
        {
            if (selY + h > ImGui::GetScrollY() + ImGui::GetWindowSize().y)
                ImGui::SetScrollY(selY - (N - 1) * h - pad);
            if (selY < ImGui::GetScrollY())
                ImGui::SetScrollY(selY - pad);
            for (size_t i = 0; i < suggestions.size(); ++i) {
                /*ImGui::PushStyleColor(ImGuiCol_Text, 0xff40b0b0);
                ImGui::Selectable(ICON_FA_FOLDER, i == suggestionSel, ImGuiSelectableFlags_SpanAvailWidth);
                ImGui::PopStyleColor();
                ImGui::SameLine(0, 4);*/
                ImGui::Selectable(suggestions[i].c_str(), i == suggestionSel, 0);
            }
            ImGui::EndTooltip();
        }
        ImGui::PopFont();
    }

    ImGui::SameLine(0, sp);
    ImGui::PushStyleColor(ImGuiCol_Text, 0xff404040);
    ImGui::PushItemFlag(ImGuiItemFlags_NoNav, true);
    if (ImGui::Button(ICON_FA_ROTATE_RIGHT "##ego")) {
        ReloadExplorer(codeGen);
        moveFocus = FirstEntry;
    }
    ImGui::PopItemFlag();
    ImGui::PopStyleColor();

    ImGui::PushStyleColor(ImGuiCol_TableRowBg, 0xffffffff);
    ImGui::PushStyleColor(ImGuiCol_TableRowBgAlt, 0xffffffff);
    if (scrollBack) {
        scrollBack = false;
        ImGui::SetNextWindowScroll({ 0, 0 });
    }
    float h = -ImGui::GetFrameHeight() - ImGui::GetStyle().ItemSpacing.y;
    if (ImGui::BeginTable("files", 2, ImGuiTableFlags_Sortable | ImGuiTableFlags_Resizable | ImGuiTableFlags_ScrollY, { -1, h }))
    {
        ImGui::TableSetupColumn("Name", ImGuiTableColumnFlags_WidthStretch);
        ImGui::TableSetupColumn("Modified", ImGuiTableColumnFlags_WidthFixed, 140);
        ImGui::TableSetupScrollFreeze(0, 1);
        auto* spec = ImGui::TableGetSortSpecs();
        if (spec && spec->SpecsDirty) {
            spec->SpecsDirty = false;
            explorerSorting = *spec->Specs;
            ReloadExplorer(codeGen);
        }
        ImGui::PushItemFlag(ImGuiItemFlags_NoNav, true);
        ImGui::TableHeadersRow();
        ImGui::PopItemFlag();
        ImGui::TableNextRow();
        ImGui::TableSetColumnIndex(0);

        ImGui::PushFont(ImRad::GetFontByName("imrad.explorer"));
        int n = 0;
        for (const auto& entry : data)
        {
            ImGui::PushID(n++);
            bool source = IsHeaderFile(entry.path) || IsCppFile(entry.path);
            ImGui::PushStyleColor(ImGuiCol_Text,
                entry.folder ? 0xff40b0b0 :
                entry.generated ? 0xffe0a060 :
                source ? 0xff60a0d0 :
                0xffa0a0a0
            );
            ImGui::Selectable(entry.folder ? ICON_FA_FOLDER :
                entry.generated ? ICON_FA_DICE_D6 :
                source ? ICON_FA_FILE_CODE :
                ICON_FA_FILE,
                false, ImGuiSelectableFlags_SpanAllColumns);
            ImGui::PopStyleColor();
            if (n == 1 && moveFocus == FirstEntry) {
                if (ImGui::IsItemFocused())
                    moveFocus = None;
                ImGui::SetKeyboardFocusHere(-1);
            }
            if (ImRad::IsItemDoubleClicked() ||
                (ImGui::IsItemActive() && ImGui::IsKeyPressed(ImGuiKey_Enter)))
            {
                if (entry.folder) {
                    explorerPath = entry.path;
                    ReloadExplorer(codeGen);
                    ImGui::PopID();
                    break;
                }
                //else if (!codeGen.ReadGenVersion(entry.path)) {
                //    ShellExec(entry.path);
                //}
                else {
                    openFileFunc(entry.path);
                }
            }
            ImGui::PushItemFlag(ImGuiItemFlags_NoNav, true);
            ImGui::SameLine(0, 4);
            ImGui::Selectable(entry.fileName.c_str(), false);
            ImGui::TableNextColumn();
            ImGui::Selectable(entry.modified.c_str(), false, ImGuiSelectableFlags_Disabled);
            ImGui::TableNextColumn();
            ImGui::PopItemFlag();
            ImGui::PopID();
        }
        ImGui::PopFont();
        ImGui::EndTable();
    }
    ImGui::PopStyleColor(2);

    ImGui::PushStyleColor(ImGuiCol_FrameBg, 0xffd0d0d0);
    ImGui::PushStyleColor(ImGuiCol_Border, 0xffb0b0b0);
    ImGui::SetNextItemWidth(-1);
    if (ImGui::Combo("##filter", &explorerFilter, "IMAGE Files (*.jpg,*.png,*.bmp)\0All Files (*.*)\0"))
        ReloadExplorer(codeGen);
    ImGui::PopStyleColor(2);

    ImGui::End();
    ImGui::PopStyleVar();
}

	#include "ui_explorer.h"
	#include "ui_message_box.h"
	#include "utils.h"
	#include "stx.h"
	#include "imrad.h"
	#include "cppgen.h"
	#include <sstream>
	#include <chrono>
	#include <IconsFontAwesome6.h>

	struct ExplorerEntry
	{
	std::string path;
	bool folder;
	bool generated;
	std::string fileName;
	std::time_t last_write_time;
	std::string modified;
	};

	std::string explorerPath;
	int explorerFilter = 0;
	ImGuiTableColumnSortSpecs explorerSorting;

	static int pathSel = -1;
	static std::vector<ExplorerEntry> data;
	static std::vector<std::string> suggestions;
	static int suggestionSel = -1;
	static std::string lastPath;
	static bool scrollBack = false;
	static bool showSuggestions = false;
	static bool autocompleted = false;
	enum MoveFocus { None, PathInput, FirstEntry };
	static MoveFocus moveFocus = None;

	bool IsHeaderFile(const fs::path& p)
	{
	auto ext = u8string(p.extension());
	return ext == ".h" \|\| ext == ".hpp" \|\| ext == ".hxx";
	}

	bool IsJsonFile(const fs::path& p)
	{
	auto ext = u8string(p.extension());
	return ext == ".json" \|\| ext == ".JSON";
	}

	bool IsImageFile(const fs::path& p)
	{
	auto ext = u8string(p.extension());
	return ext == ".jpg" \|\| ext == ".JPG" \|\| ext == ".jpeg" \|\| ext == ".JPEG" \|\| ext == ".png" \|\| ext == ".PNG" \|\| ext == ".bmp" \|\| ext == ".BMP";
	}

	bool IsCppFile(const fs::path& p)
	{
	auto ext = u8string(p.extension());
	return ext == ".c" \|\| ext == ".cpp" \|\| ext == ".cxx";
	}

	void ReloadExplorer(const CppGen& codeGen)
	{
	data.clear();
	auto path = u8path(explorerPath);
	//+= '/' so it works with paths like "c:"
	if (!path.has_root_directory())
	path = u8path(explorerPath + (char)fs::path::preferred_separator);
	path.make_preferred();
	explorerPath = u8string(path);

	if (!fs::is_directory(path)) {
	messageBox.title = "Error";
	messageBox.message = "Can't open \"" + explorerPath + "\"";
	messageBox.buttons = ImRad::Ok;
	messageBox.OpenPopup();
	return;
	}

	scrollBack = true;
	std::ostringstream os;
	auto fsnow = fs::file_time_type::clock::now();
	auto snow = std::chrono::system_clock::now();
	os.imbue(std::locale(""));
	std::error_code ec;
	for (fs::directory_iterator it(path, ec); it != fs::directory_iterator(); ++it)
	{
	if (u8string(it->path().stem())[0] == '.')
	continue;
	if (!it->is_directory() &&
	//(!explorerFilter && !IsHeaderFile(it->path())))
	(!explorerFilter && !IsImageFile(it->path())))
	continue;
	ExplorerEntry entry;
	entry.path = u8string(it->path());
	entry.folder = it->is_directory();
	entry.generated = (IsHeaderFile(it->path()) \|\| IsCppFile(it->path())) &&
	codeGen.ReadGenVersion(entry.path);
	entry.fileName = u8string(it->path().filename());
	auto sctp = std::chrono::time_point_cast<std::chrono::system_clock::duration>(
	it->last_write_time() - fsnow + snow);
	entry.last_write_time = std::chrono::system_clock::to_time_t(sctp);
	auto* tm = std::localtime(&entry.last_write_time);
	os.str("");
	os << std::put_time(tm, "%x %X");
	entry.modified = os.str();
	data.push_back(std::move(entry));
	}
	stx::sort(data, [](const ExplorerEntry& a, const ExplorerEntry& b) {
	if (a.folder != b.folder)
	return a.folder;
	if (!explorerSorting.ColumnIndex) {
	if (explorerSorting.SortDirection == ImGuiSortDirection_Ascending)
	return path_cmp(a.fileName, b.fileName);
	else
	return path_cmp(b.fileName, a.fileName);
	}
	else {
	if (explorerSorting.SortDirection == ImGuiSortDirection_Ascending)
	return a.last_write_time < b.last_write_time;
	else
	return a.last_write_time > b.last_write_time;
	}
	});
	if (!u8path(explorerPath).relative_path().empty()) {
	std::string ppath = u8string(u8path(explorerPath).parent_path());
	ExplorerEntry e;
	e.path = ppath;
	e.folder = true;
	e.fileName = "..";
	data.insert(data.begin(), e);
	}
	}

	void GetSuggestions()
	{
	suggestions.clear();
	std::error_code ec;
	auto path = u8path(explorerPath);
	//+= '/' so it works with paths like "c:"
	if (!path.has_root_directory())
	path = u8path(explorerPath + (char)fs::path::preferred_separator);
	std::string match = u8string(path.stem());
	for (fs::directory_iterator it(path.parent_path(), ec); it != fs::directory_iterator(); ++it)
	{
	std::string stem = u8string(it->path().stem());
	if (!it->is_directory() \|\| stem[0] == '.')
	continue;
	if (stem.size() > match.size())
	stem.resize(match.size());
	if (path_cmp(stem, match) \|\| path_cmp(match, stem))
	continue;
	std::string fileName = u8string(it->path().filename());
	suggestions.push_back(std::move(fileName));
	}
	stx::sort(suggestions, [](const std::string& a, const std::string& b) {
	return path_cmp(a, b);
	});
	}

	int ExplorerPathCallback(ImGuiInputTextCallbackData* data)
	{
	if (data->EventFlag == ImGuiInputTextFlags_CallbackCharFilter) {
	return DefaultCharFilter(data);
	}
	else if (data->EventFlag == ImGuiInputTextFlags_CallbackHistory)
	{
	if (data->EventKey == ImGuiKey_UpArrow && suggestions.size()) {
	if (suggestionSel < 0) {
	suggestionSel = (int)suggestions.size() - 1;
	lastPath = explorerPath;
	}
	else if (--suggestionSel < 0)
	suggestionSel = -1;
	}
	else if (data->EventKey == ImGuiKey_DownArrow && suggestions.size()) {
	if (suggestionSel < 0) {
	suggestionSel = 0;
	lastPath = explorerPath;
	}
	else if (++suggestionSel == suggestions.size())
	suggestionSel = -1;
	}

	//commit suggestion
	std::string str = lastPath;
	if (suggestionSel >= 0) {
	size_t i = explorerPath.find_last_of("/\\");
	if (i == std::string::npos)
	str = explorerPath + (char)fs::path::preferred_separator;
	else
	str = explorerPath.substr(0, i + 1);
	str += suggestions[suggestionSel];
	}
	if (str.size() + 1 < data->BufSize) { //no reallocation occured
	autocompleted = true;
	data->BufDirty = true;
	strcpy(data->Buf, str.c_str());
	data->BufTextLen = (int)str.size();
	data->SelectionStart = data->SelectionEnd = data->CursorPos = data->BufTextLen;
	}
	}
	return 0;
	}

	void ExplorerUI(const CppGen& codeGen, std::function<void(const std::string& fpath)> openFileFunc)
	{
	explorerPath.reserve(1024); //ImGuiInputText_HistoryCallback doesn't allow buffer reallocation??
	if (explorerPath == "")
	explorerPath = u8string(fs::current_path());

	ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, { 4, 4 });
	ImGui::Begin("Explorer", 0, ImGuiWindowFlags_NoCollapse);
	if (ImGui::IsWindowAppearing()) {
	ReloadExplorer(codeGen);
	showSuggestions = false;
	autocompleted = false;
	moveFocus = FirstEntry;
	}

	//clickable path box
	const int sp = 4;
	const std::string ELIDE_STR = "...";
	std::string inputId = "##explorerCwd";
	if (ImGui::GetFocusID() != ImGui::GetID(inputId.c_str()))
	{
	ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImGui::GetStyle().FramePadding);
	ImGui::PushStyleVar(ImGuiStyleVar_ChildRounding, ImGui::GetStyle().FrameRounding);
	ImGui::PushStyleColor(ImGuiCol_ChildBg, 0xffd0d0d0);
	ImGui::PushStyleColor(ImGuiCol_Border, 0xffb0b0b0);
	if (ImGui::BeginChild("cwdChild", { -ImGui::GetFrameHeight() - sp, ImGui::GetFrameHeight() }, ImGuiChildFlags_Borders, ImGuiWindowFlags_NavFlattened \| ImGuiWindowFlags_NoScrollbar))
	{
	fs::path path = u8path(explorerPath);
	char separator = (char)fs::path::preferred_separator;
	int elideStart = (int)path.has_root_name() + (int)path.has_root_directory();
	int elideN = 0;
	ImVec2 wpad = ImGui::GetStyle().WindowPadding;
	int n = 0;
	for (const auto& p : path)
	++n;
	for (; elideStart + elideN < n; ++elideN) {
	std::string tmp;
	int i = 0;
	for (const auto& p : path) {
	if (i < elideStart)
	tmp += u8string(p);
	else if (i == elideStart && elideN)
	tmp += ELIDE_STR + separator;
	else if (i >= elideStart + elideN)
	tmp += u8string(p) + separator;
	++i;
	}
	if (tmp.back() == separator)
	tmp.pop_back();
	if (elideStart + elideN + 1 == n \|\|
	ImGui::CalcTextSize(tmp.c_str()).x + 2 * wpad.x < ImGui::GetWindowWidth())
	break;
	}
	int i = 0;
	int rootDirIdx = path.has_root_directory() ? (int)path.has_root_name() : -1;
	int lastPathSel = pathSel;
	pathSel = -1;
	bool sepSel = false;
	fs::path subpath;
	for (const auto& p : path) {
	subpath /= p;
	if (i >= elideStart && i < elideStart + elideN) {
	++i;
	continue;
	}
	if (p.has_root_directory()) {
	ImGui::SameLine(0, 0);
	ImGui::Text("%s", u8string(p).c_str());
	if (ImGui::IsItemHovered())
	sepSel = true;
	++i;
	continue;
	}
	if (i && i != rootDirIdx + 1) {
	ImGui::SameLine(0, 0);
	std::string sep = elideN && i == elideStart + elideN ? ELIDE_STR : "";
	sep += separator;
	ImGui::Text("%s", sep.c_str());
	if (ImGui::IsItemHovered())
	sepSel = true;
	}
	ImGui::SameLine(0, 0);
	ImGui::PushStyleColor(ImGuiCol_Text, i == lastPathSel ? 0xff0000ff : 0xff000000);
	ImGui::Text("%s", u8string(p).c_str());
	ImGui::PopStyleColor();
	if (ImGui::IsItemHovered() && i + 1 != n)
	pathSel = i;
	if (ImGui::IsItemClicked() && i + 1 != n) {
	explorerPath = u8string(subpath);
	ReloadExplorer(codeGen);
	moveFocus = FirstEntry;
	}
	++i;
	}
	if (ImGui::IsWindowHovered() && !sepSel && pathSel < 0)
	{
	ImGui::SetMouseCursor(ImGuiMouseCursor_TextInput);
	if (ImGui::IsMouseClicked(ImGuiMouseButton_Left))
	moveFocus = PathInput;
	}
	}
	ImGui::EndChild();
	ImGui::PopStyleVar(2);
	ImGui::PopStyleColor(2);
	}

	ImGui::SameLine(0, 0);
	if (ImGui::GetContentRegionAvail().x - ImGui::GetFrameHeight() - sp <= 0)
	ImGui::SetNextItemWidth(0);
	else
	ImGui::SetNextItemWidth(-ImGui::GetFrameHeight() - sp);
	//ImGui::PushStyleColor(ImGuiCol_FrameBg, 0xffd0d0d0);
	//ImGui::PushStyleColor(ImGuiCol_Border, 0xffb0b0b0);
	ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 1);
	int fl = ImGuiInputTextFlags_ElideLeft \| ImGuiInputTextFlags_CallbackHistory \| ImGuiInputTextFlags_CallbackCharFilter;
	if (ImGui::InputText(inputId.c_str(), &explorerPath, fl, ExplorerPathCallback)) {
	if (autocompleted)
	autocompleted = false;
	else {
	GetSuggestions();
	showSuggestions = true;
	suggestionSel = -1;
	}
	}
	//ImGui::PopStyleColor(2);
	ImGui::PopStyleVar();
	if (moveFocus == PathInput)
	{
	ImGui::SetKeyboardFocusHere(-1);
	auto* state = ImGui::GetInputTextState(ImGui::GetItemID());
	if (state)
	state->ClearSelection();
	if (ImGui::IsItemFocused())
	moveFocus = None;
	}
	if (ImGui::IsItemDeactivated()) { //AfterEdit())
	ReloadExplorer(codeGen);
	showSuggestions = false;
	moveFocus = FirstEntry;
	}
	if (showSuggestions)
	{
	ImGui::PushFont(ImRad::GetFontByName("imrad.explorer"));
	ImGui::SetNextWindowPos({ ImGui::GetItemRectMin().x, ImGui::GetItemRectMax().y });
	float h = ImGui::GetTextLineHeight() + ImGui::GetStyle().ItemInnerSpacing.y;
	float pad = ImGui::GetStyle().WindowPadding.y;
	const int N = 7;
	ImGui::SetNextWindowSize({ ImGui::GetItemRectSize().x, std::min(N, (int)suggestions.size()) * h + 2 * pad });
	float selY = std::max(suggestionSel, 0) * h + pad;
	if (ImGui::BeginTooltip()) //Tooltip won't steal the focus as BeginPopup does
	{
	if (selY + h > ImGui::GetScrollY() + ImGui::GetWindowSize().y)
	ImGui::SetScrollY(selY - (N - 1) * h - pad);
	if (selY < ImGui::GetScrollY())
	ImGui::SetScrollY(selY - pad);
	for (size_t i = 0; i < suggestions.size(); ++i) {
	/*ImGui::PushStyleColor(ImGuiCol_Text, 0xff40b0b0);
	ImGui::Selectable(ICON_FA_FOLDER, i == suggestionSel, ImGuiSelectableFlags_SpanAvailWidth);
	ImGui::PopStyleColor();
	ImGui::SameLine(0, 4);*/
	ImGui::Selectable(suggestions[i].c_str(), i == suggestionSel, 0);
	}
	ImGui::EndTooltip();
	}
	ImGui::PopFont();
	}

	ImGui::SameLine(0, sp);
	ImGui::PushStyleColor(ImGuiCol_Text, 0xff404040);
	ImGui::PushItemFlag(ImGuiItemFlags_NoNav, true);
	if (ImGui::Button(ICON_FA_ROTATE_RIGHT "##ego")) {
	ReloadExplorer(codeGen);
	moveFocus = FirstEntry;
	}
	ImGui::PopItemFlag();
	ImGui::PopStyleColor();

	ImGui::PushStyleColor(ImGuiCol_TableRowBg, 0xffffffff);
	ImGui::PushStyleColor(ImGuiCol_TableRowBgAlt, 0xffffffff);
	if (scrollBack) {
	scrollBack = false;
	ImGui::SetNextWindowScroll({ 0, 0 });
	}
	float h = -ImGui::GetFrameHeight() - ImGui::GetStyle().ItemSpacing.y;
	if (ImGui::BeginTable("files", 2, ImGuiTableFlags_Sortable \| ImGuiTableFlags_Resizable \| ImGuiTableFlags_ScrollY, { -1, h }))
	{
	ImGui::TableSetupColumn("Name", ImGuiTableColumnFlags_WidthStretch);
	ImGui::TableSetupColumn("Modified", ImGuiTableColumnFlags_WidthFixed, 140);
	ImGui::TableSetupScrollFreeze(0, 1);
	auto* spec = ImGui::TableGetSortSpecs();
	if (spec && spec->SpecsDirty) {
	spec->SpecsDirty = false;
	explorerSorting = *spec->Specs;
	ReloadExplorer(codeGen);
	}
	ImGui::PushItemFlag(ImGuiItemFlags_NoNav, true);
	ImGui::TableHeadersRow();
	ImGui::PopItemFlag();
	ImGui::TableNextRow();
	ImGui::TableSetColumnIndex(0);

	ImGui::PushFont(ImRad::GetFontByName("imrad.explorer"));
	int n = 0;
	for (const auto& entry : data)
	{
	ImGui::PushID(n++);
	bool source = IsHeaderFile(entry.path) \|\| IsCppFile(entry.path);
	ImGui::PushStyleColor(ImGuiCol_Text,
	entry.folder ? 0xff40b0b0 :
	entry.generated ? 0xffe0a060 :
	source ? 0xff60a0d0 :
	0xffa0a0a0
	);
	ImGui::Selectable(entry.folder ? ICON_FA_FOLDER :
	entry.generated ? ICON_FA_DICE_D6 :
	source ? ICON_FA_FILE_CODE :
	ICON_FA_FILE,
	false, ImGuiSelectableFlags_SpanAllColumns);
	ImGui::PopStyleColor();
	if (n == 1 && moveFocus == FirstEntry) {
	if (ImGui::IsItemFocused())
	moveFocus = None;
	ImGui::SetKeyboardFocusHere(-1);
	}
	if (ImRad::IsItemDoubleClicked() \|\|
	(ImGui::IsItemActive() && ImGui::IsKeyPressed(ImGuiKey_Enter)))
	{
	if (entry.folder) {
	explorerPath = entry.path;
	ReloadExplorer(codeGen);
	ImGui::PopID();
	break;
	}
	//else if (!codeGen.ReadGenVersion(entry.path)) {
	// ShellExec(entry.path);
	//}
	else {
	openFileFunc(entry.path);
	}
	}
	ImGui::PushItemFlag(ImGuiItemFlags_NoNav, true);
	ImGui::SameLine(0, 4);
	ImGui::Selectable(entry.fileName.c_str(), false);
	ImGui::TableNextColumn();
	ImGui::Selectable(entry.modified.c_str(), false, ImGuiSelectableFlags_Disabled);
	ImGui::TableNextColumn();
	ImGui::PopItemFlag();
	ImGui::PopID();
	}
	ImGui::PopFont();
	ImGui::EndTable();
	}
	ImGui::PopStyleColor(2);

	ImGui::PushStyleColor(ImGuiCol_FrameBg, 0xffd0d0d0);
	ImGui::PushStyleColor(ImGuiCol_Border, 0xffb0b0b0);
	ImGui::SetNextItemWidth(-1);
	if (ImGui::Combo("##filter", &explorerFilter, "IMAGE Files (.jpg,.png,.bmp)\0All Files (.*)\0"))
	ReloadExplorer(codeGen);
	ImGui::PopStyleColor(2);

	ImGui::End();
	ImGui::PopStyleVar();
	}