minimal, self-contained example of a custom LogView control in U++

[Trilec]

Example proposal

would like to propose this as a example particularly how the RichEdit is working

/**
 * @file main.cpp
 * @brief A minimal, self-contained example of a custom LogView control in U++.
 *
 * This application demonstrates how to create a specialized "Facade" class by inheriting
 * from RichEdit to produce a clean, easy-to-use, and reusable logging component.
 * It's designed to be a clear, practical example for community forums, showing how
 * to abstract away complex setup and formatting.
 */
#include <CtrlLib/CtrlLib.h>
#include <RichEdit/RichEdit.h>

using namespace Upp;

//================================================================================================
/**
 * @class LogView
 * @brief A specialized RichEdit control designed for displaying formatted log output.
 *
 * This class encapsulates all the setup and QTF formatting logic required to create
 * a clean, readable, read-only log display. It provides a simple API for appending
 * styled text, abstracting away the complexities of the underlying RichEdit control.
 */
//================================================================================================
struct LogView : RichEdit {
public:
    /// Defines the visual style for a log entry.
    enum LogStyle { LOG_NORMAL, LOG_HEADER, LOG_SUCCESS, LOG_ERROR };

    /**
     * @brief Constructor that applies sensible defaults for a log control.
     * Sets the control to be read-only, hides the ruler and non-printing characters,
     * and initializes the font.
     */
    LogView() {
        SetReadOnly();
        NoRuler();
        ShowCodes(Null);
        qtf_log_buffer = "[A1] "; // Initialize with 8pt Arial font.
    }

    /**
     * @brief Appends a styled line of text to the log.
     * @param text The string to be logged.
     * @param style The visual style to apply (e.g., HEADER, SUCCESS).
     * @param newline If true, a newline character is appended.
     */
    void Log(const String& text, LogStyle style = LOG_NORMAL, bool newline = true) {
        String qtf_text = text;
        
        switch(style) {
            case LOG_HEADER:  qtf_text = "[* " + qtf_text + "]"; break;
            case LOG_SUCCESS: qtf_text = "[@g " + qtf_text + "]"; break;
            case LOG_ERROR:   qtf_text = "[*@r " + qtf_text + "]"; break;
            case LOG_NORMAL:
            default:
                break;
        }
        
        qtf_log_buffer.Cat(qtf_text);
        if(newline) qtf_log_buffer.Cat("&");

        SetQTF(qtf_log_buffer);
        Move(GetLength());
        Ctrl::ProcessEvents(); // Keep UI responsive during long operations.
    }
    
    /// @brief Adds a horizontal rule to the log for visual separation.
    void AddSeparator() {
        Log("[--]", LOG_NORMAL);
    }

private:
    /// The internal QTF string that acts as the data model for the control.
    String qtf_log_buffer;
};


//================================================================================================
/**
 * @class ExampleRunner
 * @brief The main application window that hosts and demonstrates the LogView.
 */
//================================================================================================
struct ExampleRunner : TopWindow {
    typedef ExampleRunner CLASSNAME;

    Splitter      splitter;
    LogView       logDisplay;     ///< Our custom control for displaying detailed output.
    Button        actionButton;   ///< The main button, used for cancelling or closing.
    
    bool          tasks_cancelled = false; ///< Flag to gracefully stop the process.
    
    /// @brief Logs a simple message to the standard console output.
    void ConsoleLog(const String& text) {
        Cout() << text;
    }

    // --- Example Tasks ---
    // These simple functions demonstrate using the LogView.

    void Test_TaskA() {
        logDisplay.Log("Running: Task A", LogView::LOG_HEADER);
        logDisplay.Log("  Performing some work...");
        Sleep(500); // Simulate work
        logDisplay.Log("  -> PASSED", LogView::LOG_SUCCESS);
    }

    void Test_TaskB() {
        logDisplay.Log("Running: Task B", LogView::LOG_HEADER);
        logDisplay.Log("  This one is much faster.");
        Sleep(100); // Simulate work
        logDisplay.Log("  -> PASSED", LogView::LOG_SUCCESS);
    }
    
    void Test_AFailingTask() {
        logDisplay.Log("Running: A Failing Task", LogView::LOG_HEADER);
        logDisplay.Log("  Oh no, something went wrong.");
        Sleep(300); // Simulate work
        logDisplay.Log("  -> FAILED", LogView::LOG_ERROR);
    }

