LauncherUI Class Reference

#include <LauncherUI.h>

Public Member Functions
	LauncherUI (LauncherConfig *config, SDL_Renderer *renderer)
	~LauncherUI ()
void	Render (bool *p_open)

Detailed Description

Definition at line 333 of file LauncherUI.h.

Constructor & Destructor Documentation

LauncherUI()

LauncherUI::LauncherUI	(	LauncherConfig *	config,
		SDL_Renderer *	renderer
	)

Definition at line 130 of file LauncherUI.cpp.

    : mConfig(config)
    , mRenderer(renderer)
    , mSelectedExperiment(-1)
    , mFullscreen(false)
    , mShowAbout(false)
    , mScreenshotTexture(nullptr)
    , mScreenshotWidth(0)
    , mScreenshotHeight(0)
    , mRunningExperiment(nullptr)
    , mShowStderr(false)
    , mOutputExpanded(false)
    , mSelectedStudyIndex(-1)
    , mSelectedChainIndex(-1)
    , mSelectedStudyTestIndex(-1)
    , mStudyTestScreenshot(nullptr)
    , mStudyTestScreenshotW(0)
    , mStudyTestScreenshotH(0)
    , mRunningChain(false)
    , mCurrentChainItemIndex(-1)
    , mShowParameterEditor(false)
    , mShowVariantNameDialog(false)
    , mEditingTestIndex(-1)
    , mEditingDefaultParams(true)
    , mShowDuplicateSubjectWarning(false)
    , mShowSnapshotCreated(false)
    , mShowSettings(false)
    , mShowNewStudyDialog(false)
    , mShowNewChainDialog(false)
    , mShowStudySettingsDialog(false)
    , mShowFirstRunDialog(false)
    , mShowGettingStartedDialog(false)
    , mShowEditParticipantCodeDialog(false)
    , mAddTestSubTab(0)
    , mQuickLaunchSelectedFile(-1)
    , mShowCodeEditor(false)
    , mShowScaleBuilder(false)
    , mSelectedScaleIndex(-1)
    , mSelectedDimensionIndex(-1)
    , mScaleBrowserScreenshot(nullptr)
    , mScaleBrowserScreenshotW(0)
    , mScaleBrowserScreenshotH(0)
    , mScaleBrowserScreenshotForIndex(-1)
    , mScaleTransSelectedKey(-1)
{
    mScaleTransLanguage[0] = '\0';
    // Configure PEBL syntax highlighting based on doc/pebl.lang
    auto lang = TextEditor::LanguageDefinition();
 
    lang.mName = "PEBL";
 
    // PEBL keywords (case-insensitive in actual language, but TextEditor is case-sensitive)
    // Include both cases for common usage
    lang.mKeywords = {
        "if", "If", "IF",
        "elseif", "ElseIf", "ELSEIF",
        "else", "Else", "ELSE",
        "loop", "Loop", "LOOP",
        "while", "While", "WHILE",
        "return", "Return", "RETURN",
        "define", "Define", "DEFINE",
        "and", "And", "AND",
        "or", "Or", "OR",
        "not", "Not", "NOT",
        "break", "Break", "BREAK"
    };
 
    // PEBL uses # for single-line comments (shell-like)
    lang.mSingleLineComment = "#";
    lang.mCommentStart = "";  // No multi-line comments in PEBL
    lang.mCommentEnd = "";
 
    // PEBL-specific token regex patterns (regex, palette index)
    lang.mTokenRegexStrings = {
        { "\\b[0-9]*\\.[0-9]+\\b", TextEditor::PaletteIndex::Number },  // Floats first
        { "\\b[0-9]+\\b", TextEditor::PaletteIndex::Number },           // Then integers
        { "\\bg[A-Za-z0-9_]*(\\.[A-Za-z0-9_]+)?\\b", TextEditor::PaletteIndex::Identifier },  // Global variables
        { "\\b[a-fh-z][A-Za-z0-9_]*(\\.[A-Za-z0-9_]+)?\\b", TextEditor::PaletteIndex::Identifier },  // Local variables
        { ":?[A-Z][A-Za-z0-9_]*(?=\\s*\\()", TextEditor::PaletteIndex::KnownIdentifier },  // Function names
        { "<-", TextEditor::PaletteIndex::Preprocessor },  // Assignment operator
    };
 
    lang.mCaseSensitive = true;  // For variable names (g vs others)
    lang.mAutoIndentation = true;
 
    mCodeEditor.SetLanguageDefinition(lang);
    mCodeEditor.SetShowWhitespaces(false);
    mCodeEditor.SetTabSize(4);
    mCodeEditor.SetPalette(TextEditor::GetDarkPalette());
    // Initialize UI state from config
    std::strncpy(mSubjectCode, config->GetSubjectCode().c_str(), sizeof(mSubjectCode) - 1);
    mSubjectCode[sizeof(mSubjectCode) - 1] = '\0';
    mParticipantCode[0] = '\0';
    mStudyCode[0] = '\0';
    mQuickLaunchPath[0] = '\0';
    mQuickLaunchParamFile[0] = '\0';
    mLastSnapshotName[0] = '\0';
    mLastSnapshotPath[0] = '\0';
 
    // Set Quick Launch to start in workspace directory
    // Portable mode: portable root directory (for access to PEBL/battery, demo, tutorial)
    // Installed mode: Documents/pebl-exp.2.4
    std::string peblExpPath = config->GetWorkspacePath();
    if (!peblExpPath.empty()) {
        try {
            if (fs::exists(peblExpPath) && fs::is_directory(peblExpPath)) {
                mQuickLaunchDirectory = peblExpPath;
 
                // Scan for .pbl files on startup
                for (const auto& entry : fs::directory_iterator(peblExpPath)) {
                    if (!entry.is_regular_file()) continue;
                    std::string name = entry.path().filename().string();
                    if (name.length() > 4 && name.substr(name.length() - 4) == ".pbl") {
                        mQuickLaunchFiles.push_back(name);
                    }
                }
                std::sort(mQuickLaunchFiles.begin(), mQuickLaunchFiles.end());
            } else {
                // Fall back to config directory
                mQuickLaunchDirectory = config->GetExperimentDirectory();
            }
        } catch (const fs::filesystem_error&) {
            // Fall back to config directory
            mQuickLaunchDirectory = config->GetExperimentDirectory();
        }
    }
 
    std::strncpy(mLanguageCode, config->GetLanguage().c_str(), sizeof(mLanguageCode) - 1);
    mLanguageCode[sizeof(mLanguageCode) - 1] = '\0';
    std::strncpy(mExperimentDir, config->GetExperimentDirectory().c_str(), sizeof(mExperimentDir) - 1);
    mExperimentDir[sizeof(mExperimentDir) - 1] = '\0';
    mFullscreen = config->GetFullscreen();
 
    // Initialize additional run settings
    mScreenResolution = 0;  // Default to first resolution (auto)
    mVSync = false;
    mGraphicsDriver[0] = '\0';
    mCustomArguments[0] = '\0';
 
    // Initialize study system
    mWorkspace = std::make_shared<WorkspaceManager>();
    mSnapshots = std::make_shared<SnapshotManager>();
 
    // If the config has an explicit workspace path (loaded from saved settings), use that.
    // This keeps WorkspaceManager in sync with LauncherConfig so scale tests and the UI
    // settings panel both operate on the same directory.
    if (!config->GetWorkspacePath().empty()) {
        mWorkspace->SetWorkspacePath(config->GetWorkspacePath());
    }
 
    // Initialize scale manager with battery and workspace paths
    std::string batteryPathForScales = config->GetBatteryPath();
    std::string workspacePathForScales = mWorkspace->GetWorkspacePath();
    if (!batteryPathForScales.empty()) {
        mScaleManager = std::make_shared<ScaleManager>(batteryPathForScales, workspacePathForScales);
        printf("Initialized Scale Manager with battery path: %s, workspace path: %s\n",
               batteryPathForScales.c_str(), workspacePathForScales.c_str());
        fflush(stdout);
    } else {
        printf("Warning: Battery path not set, Scale Builder will not be available\n");
        fflush(stdout);
    }
 
    // Check for first run
    if (mWorkspace->IsFirstRun()) {
        mShowFirstRunDialog = true;
    } else {
        // Initialize workspace (creates directories) only if not first run
        // On first run, we wait for user confirmation in the dialog
        if (!mWorkspace->Initialize()) {
            printf("Warning: Failed to initialize workspace\n");
        }
    }
 
    // Initialize page editor state
    mPageEditor.show = false;
    mPageEditor.editingIndex = -1;
    mPageEditor.title[0] = '\0';
    mPageEditor.content[0] = '\0';
    mPageEditor.pageType = 0;
 
    // Initialize test editor state
    mTestEditor.show = false;
    mTestEditor.editingIndex = -1;
    mTestEditor.selectedTestIndex = -1;
    mTestEditor.selectedVariantIndex = 0;  // Default variant
    mTestEditor.language[0] = '\0';
    mTestEditor.randomGroup = 0;  // No randomization by default
 
    // Initialize translation editor state (handled by constructor now)
    // mTranslationEditor is default-constructed
 
    // Initialize variant naming dialog
    mVariantName[0] = '\0';
 
    // Initialize top-level tab (default to Study)
    mTopLevelTab = 0;
 
    // Initialize new study dialog state
    mNewStudyName[0] = '\0';
    mNewStudyDescription[0] = '\0';
    mNewStudyAuthor[0] = '\0';
 
    // Initialize new chain dialog state
    mNewChainName[0] = '\0';
    mNewChainDescription[0] = '\0';
 
    // Scan battery directory for tests
    // Use battery path from config, fall back to experiment directory
    std::string batteryPath = config->GetBatteryPath();
    if (batteryPath.empty()) {
        batteryPath = mExperimentDir;
    }
 
    // Store battery path for template loading
    mBatteryPath = batteryPath;
 
    if (!batteryPath.empty() && batteryPath.length() < sizeof(mExperimentDir)) {
        std::strncpy(mExperimentDir, batteryPath.c_str(), sizeof(mExperimentDir) - 1);
        mExperimentDir[sizeof(mExperimentDir) - 1] = '\0';
        ScanExperimentDirectory(batteryPath);
        printf("Scanned battery directory: %s - found %zu tests\n",
               batteryPath.c_str(), mExperiments.size());
        fflush(stdout);
    }
 
    // Scan templates directory
    ScanTemplates();
 
    // Restore previously selected study and chain
    std::string lastStudyPath = config->GetCurrentStudyPath();
    if (!lastStudyPath.empty()) {
        printf("Restoring last study: %s\n", lastStudyPath.c_str());
        LoadStudy(lastStudyPath);
 
        // If study loaded successfully, restore the chain
        if (mCurrentStudy) {
            std::string lastChainName = config->GetCurrentChainName();
            if (!lastChainName.empty()) {
                std::string chainPath = lastStudyPath + "/chains/" + lastChainName;
                printf("Restoring last chain: %s\n", chainPath.c_str());
                LoadChain(chainPath);
            }
        }
    }
}

