GUIManagerView.h

#pragma once

 
#include "GUIFixedViewPlacementSet.h"
#include "DefinitionsGUI.h"
#include <map>
#include <set>
 
class CUIThread;

namespace FLImaging
{
    namespace GUI
    {
        class CGUIViewImageBase;
        class CGUIViewImage;
        class CGUIView3D;
        class CGUIView3DPathEditor;
        class CGUIViewDrawing;
        class CGUIViewGraph;
        class CGUIViewSNAP;
        class CGUIMainFrame;
        class CGUIViewImageObjectFigure;
        class CGUIChildFrameBase;
        class CInternalViewManager;
        class CGUIDialogCreateStencil;
        class CGUIWndGrip;
 
        typedef struct sFixedViewDeclarationGroups
        {
            std::vector<CGUIFixedViewDeclaration*> vctImage;
            std::vector<CGUIFixedViewDeclaration*> vctGraph;
            std::vector<CGUIFixedViewDeclaration*> vct3D;
            std::vector<CGUIFixedViewDeclaration*> vct3DPathEditor;
            std::vector<CGUIFixedViewDeclaration*> vctSNAP;
            std::vector<CGUIFixedViewDeclaration*> vctDrawing;
            std::vector<CGUIFixedViewDeclaration*> vctNone;
        }SFixedViewDeclarationGroups;

        class FL_EXPORT CGUIManagerView : public Base::CFLBase
        {
            CGUIManagerView();
            CGUIManagerView(const CGUIManagerView& rh);
        public:

            virtual ~CGUIManagerView();

            static const CResult CreateView(CGUIViewImageBase* pView, int32_t i32L, int32_t i32T, int32_t i32R, int32_t i32B, size_t stParentWindowHandle);

            static const CResult CreateViewImage(CGUIViewImage* pView, int32_t i32L, int32_t i32T, int32_t i32R, int32_t i32B, size_t stParentWindowHandle);

            static const CResult CreateViewGraph(CGUIViewGraph* pView, int32_t i32L, int32_t i32T, int32_t i32R, int32_t i32B, size_t stParentWindowHandle);

            static const CResult CreateView3D(CGUIView3D* pView, int32_t i32L, int32_t i32T, int32_t i32R, int32_t i32B, size_t stParentWindowHandle);

            static const CResult CreateView3DPathEditor(CGUIView3DPathEditor* pView, int32_t i32L, int32_t i32T, int32_t i32R, int32_t i32B, size_t stParentWindowHandle);

            static const CResult CreateViewDrawing(CGUIViewDrawing* pView, int32_t i32L, int32_t i32T, int32_t i32R, int32_t i32B, size_t stParentWindowHandle);

            static const CResult CloseView(CGUIViewImageBase* pView);

            static const CResult DestroyView(CGUIViewImageBase* pView);

            static const CResult DestroyAllViews();

            static void RemoveViewThread(CUIThread* pThread);

            static bool IsAvailableView(CGUIViewImageBase* pView);

            static bool IsUsedUIMultiThread();

            static void UseUIMultiThread(bool bUse);

            static void SetThumbnailDraggingMode(bool bSet);

            static bool IsThumbnailDraggingMode();

            static void SetViewImageThumbnailDraggingSource(CGUIViewImage* pViewSource);

            static CGUIViewImage* GetViewImageThumbnailDraggingSource();

            static void SetThumbnailDraggingImageSource(Base::CFLImage* pFliSource, int32_t i32SelectedPageIndex = -1);

            static void SetThumbnailDraggingImageSource(Base::CFLImage* pFliSource, Base::CFLArray<int32_t>& flaSelectedThumbnailIndex);

            static const Base::CFLImage* GetThumbnailDraggingImageSource();

            static void GetSelectedThumbnailIndex(Base::CFLArray<int32_t>& flaSelectedThumbnailIndex);

            static void ShowHelpDialogViewImage(CGUIViewImage* pView);

            static void ShowHelpDialogViewGraph(CGUIViewGraph* pView);