    /// @brief A macro to simplify running a task and logging its console status.
    #define RUN_TASK(TASK_NAME) \
        if(tasks_cancelled) break; \
        ConsoleLog("Running: " #TASK_NAME "... "); \
        TASK_NAME(); \
        if(tasks_cancelled) break; \
        ConsoleLog("DONE\n"); \
        logDisplay.AddSeparator();

    /**
     * @brief Executes all defined example tasks in sequence.
     */
    void RunAllTasks() {
        ConsoleLog("========================================\n");
        ConsoleLog("  Running Example Tasks\n");
        ConsoleLog("========================================\n");
        logDisplay.Log("LogView Example Suite", LogView::LOG_HEADER);
        logDisplay.Log("");

        do {
            RUN_TASK(Test_TaskA);
            RUN_TASK(Test_TaskB);
            RUN_TASK(Test_AFailingTask);
        } while(0);

        logDisplay.Log("");
        if(tasks_cancelled) {
            ConsoleLog("\n** Tasks Cancelled By User **\n");
            logDisplay.Log("Tasks Cancelled By User", LogView::LOG_ERROR);
        } else {
            ConsoleLog("========================================\n");
            ConsoleLog("  Tasks Finished\n");
            ConsoleLog("========================================\n");
            logDisplay.Log("All tasks finished.", LogView::LOG_SUCCESS);
        }
        
        actionButton.SetLabel("Close");
        actionButton.Enable();
        actionButton <<= callback(this, &TopWindow::Close);
        Title("LogView Example - Finished");
    }

    /// @brief Sets the cancellation flag and updates the GUI to reflect it.
    void CancelTasks() {
        tasks_cancelled = true;
        actionButton.Disable();
        actionButton.SetLabel("Cancelling...");
    }

    /// @brief Constructor for the main application window.
    ExampleRunner() {
        Title("LogView Example - Running...").Sizeable().Zoomable();
        SetRect(0, 0, 700, 400);

        splitter.Vert(logDisplay, actionButton);
        splitter.SetPos(9000); // 90% for log, 10% for button
        Add(splitter.SizePos());
        
        actionButton.SetLabel("Cancel");
        actionButton <<= THISBACK(CancelTasks);

        // Schedule the tasks to run after the window is created and displayed.
        PostCallback(THISBACK(RunAllTasks));
    }
};

/**
 * @brief The main entry point for the U++ GUI application.
 */
GUI_APP_MAIN
{
    StdLogSetup(LOG_COUT);
    ExampleRunner().Run();
}

[mirek-fidler]

• log should be thread safe
• I do not very much like how whole content is always replaced by new QTF. bad practice IMO. There are means to do it better.
• Do not use THISBACK in the new code (sorry that this is not very much emphasised in the docs)
• Can RUN_TASK be lambda instead?
• Now I am probably stubborn, but we have our style of documenting code is T++....

[Trilec]

I completely agree. My goal was to find a robust way to append styled text using only the public API. The SetQTF approach, while inefficient, was the only method I found that reliably handled all styling and state issues. If there is a public, thread-safe way to append RichText or a QTF snippet without replacing the whole document, I would be very keen to learn it. also how to do a seperator???

#include <CtrlLib/CtrlLib.h>
#include <RichEdit/RichEdit.h>

using namespace Upp;

//====================================================================================
/**
    \class LogView
    \brief A robust, thread-safe RichEdit logger using direct inline QTF formatting.

    This component provides a simple API to log text with different styles (normal,
    bold, header, success, warning, error) to a read-only RichEdit control.
    It is designed to be thread-safe via the LogAsync method.
*/
//====================================================================================
struct LogView : RichEdit {
    //! The available logging styles.
    enum LogStyle { LOG_NORMAL, LOG_HEADER, LOG_BOLD, LOG_SUCCESS, LOG_WARNING, LOG_ERROR };

private:
    //! Template for normal text (12pt, default color).
    const char* TPL_NORMAL  = "[3 %s]";
    //! Template for bold text (12pt, bold, default color).
    const char* TPL_BOLD    = "[3* %s]";
    //! Template for a header (12pt, bold, in a boxed cell).
    const char* TPL_HEADER  = "{{ [3* %s]}}";
    //! Template for a success message (12pt, bold, green).
    const char* TPL_SUCCESS = "[3*@4 %s]";
    //! Template for a warning message (12pt, bold, orange).
    const char* TPL_WARNING = "[3*@(255.165.0) %s]";
    //! Template for an error message (12pt, bold, red).
    const char* TPL_ERROR   = "[3*@6 %s]";
  
