MainWindow.h

Go to the documentation of this file.

/***********************************************************************************************************************
*                                                                                                                      *
* ngscopeclient                                                                                                        *
*                                                                                                                      *
* Copyright (c) 2012-2026 Andrew D. Zonenberg and contributors                                                         *
* All rights reserved.                                                                                                 *
*                                                                                                                      *
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the     *
* following conditions are met:                                                                                        *
*                                                                                                                      *
*    * Redistributions of source code must retain the above copyright notice, this list of conditions, and the         *
*      following disclaimer.                                                                                           *
*                                                                                                                      *
*    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the       *
*      following disclaimer in the documentation and/or other materials provided with the distribution.                *
*                                                                                                                      *
*    * Neither the name of the author nor the names of any contributors may be used to endorse or promote products     *
*      derived from this software without specific prior written permission.                                           *
*                                                                                                                      *
* THIS SOFTWARE IS PROVIDED BY THE AUTHORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED   *
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL *
* THE AUTHORS BE HELD LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES        *
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR       *
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT *
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE       *
* POSSIBILITY OF SUCH DAMAGE.                                                                                          *
*                                                                                                                      *
***********************************************************************************************************************/
 
#ifndef MainWindow_h
#define MainWindow_h
 
#include "Dialog.h"
#include "Session.h"
#include "FontManager.h"
#include "TextureManager.h"
#include "VulkanWindow.h"
#include "WaveformGroup.h"
 
#include "FilterGraphEditor.h"
#include "ManageInstrumentsDialog.h"
#include "ProtocolAnalyzerDialog.h"
#include "StreamBrowserDialog.h"
#include "TriggerPropertiesDialog.h"
#include "TutorialWizard.h"
#include "Workspace.h"
#include "imgui_markdown.h"
 
#include "PreferenceTypes.h"
 
#include "../scopehal/PacketDecoder.h"
 
class MeasurementsDialog;
class HistoryDialog;
class FileBrowser;
class CreateFilterBrowser;
 
class SplitGroupRequest
{
public:
    SplitGroupRequest(
        std::shared_ptr<WaveformGroup> group,
        ImGuiDir direction,
        StreamDescriptor stream,
        std::string ramp)
    : m_group(group)
    , m_direction(direction)
    , m_stream(stream)
    , m_ramp(ramp)
    , m_streamGroup(nullptr)
    , m_singleArea(false)
    {
        auto schan = dynamic_cast<OscilloscopeChannel*>(stream.m_channel);
        if(schan)
            schan->AddRef();
    }
 
    SplitGroupRequest(std::shared_ptr<WaveformGroup> group, ImGuiDir direction, std::shared_ptr<StreamGroupDescriptor> streamGroup, bool singleArea)
    : m_group(group)
    , m_direction(direction)
    , m_streamGroup(streamGroup)
    , m_singleArea(singleArea)
    {
        if(streamGroup)
        {
            for(auto chan : streamGroup->m_channels)
            {
                chan->AddRef();
            }
        }
    }
 
    SplitGroupRequest(const SplitGroupRequest& rhs)
    : m_group(rhs.m_group)
    , m_direction(rhs.m_direction)
    , m_stream(rhs.m_stream)
    , m_ramp(rhs.m_ramp)
    , m_streamGroup(rhs.m_streamGroup)
    , m_singleArea(rhs.m_singleArea)
    {
        if(rhs.m_stream)
        {
            auto schan = dynamic_cast<OscilloscopeChannel*>(rhs.m_stream.m_channel);
            if(schan)
                schan->AddRef();
        }
        else if(rhs.m_streamGroup)
        {
            for(auto chan : rhs.m_streamGroup->m_channels)
            {
                chan->AddRef();
            }
        }
    }
 
    SplitGroupRequest& operator=(const SplitGroupRequest& /*rhs*/) =delete;
 