            static void ShowHelpDialogView3D(CGUIView3D* pView);

            static void ShowHelpDialogViewSNAP(CGUIViewSNAP* pView);

            static void ShowHelpDialogViewDrawing(CGUIViewDrawing* pView);

            static void ShowHelpDialogMainFrame(CGUIMainFrame* pMF);

            static void InitializeClassContainer();

            static std::string ExtractClassName(const type_info& rhs);

            static std::string ExtractClassNameWithNamespace(const type_info& rhs);

            static void CommonExtractClassName(std::string& strResult, size_t stInitialPosition);

            static bool AddMultiDocTemplate(UINT uIDResource, CRuntimeClass* pDoc, CRuntimeClass* pFrame, CRuntimeClass* pView);

            static bool AddWindow(CDocument* pDoc, CFrameWnd* pFrame, CView* pView);

            static bool DeleteWindow(CDocument* pDoc);

            static bool DeleteWindow(CFrameWnd* pFrame);

            static bool DeleteWindow(CView* pView);

            static int64_t GetMultiDocTemplateCount();

            static CMultiDocTemplate* GetMultiDocTemplate(size_t stIndex);

            static CMultiDocTemplate* GetMultiDocTemplate(std::string strMultiDocTemplateName);

            static std::string GetMultiDocTemplateName(size_t stIndex);

            static std::string GetMultiDocTemplateName(CRuntimeClass* pDoc, CRuntimeClass* pFrame, CRuntimeClass* pView);

            static std::string GetMultiDocTemplateName(CMultiDocTemplate* pMultiDocTemplate);

            static size_t GetViewCount();

            static CGUIViewBase* FindViewByIndex(size_t stIndex);

            static CGUIViewBase* FindViewByIndex(CRuntimeClass* pRtcView, size_t stIndex);

            static CGUIViewBase* FindViewByIndexDerivedFrom(CRuntimeClass* pRtcView, size_t stIndex);

            static CGUIViewBase* FindViewByViewNumber(size_t stViewNumber);

            static CGUIViewBase* FindViewByViewNumber(const Base::CFLString<wchar_t>& strTitle);

            static CGUIViewBase* FindViewByViewNumber(CRuntimeClass* pRtcView, size_t stViewNumber);

            static CGUIViewBase* FindViewByViewNumber(CRuntimeClass* pRtcView, const Base::CFLString<wchar_t>& strTitle);

            static CGUIViewBase* FindViewByViewNumberDerivedFrom(CRuntimeClass* pRtcView, size_t stViewNumber);

            static CGUIViewBase* FindViewByViewNumberDerivedFrom(CRuntimeClass* pRtcView, const Base::CFLString<wchar_t>& strTitle);

            static std::vector<CGUIViewBase*> FindView(const Base::CFLString<wchar_t>& strTitle);

            static std::vector<CGUIViewBase*> FindView(CRuntimeClass* pRtcView);

            static std::vector<CGUIViewBase*> FindViewDerivedFrom(CRuntimeClass* pRtcView);

            static std::vector<CGUIViewBase*> FindView(CRuntimeClass* pRtcView, const Base::CFLString<wchar_t>& strTitle);

            static std::vector<CGUIViewBase*> FindViewDerivedFrom(CRuntimeClass* pRtcView, const Base::CFLString<wchar_t>& strTitle);

            static std::vector<CGUIViewImage*> FindViewImage();

            static const CResult FindView(const Base::CFLString<wchar_t>& strTitle, std::vector<CGUIViewBase*>& vctResult);

            static const CResult FindView(CRuntimeClass* pRtcView, std::vector<CGUIViewBase*>& vctResult);

            static const CResult FindViewDerivedFrom(CRuntimeClass* pRtcView, std::vector<CGUIViewBase*>& vctResult);

            static const CResult FindView(CRuntimeClass* pRtcView, const Base::CFLString<wchar_t>& strTitle, std::vector<CGUIViewBase*>& vctResult);