References PageEditorState::content, PageEditorState::editingIndex, TestEditorState::editingIndex, LauncherConfig::GetBatteryPath(), LauncherConfig::GetCurrentChainName(), LauncherConfig::GetCurrentStudyPath(), TextEditor::GetDarkPalette(), LauncherConfig::GetExperimentDirectory(), LauncherConfig::GetFullscreen(), LauncherConfig::GetLanguage(), LauncherConfig::GetSubjectCode(), LauncherConfig::GetWorkspacePath(), TextEditor::Identifier, TextEditor::KnownIdentifier, TestEditorState::language, TextEditor::Number, PageEditorState::pageType, TextEditor::Preprocessor, TestEditorState::randomGroup, TestEditorState::selectedTestIndex, TestEditorState::selectedVariantIndex, TextEditor::SetLanguageDefinition(), TextEditor::SetPalette(), TextEditor::SetShowWhitespaces(), TextEditor::SetTabSize(), PageEditorState::show, TestEditorState::show, and PageEditorState::title.

~LauncherUI()

LauncherUI::~LauncherUI

(

)

Definition at line 377 of file LauncherUI.cpp.

{
    FreeScreenshot();
    FreeStudyTestScreenshot();
 
    if (mScaleBrowserScreenshot) {
        SDL_DestroyTexture(mScaleBrowserScreenshot);
        mScaleBrowserScreenshot = nullptr;
    }
 
    // Clean up running experiment if any
    if (mRunningExperiment) {
        delete mRunningExperiment;
        mRunningExperiment = nullptr;
    }
}

