class_draw_panel_gal.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2013-2018 CERN
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * @author Tomasz Wlostowski <[email protected]>
 * @author Maciej Suminski <[email protected]>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef  PANELGAL_WXSTRUCT_H
#define  PANELGAL_WXSTRUCT_H
 
#include <wx/window.h>
#include <wx/timer.h>
#include <wx/grid.h> // needed for MSVC to see wxScrolledCanvas indirectly exported
#include <math/box2.h>
#include <math/vector2d.h>
#include <view/automatic_fit.h>
#include <widgets/msgpanel.h>
#include <rhi/frame_packet.h>
#include <rhi/rhi_surface.h>
#include <atomic>
#include <memory>
#include <optional>
#include <mutex>
#include <chrono>
 
#include <gal/cursors.h>
 
class BOARD;
class EDA_DRAW_FRAME;
class TOOL_DISPATCHER;
class PROF_COUNTER;
class wxImage;
 
namespace KIPLATFORM
{
namespace UI
{
class TOUCHPAD_GESTURE_HANDLER;
}
}
 
namespace KIGFX
{
class GAL;
class FRAME_MAILBOX;
class RENDER_THREAD;
class RHI_DEVICE_PROXY;
class SWAPCHAIN_CONTROLLER;
class VIEW;
class WX_VIEW_CONTROLS;
class VIEW_CONTROLS;
class PAINTER;
class GAL_DISPLAY_OPTIONS;
class VIEW_OVERLAY;
struct VC_SETTINGS;
}
 
 
class EDA_DRAW_PANEL_GAL : public wxScrolledCanvas
{
public:
    enum GAL_TYPE {
        GAL_TYPE_UNKNOWN = -1,  
        GAL_TYPE_NONE = 0,      
        GAL_TYPE_OPENGL = 1,    
        GAL_TYPE_CAIRO = 2,     
        GAL_TYPE_MODERN = 3,    
        GAL_TYPE_LAST           
    };
 
#ifdef __WXMAC__
    // Cairo doesn't work on OSX so we really have no fallback available.
    static constexpr GAL_TYPE GAL_FALLBACK = GAL_TYPE_OPENGL;
#else
    static constexpr GAL_TYPE GAL_FALLBACK = GAL_TYPE_CAIRO;
#endif
    static constexpr bool GAL_FALLBACK_AVAILABLE = GAL_FALLBACK != GAL_TYPE_OPENGL;

    EDA_DRAW_PANEL_GAL( wxWindow* aParentWindow, wxWindowID aWindowId,
                        const wxPoint& aPosition, const wxSize& aSize,
                        KIGFX::GAL_DISPLAY_OPTIONS& aOptions,
                        GAL_TYPE aGalType = GAL_TYPE_OPENGL );
    ~EDA_DRAW_PANEL_GAL();
 
    void SetFocus() override;
 
    bool StatusPopupHasFocus()
    {
        return m_statusPopup && m_statusPopup->HasFocus();
    }
 
    void SetStatusPopup( wxWindow* aPopup )
    {
        m_statusPopup = aPopup;
    }

    static GAL_TYPE ResolveStoredCanvasType( int aStoredCanvasType );

    static GAL_TYPE CanvasAfterFailure( GAL_TYPE aFailedCanvasType );

    static bool IsAccelerated( GAL_TYPE aCanvasType )
    {
        return aCanvasType == GAL_TYPE_OPENGL || aCanvasType == GAL_TYPE_MODERN;
    }

    virtual bool SwitchBackend( GAL_TYPE aGalType );

    void UpdateTouchpadGestureHandler();

    inline GAL_TYPE GetBackend() const { return m_backend; }

    KIGFX::GAL* GetGAL() const { return m_gal; }

    virtual KIGFX::VIEW* GetView() const { return m_view; }

    KIGFX::VIEW_CONTROLS* GetViewControls() const
    {
        return (KIGFX::VIEW_CONTROLS*)( m_viewControls );
    }

    bool GetScreenshot( wxImage& aDstImage );

    virtual void Refresh( bool aEraseBackground = true, const wxRect* aRect = nullptr ) override;

    void ForceRefresh();

    void RequestRefresh();

    void UpdateOverlayExclusions();

    void ResizeGal( bool aForce = false );

    static int ScreenSizePad( GAL_TYPE aBackend );

    void SetEventDispatcher( TOOL_DISPATCHER* aEventDispatcher );

    void StartDrawing();

    void StopDrawing();

    virtual void SetHighContrastLayer( int aLayer );

    virtual void SetTopLayer( int aLayer );
 
    virtual void GetMsgPanelInfo( EDA_DRAW_FRAME* aFrame, std::vector<MSG_PANEL_ITEM>& aList )
    {
        wxASSERT( false );
    }

    EDA_DRAW_FRAME* GetParentEDAFrame() const { return m_edaFrame; }
 