    ~SplitGroupRequest()
    {
        if(m_stream)
        {
            auto schan = dynamic_cast<OscilloscopeChannel*>(m_stream.m_channel);
            if(schan)
                schan->Release();
        }
        else if(m_streamGroup)
        {
            for(auto chan : m_streamGroup->m_channels)
            {
                chan->Release();
            }
        }
    }
 
    std::shared_ptr<WaveformGroup> m_group;
    ImGuiDir m_direction;
    StreamDescriptor m_stream;
 
    std::string m_ramp;
 
    std::shared_ptr<StreamGroupDescriptor> m_streamGroup;
    bool m_singleArea;
};
 
class DockDialogRequest
{
public:
    DockDialogRequest(std::shared_ptr<Dialog> dlg)
    : m_dlg(dlg)
    {}
 
    std::shared_ptr<Dialog> m_dlg;
};
 
class MainWindow : public VulkanWindow
{
public:
    MainWindow(std::shared_ptr<QueueHandle> queue, bool maximized, bool restored);
    virtual ~MainWindow();
 
    static bool OnMemoryPressureStatic(MemoryPressureLevel level, MemoryPressureType type, size_t requestedSize);
    bool OnMemoryPressure(MemoryPressureLevel level, MemoryPressureType type, size_t requestedSize);
    void LogMemoryUsage();
 
    void AddDialog(std::shared_ptr<Dialog> dlg);
    void RemoveFunctionGenerator(std::shared_ptr<SCPIFunctionGenerator> gen);
 
    void OnScopeAdded(std::shared_ptr<Oscilloscope> scope, bool createViews);
 
    void QueueSplitGroup(
        std::shared_ptr<WaveformGroup> group,
        ImGuiDir direction,
        StreamDescriptor stream,
        const std::string& colorRamp)
    { m_splitRequests.push_back(SplitGroupRequest(group, direction, stream, colorRamp)); }
 
    void QueueSplitGroup(std::shared_ptr<WaveformGroup> group, ImGuiDir direction, std::shared_ptr<StreamGroupDescriptor> streamGroup, bool singleArea)
    { m_splitRequests.push_back(SplitGroupRequest(group, direction, streamGroup, singleArea)); }
 
    void ShowChannelProperties(OscilloscopeChannel* channel);
    void HideChannelProperties(InstrumentChannel* channel);
    void ShowInstrumentProperties(std::shared_ptr<Instrument> instrument);
    void ShowTriggerProperties();
    void ShowManageInstruments();
    void ShowSyncWizard(std::shared_ptr<TriggerGroup> group, std::shared_ptr<Oscilloscope> secondary);
 
    void OnCursorMoved(int64_t offset);
 
    static void SetTooltipPosition()
    {
        auto pos = ImGui::GetIO().MousePos;
        ImGui::SetNextWindowPos(ImVec2(pos.x + ImGui::GetFontSize(), pos.y), ImGuiCond_Always, ImVec2(0.0, 0.5));
    }
 
    void NavigateToTimestamp(
        int64_t stamp,
        int64_t duration = 0,
        StreamDescriptor target = StreamDescriptor(nullptr, 0));
 
    void RefreshStreamBrowserDialog()
    {
        if(m_streamBrowser)
            m_streamBrowser->FlushConfigCache();
    }
 
    void RefreshTriggerPropertiesDialog()
    {
        if(m_triggerDialog)
            m_triggerDialog->Refresh();
    }
 
    void ToneMapAllWaveforms(vk::raii::CommandBuffer& cmdbuf);
 
    void RenderWaveformTextures(
        vk::raii::CommandBuffer& cmdbuf,
        std::vector<std::shared_ptr<InputDescriptor> >& channels);
 
    void SetNeedRender()
    { m_needRender = true; }
 
    void ClearPersistence()
    {
        m_clearPersistence = true;
        SetNeedRender();
    }
 
    virtual void Render();
 
    void QueueCloseSession()
    { m_sessionClosing = true; }
 
    Session& GetSession()
    { return m_session; }
 
