GUIViewDrawing.h

#pragma once

 
#include <afxwin.h>
 
#include "GUIViewImageBase.h"
#include "DefinitionsGUI.h"
#include "DefinitionsGUIViewDrawing.h"
#include "D2DObject.h"
 
#include <set>
#include <map>

namespace FLImaging
{
    namespace GUI
    {
        class CGUIViewImageLayer;
        class CGUIBoxLayout;
        class CGUIManagerView;
        class CInternalViewManager;
        class CGUIManagerViewDrawingObject;
        class CGUIManagerViewImageSelectionImage;
        class CGUIManagerContextMenuViewDrawing;
        class CGUIManagerContextMenuViewImageObject;
        class CInternalCanvas;
        class CGUIViewImageMiniMap;
        class CGUIViewToolBar;
        class CGUIDialogImageInfo;
        class CGUIDialogImagePageList;
        class CGUIDialogLayerProperties;
        class CGUIDialogLayerProperties;
        class CGUIPaneDialog;

        class FL_EXPORT CGUIViewDrawing : public CGUIViewImageBase
        {
        public: // serialization 에서만 만들어집니다.
            CGUIViewDrawing();

            CGUIViewDrawing(const CGUIViewDrawing& rhs);

            CGUIViewDrawing(const CGUIViewDrawing* pRhs);
            DECLARE_DYNCREATE(CGUIViewDrawing)
 
            
            virtual ~CGUIViewDrawing();
 
        public:

            enum EStatusPaneItem
            {
                EStatusPaneItem_FileNameCaption,

                EStatusPaneItem_FileNameValue,

                EStatusPaneItem_WidthCaption,

                EStatusPaneItem_WidthValue,

                EStatusPaneItem_HeightCaption,

                EStatusPaneItem_HeightValue,

                EStatusPaneItem_ZoomCaption,

                EStatusPaneItem_ZoomValue,

                EStatusPaneItem_CursorXCaption,

                EStatusPaneItem_CursorXValue,

                EStatusPaneItem_CursorYCaption,

                EStatusPaneItem_CursorYValue,

                EStatusPaneItem_ItemCount,
            };
 
            enum
            {
                EMaxLayerCount = 10,
            };

            static CGUIViewDrawing* CreateView();

            static CGUIViewDrawing* CreateView(int32_t i32L, int32_t i32T, int32_t i32R, int32_t i32B, bool bStandalone = false);

            virtual const CResult Load(const wchar_t* pWcsPath = nullptr, EViewDrawingLoadOption eOption = EViewDrawingLoadOption_Load);

            virtual const CResult Load(Base::CFLArray<Base::CFLString<wchar_t>>& flaFilePathToLoad, EViewDrawingLoadOption eOption = EViewDrawingLoadOption_Load);

            virtual const CResult Save(const wchar_t* pWcsFileNameWithPath = nullptr);

            virtual const CResult ClearFile();

            virtual Foundation::CFLPoint<double> ConvertClientCoordToImageCoord(const Foundation::CFLPoint<int32_t>& point) const;

            virtual Foundation::CFLRect<double> ConvertClientCoordToImageCoord(const Foundation::CFLRect<int32_t>& rect) const;

            virtual Foundation::CFLPoint<double> ConvertClientCoordToImageCoord(int32_t i32X, int32_t i32Y) const;

            virtual Foundation::CFLPoint<int32_t> ConvertImageCoordToClientCoord(const Foundation::CFLPoint<double>& flp) const;

            virtual Foundation::CFLRect<int32_t> ConvertImageCoordToClientCoord(const Foundation::CFLRect<double>& flr) const;

            virtual Foundation::CFLPoint<int32_t> ConvertImageCoordToClientCoord(double f64X, double f64Y) const;

            virtual Foundation::CFLPoint<int32_t> ConvertClientCoordToCanvasCoord(const Foundation::CFLPoint<int32_t>& flp) const;

            virtual Foundation::CFLRect<int32_t> ConvertClientCoordToCanvasCoord(const Foundation::CFLRect<int32_t>& flr) const;

            virtual Foundation::CFLPoint<int32_t> ConvertClientCoordToCanvasCoord(int32_t i32X, int32_t i32Y) const;

