MarkdownRenderer Class Reference

#include <MarkdownRenderer.h>

Inheritance diagram for MarkdownRenderer:

Collaboration diagram for MarkdownRenderer:

Classes
struct	Parsed

Public Types
enum class	Action { OpenExternal , RollExpr , NoteOpen , Unknown }

Public Member Functions
	MarkdownRenderer ()=default
void	open_url () const override
void	soft_break () override

Static Public Member Functions
static void	openDefaultBrowser_ (const std::string &url)

Public Attributes
std::function< void(const std::string &url)	onOpenExternal )
std::function< void(const std::string &expr)	onRoll )
std::function< void(const std::string &uuid)	onNoteOpen )
std::function< std::string(const std::string &ref)	resolveNoteRef )

Private Member Functions
Parsed	parseHref_ (const std::string &href) const
std::string	resolveNote_ (const std::string &ref) const

Static Private Member Functions
static bool	startsWith_ (const std::string &s, const char *pref)
static bool	looksLikeUuid_ (const std::string &s)
static bool	looksLikeShortId_ (const std::string &s)
static bool	isHex_ (char c)

Detailed Description

Definition at line 12 of file MarkdownRenderer.h.

Member Enumeration Documentation

Action

enum class MarkdownRenderer::Action

strong

Enumerator
OpenExternal
RollExpr
NoteOpen
Unknown

Definition at line 15 of file MarkdownRenderer.h.

    {
        OpenExternal, // http/https
        RollExpr,     // roll:1d20+5 or roll://1d20+5
        NoteOpen,     // note://open/<ref>, note:/<ref>, note:<ref>
        Unknown
    };

Constructor & Destructor Documentation

MarkdownRenderer()

MarkdownRenderer::MarkdownRenderer ( )

default

Member Function Documentation

isHex_()

bool MarkdownRenderer::isHex_ ( char c )

staticprivate

Definition at line 150 of file MarkdownRenderer.cpp.

{
    return std::isxdigit(static_cast<unsigned char>(c)) != 0;
}

Here is the caller graph for this function:

looksLikeShortId_()

bool MarkdownRenderer::looksLikeShortId_ ( const std::string & s )

staticprivate

Definition at line 136 of file MarkdownRenderer.cpp.

{
    if (s.size() < 8)
        return false;
    for (char c : s)
    {
        if (c == '-')
            return false;
        if (!isHex_(c))
            return false;
    }
    return true;
}

Here is the call graph for this function:

looksLikeUuid_()

bool MarkdownRenderer::looksLikeUuid_ ( const std::string & s )

staticprivate

Definition at line 116 of file MarkdownRenderer.cpp.