    bool IsDialogPreview() const { return m_parent != (wxWindow*) m_edaFrame; }

    virtual void OnShow();

    void SetStealsFocus( bool aStealsFocus ) { m_stealsFocus = aStealsFocus; }

    void SetCurrentCursor( KICURSOR aCursor );

    virtual BOX2I GetDefaultViewBBox() const { return BOX2I(); }

    void ZoomToFit( const BOX2I& aBox, std::optional<double> aMarginScale = std::nullopt );

    void OnEvent( wxEvent& aEvent );

    static void NoteInput();

    bool DoRePaint( bool aAllowSkip = true );

    std::shared_ptr<KIGFX::VIEW_OVERLAY> DebugOverlay();
 

    void ClearDebugOverlay();
 

    static KIGFX::VC_SETTINGS GetVcSettings();

    bool m_MouseCapturedLost;
 
    std::unique_ptr<PROF_COUNTER> m_PaintEventCounter;

    virtual void prepareGridSources() {}

    virtual void beforeRedraw() {}
 
protected:
    virtual void onPaint( wxPaintEvent& WXUNUSED( aEvent ) );
    void onSize( wxSizeEvent& aEvent );
    void onEnter( wxMouseEvent& aEvent );
    void onLostFocus( wxFocusEvent& aEvent );
    void onIdle( wxIdleEvent& aEvent );
    void onRefreshTimer( wxTimerEvent& aEvent );
    void onShowEvent( wxShowEvent& aEvent );
 
    bool recoverFromGalError( const std::exception& aErr );

    float displayRefreshRate();

    bool handleContextLoss();

    void showMessageLater( const wxString& aTitle, const wxString& aDetail, bool aError );

    bool abandonRhiCanvas( const wxString& aDetail );

    void teardownModernRenderInfra();

    const RHI_NATIVE_WINDOW_HANDLE& getCachedNativeWindowHandle();
    void releaseCachedNativeWindowHandle();

    void presentFrame();

    wxSize backendScreenSize() const;

    void submitCachedScene();
 
    wxWindow*                m_parent;           
    EDA_DRAW_FRAME*          m_edaFrame;         
 
    std::chrono::steady_clock::time_point m_lastRepaintStart; 
    std::chrono::steady_clock::time_point m_lastRepaintEnd;   
    wxTimer                               m_refreshTimer;     
 
    std::mutex               m_refreshMutex;     

    bool                     m_drawing;

    bool                     m_drawingEnabled;

    bool                     m_needIdleRefresh;

    bool                     m_refreshDeferred = false;

    VECTOR2D                 m_lastCursorPosition;

    KIGFX::GAL*              m_gal;

    KIGFX::VIEW*             m_view;

    std::unique_ptr<KIGFX::PAINTER> m_painter;

    KIGFX::WX_VIEW_CONTROLS* m_viewControls;

    GAL_TYPE                    m_backend;
    KIGFX::GAL_DISPLAY_OPTIONS& m_options;

    TOOL_DISPATCHER*         m_eventDispatcher;

    bool                     m_lostFocus;

    KIGFX::AUTOMATIC_FIT     m_automaticFit;

    bool                     m_recoveryAttempted;

    int                      m_contextBindFailures;

    bool                     m_rebuiltAfterReset;

    bool                     m_pendingResize;

    int                      m_overlayInsetTop = 0;

    bool                     m_stealsFocus;
 
    wxWindow*                m_statusPopup;

    std::shared_ptr<KIGFX::RENDER_THREAD> m_renderThread;

    std::unique_ptr<KIGFX::RHI_DEVICE_PROXY> m_deviceProxy;
 
    std::unique_ptr<KIGFX::SWAPCHAIN_CONTROLLER> m_swapchainCtrl;

    std::unique_ptr<KIGFX::FRAME_MAILBOX> m_frameMailbox;

    uint32_t m_windowId = 0;

    bool m_needsExternalRenderingSetup = false;

    RHI_NATIVE_WINDOW_HANDLE m_cachedNativeHandle;
    bool                     m_nativeHandleValid = false;

    float                                 m_refreshRate = 0.0f;
    std::chrono::steady_clock::time_point m_refreshRateAsked;

    KIGFX::FRAME_DRAW_DESC m_lastFullStaticDesc;
    KIGFX::FRAME_DRAW_DESC m_lastFullDynamicDesc;
    bool m_hasLastFullDrawDesc = false;

    uint64_t m_staticEpoch = 1;
    uint64_t m_dynamicEpoch = 1;

    KIGFX::RHI_LINE_PIPELINE_KIND m_linePipelineKind = KIGFX::RHI_LINE_PIPELINE_KIND::PCB_TRACKS;

    std::shared_ptr<KIGFX::VIEW_OVERLAY> m_debugOverlay;
 
    std::unique_ptr<KIPLATFORM::UI::TOUCHPAD_GESTURE_HANDLER> m_touchpadGestureHandler;
};
 
#endif