            virtual Foundation::CFLPoint<int32_t> ConvertCanvasCoordToClientCoord(const Foundation::CFLPoint<int32_t>& flp) const;

            virtual Foundation::CFLRect<int32_t> ConvertCanvasCoordToClientCoord(const Foundation::CFLRect<int32_t>& flr) const;

            virtual Foundation::CFLPoint<int32_t> ConvertCanvasCoordToClientCoord(int32_t i32X, int32_t i32Y) const;
 

            virtual Foundation::CFLPoint<double> ConvertCanvasCoordToImageCoord(const Foundation::CFLPoint<int32_t>& flp) const;

            virtual Foundation::CFLRect<double> ConvertCanvasCoordToImageCoord(const Foundation::CFLRect<int32_t>& flr) const;

            virtual Foundation::CFLPoint<double> ConvertCanvasCoordToImageCoord(int32_t i32X, int32_t i32Y) const;

            virtual Foundation::CFLPoint<int32_t> ConvertImageCoordToCanvasCoord(const Foundation::CFLPoint<double>& flp) const;

            virtual Foundation::CFLRect<int32_t> ConvertImageCoordToCanvasCoord(const Foundation::CFLRect<double>& flr) const;

            virtual Foundation::CFLPoint<int32_t> ConvertImageCoordToCanvasCoord(double f64X, double f64Y) const;
 

            virtual void ClearAllLayers();

            CGUIViewImageLayer* GetLayer(int32_t i32Index) const;

            CGUIViewImageLayer* GetLayerByName(const std::wstring& strLayerName);

            CGUIViewImageLayer* GetLayerByName(const std::wstring& strLayerName, const CGUIViewImageLayer* pLayerRTTI);

            const CResult DeleteLayerByName(const std::wstring& strLayerName);

            bool DoesLayerExist(const std::wstring& strLayerName) const;

            int32_t GetNamedLayerCount() const;

            CGUIViewImageLayer* GetNamedLayer(int32_t i32Index) const;

            virtual const CResult SetLayerAutoClearMode(int32_t i32LayerIndex, ELayerAutoClearMode eMode, bool bSet);

            virtual const CResult SetLayerAutoClearMode(CGUIViewImageLayer* pLayer, ELayerAutoClearMode eMode, bool bSet);

            virtual const CResult SetLayerAutoClearMode(ELayerAutoClearMode eMode, bool bSet);

            virtual bool GetLayerAutoClearMode(int32_t i32LayerIndex, ELayerAutoClearMode eMode) const;

            virtual bool GetLayerAutoClearMode(const CGUIViewImageLayer* pLayer, ELayerAutoClearMode eMode) const;

            virtual const CResult ZoomFitToLayer(int32_t i32LayerIndex);

            virtual const CResult ZoomFitToLayer(const CGUIViewImageLayer* pLayer);

            const CResult ClearMeasurement();

            virtual Foundation::CFLPoint<double> GetViewCenterImageCoord() const;

            virtual const CResult SetViewCenter(const Foundation::CFLPoint<double>& flpImageCoord);

            virtual const CResult SetViewCenterAndScale(const Foundation::CFLPoint<double>& flpImageCoord, double f64Scale);

            virtual const CResult ZoomAtCenter(double f64Scale);

            Foundation::CFLPoint<double> GetOffset() const;
 
            virtual const CResult InternalSetOffset(Foundation::CFLPoint<double> flpOffset);

            virtual double GetScale() const;
 
            virtual const CResult InternalSetScale(double f64Scale);

            double GetZoomFitScale(double f64CanvasWidth, double f64CanvasHeight) const;
 
            virtual const CResult InternalZoomIn(POINT ptCanvas, double f64Ratio = 1.25);
 
            virtual const CResult InternalZoomOut(POINT ptCanvas, double f64Ratio = .8);

            virtual const CResult ZoomFit();

            EGUIViewDrawingHitArea GetHitArea() const;

            virtual void SetCanvasColor(COLORREF clrCanvas);

            virtual COLORREF GetCanvasColor() const;

            virtual void ShowImageMiniMap(bool bShow);

            virtual bool IsImageMiniMapVisible() const;