{
    if (s.size() != 36)
        return false;
    const int dashPos[4] = {8, 13, 18, 23};
    for (int i = 0; i < 36; ++i)
    {
        if (i == dashPos[0] || i == dashPos[1] || i == dashPos[2] || i == dashPos[3])
        {
            if (s[i] != '-')
                return false;
        }
        else if (!isHex_(s[i]))
        {
            return false;
        }
    }
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

open_url()

void MarkdownRenderer::open_url ( ) const

override

Definition at line 8 of file MarkdownRenderer.cpp.

{
    const auto a = parseHref_(m_href);
    switch (a.kind)
    {
        case Action::OpenExternal:
            if (onOpenExternal)
                onOpenExternal(a.payload);
            break;
 
        case Action::RollExpr:
            if (onRoll)
                onRoll(a.payload);
            break;
 
        case Action::NoteOpen:
        {
            std::string uuid = resolveNote_(a.payload);
            if (!uuid.empty() && onNoteOpen)
                onNoteOpen(uuid);
            break;
        }
 
        default:
            // Fallback: try external open if handler present
            if (onOpenExternal)
                onOpenExternal(m_href);
            else
                openDefaultBrowser_(m_href);
            break;
    }
}

Here is the call graph for this function:

openDefaultBrowser_()

void MarkdownRenderer::openDefaultBrowser_ ( const std::string & url )

static

Definition at line 88 of file MarkdownRenderer.cpp.

{
    if (url.empty())
        return;
 
    // Use wide API for unicode URLs
    int wlen = MultiByteToWideChar(CP_UTF8, 0, url.c_str(), -1, nullptr, 0);
    std::wstring wurl;
    wurl.resize(wlen ? (wlen - 1) : 0);
    if (wlen > 0)
        MultiByteToWideChar(CP_UTF8, 0, url.c_str(), -1, wurl.data(), wlen);
 
    HINSTANCE r = ShellExecuteW(nullptr, L"open", wurl.c_str(), nullptr, nullptr, SW_SHOWNORMAL);
    if ((INT_PTR)r <= 32)
    {
        // Very dumb fallback
        std::string cmd = "start \"\" \"" + url + "\"";
        std::system(cmd.c_str());
    }
}

Here is the caller graph for this function:

parseHref_()

MarkdownRenderer::Parsed MarkdownRenderer::parseHref_ ( const std::string & href ) const

private

Definition at line 51 of file MarkdownRenderer.cpp.

{
    // external?
    if (startsWith_(href, "http://") || startsWith_(href, "https://"))
        return {Action::OpenExternal, href};
 
    // roll://expr or roll:expr
    if (startsWith_(href, "roll://"))
        return {Action::RollExpr, href.substr(7)};
    if (startsWith_(href, "roll:"))
        return {Action::RollExpr, href.substr(5)};
 
    // note://open/<ref>
    if (startsWith_(href, "note://open/"))
        return {Action::NoteOpen, href.substr(std::string("note://open/").size())};
 
    // Short forms: note:/<ref> / note:<ref>
    if (startsWith_(href, "note:/"))
        return {Action::NoteOpen, href.substr(6)};
    if (startsWith_(href, "note:"))
        return {Action::NoteOpen, href.substr(5)};
 
    return {};
}

Here is the call graph for this function:

Here is the caller graph for this function:

resolveNote_()

std::string MarkdownRenderer::resolveNote_ ( const std::string & ref ) const

private

Definition at line 76 of file MarkdownRenderer.cpp.

{
    if (looksLikeUuid_(ref))
        return ref;
 
    if (resolveNoteRef)
        return resolveNoteRef(ref);
 
    return {};
}

Here is the call graph for this function:

Here is the caller graph for this function:

soft_break()

void MarkdownRenderer::soft_break ( )

override

Definition at line 41 of file MarkdownRenderer.cpp.

{
    // Turn Markdown soft-breaks into visible line breaks.
    // Either of these works; TextUnformatted("\n") is a common pattern with imgui_md.
    ImGui::TextUnformatted("\n");
    // Alternatively:
    // ImGui::NewLine();
}

startsWith_()

bool MarkdownRenderer::startsWith_ ( const std::string & s, const char * pref )

staticprivate

Definition at line 110 of file MarkdownRenderer.cpp.

{
    const size_t n = std::strlen(pref);
    return s.size() >= n && std::equal(pref, pref + n, s.begin());
}

Here is the caller graph for this function:

Member Data Documentation

onNoteOpen

std::function<void(const std::string& uuid) MarkdownRenderer::onNoteOpen)

Definition at line 26 of file MarkdownRenderer.h.

onOpenExternal

std::function<void(const std::string& url) MarkdownRenderer::onOpenExternal)

Definition at line 24 of file MarkdownRenderer.h.

onRoll

std::function<void(const std::string& expr) MarkdownRenderer::onRoll)

Definition at line 25 of file MarkdownRenderer.h.

resolveNoteRef

std::function<std::string(const std::string& ref) MarkdownRenderer::resolveNoteRef)

Definition at line 29 of file MarkdownRenderer.h.

---

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

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