    float GetTraceAlpha()
    { return m_traceAlpha; }
 
    float GetPersistDecay()
    { return m_persistenceDecay; }
 
    enum FilterCreate_t
    {
        ADD_PLOT    = 1,    //Add to waveform areas, if applicable (implies ADD_MEASURE too)
        ADD_MEASURE = 2     //Add to measurements, if applicable
    };
 
    Filter* CreateFilter(
        const std::string& name,
        uint32_t flags,
        WaveformArea* area,
        StreamDescriptor initialStream);
 
    void FindAreaForStream(WaveformArea* area, StreamDescriptor stream);
 
    void OnFilterReconfigured(Filter* f);
 
    const std::vector<std::string>& GetEyeGradients()
    { return m_eyeGradients; }
 
    std::string GetEyeGradientFriendlyName(const std::string& internalName)
    { return m_eyeGradientFriendlyNames[internalName]; }
 
    std::shared_ptr<MeasurementsDialog> GetMeasurementsDialog(bool createIfNotExisting);
 
    void AddAreaForStreamIfNotAlreadyVisible(StreamDescriptor stream);
 
    const std::map<uintptr_t, std::string>& GetGraphEditorGroups()
    { return m_graphEditorGroups; }
 
    void SetStartupSession(const std::string& path)
    { m_startupSession = path; }
 
    std::shared_ptr<TutorialWizard> GetTutorialWizard()
    { return m_tutorialDialog; }
 
protected:
    virtual void DoRender(vk::raii::CommandBuffer& cmdBuf);
 
    void CloseSession();
    void InitializeDefaultSession();
 
    // GUI handlers
 
    virtual void RenderUI();
        void MainMenu();
            void FileMenu();
                void FileRecentMenu();
            void ViewMenu();
            void AddMenu();
                void DoAddSubMenu(
                    std::vector<time_t>& timestamps,
                    std::map<time_t, std::vector<std::string> >& reverseMap,
                    const std::string& typePretty,
                    const std::string& defaultName,
                    const std::string& typeInternal
                    );
                void AddChannelsMenu();
                void AddImportMenu();
                void AddGenerateMenu();
            void SetupMenu();
            void WindowMenu();
                void WindowAnalyzerMenu();
                void WindowPSUMenu();
            void DebugMenu();
                void DebugSCPIConsoleMenu();
            void HelpMenu();
        void Toolbar();
            void LoadToolbarIcons();
            void ToolbarButtons();
                void TriggerStartDropdown(float buttonsize);
                void TriggerSingleDropdown(float buttonsize);
                void TriggerForceDropdown(float buttonsize);
                void TriggerAutoDropdown(float buttonsize);
                void TriggerStopDropdown(float buttonsize);
                void DoTriggerDropdown(const char* action, std::shared_ptr<TriggerGroup>& group, bool& all);
        void DockingArea();
            void StatusBar(float height);
 
    void LoadGradients();
    void LoadGradient(const std::string& friendlyName, const std::string& internalName);
    std::map<std::string, std::string> m_eyeGradientFriendlyNames;
    std::vector<std::string> m_eyeGradients;
 
    void LoadFilterIcons();
    void LoadMiscIcons();
    void LoadStatusBarIcons();
    void LoadWaveformShapeIcons();
    void LoadAppIcon();
 
    bool m_showDemo;
 
    ImVec2 m_workPos;
 
    ImVec2 m_workSize;
 
    std::set< std::shared_ptr<Workspace> > m_workspaces;
 
    std::set< std::shared_ptr<Dialog> > m_dialogs;
 
    std::map<std::shared_ptr<SCPIMultimeter>, std::shared_ptr<Dialog> > m_meterDialogs;
 
    std::map<std::shared_ptr<SCPIPowerSupply>, std::shared_ptr<Dialog> > m_psuDialogs;
 
    std::map<std::shared_ptr<SCPIFunctionGenerator>, std::shared_ptr<Dialog> > m_generatorDialogs;
 
