NoteEditorUI Class Reference

#include <NoteEditorUI.h>

Collaboration diagram for NoteEditorUI:

Classes
struct	TabState

Public Member Functions
	NoteEditorUI (std::shared_ptr< NotesManager > notes_manager, std::shared_ptr< ImGuiToaster > toaster)
void	render ()
void	openNoteTab (const std::string &uuid)
void	setActiveTable (std::optional< std::string > tableName)
void	setVisible (bool v)
bool	isVisible () const
bool	openTabByUuid (const std::string &uuid)
void	setChatManager (std::shared_ptr< ChatManager > chat_manager)

Private Member Functions
void	renderDirectory_ (float height)
void	renderTabsArea_ (float width, float height)
void	renderOneTab_ (const std::string &uuid, float availW, float availH)
void	actCreateNote_ ()
void	actSaveNote_ (const std::string &uuid)
void	actDeleteNote_ (const std::string &uuid)
void	actSaveInboxToLocal_ (const std::string &uuid)
void	toggleOpenEditor_ (const std::string &uuid)
void	addTabIfMissing_ (const std::string &uuid)
void	openOrFocusTab (const std::string &uuid)
void	closeTab_ (int tabIndex)
bool	filterMatch_ (const Note &n) const

Private Attributes
std::shared_ptr< NotesManager >	notes_manager
std::shared_ptr< ImGuiToaster >	toaster_
std::shared_ptr< ChatManager >	chat_manager
MarkdownRenderer	md_
bool	visible_ = false
float	leftWidth_ = 260.f
bool	showCreatePopup_ = false
bool	showDeletePopup_ = false
std::string	pendingDeleteUuid_
char	createTitle_ [128] = {0}
char	createAuthor_ [128] = {0}
std::vector< std::string >	openTabs_
int	currentTabIndex_ = -1
std::unordered_map< std::string, TabState >	tabState_
char	searchBuf_ [128] = {0}

Detailed Description

Definition at line 12 of file NoteEditorUI.h.

Constructor & Destructor Documentation

NoteEditorUI()

NoteEditorUI::NoteEditorUI	(	std::shared_ptr< NotesManager >	notes_manager,
		std::shared_ptr< ImGuiToaster >	toaster )

Definition at line 131 of file NoteEditorUI.cpp.

                                                                                                         :
    notes_manager(std::move(notes_manager)), toaster_(std::move(toaster)) {}

Member Function Documentation

actCreateNote_()

void NoteEditorUI::actCreateNote_ ( )

private

Definition at line 512 of file NoteEditorUI.cpp.

{
    static char titleBuf[128] = {0};
    static char authorBuf[128] = {0};
    ImGui::OpenPopup("Create Note");
    if (ImGui::BeginPopupModal("Create Note", nullptr, ImGuiWindowFlags_AlwaysAutoResize))
    {
        ImGui::InputText("Title", titleBuf, sizeof(titleBuf));
        UiTypingGuard::TrackThisInput();
        ImGui::InputText("Author", authorBuf, sizeof(authorBuf));
        UiTypingGuard::TrackThisInput();
        if (ImGui::Button("Create"))
        {
            std::string title = titleBuf[0] ? titleBuf : "Untitled";
            std::string author = authorBuf[0] ? authorBuf : "unknown";
            auto id = notes_manager->createNote(title, author);
            openOrFocusTab(id);
            titleBuf[0] = 0;
            authorBuf[0] = 0;
            ImGui::CloseCurrentPopup();
        }
        ImGui::SameLine();
        if (ImGui::Button("Cancel"))
        {
            ImGui::CloseCurrentPopup();
        }
        ImGui::EndPopup();
    }
}

Here is the call graph for this function:

actDeleteNote_()

void NoteEditorUI::actDeleteNote_ ( const std::string & uuid )

private

Definition at line 547 of file NoteEditorUI.cpp.

{
    ImGui::OpenPopup("Delete Note?");
    if (ImGui::BeginPopupModal("Delete Note?", nullptr, ImGuiWindowFlags_AlwaysAutoResize))
    {
        static bool alsoDisk = false;
        ImGui::Checkbox("Also delete from disk", &alsoDisk);
        if (ImGui::Button("Delete"))
        {
            notes_manager->deleteNote(uuid, alsoDisk);
            auto it = std::find(openTabs_.begin(), openTabs_.end(), uuid);
            if (it != openTabs_.end())
            {
                int idx = (int)std::distance(openTabs_.begin(), it);
                closeTab_(idx);
            }
            alsoDisk = false;
            ImGui::CloseCurrentPopup();
        }
        ImGui::SameLine();
        if (ImGui::Button("Cancel"))
        {
            ImGui::CloseCurrentPopup();
        }
        ImGui::EndPopup();
    }
}