            virtual void ShowCrosshair(bool bShow);

            virtual bool IsCrosshairVisible() const;

            virtual void ShowGrid(bool bShow);

            virtual bool IsGridVisible() const;

            virtual void ShowImageCoordinateOnCursor(bool bShow);

            virtual bool IsImageCoordinateOnCursorVisible() const;

            virtual const CResult SetDecimalPlacesOfCoordinate(uint8_t u8DecimalPlaces = 2);

            virtual uint8_t GetDecimalPlacesOfCoordinate() const;

            const CResult SetPixelAccuracy(double f64PixelAccuracyX, double f64PixelAccuracyY);

            const CResult GetPixelAccuracy(double* pF64PixelAccuracyX, double* pF64PixelAccuracyY) const;

            const CResult GetPixelAccuracy(double& f64PixelAccuracyX, double& f64PixelAccuracyY) const;

            const CResult SetPixelAccuracyX(double f64PixelAccuracyX);

            double GetPixelAccuracyX() const;

            const CResult SetPixelAccuracyY(double f64PixelAccuracyY);

            double GetPixelAccuracyY() const;

            const CResult SetPixelAccuracyUnit(Foundation::ELengthUnit eLenUnit);

            Foundation::ELengthUnit GetPixelAccuracyUnit() const;

            virtual const CResult SelectMenuItem(EMenuItemViewDrawing eMenuItemViewDrawing);

            bool IsSynchronized(EViewDrawingSyncOption eViewDrawingSyncOption) const;

            CGUIViewDrawing* GetRootSyncView(EViewDrawingSyncOption eViewDrawingSyncOption) const;

            const CResult ResignRootSyncView(EViewDrawingSyncOption eViewDrawingSyncOption);

            const CResult SynchronizePointOfView(CGUIViewDrawing* pTargetView);

            const CResult DesynchronizePointOfView(CGUIViewDrawing* pTargetView);

            const CResult DesynchronizePointOfViewAll();

            const CResult ShowScrollBar(bool bShow);

            virtual const CResult ShowToolBar(bool bShow)override;

            const CResult ShowStatusBar(bool bShow);

            const CResult CaptureScreen(Base::CFLImage& fliImage, bool bIncludeFrame = false);

            const CResult CaptureScreen(Base::CFLImage* pFliImage, bool bIncludeFrame = false);

            void AddAvailableViewDrawingContextMenu(const FLImaging::GUI::EMenuItemViewDrawing* pArrEnum, int64_t i64Count);

            void RemoveAvailableViewDrawingContextMenu(const FLImaging::GUI::EMenuItemViewDrawing* pArrEnum, int64_t i64Count);

            void EnableAvailableViewDrawingContextMenuAll(bool bEnable);

            bool IsViewDrawingContextMenuAvailable(FLImaging::GUI::EMenuItemViewDrawing eMenu) const;

            void SetAvailableViewDrawingContextMenu(const FLImaging::GUI::EMenuItemViewDrawing* pArrEnum, int64_t i64Count);

            void GetAvailableViewDrawingContextMenu(Base::CFLArray<int32_t>& flaEnum) const;

            static void GetViewDrawingContextMenuChildren(FLImaging::GUI::EMenuItemViewDrawing eMenu, Base::CFLArray<int32_t>& flaEnum);

            virtual void EnableSelection(bool bEnable);

            virtual bool IsSelectionEnabled() const;

            virtual void SetPanningMode(bool bSet);

            virtual bool IsPanningMode() const;

            virtual void SetZoomMode(EZoomMode eZoomMode);

            virtual EZoomMode GetZoomMode() const;

            virtual const CResult SetTeachingMode(EGUIViewDrawingTeachingMode eTeachingMode);

            virtual EGUIViewDrawingTeachingMode GetTeachingMode() const;

            virtual CGUIManagerContextMenuViewDrawing* GetManagerContextMenu() const;
            
            virtual void SetManagerContextMenu(const CGUIManagerContextMenuViewDrawing* pMgr);

            virtual CGUIManagerViewDrawingObject* GetManagerViewDrawingObject() const;

            virtual void SetManagerViewDrawingObject(const CGUIManagerViewDrawingObject* pMgr);