Member Function Documentation

Render()

void LauncherUI::Render

(

bool *

p_open

)

Definition at line 394 of file LauncherUI.cpp.

{
    // Update running experiment output if any
    if (mRunningExperiment && mRunningExperiment->IsRunning()) {
        mRunningExperiment->UpdateOutput();
    }
 
    // Check if chain execution needs to advance to next item
    if (mRunningChain && mRunningExperiment) {
        bool isRunning = mRunningExperiment->IsRunning();
        if (!isRunning) {
            printf("DEBUG: Chain item finished (IsRunning=false), advancing...\n");
 
            // Check exit code - only abort chain if it's a consent form with exit code 1
            // Exit code 1 = user explicitly declined consent
            // Other non-zero codes = crash or error, not consent decline
            int exitCode = mRunningExperiment->GetExitCode();
 
            // Debug logging to file and stdout
            FILE* debugLog = fopen("chain_debug.log", "a");
            if (debugLog) {
                fprintf(debugLog, "=== Chain item finished ===\n");
                fprintf(debugLog, "  Exit code: %d\n", exitCode);
                fprintf(debugLog, "  mCurrentChainItemIndex: %d\n", mCurrentChainItemIndex);
                fflush(debugLog);
            }
            printf("=== Chain item finished ===\n");
            printf("  Exit code from GetExitCode(): %d\n", exitCode);
            printf("  mCurrentChainItemIndex: %d\n", mCurrentChainItemIndex);
 
            // Get the current chain item to check its type
            bool shouldAbortChain = false;
            bool isConsentDecline = false;
            if (debugLog) {
                fprintf(debugLog, "  Checking: exitCode=%d, chainItemIndex=%d\n", exitCode, mCurrentChainItemIndex);
            }
            if (exitCode != 0 && mCurrentChain && mCurrentChainItemIndex >= 0 &&
                mCurrentChainItemIndex < (int)mCurrentChain->GetItems().size()) {
                const ChainItem& currentItem = mCurrentChain->GetItems()[mCurrentChainItemIndex];
                if (debugLog) {
                    fprintf(debugLog, "  Item type=%d (Consent=%d)\n", (int)currentItem.type, (int)ItemType::Consent);
                    fflush(debugLog);
                }
 
                // Treat exit code 1 as "declined/ineligible" for:
                //   - ItemType::Consent (built-in consent page)
                //   - ItemType::Test when exit code is 1 (ScaleRunner gateTriggered path)
                // Other non-zero codes = crash/error, continue chain.
                if (exitCode == 1 && (currentItem.type == ItemType::Consent ||
                                      currentItem.type == ItemType::Test)) {
                    shouldAbortChain = true;
                    isConsentDecline = true;
                    if (debugLog) fprintf(debugLog, "  -> CONSENT/GATE DECLINED (code 1), aborting chain\n");
                } else if (currentItem.type == ItemType::Consent && exitCode != 0) {
                    if (debugLog) fprintf(debugLog, "  -> Consent error (code %d), continuing\n", exitCode);
                } else {
                    if (debugLog) fprintf(debugLog, "  -> Non-consent item or error (code %d), continuing\n", exitCode);
                }
            } else {
                if (debugLog) fprintf(debugLog, "  exitCode==0 or invalid index, continuing chain\n");
            }
            if (debugLog) {
                fflush(debugLog);
                fclose(debugLog);
            }
 
            if (shouldAbortChain && isConsentDecline) {
                // Exit code 1 on consent form - user explicitly declined consent
                printf("Chain terminated: User declined consent\n");
 
                // Accumulate output from this final item
                mChainAccumulatedStdout += mRunningExperiment->GetStdout();
                mChainAccumulatedStderr += mRunningExperiment->GetStderr();
                mChainAccumulatedStdout += "\n=== Chain terminated: User declined consent ===\n";
 
                // Stop chain execution
                mRunningChain = false;
                mCurrentChainItemIndex = -1;
 
                // Increment participant counter so next run gets a fresh subject number
                if (mCurrentChain) {
                    mCurrentChain->IncrementParticipantCounter();
                    printf("Participant counter incremented to: %d\n", mCurrentChain->GetParticipantCounter());
                }
 
                // Clean up runner
                delete mRunningExperiment;
                mRunningExperiment = nullptr;
 
                // Return early - don't continue to next item
                goto render_ui;
            }
 
            // Accumulate output from completed item BEFORE deleting runner
            mChainAccumulatedStdout += mRunningExperiment->GetStdout();
            mChainAccumulatedStderr += mRunningExperiment->GetStderr();
 
            // Add separator between items for clarity
            mChainAccumulatedStdout += "\n=== End of item " + std::to_string(mCurrentChainItemIndex + 1) + " ===\n\n";
            mChainAccumulatedStderr += "\n=== End of item " + std::to_string(mCurrentChainItemIndex + 1) + " ===\n\n";
 
            // Current item has finished, advance to next
            printf("Chain item %d finished, advancing...\n", mCurrentChainItemIndex + 1);
            mCurrentChainItemIndex++;
 
            if (mCurrentChain && mCurrentChainItemIndex < (int)mCurrentChain->GetItems().size()) {
                // Execute next item
                const ChainItem& item = mCurrentChain->GetItems()[mCurrentChainItemIndex];
                printf("Advancing to chain item %d/%zu: %s\n",
                       mCurrentChainItemIndex + 1,
                       mCurrentChain->GetItems().size(),
                       item.GetDisplayName().c_str());
 
                // Clean up previous runner (output already accumulated)
                delete mRunningExperiment;
                mRunningExperiment = nullptr;
 
                // Execute the next item
                ExecuteChainItem(mCurrentChainItemIndex);
            } else {
                // Chain completed
                printf("Chain execution completed (all %zu items finished)\n", mCurrentChain->GetItems().size());
                mRunningChain = false;
                mCurrentChainItemIndex = -1;
 
                // Increment participant counter for next run
                if (mCurrentChain) {
                    mCurrentChain->IncrementParticipantCounter();
                    printf("Participant counter incremented to: %d\n", mCurrentChain->GetParticipantCounter());
                }
 
                // Clean up runner (output already accumulated)
                if (mRunningExperiment) {
                    delete mRunningExperiment;
                    mRunningExperiment = nullptr;
                }
            }
        }
    }
 
render_ui:
    // Main window takes up full viewport
    ImGuiViewport* viewport = ImGui::GetMainViewport();
    ImGui::SetNextWindowPos(viewport->WorkPos);
    ImGui::SetNextWindowSize(viewport->WorkSize);
 
    ImGuiWindowFlags window_flags = ImGuiWindowFlags_MenuBar | ImGuiWindowFlags_NoTitleBar |
                                     ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize |
                                     ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoBringToFrontOnFocus;
 
    ImGui::Begin("PEBL Launcher", p_open, window_flags);
 
    RenderMenuBar();
 
    // Reserve space at bottom for output panel, then wrap tab content
    float outputPanelHeight = mOutputExpanded ? 250.0f : 30.0f;
    float contentHeight = ImGui::GetContentRegionAvail().y - outputPanelHeight;
    ImGui::BeginChild("MainTabArea", ImVec2(0, contentHeight));
 
    // Top-level tabbed interface: Manage Studies vs Quick Launch
    // Make tab headers larger and more prominent (colors, padding, and larger font)
    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(30, 8));   // Larger horizontal and vertical padding
    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(12, 8));    // More spacing around tabs
    ImGui::PushStyleVar(ImGuiStyleVar_TabRounding, 8.0f);             // Rounded corners for pill effect
    ImGui::PushStyleColor(ImGuiCol_Tab, ImVec4(0.35f, 0.40f, 0.48f, 1.0f));           // Darker blue for inactive
    ImGui::PushStyleColor(ImGuiCol_TabHovered, ImVec4(0.35f, 0.60f, 0.85f, 1.0f));    // Brighter blue on hover
    ImGui::PushStyleColor(ImGuiCol_TabActive, ImVec4(0.20f, 0.60f, 0.95f, 1.0f));     // Vivid blue for active
 
    if (ImGui::BeginTabBar("TopLevelTabs", ImGuiTabBarFlags_None)) {
        // Manage Studies tab
        ImGui::SetWindowFontScale(1.5f);  // Large font for tab header
        if (ImGui::BeginTabItem("Manage Studies")) {
            if (mTopLevelTab != 1) {  // Don't override if we're switching to Quick Launch
                mTopLevelTab = 0;
            }
            ImGui::SetWindowFontScale(1.0f);
            ImGui::PopStyleColor(3);
            ImGui::PopStyleVar(3);
 
            // Show study bar (study selector, new study button, etc.)
            RenderStudyBar();
 
            // Small spacing before second-level tabs
            ImGui::Dummy(ImVec2(0, 5));
 
            // Second-level tab styling
            ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(20, 6));
            ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(8, 6));
            ImGui::PushStyleVar(ImGuiStyleVar_TabRounding, 6.0f);
            ImGui::PushStyleColor(ImGuiCol_Tab, ImVec4(0.35f, 0.40f, 0.48f, 1.0f));
            ImGui::PushStyleColor(ImGuiCol_TabHovered, ImVec4(0.35f, 0.60f, 0.85f, 1.0f));
            ImGui::PushStyleColor(ImGuiCol_TabActive, ImVec4(0.20f, 0.60f, 0.95f, 1.0f));
 
            if (ImGui::BeginTabBar("StudyTabs", ImGuiTabBarFlags_None)) {
                ImGui::SetWindowFontScale(1.3f);  // Medium font for second-level tabs
                if (ImGui::BeginTabItem("Tests")) {
                    ImGui::SetWindowFontScale(1.0f);
                    ImGui::PopStyleColor(3);
                    ImGui::PopStyleVar(3);
 
                    RenderTestsTab();
                    ImGui::EndTabItem();
 
                    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(20, 6));
                    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(8, 6));
                    ImGui::PushStyleVar(ImGuiStyleVar_TabRounding, 6.0f);
                    ImGui::PushStyleColor(ImGuiCol_Tab, ImVec4(0.35f, 0.40f, 0.48f, 1.0f));
                    ImGui::PushStyleColor(ImGuiCol_TabHovered, ImVec4(0.35f, 0.60f, 0.85f, 1.0f));
                    ImGui::PushStyleColor(ImGuiCol_TabActive, ImVec4(0.20f, 0.60f, 0.95f, 1.0f));
                    ImGui::SetWindowFontScale(1.3f);
                }
 
                if (ImGui::BeginTabItem("Chains")) {
                    ImGui::SetWindowFontScale(1.0f);
                    ImGui::PopStyleColor(3);
                    ImGui::PopStyleVar(3);
 
                    RenderChainsTab();
                    ImGui::EndTabItem();
 
                    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(20, 6));
                    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(8, 6));
                    ImGui::PushStyleVar(ImGuiStyleVar_TabRounding, 6.0f);
                    ImGui::PushStyleColor(ImGuiCol_Tab, ImVec4(0.35f, 0.40f, 0.48f, 1.0f));
                    ImGui::PushStyleColor(ImGuiCol_TabHovered, ImVec4(0.35f, 0.60f, 0.85f, 1.0f));
                    ImGui::PushStyleColor(ImGuiCol_TabActive, ImVec4(0.20f, 0.60f, 0.95f, 1.0f));
                    ImGui::SetWindowFontScale(1.3f);
                }
 
                if (ImGui::BeginTabItem("Run")) {
                    ImGui::SetWindowFontScale(1.0f);
                    ImGui::PopStyleColor(3);
                    ImGui::PopStyleVar(3);
 
                    RenderRunTab();
                    ImGui::EndTabItem();
 
                    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(20, 6));
                    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(8, 6));
                    ImGui::PushStyleVar(ImGuiStyleVar_TabRounding, 6.0f);
                    ImGui::PushStyleColor(ImGuiCol_Tab, ImVec4(0.35f, 0.40f, 0.48f, 1.0f));
                    ImGui::PushStyleColor(ImGuiCol_TabHovered, ImVec4(0.35f, 0.60f, 0.85f, 1.0f));
                    ImGui::PushStyleColor(ImGuiCol_TabActive, ImVec4(0.20f, 0.60f, 0.95f, 1.0f));
                }
 
                // Final cleanup for second-level tabs
                ImGui::SetWindowFontScale(1.0f);
                ImGui::PopStyleColor(3);
                ImGui::PopStyleVar(3);
 
                ImGui::EndTabBar();
            } else {
                // If tab bar didn't begin, clean up styles
                ImGui::SetWindowFontScale(1.0f);
                ImGui::PopStyleColor(3);
                ImGui::PopStyleVar(3);
            }
 
            ImGui::EndTabItem();
 
            // Restore styles for next top-level tab header
            ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(30, 8));
            ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(12, 8));
            ImGui::PushStyleVar(ImGuiStyleVar_TabRounding, 8.0f);
            ImGui::PushStyleColor(ImGuiCol_Tab, ImVec4(0.35f, 0.40f, 0.48f, 1.0f));
            ImGui::PushStyleColor(ImGuiCol_TabHovered, ImVec4(0.35f, 0.60f, 0.85f, 1.0f));
            ImGui::PushStyleColor(ImGuiCol_TabActive, ImVec4(0.20f, 0.60f, 0.95f, 1.0f));
            ImGui::SetWindowFontScale(1.5f);
        }
 
        // Quick Launch tab
        ImGuiTabItemFlags quickLaunchFlags = (mTopLevelTab == 1) ? ImGuiTabItemFlags_SetSelected : 0;
        if (ImGui::BeginTabItem("Quick Launch", nullptr, quickLaunchFlags)) {
            if (mTopLevelTab == 1) {
                mTopLevelTab = -1;  // Reset flag after first frame
            }
            ImGui::SetWindowFontScale(1.0f);
            ImGui::PopStyleColor(3);
            ImGui::PopStyleVar(3);
 
            RenderQuickLaunchTab();
            ImGui::EndTabItem();
 
            // Restore styles for next top-level tab header
            ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(30, 8));
            ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(12, 8));
            ImGui::PushStyleVar(ImGuiStyleVar_TabRounding, 8.0f);
            ImGui::PushStyleColor(ImGuiCol_Tab, ImVec4(0.35f, 0.40f, 0.48f, 1.0f));
            ImGui::PushStyleColor(ImGuiCol_TabHovered, ImVec4(0.35f, 0.60f, 0.85f, 1.0f));
            ImGui::PushStyleColor(ImGuiCol_TabActive, ImVec4(0.20f, 0.60f, 0.95f, 1.0f));
            ImGui::SetWindowFontScale(1.5f);
        }
 
        // Scales/Surveys tab
        ImGuiTabItemFlags scaleBuilderFlags = (mTopLevelTab == 2) ? ImGuiTabItemFlags_SetSelected : 0;
        if (ImGui::BeginTabItem("Scales/Surveys", nullptr, scaleBuilderFlags)) {
            if (mTopLevelTab == 2) {
                mTopLevelTab = -1;  // Reset flag after first frame
            }
            ImGui::SetWindowFontScale(1.0f);
            ImGui::PopStyleColor(3);
            ImGui::PopStyleVar(3);
 
            ShowScaleBuilder();
            ImGui::EndTabItem();
 
            // Restore styles for consistency
            ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(30, 8));
            ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(12, 8));
            ImGui::PushStyleVar(ImGuiStyleVar_TabRounding, 8.0f);
            ImGui::PushStyleColor(ImGuiCol_Tab, ImVec4(0.35f, 0.40f, 0.48f, 1.0f));
            ImGui::PushStyleColor(ImGuiCol_TabHovered, ImVec4(0.35f, 0.60f, 0.85f, 1.0f));
            ImGui::PushStyleColor(ImGuiCol_TabActive, ImVec4(0.20f, 0.60f, 0.95f, 1.0f));
        }
 
        // Final cleanup - pop the styles that are still on the stack
        ImGui::SetWindowFontScale(1.0f);
        ImGui::PopStyleColor(3);
        ImGui::PopStyleVar(3);
 
        ImGui::EndTabBar();
    } else {
        // If tab bar didn't begin, clean up styles
        ImGui::SetWindowFontScale(1.0f);
        ImGui::PopStyleColor(3);
        ImGui::PopStyleVar(3);
    }
 
    ImGui::EndChild();  // MainTabArea
 
    // Output panel at bottom of window
    RenderOutputPanel();
 
    ImGui::End();
 
    // Show about dialog if requested
    if (mShowAbout) {
        ShowAboutDialog();
    }
 
    // Show variant naming dialog if requested
    if (mShowVariantNameDialog) {
        ShowVariantNameDialog();
    }
 
    // Show parameter editor if requested
    if (mShowParameterEditor) {
        ShowParameterEditor();
    }
 
    // Show settings dialog if requested
    if (mShowSettings) {
        ShowSettingsDialog();
    }
 
    // Show page editor if requested
    if (mPageEditor.show) {
        ShowPageEditor();
    }
 
    // Show test editor if requested
    if (mTestEditor.show) {
        ShowTestEditor();
    }
 
    // Show code editor if requested
    if (mShowCodeEditor) {
        ShowCodeEditor();
    }
 
    // Show question editor dialog if requested
    if (mQuestionEditor.show) {
        ShowQuestionEditor();
    }
 
    // Show batch import dialog if requested
    if (mBatchImport.show) {
        ShowBatchImportDialog();
    }
 
    // Show dimension editor dialog if requested
    if (mDimensionEditor.show) {
        ShowDimensionEditor();
    }
 
    // Show create study from scale dialog if requested
    if (mCreateStudyDialog.show) {
        ShowCreateStudyFromScaleDialog();
    }
 
    // Show correct answers editor dialog if requested
    if (mCorrectAnswersEditor.show) {
        ShowCorrectAnswersEditor();
    }
 
    // Show norms editor dialog if requested
    if (mNormsEditor.show) {
        ShowNormsEditor();
    }
 
    // Show translation editor dialog if requested.
    // When opened from inside the test editor popup (fromTestEditor), it renders
    // inline there (correct ImGui stack level). Skip rendering it here in that case.
    bool translationEditorWasShown = mTranslationEditor.show;
    if (mTranslationEditor.show && !mTranslationEditor.fromTestEditor) {
        ShowTranslationEditorDialog();
    }
    // When scale-mode translation editor closes, reload translations from disk into mCurrentScale
    if (translationEditorWasShown && !mTranslationEditor.show &&
        mTranslationEditor.scaleMode && mCurrentScale && mScaleManager) {
        auto reloaded = mScaleManager->LoadScale(mCurrentScale->GetScaleInfo().code);
        if (reloaded) {
            mCurrentScale->GetTranslations() = reloaded->GetTranslations();
        }
        mTranslationEditor.ClearScaleMode();
    }
 
    // Show new study dialog if requested
    if (mShowNewStudyDialog) {
        ShowNewStudyDialog();
    }
 
    // Show new chain dialog if requested
    if (mShowNewChainDialog) {
        ShowNewChainDialog();
    }
 
    // Show study settings dialog if requested
    if (mShowStudySettingsDialog) {
        ShowStudySettingsDialog();
    }
 
    // Show first run dialog if requested
    if (mShowFirstRunDialog) {
        ShowFirstRunDialog();
    }
 
    // Show getting started dialog if there are no studies
    if (mShowGettingStartedDialog) {
        ShowGettingStartedDialog();
    }
 
    // Show duplicate subject code warning if requested
    if (mShowDuplicateSubjectWarning) {
        ShowDuplicateSubjectWarning();
    }
 
    // Show edit participant code dialog if requested
    if (mShowEditParticipantCodeDialog) {
        ShowEditParticipantCodeDialog();
    }
 
    // Show snapshot created dialog if requested
    if (mShowSnapshotCreated) {
        ShowSnapshotCreatedDialog();
    }
 
    // Show OpenScales browser if requested
    mOpenScalesBrowser.Render();
}

References TranslationEditorState::ClearScaleMode(), Consent, TranslationEditorState::fromTestEditor, ChainItem::GetDisplayName(), ExperimentRunner::GetExitCode(), ExperimentRunner::GetStderr(), ExperimentRunner::GetStdout(), ExperimentRunner::IsRunning(), OpenScalesBrowser::Render(), TranslationEditorState::scaleMode, PageEditorState::show, TestEditorState::show, TranslationEditorState::show, QuestionEditorState::show, DimensionEditorState::show, BatchImportState::show, NormsEditorState::show, CorrectAnswersEditorState::show, CreateStudyFromScaleState::show, Test, ChainItem::type, and ExperimentRunner::UpdateOutput().

Referenced by main().

---

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

• LauncherUI.h
• LauncherUI.cpp