Here is the call graph for this function:

actSaveInboxToLocal_()

void NoteEditorUI::actSaveInboxToLocal_ ( const std::string & uuid )

private

Definition at line 575 of file NoteEditorUI.cpp.

{
    notes_manager->saveInboxToLocal(uuid, std::nullopt);
}

actSaveNote_()

void NoteEditorUI::actSaveNote_ ( const std::string & uuid )

private

Definition at line 542 of file NoteEditorUI.cpp.

{
    notes_manager->saveNote(uuid);
}

Here is the caller graph for this function:

addTabIfMissing_()

void NoteEditorUI::addTabIfMissing_ ( const std::string & uuid )

private

Definition at line 593 of file NoteEditorUI.cpp.

{
    if (std::find(openTabs_.begin(), openTabs_.end(), uuid) == openTabs_.end())
    {
        openTabs_.push_back(uuid);
        currentTabIndex_ = (int)openTabs_.size() - 1;
        if (auto n = notes_manager->getNote(uuid))
        {
            auto& ts = tabState_[uuid];
            ts.editBuffer = n->markdown_text;
            ts.bufferInit = true;
        }
    }
    else
    {
        currentTabIndex_ = (int)std::distance(openTabs_.begin(),
                                              std::find(openTabs_.begin(), openTabs_.end(), uuid));
    }
}

Here is the caller graph for this function:

closeTab_()

void NoteEditorUI::closeTab_ ( int tabIndex )

private

Definition at line 627 of file NoteEditorUI.cpp.

{
    if (tabIndex < 0 || tabIndex >= (int)openTabs_.size())
        return;
    tabState_.erase(openTabs_[tabIndex]);
    openTabs_.erase(openTabs_.begin() + tabIndex);
}

Here is the caller graph for this function:

filterMatch_()

bool NoteEditorUI::filterMatch_ ( const Note & n ) const

private

Definition at line 635 of file NoteEditorUI.cpp.

{
    if (searchBuf_[0] == 0)
        return true;
    std::string needle = searchBuf_;
    std::transform(needle.begin(), needle.end(), needle.begin(), ::tolower);
    auto contains = [&](const std::string& hay)
    {
        std::string low = hay;
        std::transform(low.begin(), low.end(), low.begin(), ::tolower);
        return low.find(needle) != std::string::npos;
    };
    return contains(n.title) || contains(n.author) || contains(n.markdown_text);
}

Here is the caller graph for this function:

isVisible()

bool NoteEditorUI::isVisible ( ) const

inline

Definition at line 25 of file NoteEditorUI.h.

    {
        return visible_;
    }

openNoteTab()

void NoteEditorUI::openNoteTab

(

const std::string &

uuid

)

Definition at line 650 of file NoteEditorUI.cpp.

{
    openOrFocusTab(uuid);
}

Here is the call graph for this function:

openOrFocusTab()

void NoteEditorUI::openOrFocusTab ( const std::string & uuid )

private

Definition at line 613 of file NoteEditorUI.cpp.