            virtual FLImaging::Foundation::CFLPoint<double> GetCursorPosOnLButtonDown() const;

            virtual FLImaging::Foundation::CFLPoint<double> GetCursorPosOnMButtonDown() const;

            virtual FLImaging::Foundation::CFLPoint<double> GetCursorPosOnRButtonDown() const;
 
            virtual CD2DObject* GetD2DObject();
 
        public:
            Foundation::CFLPoint<int32_t> GetLastCursorClient() const;
 
            virtual void SetTitle(LPCTSTR lpszTitle)override;
            void SetHitArea(EGUIViewDrawingHitArea eHitArea);
            CGUIViewImageMiniMap* GetMiniMap() const;
            virtual void UpdateTheme() override;
            virtual const CResult UpdateStatusBar();
            virtual void ChangeImageCanvasSize();
            virtual void ActivatedPopupMenu(CGUIPopupMenuShell* pPopupMenu)override;
 
            virtual void ShowMultiSelectRect(bool bShow);
            virtual bool IsMultiSelectRectVisible() const;
 
            virtual void ShowMultiSelectCandidateRect(bool bShow);
            virtual bool IsMultiSelectCandidateRectVisible() const;
 
            EContextMenuFlag GetViewDrawingContextMenuFlag(EMenuItemViewDrawing eMenu) const;
            UINT GetViewDrawingContextMenuFlag(EMenuItemViewDrawing eMenu, UINT uAssignFlag) const;
            UINT GetViewDrawingContextMenuFlag(const EMenuItemViewDrawing* pArrMenuItem, int64_t i64Count) const;
 
            Foundation::CFLRect<double>& GetMultiSelectRect();
 
            void SetCurrentCursor(UINT nCursor);
            UINT GetCurrentCursor() const;
 
            virtual void SetFileNameOnStatusBar(bool bSet);
            virtual bool IsFileNameOnStatusBar() const;
 
            virtual const CResult GetPOVToFit(const Foundation::CFLFigure* pFigure, Foundation::CFLRect<double> flrCanvas, double& f64Scale, Foundation::CFLPoint<double>& flpOffset, int32_t i32WidthMargin, int32_t i32HeightMargin) const;
 
            virtual void SetVisible(bool bVisible)override;
 
            virtual void UpdateScrollBar();
 
 
 
 
            virtual void SetDialogLayerPropertiesPtr(CGUIDialogLayerProperties* pDlg);
            virtual void InternalDrawCustomLayers(const Foundation::CFLPoint<double>& flpOffset, const Foundation::CFLPoint<double>& flpOffsetOnBtnDown, double f64Scale, const Foundation::CFLRect<int32_t>& flrWindowRect, const D2D1::Matrix3x2F matTransform);
 
            virtual const CResult InternalCreateDialogLoadFigureGbr(const std::vector<Base::CFLString<wchar_t>>& vctGbrPath, std::vector<COLORREF>& vctGbrColor);
            virtual const CResult InternalCreateDialogLoadFigureDxf(const std::vector<Base::CFLString<wchar_t>>& vctDxfPath);
 
            virtual void HitTest(const Foundation::CFLPoint<int32_t>& flpCanvas);
 
            virtual const CResult LoadFigure(EFileExtension eFileExt, const wchar_t* pWcsFileNameWithPath = nullptr, bool bErrorMsgBox = false);
            virtual const CResult LoadFigureDXF(const std::vector<Base::CFLString<wchar_t>>& vctFileNameWithPath, Foundation::CFLFigureArray* pFlfa = nullptr);
 