    std::map<std::shared_ptr<SCPIBERT>, std::shared_ptr<Dialog> > m_bertDialogs;
 
    std::map<std::shared_ptr<SCPIRFSignalGenerator>, std::shared_ptr<Dialog> > m_rfgeneratorDialogs;
 
    std::map<std::shared_ptr<SCPILoad>, std::shared_ptr<Dialog> > m_loadDialogs;
 
    std::map<std::shared_ptr<SCPIInstrument>, std::shared_ptr<Dialog> > m_scpiConsoleDialogs;
 
    std::map<InstrumentChannel*, std::shared_ptr<Dialog> > m_channelPropertiesDialogs;
 
    std::map<PacketDecoder*, std::shared_ptr<ProtocolAnalyzerDialog> > m_protocolAnalyzerDialogs;
 
    std::vector<std::shared_ptr<WaveformGroup> > m_waveformGroups;
 
    std::recursive_mutex m_waveformGroupsMutex;
 
    std::vector<std::shared_ptr<WaveformGroup> > m_newWaveformGroups;
 
    int m_nextWaveformGroup;
 
    std::string NameNewWaveformGroup();
 
    std::shared_ptr<Dialog> m_logViewerDialog;
 
    std::shared_ptr<Dialog> m_metricsDialog;
 
    std::shared_ptr<Dialog> m_memoryDialog;
 
    std::shared_ptr<Dialog> m_preferenceDialog;
 
    std::shared_ptr<HistoryDialog> m_historyDialog;
 
    std::shared_ptr<TriggerPropertiesDialog> m_triggerDialog;
 
    std::shared_ptr<ManageInstrumentsDialog> m_manageInstrumentsDialog;
 
    std::shared_ptr<Dialog> m_notesDialog;
 
    std::shared_ptr<TutorialWizard> m_tutorialDialog;
 
    std::shared_ptr<FilterGraphEditor> m_graphEditor;
 
    std::shared_ptr<StreamBrowserDialog> m_streamBrowser;
 
    std::shared_ptr<CreateFilterBrowser> m_filterPalette;
 
    std::string m_graphEditorConfigBlob;
 
    std::map<uintptr_t, std::string> m_graphEditorGroups;
 
    std::shared_ptr<MeasurementsDialog> m_measurementsDialog;
 
    void OnDialogClosed(const std::shared_ptr<Dialog>& dlg);
 
    std::vector<SplitGroupRequest> m_splitRequests;
 
    std::shared_ptr<Workspace> m_initialWorkspaceDockRequest;
 
    std::vector<size_t> m_groupsToClose;
 
    std::shared_ptr<WaveformGroup> GetBestGroupForWaveform(StreamDescriptor stream);
 
    int m_toolbarIconSize;
 
    IconTheme_t m_toolbarIconTheme;
 
    float m_traceAlpha;
 
    float m_persistenceDecay;
 
    std::set< std::pair<OscilloscopeChannel*, WaveformArea*> > m_pendingChannelDisplayRequests;
 
    std::string m_startupSession;
 
    // Session state
 
    Session m_session;
 
    bool m_sessionClosing;
 
    SCPITransport* MakeTransport(const std::string& trans, const std::string& args);
 
    // Serialization
 
    void OnOpenFile(bool online);
    void DoOpenFile(const std::string& sessionPath, bool online);
    bool PreLoadSessionFromYaml(const YAML::Node& node, const std::string& dataDir, bool online);
    bool LoadSessionFromYaml(const YAML::Node& node, const std::string& dataDir, bool online);
public:
    bool LoadUIConfiguration(int version, const YAML::Node& node);
 
    void OnGraphEditorConfigModified(const std::string& blob)
    { m_graphEditorConfigBlob = blob; }
 