    //! The internal buffer holding the entire QTF document.
    String content_buffer;
public:
    LogView() {
        SetReadOnly();
        NoRuler();
        ShowCodes(Null);
    }

    //! Logs a string of text with a specific style.
    void Log(const String& text, LogStyle style = LOG_NORMAL, bool newline = true) {
		const char* qtf_template;
        switch(style) {
            case LOG_BOLD:    qtf_template = TPL_BOLD;    break;
            case LOG_HEADER:  qtf_template = TPL_HEADER;  break;
            case LOG_SUCCESS: qtf_template = TPL_SUCCESS; break;
            case LOG_WARNING: qtf_template = TPL_WARNING; break;
            case LOG_ERROR:   qtf_template = TPL_ERROR;   break;
            default:          qtf_template = TPL_NORMAL;  break;
        }

        content_buffer.Cat(Format(qtf_template, DeQtf(text)));
  
        if (newline) {
            content_buffer.Cat('&');
        }

        SetQTF(content_buffer);
        Move(GetLength());
        ScrollToCursor();
    }
    
    //! Adds a simple horizontal line to the log (cant find better way)
    void AddSeparator() {
        content_buffer.Cat("[1 _____________________________]&");
        SetQTF(content_buffer);
        Move(GetLength());
        ScrollToCursor();
    }
  
    //! Posts a logging request to the main GUI thread.
    void LogAsync(const String& text, LogStyle style = LOG_NORMAL, bool newline = true) {
        PostCallback([=] { Log(text, style, newline); });
    }
};


//====================================================================================
// ExampleRunner: Demonstrates the LogView component.
//====================================================================================
struct ExampleRunner : TopWindow {
    typedef ExampleRunner CLASSNAME;
	
    LogView logDisplay;
    Button  actionButton;
    bool    tasks_cancelled = false;

	ExampleRunner() {
	    Title("LogView Example").Sizeable().Zoomable();
	    SetRect(0, 0, 600, 300);
	
	    Add(logDisplay.VSizePos(0, 40).HSizePos());
	    Add(actionButton.BottomPos(4, 30).HSizePos(4, 4));
	
	    actionButton.SetLabel("Cancel");

	    actionButton <<= callback(this, &ExampleRunner::CancelTasks);
	
	    PostCallback([this] { RunAllTasks(); });
	}

    void CancelTasks() {
        tasks_cancelled = true;
        actionButton.Disable();
        actionButton.SetLabel("Cancelling...");
    }

    void RunAllTasks() {
        logDisplay.Log("Tasks Started.", LogView::LOG_HEADER);
        RunTask("Task A:", 150, true);
        RunTask("Task B:", 150, true);
        RunTask("Task C:", 150, false, true); // This one will show a warning
        RunTask("Failing Task:", 150, false);

        if (tasks_cancelled) {
            logDisplay.Log("Tasks Cancelled By User", LogView::LOG_ERROR);
        } else {
            logDisplay.Log("All tasks finished.", LogView::LOG_HEADER);
        }

        actionButton.SetLabel("Close");
        actionButton.Enable();
        actionButton <<= callback(this, &TopWindow::Close);
    }

    void RunTask(const String& name, int delay_ms, bool pass, bool with_warning = false) {
        if (tasks_cancelled) return;

        logDisplay.Log(name, LogView::LOG_NORMAL, false); 
        logDisplay.Log(" Performing some work...", LogView::LOG_NORMAL, false);
        Sleep(delay_ms);

        if (with_warning) {
             logDisplay.Log(" -> WARNING", LogView::LOG_WARNING);
        } else if (pass) {
            logDisplay.Log(" -> PASSED", LogView::LOG_SUCCESS);
        } else {
            logDisplay.Log(" -> FAILED", LogView::LOG_ERROR);
        }
    }
};

// Entry point
GUI_APP_MAIN {
    StdLogSetup(LOG_COUT);
    ExampleRunner().Run();
}