            static const CResult FindViewDerivedFrom(CRuntimeClass* pRtcView, const Base::CFLString<wchar_t>& strTitle, std::vector<CGUIViewBase*>& vctResult);

            static const CResult FindViewImage(std::vector<CGUIViewImage*>& vctResult);

            static std::vector<CView*> GetViews();

            static bool DoesViewImageExist();

            static bool DoesViewGraphExist();

            static bool DoesView3DExist();

            static bool DoesView3DPathEditorExist();

            static bool DoesViewDrawingExist();

            static bool DoesViewSNAPExist();

            static bool DoesVisibleViewImageExist();

            static bool DoesVisibleViewGraphExist();

            static bool DoesVisibleView3DExist();

            static bool DoesVisibleView3DPathEditorExist();

            static bool DoesVisibleViewDrawingExist();

            static bool DoesVisibleViewSNAPExist();

            static std::vector<CGUIViewBase*> FindViewAnyOf(const Base::CFLString<wchar_t>& strTitle);

            static CDocument* FindWindowVDocument(size_t stIndex);

            static std::vector<CDocument*> FindWindowVDocument(const Base::CFLString<wchar_t>& strTitle);

            static CFrameWnd* FindWindowFrame(size_t stIndex);

            static std::vector<CFrameWnd*> FindWindowFrame(const Base::CFLString<wchar_t>& strTitle);

            static CView* FindWindowView(size_t stIndex);

            static std::vector<CView*> FindWindowView(const Base::CFLString<wchar_t>& strTitle);
            
            static const CResult ActivateNextView(bool bCircular = true);

            static const CResult ActivatePreviousView(bool bCircular = true);

            static const CResult AddFixedViewDeclaration(CGUIFixedViewDeclaration* pFixedViewDeclaration);

            static int64_t GetFixedViewDeclarationCount();

            static int64_t GetFixedViewDeclarationIndex(const CGUIFixedViewDeclaration* pFVD);

            static const CResult RemoveFixedViewDeclaration(size_t stIndex);
            static const CResult RemoveFixedViewDeclaration(CGUIFixedViewDeclaration* pFixedViewDeclaration);

            static const CResult RemoveFixedViewDeclarationIfUnused(CGUIFixedViewDeclaration* pFixedViewDeclaration);

            static const CResult RemoveFixedViewDeclarationSafe(CGUIFixedViewDeclaration* pFixedViewDeclaration);

            static const CResult ClearFixedViewDeclarationAll();

            static CGUIFixedViewDeclaration* GetFixedViewDeclaration(int64_t i64Index);

            static const CResult AddFixedViewPlacementSet(CGUIFixedViewPlacementSet& fvpSet, bool bAddMenuItem = true);

            static const CResult AddFixedViewPlacementSet(CGUIFixedViewPlacementSet* pFvpSet, bool bAddMenuItem = true);

            static const CResult RemoveFixedViewPlacementSet(size_t stIndex);

            static int64_t GetFixedViewPlacementSetCount();

            static CGUIFixedViewPlacementSet* GetFixedViewPlacementSet(size_t stIndex);

            static CGUIFixedViewPlacementSet* GetFixedViewPlacementSet(const Base::CFLString<wchar_t>& strFvpSetName);

            static int64_t GetFixedViewPlacementSetIndex(const CGUIFixedViewPlacementSet* pFvpSet);

            static int64_t GetSelectedFixedViewPlacementSetIndex();

            static CGUIFixedViewPlacementSet* GetSelectedFixedViewPlacementSet();

            static bool SelectFixedViewPlacementSet(const Base::CFLString<wchar_t>& strFvpSetName);

            static bool SelectFixedViewPlacementSet(size_t stIndex);

            static const CResult CreateFixedView(size_t stIndex, bool bLoadFixedViewSetting = true);

            static bool RelocateFixedView();

            static const CResult CollectFixedViewDeclarationsByType(SFixedViewDeclarationGroups& sFvdGroups);

            static bool PreDestroyViewImage();

            static bool PreDestroyViewGraph();

