ImGuiToaster Class Reference

#include <ImGuiToaster.h>

Collaboration diagram for ImGuiToaster:

Classes
struct	Config
struct	Toast

Public Types
enum class	Level { Info , Good , Warning , Error }

Public Member Functions
	ImGuiToaster ()=default
	ImGuiToaster (const Config &cfg)
void	Push (Level lvl, const std::string &msg, float durationSec=4.0f)
void	Info (const std::string &msg, float sec=5.f)
void	Good (const std::string &msg, float sec=5.f)
void	Warn (const std::string &msg, float sec=5.f)
void	Error (const std::string &msg, float sec=5.f)
void	Clear ()
void	Render ()
void	SetConfig (const Config &cfg)
const Config &	GetConfig () const

Private Member Functions
ImVec4	ColorForLevel_ (Level lvl) const

Private Attributes
std::atomic< uint64_t >	next_id_ {1}
std::mutex	mtx_
std::deque< Toast >	toasts_
Config	cfg_

Detailed Description

Definition at line 12 of file ImGuiToaster.h.

Member Enumeration Documentation

Level

enum class ImGuiToaster::Level

strong

Enumerator
Info
Good
Warning
Error

Definition at line 15 of file ImGuiToaster.h.

    {
        Info,
        Good,
        Warning,
        Error
    };

Constructor & Destructor Documentation

ImGuiToaster() [1/2]

ImGuiToaster::ImGuiToaster ( )

default

ImGuiToaster() [2/2]

ImGuiToaster::ImGuiToaster ( const Config & cfg )

inlineexplicit

Definition at line 69 of file ImGuiToaster.h.

                                             :
        cfg_(cfg) {}

Member Function Documentation

Clear()

void ImGuiToaster::Clear ( )

inline

Definition at line 104 of file ImGuiToaster.h.

    {
        std::scoped_lock lk(mtx_);
        toasts_.clear();
    }

ColorForLevel_()

ImVec4 ImGuiToaster::ColorForLevel_ ( Level lvl ) const

inlineprivate

Definition at line 294 of file ImGuiToaster.h.

    {
        switch (lvl)
        {
            case Level::Good:
                return cfg_.colorGood;
            case Level::Warning:
                return cfg_.colorWarning;
            case Level::Error:
                return cfg_.colorError;
            case Level::Info:
            default:
                return cfg_.colorInfo;
        }
    }

Here is the caller graph for this function:

Error()

void ImGuiToaster::Error ( const std::string & msg, float sec = 5.f )

inline

Definition at line 99 of file ImGuiToaster.h.

    {
        Push(Level::Error, msg, sec);
    }

Here is the call graph for this function:

GetConfig()

const Config & ImGuiToaster::GetConfig ( ) const

inline

Definition at line 279 of file ImGuiToaster.h.

    {
        return cfg_;
    }

Good()

void ImGuiToaster::Good ( const std::string & msg, float sec = 5.f )

inline

Definition at line 91 of file ImGuiToaster.h.

    {
        Push(Level::Good, msg, sec);
    }

Here is the call graph for this function:

Info()

void ImGuiToaster::Info ( const std::string & msg, float sec = 5.f )

inline

Definition at line 87 of file ImGuiToaster.h.

    {
        Push(Level::Info, msg, sec);
    }

Here is the call graph for this function:

Push()

void ImGuiToaster::Push ( Level lvl, const std::string & msg, float durationSec = 4.0f )

inline

Definition at line 72 of file ImGuiToaster.h.

    {
        using clock = std::chrono::steady_clock;
        Toast t;
        t.id = next_id_.fetch_add(1, std::memory_order_relaxed);
        t.message = msg;
        t.level = lvl;
        t.expiresAt = clock::now() + std::chrono::duration_cast<clock::duration>(std::chrono::duration<float>(durationSec));
        {
            std::scoped_lock lk(mtx_);
            toasts_.push_back(std::move(t));
            if (toasts_.size() > cfg_.maxToasts)
                toasts_.pop_front();
        }
    }

Here is the caller graph for this function:

Render()

void ImGuiToaster::Render ( )

inline

Definition at line 111 of file ImGuiToaster.h.

    {
        using clock = std::chrono::steady_clock;
 
        // Copy & prune under lock
        std::vector<Toast> local;
        {
            std::scoped_lock lk(mtx_);
            const auto now = clock::now();
            while (!toasts_.empty() && toasts_.front().expiresAt <= now)
                toasts_.pop_front();
            local.assign(toasts_.begin(), toasts_.end());
        }
        if (local.empty())
            return;
 
        ImGuiViewport* vp = ImGui::GetMainViewport();
        const float PAD = cfg_.edgePadding;
 
        ImVec2 basePos;
        switch (cfg_.corner)
        {
            case Config::Corner::TopLeft:
                basePos = ImVec2(vp->WorkPos.x + PAD, vp->WorkPos.y + PAD);
                break;
            case Config::Corner::TopRight:
                basePos = ImVec2(vp->WorkPos.x + vp->WorkSize.x - PAD, vp->WorkPos.y + PAD);
                break;
            case Config::Corner::BottomLeft:
                basePos = ImVec2(vp->WorkPos.x + PAD, vp->WorkPos.y + vp->WorkSize.y - PAD);
                break;
            case Config::Corner::BottomRight:
                basePos = ImVec2(vp->WorkPos.x + vp->WorkSize.x - PAD, vp->WorkPos.y + vp->WorkSize.y - PAD);
                break;
        }
 
        ImVec2 anchor = cfg_.anchorPivot;
        float y_step = (cfg_.corner == Config::Corner::BottomLeft || cfg_.corner == Config::Corner::BottomRight)
                           ? -cfg_.verticalSpacing
                           : cfg_.verticalSpacing;
 
        ImVec2 pos = basePos;
        int idx = 0;
 
        for (const auto& t : local)
        {
            const ImVec4 lvlCol = ColorForLevel_(t.level);
            ImVec4 bg = lvlCol;
            bg.w = cfg_.bgOpacity; // apply opacity to window bg
            bool delete_this_toast = false;
 
            ImGui::SetNextWindowViewport(vp->ID);
            ImGui::SetNextWindowPos(pos, ImGuiCond_Always, anchor);
 
            // Sizing setup
            if (cfg_.fixedSize.x > 0.f || cfg_.fixedSize.y > 0.f)
            {
                ImGui::SetNextWindowSize(ImVec2(
                                             cfg_.fixedSize.x > 0.f ? cfg_.fixedSize.x : 0.f,
                                             cfg_.fixedSize.y > 0.f ? cfg_.fixedSize.y : 0.f),
                                         ImGuiCond_Always);
            }
            else
            {
                ImVec2 minC = cfg_.minSize;
                ImVec2 maxC = cfg_.maxSize;
                if (maxC.x <= 0.f || maxC.y <= 0.f)
                {
                    maxC.x = (maxC.x <= 0.f) ? (vp->WorkSize.x * 0.9f) : maxC.x;
                    maxC.y = (maxC.y <= 0.f) ? (vp->WorkSize.y * 0.9f) : maxC.y;
                }
                ImGui::SetNextWindowSizeConstraints(minC, maxC);
                if (!cfg_.autoResize)
                {
                    ImGui::SetNextWindowSize(minC, ImGuiCond_Always);
                }
            }
 
            ImGuiWindowFlags flags = ImGuiWindowFlags_NoDecoration |
                                     ImGuiWindowFlags_NoSavedSettings |
                                     ImGuiWindowFlags_NoNav;
            if (!cfg_.focusOnAppear)
                flags |= ImGuiWindowFlags_NoFocusOnAppearing;
            if (cfg_.clickThrough && !cfg_.killOnClickAnywhere)
                flags |= ImGuiWindowFlags_NoInputs;
            if (cfg_.autoResize && !(cfg_.fixedSize.x > 0.f || cfg_.fixedSize.y > 0.f))
                flags |= ImGuiWindowFlags_AlwaysAutoResize;
 
            // Style: background colored by level, text always white, optional border
            ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, cfg_.rounding);
            ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, cfg_.windowPadding);
 
            ImGui::PushStyleColor(ImGuiCol_WindowBg, bg);
            if (cfg_.showBorder)
            {
                ImGui::PushStyleColor(ImGuiCol_Border, cfg_.borderColor);
                ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, cfg_.borderSize);
            }
 
            std::string name = "##toast-" + std::to_string(idx++);
            if (ImGui::Begin(name.c_str(), nullptr, flags))
            {
                if (cfg_.killOnClickAnywhere &&
                    ImGui::IsWindowHovered(ImGuiHoveredFlags_AllowWhenBlockedByActiveItem) &&
                    ImGui::IsMouseClicked(ImGuiMouseButton_Left))
                {
                    delete_this_toast = true;
                }
 
                // Text wrapping
                float wrapAt = 0.f;
                if (cfg_.wrapText)
                {
                    wrapAt = (cfg_.maxWidth > 0.f) ? cfg_.maxWidth : ImGui::GetContentRegionAvail().x;
                    ImGui::PushTextWrapPos(ImGui::GetCursorPosX() + wrapAt);
                }
 
                ImGui::PushStyleColor(ImGuiCol_Text, cfg_.textColor);
                ImGui::TextUnformatted(t.message.c_str());
                ImGui::PopStyleColor();
 
                if (cfg_.wrapText)
                {
                    ImGui::PopTextWrapPos();
                }
 
                /*if (cfg_.killOnClickAnywhere) {
                    // Cover the content region with an invisible button.
                    // It won't change layout because we restore the cursor after.
                    ImVec2 crMin = ImGui::GetWindowContentRegionMin();
                    ImVec2 crMax = ImGui::GetWindowContentRegionMax();
                    ImVec2 old   = ImGui::GetCursorPos();
                
                    ImGui::SetCursorPos(crMin);
                    ImVec2 size(crMax.x - crMin.x, crMax.y - crMin.y);
                    ImGui::InvisibleButton("##toast_kill", size);
                    if (ImGui::IsItemClicked(ImGuiMouseButton_Left)) {
                        delete_this_toast = true;
                    }
                    ImGui::SetCursorPos(old);
                }*/
            }
            ImGui::End();
 
            if (cfg_.showBorder)
            {
                ImGui::PopStyleVar();   // WindowBorderSize
                ImGui::PopStyleColor(); // Border
            }
            ImGui::PopStyleColor(); // WindowBg
            ImGui::PopStyleVar(2);  // rounding, padding
            if (cfg_.killOnClickAnywhere && delete_this_toast)
            {
                std::scoped_lock lk(mtx_);
                auto it_real = std::find_if(toasts_.begin(), toasts_.end(),
                                            [&](const Toast& tt)
                                            { return tt.id == t.id; });
                if (it_real != toasts_.end())
                    toasts_.erase(it_real);
            }
            pos.y += y_step;
        }
    }

Here is the call graph for this function:

SetConfig()

void ImGuiToaster::SetConfig ( const Config & cfg )

inline

Definition at line 275 of file ImGuiToaster.h.

    {
        cfg_ = cfg;
    }

Warn()

void ImGuiToaster::Warn ( const std::string & msg, float sec = 5.f )

inline

Definition at line 95 of file ImGuiToaster.h.

    {
        Push(Level::Warning, msg, sec);
    }

Here is the call graph for this function:

Member Data Documentation

cfg_

Config ImGuiToaster::cfg_

private

Definition at line 312 of file ImGuiToaster.h.

mtx_

std::mutex ImGuiToaster::mtx_

mutableprivate

Definition at line 310 of file ImGuiToaster.h.

next_id_

std::atomic<uint64_t> ImGuiToaster::next_id_ {1}

private

Definition at line 285 of file ImGuiToaster.h.

{1};

toasts_

std::deque<Toast> ImGuiToaster::toasts_

private

Definition at line 311 of file ImGuiToaster.h.

---

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

• include/ImGuiToaster.h