            virtual const CResult InternalLoadFigure(const wchar_t* pWcsFileNameWithPath, Foundation::CFLFigureArray* pFlfa = nullptr);
            virtual const CResult InternalLoadFigureGBR(const wchar_t* pWcsFileNameWithPath, const wchar_t* pWcsLayerName, uint32_t u32Color, Foundation::CFLFigureArray* pFlfa = nullptr);
            virtual const CResult InternalLoadFigureDXF(const wchar_t* pWcsFileNameWithPath);
            virtual const CResult SynchronizePointOfViewFromPopupMenu(int32_t i32ViewIndex);
        public:
            DECLARE_MESSAGE_MAP()
            afx_msg void OnLButtonDblClk(UINT nFlags, CPoint ptClient);
            afx_msg void OnLButtonDown(UINT nFlags, CPoint ptClient);
            afx_msg void OnLButtonUp(UINT nFlags, CPoint ptClient);
            afx_msg void OnMButtonDblClk(UINT nFlags, CPoint ptClient);
            afx_msg void OnMButtonDown(UINT nFlags, CPoint ptClient);
            afx_msg void OnMButtonUp(UINT nFlags, CPoint ptClient);
            afx_msg void OnRButtonDblClk(UINT nFlags, CPoint ptClient);
            afx_msg void OnRButtonDown(UINT nFlags, CPoint ptClient);
            afx_msg void OnRButtonUp(UINT nFlags, CPoint ptClient);
            afx_msg BOOL OnMouseWheel(UINT nFlags, int16_t zDelta, CPoint pt);
            afx_msg void OnSize(UINT nType, int32_t cx, int32_t cy);
            virtual void PreSubclassWindow();
            virtual BOOL PreTranslateMessage(MSG* pMsg);
            virtual void OnDraw(CDC* /*pDC*/);
            afx_msg void OnMouseMove(UINT nFlags, CPoint ptClient);
            afx_msg void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags);
            afx_msg void OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags);
            afx_msg void OnTimer(UINT_PTR nIDEvent);
            afx_msg BOOL OnEraseBkgnd(CDC* pDC);
            afx_msg BOOL OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message);
            afx_msg void OnDropFiles(HDROP hDropInfo);
            afx_msg void OnMouseLeave();
            afx_msg void OnMouseHover(UINT nFlags, CPoint point);
            afx_msg void OnEnterIdle(UINT nWhy, CWnd* pWho);
 
        public:
            virtual void OnInitialUpdate();
            afx_msg void OnFileOpen();
            afx_msg void OnUpdateFileOpen(CCmdUI* pCmdUI);
            afx_msg void OnFileIO(UINT uID);
            afx_msg void OnUpdateFileIO(CCmdUI* pCmdUI);
            afx_msg void OnMoreMenu();
 
            afx_msg void OnSetZoomMode(UINT uID);
            afx_msg void OnSetZoomFitMode();
            afx_msg void OnSetPanningMode();
            afx_msg void OnShowScrollBar();
            afx_msg void OnShowStatusBar();
            afx_msg void OnUpdateZoomIn(CCmdUI* pCmdUI);
            afx_msg void OnUpdateZoomOut(CCmdUI* pCmdUI);
            afx_msg void OnUpdateZoomFit(CCmdUI* pCmdUI);
            afx_msg void OnUpdatePanningMode(CCmdUI* pCmdUI);
            afx_msg void OnUpdateShowScrollBarMode(CCmdUI* pCmdUI);
            afx_msg void OnUpdateShowStatusBarMode(CCmdUI* pCmdUI);
 
            afx_msg void OnMeasurementDistance();
            afx_msg void OnUpdateMeasurement(CCmdUI* pCmdUI);
            afx_msg void OnSetMeasureMode(UINT uID);
 
            afx_msg void OnLayers();
            afx_msg void OnSetLayers(UINT uID);
            afx_msg void OnUpdateLayers(CCmdUI* pCmdUI);
 
            afx_msg void OnSyncView();
            afx_msg void OnSetSyncView(UINT uID);
            afx_msg void OnUpdateSyncView(CCmdUI* pCmdUI);
 
            afx_msg void OnSetSyncWindow(UINT uID);
 
            afx_msg void OnShowGrid();
            afx_msg void OnUpdateShowGrid(CCmdUI* pCmdUI);
 
            afx_msg void OnShowCrosshair();
            afx_msg void OnUpdateShowCrosshair(CCmdUI* pCmdUI);
 
            afx_msg void OnShowImageCoordinateOnCursor();
            afx_msg void OnUpdateShowImageCoordinateOnCursor(CCmdUI* pCmdUI);
 
            afx_msg void OnSetCanvasColor();
            afx_msg void OnUpdateSetCanvasColor(CCmdUI* pCmdUI);
 
            afx_msg void OnSetPixelAccuracy();
            afx_msg void OnUpdateSetPixelAccuracy(CCmdUI* pCmdUI);
 
            afx_msg void OnInformationHelp();
 
            afx_msg void OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar);
            afx_msg void OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar);
 
 
            afx_msg void OnSetFocus(CWnd* pOldWnd);
            afx_msg void OnNcLButtonDown(UINT nHitTest, CPoint point);
            afx_msg void OnNcLButtonUp(UINT nHitTest, CPoint point);
            afx_msg LRESULT OnMessageRunOnMainThread(WPARAM wParam, LPARAM lParam);
            afx_msg LRESULT OnMessageRunOnMainThreadPost(WPARAM wParam, LPARAM lParam);
            afx_msg void OnClipboardUpdate();
 
            afx_msg void OnDestroy();
 
            BOOL OnNeedText(UINT id, NMHDR* pNMHDR, LRESULT* pResult);
            virtual void PostNcDestroy();
 
        protected:
            virtual const CResult MoveNamedLayerUp(int32_t i32LayerIndex);
            virtual const CResult MoveNamedLayerDown(int32_t i32LayerIndex);
 
            virtual const CResult InternalAssign(const CGUIViewBase& rhs) override;
 
            virtual const CResult InternalConvertLayerToFigure(Foundation::CFLFigureArray& flfaResult);
 
            virtual const CResult PreDestroy() override;
 
            virtual const CResult DrawBackground();
 
            virtual const CResult InitializeDIB();
            virtual const CResult TerminateDIB();
            virtual const CResult CommitDraw(CDC* pDC);
            virtual const CResult SetDefaultView();
 
            EMenuItemViewDrawing GetLastMenuStatus() const;
            void SetLastMenuStatus(EMenuItemViewDrawing eMenuItemViewDrawing);
 
            CGUIViewImageLayer* GetObjectLayer() const;
 
            LRESULT OnCursorPosChanged(WPARAM wParam, LPARAM lParam);
            LRESULT OnScaleChanged(WPARAM wParam, LPARAM lParam);
            LRESULT OnLazyBroadcastScaleChanged(WPARAM wParam, LPARAM lParam);
            LRESULT OnUpdateStatusBar(WPARAM wParam, LPARAM lParam);
            LRESULT OnPaneDialogClosed(WPARAM wParam, LPARAM lParam);
 
            void BroadcastOffsetChanged();
            void BroadcastScaleChanged();
 
            virtual void OnReceiveBroadcast(const Base::CBroadcastMessage* pMessage) override;
 
            void SetStatusBarText(CGUIViewDrawing::EStatusPaneItem eIndex, LPCTSTR lpszText);
            void SetStatusBarText(CGUIViewDrawing::EStatusPaneItem eIndex, int32_t i32Value);
            void SetStatusBarText(CGUIViewDrawing::EStatusPaneItem eIndex, int64_t i64Value);
            void SetStatusBarText(CGUIViewDrawing::EStatusPaneItem eIndex, double f64Value, int32_t i32DecimalPlaces = 3);
 
            virtual const CResult RestoreButtonInfo();
            virtual void UpdateToolBarButtons() override;
            virtual void UpdateToolBarButtonVisible() override;
 
            const CResult SetPixelAccuracy(double f64PixelAccuracyX, double f64PixelAccuracyY, Foundation::ELengthUnit eLenUnit, bool bWriteFile);
 
            void SetMinMaxScale();
            void SetZoomFitMode(bool bSet);
            bool IsZoomFitMode();
 
            virtual bool DrawLayerBegin();
            virtual bool DrawLayerEnd();
            virtual bool DrawGrid();
            virtual bool DrawLayerElements();
            virtual bool DrawMiniMap();
            virtual bool DrawCrosshair();
 
            virtual const CResult CreateDialogOfSetDecimalPlacesOfCoordinate();
            virtual const CResult CreateDialogOfPixelAccuracy();
            virtual const CResult CreateDialogOfSetViewCenterAndScale();
            virtual const CResult CreateDialogOfSetScale();
            virtual const CResult CreateDialogOfLayerProperties();
            virtual const CResult CreateDialogLoadFigureDxf(const std::vector<Base::CFLString<wchar_t>>& vctDxfPath);
 
            virtual bool IsLayerPropertiesDialogVisible() const;
            virtual void UpdateAllLayersGeometryFlag(bool bUpdate);
            virtual void ClearAllLayersOffscreenD2DGeometry();
            virtual void BeginOffsetOnlyChanging();
            virtual void EndOffsetOnlyChanging();
 
            virtual const CResult SynchronizeView(CGUIViewDrawing* pTargetView, EViewDrawingSyncOption eSyncOption);
            virtual const CResult DesynchronizeView(CGUIViewDrawing* pTargetView, EViewDrawingSyncOption eSyncOption);
            virtual const CResult DesynchronizeViewAll(EViewDrawingSyncOption eSyncOption);
            
            virtual void UpdateDragAndDropState();
 
            DeclareGetClassType();
 
        protected:
            CGUIViewImageMiniMap* m_pMiniMap;
            CGUIManagerContextMenuViewDrawing* m_pMgrContextMenu;
            CGUIManagerViewDrawingObject* m_pMgrViewDrawingObject;
 
 
            /* Parent Window*/
            CWnd* m_pParentWnd;
 
            /* Scale*/
            double m_f64Scale;
            double m_f64MinScale;
            double m_f64MaxScale;
            EZoomMode m_eZoomMode;
            uint32_t m_u32ForceZoomFitCount;
 
            /* Scale & Offset*/
            bool m_bZoomFitMode;
            bool m_bPanningMode;
            bool m_bRButtonDragPanningMode;
 
            /* Offset*/
            Foundation::CFLPoint<double> m_flpOffset;
            Foundation::CFLPoint<double> m_flpOffsetOnBegin;
            bool m_bOffsetOnlyChanging;
            
 
            /* View Properties*/
            int32_t m_i32CanvasLeft;
            int32_t m_i32CanvasTop;
            int32_t m_i32CanvasWidth;
            int32_t m_i32CanvasHeight;
            COLORREF m_clrClientFillColor;
            EGUIViewDrawingTeachingMode m_eTeachingMode;
 
            /* Bitmap & DC*/
            typedef struct sDibInfo
            {
                BITMAPINFOHEADER    header;
                RGBQUAD             acolors[256];
            }
            SDibInfo;
 
            SDibInfo m_bitmapInfo;
            HBITMAP m_hDibSection;
 
            uint8_t* m_pDibBase;
            uint8_t* m_pOffBuffer;
 
            CDC m_dcDIB;
            HDC m_hdcDIB;
            HANDLE m_hDrawDIB;
            HGDIOBJ m_hPreviousSelectedGdiObj;
 
            /* View Status*/
            bool m_bBreak;
            bool m_bShiftKeyDown;
            bool m_bNCLButtonDown;
            bool m_bContextMenuFromRButtonUp;
            bool m_bOnSize;
            bool m_bKeyDown;
            bool m_bEnableSystemMenuOnFileDialog;
            int16_t m_i16DownKey;
 
            int32_t m_i32LastNCPointX;
            int32_t m_i32LastNCPointY;
 
            bool m_bEnableSelection;
 
            SViewImageObjectSettings m_sVioSettings;
            SViofSettings m_sViofSettings;
            Base::CFLString<wchar_t> m_strFormatForViofD;
            Base::CFLString<wchar_t> m_strFormatForViofF;
            Base::CFLString<wchar_t> m_strFormatForViofL;
            Base::CFLString<wchar_t> m_strFormatForViofLL;
 
            bool m_bGrayFillColor;
            bool m_bMouseOnView;
            bool m_bSetFileNameOnStatusBar;
 
            /* Mouse Point*/
            Foundation::CFLPoint<int32_t> m_flpLastCursorClient;
            Foundation::CFLPoint<int32_t> m_flpLastDraggingPositionClient;
            Foundation::CFLPoint<double> m_flpTeachingCursorImage;
            Foundation::CFLPoint<double> m_flpRButtonUpCursorImage;
            Foundation::CFLPoint<double> m_flpCursorImageLBtnDown;
            Foundation::CFLPoint<double> m_flpCursorImageMBtnDown;
            Foundation::CFLPoint<double> m_flpCursorImageRBtnDown;
            CPoint m_ptPrevClient;
            CPoint m_ptClientRBtnDown;
            CPoint m_ptClientLBtnDown;
            int32_t m_i32MouseDragDistance;
            int32_t m_i32MouseDragDistanceThreshold;
            
            /* Cursor*/
            UINT m_nCursor;
 
            /* Multi selection*/
            bool m_bShowMultiSelectRect;
            bool m_bShowMultiSelectCandidateRect;
            Foundation::CFLRect<double> m_flrMultiSelectRect;
            Foundation::CFLRect<double> m_flrSelectionCandidate;
 
            /* Pixel Accuracy*/
            double m_f64PixelAccuracyX;
            double m_f64PixelAccuracyY;
            Foundation::ELengthUnit m_eLengthUnit;
 
            uint8_t m_u8DecimalPlacesOfCoordinate;
 
            bool m_bToBroadcastScaleChanged;
 
            CD2DObject m_d2dObject;
 
            /* Synchronize view*/
            std::map<EViewDrawingSyncOption, CGUIViewDrawing*> m_mapRootSyncView;
 
            /* Layers*/
            std::vector<CGUIViewImageLayer*> m_vctDrawingLayers;
            std::vector<CGUIViewImageLayer*> m_vctDrawingLayersNamed;
            std::unordered_map<std::wstring, CGUIViewImageLayer*> m_mapDrawingLayers;
 
            CGUIViewImageLayer* m_pLayerInfoOnCursor;
 
            CGUIViewImageLayer* m_pViewObjectLayer;
            CGUIViewImageLayer* m_pViewObjectHoverLayer;
            CGUIViewImageLayer* m_pViewObjectModifyPreviewLayer;
 
            /* Key */
            bool m_bCtrlKeyDown;
 
            EGUIViewDrawingHitArea m_eHitArea;
            EGUIViewDrawingHitArea m_eHitAreaOnLButtonDown;
 
            bool m_bShowImage;
            bool m_bShowGrid;
            bool m_bShowCrosshair;
            bool m_bShowImageCoordinateOnCursor;
            bool m_bFirstShowScrollBar;
            bool m_bRotateFigureZOrder;
 
            /* Popup Menu*/
            EMenuItemViewDrawing m_eLastMenuStatus;
            EMenuItemViewDrawing m_eLastMenuStatusBefore;
 
            /* Dialog */
            CGUIPaneDialog* m_pPaneDlgLayerProperties;
            CGUIDialogLayerProperties* m_pDlgLayerProperties;
            CGUIPaneDialog* m_pPaneDlgFigureGbrAttribute;
 
 
            friend class CInternalViewImage;
            friend class CGUIManagerContextMenuViewDrawing;
            friend class CGUIViewImageMiniMap;
            friend class CGUIPropertyGridPropertyViewImageList;
            friend class CGUIPropertyItemViewImageList;
            friend class CGUIPropertyGridPropertyViewFigure;
            friend class CGUIPropertyGridPropertyCategory;
            friend class CGUIPropertyItemViewFigure;
            friend class CGUIChildFrameImage;
            friend class CGUIViewImageLayer;
            friend class CGUIViewImageLayerObject;
            friend class CGUIManagerView;
            friend class CGUIManager;
            friend class CInternalViewManager;
            friend class CInternalCanvas;
            friend class CGUIManagerViewImageObject;
            friend class CGUIManagerDrawingViewImageObject;
            friend class CGUIManagerContextMenuViewImageObject;
            friend class CGUIViewImageCanvas;
            friend class CGUIViewToolBar;
            friend class CGUIMainFrame;
            friend class CGUIDialogCreateStencil;
            friend class CGUIDialogImageInfo;
            friend class CGUIDialogImagePageList;
            friend class CGUIDialogLayerProperties;
            friend class CGUIDialogLayerProperties;
            friend class CGUIDialogLoadRawImageSetting;
            friend class CGUIDialogLoadRawImageMultiSetting;
            friend class CGUIDialogHelp;
            friend class CGUIFixedViewDeclaration;
            friend class CGUIManagerViewDrawingObject;
        };
    }
}