            static bool PreDestroyView3D();

            static bool PreDestroyView3DPathEditor();

            static bool PreDestroyViewDrawing();

            static bool PreDestroyViewSNAP();

            static bool PreDestroyViewImageBase();

            static bool IsInitialized();

            static int64_t GetSNAPViewSerialNumber();

            virtual Base::CFLString<wchar_t> GetFileName() const;
 
            DeclareGetClassType();
 
        public:
            static void LButtonDownOnNcHitView(const Base::TPoint<int>& tpScreen);
            static void LButtonUpOnNcHitView(const Base::TPoint<int>& tpScreen);
            static void MouseMoveOnNcHitView(Base::TPoint<int>& tpScreen);
            static bool InitializeLayoutGrip(CWnd* pWndParent);
            static void HideLayoutGrip();
            static void ViewNcHitTest(const Base::TPoint<int>& tpScreen);
   
            // 동기화된 뷰 그룹의 Point of View 스케일 변경 메시지를 지연 전송(PostMessage)합니다.
            static void BroadcastSyncPOVScale(const std::set<CGUIViewImage*>& setSyncViewImageRoot);
            static void CollectRootSyncViewsPOVScale(CGUIViewImage* pViewImage, std::set<CGUIViewImage*>& setSyncViewImageRoot);
 
        protected:
            static Foundation::CStencil* GetInternalStencilPtr();
            static const CResult RemoveMismatchedFixedViewDeclarations(const CGUIFixedViewPlacementSet* pFVPSet);
 
        private:
            static bool Initialize();
            static bool Terminate();
 
            static bool CreateFixedView();
            static bool ShowOnlySelectedFixedViews();
 
            static void SetInitialize(bool bSet);
 
            virtual void OnReceiveBroadcast(const Base::CBroadcastMessage* pMessage) override;
            static CGUIManagerView* GetObject();
 
        private:
            CInternalViewManager* m_pInternal;
            
            CGUIViewImage* m_pViewImageThumbnailDraggingSource;
            Base::CFLImage* m_pFliThumbnailDraggingSource;
            Base::CFLArray<int32_t> m_flaSelectedThumbnailIdx;
            bool m_bThumbnailDraggingMode;
 
            bool m_bUsedUIMultiThread;
            std::map<CGUIViewImageBase*, CUIThread*>& m_mapThreads;
 
            volatile bool m_bInitialized;
 
            CGUIWndGrip* m_pLayoutGripVert;
            CGUIWndGrip* m_pLayoutGripHorz;
            Base::TPoint<int> m_tpScreenPrev;
            Base::TRect<int> m_trScreenVertRect;
            Base::TRect<int> m_trScreenHorzRect;
            int32_t m_i32MFOffsetX;
            int32_t m_i32MFOffsetY;
 
            bool m_bHorzRectVisible;
            bool m_bVertRectVisible;
            bool m_bLButtonDownOnNcHitView;
 
            std::vector<CMultiDocTemplate*>& m_vctMultiDocTemplates;
            std::map<std::string, CMultiDocTemplate*>& m_mapMultiDocTemplates;
            std::map<CMultiDocTemplate*, std::string>& m_mapMultiDocTemplatesReverse;
 
            std::vector<CGUIFixedViewDeclaration*>& m_vctFixedViewDeclaration;
            std::vector<CGUIFixedViewPlacementSet*>& m_vctFixedViewPlacementSet;
 
            std::vector<CDocument*>& m_vctDoc;
            std::vector<CFrameWnd*>& m_vctFrame;
            std::vector<CView*>& m_vctView;
 
            std::vector <CGUIChildFrameBase*>& m_vctFrameToResize;
            std::set <int32_t>& m_setI32FrameX;
            std::set <int32_t>& m_setI32FrameY;
 
            size_t m_stSelectedPlacementSet;
 
            friend class CGUIManager;
 
            friend class CInternalViewManager;
            friend class CGUIDialogCreateStencil;
            friend class CGUIFixedViewPlacementSet;
        };
    }
}