{
    auto it = std::find(openTabs_.begin(), openTabs_.end(), uuid);
    if (it == openTabs_.end())
    {
        addTabIfMissing_(uuid); // opens and selects
    }
    else
    {
        currentTabIndex_ = (int)std::distance(openTabs_.begin(), it);
        // ImGui will focus the item with BeginTabItem anyway; this ensures index is correct
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

openTabByUuid()

bool NoteEditorUI::openTabByUuid

(

const std::string &

uuid

)

Definition at line 655 of file NoteEditorUI.cpp.

{
    if (!notes_manager)
        return false;
 
    // must exist
    auto n = notes_manager->getNote(uuid);
    if (!n)
        return false;
 
    // focus if already open
    auto it = std::find(openTabs_.begin(), openTabs_.end(), uuid);
    if (it != openTabs_.end())
    {
        currentTabIndex_ = static_cast<int>(std::distance(openTabs_.begin(), it));
        visible_ = true;
        return true;
    }
 
    // otherwise open a new tab
    openOrFocusTab(uuid);
    visible_ = true;
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

render()

void NoteEditorUI::render

(

)

Definition at line 139 of file NoteEditorUI.cpp.

{
    if (!visible_)
        return;
 
    const ImU32 winBg = IM_COL32(16, 16, 18, 255);
    ImGui::PushStyleColor(ImGuiCol_WindowBg, winBg);
    ImGui::SetNextWindowSizeConstraints(ImVec2(800, 600), ImVec2(FLT_MAX, FLT_MAX));
    bool open = true;
    ImGui::Begin("Notes", &open);
 
    const float fullW = ImGui::GetContentRegionAvail().x;
    const float fullH = ImGui::GetContentRegionAvail().y;
 
    ImGui::BeginChild("##Dir", ImVec2(leftWidth_, fullH), true);
    renderDirectory_(fullH);
    ImGui::EndChild();
 
    ImGui::SameLine();
    ImGui::InvisibleButton("##splitter", ImVec2(6, fullH));
    if (ImGui::IsItemActive())
    {
        leftWidth_ += ImGui::GetIO().MouseDelta.x;
        leftWidth_ = std::clamp(leftWidth_, 180.0f, fullW - 240.0f);
    }
    ImGui::SameLine();
 
    // Let ImGui compute exact remaining width to avoid h-scroll.
    ImGui::BeginChild("##Tabs", ImVec2(0.f, fullH), true,
                      ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse);
    renderTabsArea_(/*unused*/ 0.f, fullH);
    ImGui::EndChild();
 
    ImGui::End();
    ImGui::PopStyleColor(1); // <-- only 1 was pushed
 
    if (!open)
        visible_ = false;
 
    // ---- CREATE NOTE MODAL ----
    if (showCreatePopup_)
        ImGui::OpenPopup("Create Note"); // one-shot
 
    bool createOpen = true;
    if (ImGui::BeginPopupModal("Create Note", &createOpen, ImGuiWindowFlags_AlwaysAutoResize))
    {
        ImGui::InputText("Title", createTitle_, sizeof(createTitle_));
        UiTypingGuard::TrackThisInput();
        ImGui::InputText("Author", createAuthor_, sizeof(createAuthor_));
        UiTypingGuard::TrackThisInput();
 
        if (ImGui::Button("Create"))
        {
            std::string title = createTitle_[0] ? createTitle_ : "Untitled";
            std::string author = createAuthor_[0] ? createAuthor_ : "unknown";
            auto id = notes_manager->createNote(title, author);
            openOrFocusTab(id);
            createTitle_[0] = 0;
            createAuthor_[0] = 0;
            showCreatePopup_ = false;
            ImGui::CloseCurrentPopup();
        }
        ImGui::SameLine();
        if (ImGui::Button("Cancel"))
        {
            showCreatePopup_ = false;
            ImGui::CloseCurrentPopup();
        }
 
        ImGui::EndPopup();
    }
    else
    {
        // If not visible anymore (closed via ESC or X), clear flag
        showCreatePopup_ = false;
    }
 
    // ---- DELETE NOTE MODAL ----
    if (showDeletePopup_)
        ImGui::OpenPopup("Delete Note?");
 
    bool delOpen = true;
    if (ImGui::BeginPopupModal("Delete Note?", &delOpen, ImGuiWindowFlags_AlwaysAutoResize))
    {
        static bool alsoDisk = false;
        ImGui::Checkbox("Also delete from disk", &alsoDisk);
 
        if (ImGui::Button("Delete"))
        {
            if (!pendingDeleteUuid_.empty())
            {
                notes_manager->deleteNote(pendingDeleteUuid_, alsoDisk);
                auto it = std::find(openTabs_.begin(), openTabs_.end(), pendingDeleteUuid_);
                if (it != openTabs_.end())
                {
                    int idx = (int)std::distance(openTabs_.begin(), it);
                    closeTab_(idx);
                }
            }
            pendingDeleteUuid_.clear();
            alsoDisk = false;
            showDeletePopup_ = false;
            ImGui::CloseCurrentPopup();
        }
        ImGui::SameLine();
        if (ImGui::Button("Cancel"))
        {
            pendingDeleteUuid_.clear();
            showDeletePopup_ = false;
            ImGui::CloseCurrentPopup();
        }
 
        ImGui::EndPopup();
    }
    else
    {
        // ESC or close -> reset state
        if (!delOpen)
        {
            pendingDeleteUuid_.clear();
            showDeletePopup_ = false;
        }
    }
}

Here is the call graph for this function:

renderDirectory_()

void NoteEditorUI::renderDirectory_ ( float height )

private

Definition at line 263 of file NoteEditorUI.cpp.

{
    if (ImGui::Button("New"))
    {
        showCreatePopup_ = true;
    }
    ImGui::SameLine();
    if (ImGui::Button("Reload"))
    {
        notes_manager->loadAllFromDisk();
    }
    ImGui::Separator();
 
    ImGui::SetNextItemWidth(-1);
    ImGui::InputTextWithHint("##search", "Search title/author/text...", searchBuf_, sizeof(searchBuf_));
    UiTypingGuard::TrackThisInput();
    ImGui::Separator();
 
    if (ImGui::CollapsingHeader("My Notes", ImGuiTreeNodeFlags_DefaultOpen))
    {
        auto mine = notes_manager->listMyNotes();
        if (mine.empty())
        {
            ImGui::TextDisabled("(none)");
        }
        else
        {
            for (auto& n : mine)
            {
                if (!n || !filterMatch_(*n))
                    continue;
                ImGui::PushID(n->uuid.c_str());
 
                const bool selected = (std::find(openTabs_.begin(), openTabs_.end(), n->uuid) != openTabs_.end());
                const std::string label = n->title.empty() ? n->uuid : n->title; // ← no '*' or '(unsaved)'
                if (ImGui::Selectable(label.c_str(), selected))
                    openOrFocusTab(n->uuid);
 
                ImGui::PopID();
            }
        }
    }
 
    ImGui::Separator();
 
    //if (ImGui::CollapsingHeader("Shared Inbox", ImGuiTreeNodeFlags_DefaultOpen))
    //{
    //    auto inbox = notes_manager->listInbox();
    //    if (inbox.empty())
    //    {
    //        ImGui::TextDisabled("(empty)");
    //    }
    //    else
    //    {
    //        for (auto& n : inbox)
    //        {
    //            if (!n || !filterMatch_(*n))
    //                continue;
    //            ImGui::PushID(n->uuid.c_str());
 
    //            const bool selected = (std::find(openTabs_.begin(), openTabs_.end(), n->uuid) != openTabs_.end());
    //            const std::string label = (n->title.empty() ? n->uuid : n->title) + "  [from: " + (n->shared_from ? *n->shared_from : "?") + "]";
    //            if (ImGui::Selectable(label.c_str(), selected))
    //                openOrFocusTab(n->uuid);
 
    //            ImGui::SameLine();
    //            if (ImGui::SmallButton("Save locally"))
    //                actSaveInboxToLocal_(n->uuid);
 
    //            ImGui::PopID();
    //        }
    //    }
    //}
}

Here is the call graph for this function:

Here is the caller graph for this function:

renderOneTab_()

void NoteEditorUI::renderOneTab_ ( const std::string & uuid, float availW, float availH )

private

Definition at line 394 of file NoteEditorUI.cpp.

{
    auto n = notes_manager->getNote(uuid);
    if (!n)
        return;
 
    ImGuiIO& io = ImGui::GetIO();
    const bool windowFocused = ImGui::IsWindowFocused(ImGuiFocusedFlags_ChildWindows | ImGuiFocusedFlags_RootAndChildWindows);
    if (windowFocused && io.KeyCtrl && ImGui::IsKeyPressed(ImGuiKey_S, false))
        actSaveNote_(uuid);
 
    if (ImGui::Button(n->open_editor ? "Hide Editor" : "Show Editor"))
        toggleOpenEditor_(uuid);
    ImGui::SameLine();
    if (ImGui::Button("Save"))
        actSaveNote_(uuid);
    ImGui::SameLine();
    if (ImGui::Button("Delete"))
    {
        pendingDeleteUuid_ = uuid;
        showDeletePopup_ = true;
        return;
    }
    ImGui::SameLine();
    ImGui::TextDisabled("%s", n->saved_locally ? n->file_path.filename().string().c_str() : "(unsaved)");
    ImGui::Separator();
 
    const float spacing = ImGui::GetStyle().ItemSpacing.x;
    const float splitterW = 6.f;
 
    float editorW = 0.f, viewerW = 0.f;
    if (n->open_editor)
    {
        const float shared = availW - splitterW - spacing;
        editorW = floorf(shared * 0.5f);
        viewerW = shared - editorW; // exact remainder => no 1px overflow
    }
    else
    {
        viewerW = availW;
    }
 
    // --- Editor ---
    if (n->open_editor)
    {
        ImGui::BeginChild("##editor", ImVec2(editorW, 0.f), true); // 0 height => fill
        auto& ts = tabState_[uuid];
        if (!ts.bufferInit)
        {
            ts.editBuffer = n->markdown_text;
            ts.bufferInit = true;
        }
 
        ImVec2 editorSize = ImGui::GetContentRegionAvail();
        float wrap_px = editorSize.x - ImGui::GetStyle().FramePadding.x * 2.0f;
 
        // hard-wrap (inserts '\n' when exceeding width)
        InputTextMultilineString_HardWrap("##NoteEdit",
                                          &ts.editBuffer,
                                          editorSize,
                                          wrap_px,
                                          ImGuiInputTextFlags_AllowTabInput);
        UiTypingGuard::TrackThisInput();
        ImGui::EndChild();
 
        ImGui::SameLine();
        ImGui::InvisibleButton("##split2", ImVec2(splitterW, 0.f));
        ImGui::SameLine();
    }
 
    // --- Viewer ---
    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(8.f, 8.f)); // padding to avoid clipped glyphs
    ImGui::BeginChild("##viewer", ImVec2(viewerW, 0.f), true);
    {
        const auto toMs = NotesManager::toEpochMillis;
        ImGui::TextDisabled("Author: %s", n->author.c_str());
        ImGui::SameLine();
        ImGui::TextDisabled("Created: %lld", (long long)toMs(n->creation_ts));
        ImGui::SameLine();
        ImGui::TextDisabled("Updated: %lld", (long long)toMs(n->last_update_ts));
        ImGui::Separator();
 
        // only set handlers we need; leave external open to MarkdownRenderer default
        md_.onRoll = [this](const std::string& expr)
        {
            if (chat_manager)
                chat_manager->tryHandleSlashCommand(chat_manager->generalGroupId_, "/roll " + expr);
            //if (toaster_)
            //toaster_->Push(ImGuiToaster::Level::Good, "Roll: " + expr);
        };
        md_.resolveNoteRef = [this](const std::string& ref) -> std::string
        {
            return notes_manager->resolveRef(ref);
        };
        md_.onNoteOpen = [this](const std::string& id)
        { openTabByUuid(id); };
 
        const std::string& md = n->open_editor ? tabState_[uuid].editBuffer : n->markdown_text;
 
        ImGui::PushTextWrapPos(0.f); // wrap md to viewer width (safety; imgui_md usually wraps, this enforces)
        if (!md.empty())
            md_.print(md.c_str(), md.c_str() + md.size());
        else
            ImGui::TextDisabled("(empty)");
        ImGui::PopTextWrapPos();
    }
    ImGui::EndChild();
    ImGui::PopStyleVar();
 
    // Propagate editor changes to manager
    if (n->open_editor)
    {
        auto& ts = tabState_[uuid];
        if (ts.bufferInit && ts.editBuffer != n->markdown_text)
            notes_manager->setContent(uuid, ts.editBuffer);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

renderTabsArea_()

void NoteEditorUI::renderTabsArea_ ( float width, float height )

private

Definition at line 338 of file NoteEditorUI.cpp.

{
    if (openTabs_.empty())
    {
        ImGui::TextDisabled("No notes open. Select a note on the left or create a new one.");
        return;
    }
 
    if (ImGui::BeginTabBar("##NoteTabs",
                           ImGuiTabBarFlags_AutoSelectNewTabs |
                               ImGuiTabBarFlags_Reorderable))
    {
        for (int i = 0; i < (int)openTabs_.size(); ++i)
        {
            const std::string& uuid = openTabs_[i];
            auto n = notes_manager->getNote(uuid);
            if (!n)
            {
                if (currentTabIndex_ == i)
                    currentTabIndex_ = -1;
                closeTab_(i);
                --i;
                continue;
            }
 
            // Visible label stays constant; ID is after '###'
            const std::string visible = n->title.empty() ? n->uuid : n->title;
            const std::string label = visible + "###" + uuid;
 
            ImGuiTabItemFlags tif = 0;
            if (n->dirty)
                tif |= ImGuiTabItemFlags_UnsavedDocument;
 
            bool open = true;
            if (ImGui::BeginTabItem(label.c_str(), &open, tif))
            {
                currentTabIndex_ = i;
 
                const float availW = ImGui::GetContentRegionAvail().x;
                const float availH = ImGui::GetContentRegionAvail().y;
                renderOneTab_(uuid, availW, availH);
 
                ImGui::EndTabItem();
            }
            if (!open)
            {
                closeTab_(i);
                if (currentTabIndex_ >= (int)openTabs_.size())
                    currentTabIndex_ = (int)openTabs_.size() - 1;
                --i;
            }
        }
        ImGui::EndTabBar();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

setActiveTable()

void NoteEditorUI::setActiveTable

(

std::optional< std::string >

tableName

)

Definition at line 134 of file NoteEditorUI.cpp.

{
    (void)tableName; // reserved for future save-locations UX
}

setChatManager()

void NoteEditorUI::setChatManager ( std::shared_ptr< ChatManager > chat_manager )

inline

Definition at line 31 of file NoteEditorUI.h.

    {
        this->chat_manager = chat_manager;
    }

setVisible()

void NoteEditorUI::setVisible ( bool v )

inline

Definition at line 21 of file NoteEditorUI.h.

    {
        visible_ = v;
    }

toggleOpenEditor_()

void NoteEditorUI::toggleOpenEditor_ ( const std::string & uuid )

private

Definition at line 580 of file NoteEditorUI.cpp.

{
    auto n = notes_manager->getNote(uuid);
    if (!n)
        return;
    n->open_editor = !n->open_editor;
    if (n->open_editor)
    {
        auto& ts = tabState_[uuid];
        ts.bufferInit = false;
    }
}

Here is the caller graph for this function:

Member Data Documentation

chat_manager

std::shared_ptr<ChatManager> NoteEditorUI::chat_manager

private

Definition at line 39 of file NoteEditorUI.h.

createAuthor_

char NoteEditorUI::createAuthor_[128] = {0}

private

Definition at line 49 of file NoteEditorUI.h.

{0};

createTitle_

char NoteEditorUI::createTitle_[128] = {0}

private

Definition at line 48 of file NoteEditorUI.h.

{0};

currentTabIndex_

int NoteEditorUI::currentTabIndex_ = -1

private

Definition at line 52 of file NoteEditorUI.h.

leftWidth_

float NoteEditorUI::leftWidth_ = 260.f

private

Definition at line 42 of file NoteEditorUI.h.

md_

MarkdownRenderer NoteEditorUI::md_

private

Definition at line 40 of file NoteEditorUI.h.

notes_manager

std::shared_ptr<NotesManager> NoteEditorUI::notes_manager

private

Definition at line 37 of file NoteEditorUI.h.

openTabs_

std::vector<std::string> NoteEditorUI::openTabs_

private

Definition at line 51 of file NoteEditorUI.h.

pendingDeleteUuid_

std::string NoteEditorUI::pendingDeleteUuid_

private

Definition at line 46 of file NoteEditorUI.h.

searchBuf_

char NoteEditorUI::searchBuf_[128] = {0}

private

Definition at line 61 of file NoteEditorUI.h.

{0};

showCreatePopup_

bool NoteEditorUI::showCreatePopup_ = false

private

Definition at line 44 of file NoteEditorUI.h.

showDeletePopup_

bool NoteEditorUI::showDeletePopup_ = false

private

Definition at line 45 of file NoteEditorUI.h.

tabState_

std::unordered_map<std::string, TabState> NoteEditorUI::tabState_

private

Definition at line 59 of file NoteEditorUI.h.

toaster_

std::shared_ptr<ImGuiToaster> NoteEditorUI::toaster_

private

Definition at line 38 of file NoteEditorUI.h.

visible_

bool NoteEditorUI::visible_ = false

private

Definition at line 41 of file NoteEditorUI.h.

---

The documentation for this class was generated from the following files:

• include/note_editor/NoteEditorUI.h
• src/note_editor/NoteEditorUI.cpp