    const std::string& GetGraphEditorConfigBlob()
    { return m_graphEditorConfigBlob; }
 
protected:
    void OnSaveAs();
    void DoSaveFile(std::string sessionPath);
    bool SaveSessionToYaml(YAML::Node& node, const std::string& dataDir);
    void SaveLabNotes(const std::string& dataDir);
    void LoadLabNotes(const std::string& dataDir);
    bool SetupDataDirectory(const std::string& dataDir);
    YAML::Node SerializeUIConfiguration();
    YAML::Node SerializeDialogs();
    bool LoadDialogs(const YAML::Node& node);
 
    void RenderFileBrowser();
 
    enum
    {
        BROWSE_OPEN_SESSION,
        BROWSE_SAVE_SESSION
    } m_fileBrowserMode;
 
    std::shared_ptr<FileBrowser> m_fileBrowser;
 
    std::vector<YAML::Node> m_fileBeingLoaded;
 
    bool m_fileLoadInProgress;
 
    std::string m_sessionFileName;
 
    std::string m_sessionDataDir;
 
    std::string m_lastWindowTitle;
 
public:
    const std::string& GetDataDir()
    { return m_sessionDataDir; }
 
protected:
 
    bool m_openOnline;
 
protected:
 
    // Recent item lists
 
    std::map<std::string, time_t> m_recentInstruments;
 
    void LoadRecentInstrumentList();
    void SaveRecentInstrumentList();
 
    std::map<std::string, time_t> m_recentFiles;
 
    void LoadRecentFileList();
    void SaveRecentFileList();
 
public:
    void AddToRecentInstrumentList(std::shared_ptr<SCPIInstrument> inst);
    void RenameRecentInstrument(std::shared_ptr<SCPIInstrument> inst, const std::string& oldName);
    void RepathRecentInstrument(std::shared_ptr<SCPIInstrument> inst, const std::string& oldPath);
 
protected:
 
    // Error handling
 
    std::string m_errorPopupTitle;
    std::string m_errorPopupMessage;
 
    bool m_showingLoadWarnings;
    bool m_loadConfirmationChecked;
 
    void RenderReconnectPopup();
    void RenderErrorPopup();
    void RenderLoadWarningPopup();
public:
    void ShowErrorPopup(const std::string& title, const std::string& msg);
 
protected:
    // Graphics items
 
    TextureManager m_texmgr;
 
    bool m_needRender;
 
    std::atomic<bool> m_clearPersistence;
 
    std::unique_ptr<vk::raii::CommandBuffer> m_cmdBuffer;
 
    bool DropdownButton(const char* id, float height);
 
public:
 
    void ResetStyle();
 
    FontWithSize GetFontPref(const std::string& name)
    {
        auto desc = m_session.GetPreferences().GetFont(name);
        return std::pair<ImFont*, float>(m_fontmgr.GetFont(desc), desc.second);
    }
 
    ImU32 GetColorPref(const std::string& name)
    { return m_session.GetPreferences().GetColor(name); }
 
    ImTextureID GetTexture(const std::string& name)
    { return m_texmgr.GetTexture(name); }
 
    TextureManager* GetTextureManager()
    { return &m_texmgr; }
 
    std::string GetIconForFilter(Filter* f);
 
    std::string GetIconForWaveformShape(FunctionGenerator::WaveShape shape);
 
    ImGui::MarkdownConfig GetMarkdownConfig();
 
protected:
    FontManager m_fontmgr;
 
    std::map<std::type_index, std::string> m_filterIconMap;
 
    std::map<FunctionGenerator::WaveShape, std::string> m_waveformShapeIconMap;
 
    void UpdateFonts();
 
    // Status bar
public:
 
    void AddStatusHelp(const std::string& icon, const std::string& text)
    { m_statusHelp[icon] = text; }
 
protected:
    std::map<std::string, std::string> m_statusHelp;
 
    // Performance counters
 
protected:
    int64_t m_toneMapTime;
 
public:
    int64_t GetToneMapTime()
    { return m_toneMapTime; }
};
 
#endif