GUIViewImageWrap.h

#pragma once
 
#include "GUIViewImageBaseWrap.h"
 
#include "GUIViewImageLayerWrap.h"
#include "GUIDefinitionsBroadcast.h"
 
namespace FLImaging
{
    namespace GUI
    {
        class FL_EXPORT CGUIViewImageWrap : public CGUIViewImageBaseWrap
        {
            SupportToDuplicateObject(CGUIViewImageWrap);
 
        public:
            CGUIViewImageWrap();
 
            virtual ~CGUIViewImageWrap();
 
            const CResult Create(int32_t i32L, int32_t i32T, int32_t i32R, int32_t i32B, size_t stParentWindowHandle = 0);
 
            const CResult CreateAndFitParent(size_t stParentWindowHandle, bool bAutoFit = true);
 
            const CResult Destroy();
 
            size_t GetWindowHandle();
 
            Foundation::CFLRect<int32_t> GetImageRect() const;
 
            virtual const CResult Load(const wchar_t* pWcsPath = nullptr, FLImaging::GUI::EViewImageLoadOption eOption = EViewImageLoadOption_Default);
 
            virtual const CResult Load(Base::CFLArray<FLImaging::Base::CFLString<wchar_t>>* pFlaStrPath, FLImaging::GUI::EViewImageLoadOption eOption = EViewImageLoadOption_Default);
 
            virtual const CResult LoadRaw(const wchar_t* pWcsPath = nullptr, FLImaging::GUI::EViewImageLoadOption eOption = EViewImageLoadOption_Load);
 
            virtual const CResult LoadRaw(const wchar_t* pWcsPath, int64_t i64Width, int64_t i64Height, Base::EPixelFormat ePixelFormat = Base::EPixelFormat_C1_U8, int32_t i32AlignByte = 4, int64_t i64OffsetByteFromBegin = 0, int64_t i64OffsetByteFromEnd = 0, FLImaging::GUI::EViewImageLoadOption eOption = EViewImageLoadOption_Load);
 
            virtual const CResult Save(const wchar_t* pWcsFileNameWithPath = nullptr, bool bSaveCurrentPage = false, bool bWithLayers = false);
 
            virtual const CResult SavePage(int32_t i32PageIndex, const wchar_t* pWcsFileNameWithPath = nullptr);
 
            virtual const CResult SavePages(Base::CFLArray<int32_t>* pFlaPageIndices, const wchar_t* pWcsFileNameWithPath = nullptr);
 
            virtual const CResult LoadFigure(const wchar_t* pWcsPath = nullptr, bool bErrorMsgBox = false);
 
            virtual const CResult LoadFigureGBR(const wchar_t* pWcsPath = nullptr, const wchar_t* pWcsLayerName = nullptr, uint32_t u32Color = -1);
 
            virtual const CResult LoadFigureGBR(const wchar_t* pWcsPath, int32_t i32LayerNo, bool bClearLayer);
 
            virtual const CResult LoadFigureDXF(const wchar_t* pWcsPath = nullptr, bool bErrorMsgBox = false);
 
            virtual const CResult SaveFigure(Foundation::CFLFigure* pFigure, const wchar_t* pWcsPath = nullptr);
 
            virtual const CResult ClearFile();
 
            virtual const CResult ClearPage();
 
            virtual const CResult ClearPages(Base::CFLArray<int32_t>* pFlaPageIndices);
 
            virtual const CResult CreatePage(FLImaging::GUI::EViewImageCreatePageOption eOption = EViewImageCreatePageOption_Append);
 
 
            virtual const CResult CreateImage(int64_t i64Width, int64_t i64Height, int32_t i32Channel, int32_t i32Depth, Base::EValueType eType, bool bOptSeparateChannel, int64_t i64FillValue, int32_t i32AlignByte);
 
            bool DoesFLImageBufferExist();
 
            bool DoesFLImageExist();
 
            virtual Base::CFLImage* GetIntrinsicImage();
 
            virtual Base::CFLImage* GetImagePtr();
 
            virtual const CResult SetImagePtr(Base::CFLImage* pImage);
 
            virtual Foundation::CFLPoint<double> ConvertClientCoordToImageCoord(const Foundation::CFLPoint<int32_t>& flp);
 
            virtual Foundation::CFLRect<double> ConvertClientCoordToImageCoord(const Foundation::CFLRect<int32_t>& flr);
 
            virtual Foundation::CFLPoint<double> ConvertClientCoordToImageCoord(int32_t i32X, int32_t i32Y);
 
            virtual Foundation::CFLPoint<int32_t> ConvertImageCoordToClientCoord(const Foundation::CFLPoint<double>& flp);
 
            virtual Foundation::CFLRect<int32_t> ConvertImageCoordToClientCoord(const Foundation::CFLRect<double>& flr);
 
            virtual Foundation::CFLPoint<int32_t> ConvertImageCoordToClientCoord(double x, double y);
 
 
            virtual Foundation::CFLPoint<int32_t> ConvertClientCoordToCanvasCoord(const Foundation::CFLPoint<int32_t>& flp);
 
            virtual Foundation::CFLRect<int32_t> ConvertClientCoordToCanvasCoord(const Foundation::CFLRect<int32_t>& flr);
 
            virtual Foundation::CFLPoint<int32_t> ConvertClientCoordToCanvasCoord(int32_t x, int32_t y);
 
            virtual Foundation::CFLPoint<int32_t> ConvertCanvasCoordToClientCoord(const Foundation::CFLPoint<int32_t>& flp);
 
            virtual Foundation::CFLRect<int32_t> ConvertCanvasCoordToClientCoord(const Foundation::CFLRect<int32_t>& flr);
 
            virtual Foundation::CFLPoint<int32_t> ConvertCanvasCoordToClientCoord(int32_t x, int32_t y);
 
            virtual Foundation::CFLPoint<double> ConvertCanvasCoordToImageCoord(const Foundation::CFLPoint<int32_t>& flp);
 
            virtual Foundation::CFLRect<double> ConvertCanvasCoordToImageCoord(const Foundation::CFLRect<int32_t>& flr);
 
            virtual Foundation::CFLPoint<double> ConvertCanvasCoordToImageCoord(int32_t x, int32_t y);
 
            virtual Foundation::CFLPoint<int32_t> ConvertImageCoordToCanvasCoord(const Foundation::CFLPoint<double>& flp);
 
            virtual Foundation::CFLRect<int32_t> ConvertImageCoordToCanvasCoord(const Foundation::CFLRect<double>& flr);
 
            virtual Foundation::CFLPoint<int32_t> ConvertImageCoordToCanvasCoord(double x, double y);
 
            virtual void ClearAllLayers();
 
            CGUIViewImageLayerWrap GetLayer(int32_t i32Index) const;
 
            CGUIViewImageLayerWrap GetLayerByName(const wchar_t* pWcsLayerName);
 
            const CResult DeleteLayerByName(const wchar_t* pWcsLayerName);
 
            bool DoesLayerExist(const wchar_t* pWcsLayerName) const;
 
            int32_t GetNamedLayerCount() const;
 
            CGUIViewImageLayerWrap GetNamedLayer(int32_t i32Index) const;
 
            virtual const CResult SetLayerAutoClearMode(int32_t i32LayerIndex, ELayerAutoClearMode eMode, bool bSet);
 
            virtual const CResult SetLayerAutoClearMode(CGUIViewImageLayerWrap* pLayer, ELayerAutoClearMode eMode, bool bSet);
 
            virtual const CResult SetLayerAutoClearMode(ELayerAutoClearMode eMode, bool bSet);
 
            virtual bool GetLayerAutoClearMode(int32_t i32LayerIndex, FLImaging::GUI::ELayerAutoClearMode eMode) const;
 
            virtual bool GetLayerAutoClearMode(const CGUIViewImageLayerWrap* pLayer, ELayerAutoClearMode eMode) const;
 
            virtual const CResult ZoomFitToLayer(int32_t i32LayerIndex);
 
            virtual const CResult ZoomFitToLayer(const CGUIViewImageLayerWrap* pLayer);
 
            const CResult ClearMeasurement();
 
            const CResult ConvertLayerToFigureObject(int32_t i32LayerIndex);
 
            const CResult ConvertLayerToFigureObject(CGUIViewImageLayerWrap* pLayer);
 
            const CResult ConvertSelectedFigureObjectToLayer(int32_t i32LayerIndex, uint32_t u32Color = -1);
 
            const CResult ConvertSelectedFigureObjectToLayer(CGUIViewImageLayerWrap* pLayer, uint32_t u32Color = -1);
 
            const CResult ConvertAllFigureObjectsToLayer(int32_t i32LayerIndex, uint32_t u32Color = -1);
 
            const CResult ConvertAllFigureObjectsToLayer(CGUIViewImageLayerWrap* pLayer, uint32_t u32Color = -1);
 
            const CResult SelectFigureObject(int32_t i32Index);
 
            const CResult ClearFigureObject();
 
            const CResult PushFrontFigureObject(Foundation::CFLFigure* pFigure, FLImaging::GUI::EAvailableFigureContextMenu eMenu = FLImaging::GUI::EAvailableFigureContextMenu_All, FLImaging::GUI::EAvailableFigureContextMenu2 eMenu2 = FLImaging::GUI::EAvailableFigureContextMenu2_All);
 
            const CResult PushBackFigureObject(Foundation::CFLFigure* pFigure, FLImaging::GUI::EAvailableFigureContextMenu eMenu = FLImaging::GUI::EAvailableFigureContextMenu_All, FLImaging::GUI::EAvailableFigureContextMenu2 eMenu2 = FLImaging::GUI::EAvailableFigureContextMenu2_All);
 
 
            const CResult DeleteFigureObject(int32_t i32Index);
 
            const CResult DeleteFigureObject(const wchar_t* pWcsObjectName);
 
 
            Foundation::CFLFigure* GetFigureObject(int32_t i32Index) const;
 
            Foundation::CFLFigure* GetFigureObject(const wchar_t* pWcsObjectName) const;
 
            Foundation::CFLFigure* GetAllFigureObject() const;
 
            Foundation::CFLFigure* PopFrontFigureObject();
 
            Foundation::CFLFigure* PopBackFigureObject();
 
            Foundation::CFLFigure* PopFigureObject(int32_t i32Index);
 
            Foundation::CFLFigure* PopFigureObject(const wchar_t* pWcsObjectName);
 
            Foundation::CFLFigure* PopAllFigureObject();
 
            bool DoesFigureObjectExist(int32_t i32Index);
 
            bool DoesFigureObjectExist(const wchar_t* pWcsObjectName);
 
 
            int32_t GetFigureObjectCount() const;
 
 
            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);
 
            virtual Foundation::CFLPoint<double> GetOffset() const;
 
            virtual const CResult InternalSetOffset(const Foundation::CFLPoint<double>& flpOffset);
 
 
            virtual double GetScale() const;
 
            virtual const CResult InternalSetScale(double f64Scale);
 
            double GetZoomFitScale(double f64ClientWidth, double f64ClientHeight) const;
 
 
            virtual const CResult InternalZoomIn(int32_t i32CanvasX, int32_t i32CanvasY, double f64Ratio = 1.25);
 
            virtual const CResult InternalZoomOut(int32_t i32CanvasX, int32_t i32CanvasY, double f64Ratio = 0.8);
 
            virtual const CResult ZoomFit();
 
            virtual const CResult MoveToPrevPage();
 
            virtual const CResult MoveToNextPage();
 
            virtual const CResult MoveToPage(int32_t i32PageNum);
 
            EGUIViewImageHitArea GetHitArea() const;
 
            virtual void SetCanvasColor(uint32_t u32Color);
 
            virtual uint32_t GetCanvasColor() const;
 
            virtual void ShowImage(bool bShow);
 
            virtual bool IsImageVisible();
 
            virtual void ShowThumbnailView(bool bShow);
 
            virtual bool IsThumbnailViewVisible();
 
            virtual void SetFixThumbnailView(bool bFix);
 
            virtual bool IsThumbnailViewFixed();
 
 
            virtual void ShowImageMiniMap(bool bShow);
 
            virtual bool IsImageMiniMapVisible();
 
            virtual void ShowPageIndex(bool bShow);
 
            virtual bool IsPageIndexVisible();
 
 
            virtual void ShowGrid(bool bShow);
 
            virtual bool IsGridVisible();
 
 
            virtual void ShowImageCenter(bool bShow);
 
            virtual bool IsImageCenterVisible();
 
 
            virtual void ShowCrosshair(bool bShow);
 
            virtual bool IsCrosshairVisible();
 
            virtual void ShowImageCoordinateOnCursor(bool bShow);
 
            virtual bool IsImageCoordinateOnCursorVisible();
 
            virtual void ShowImagePixelValueOnCursor(bool bShow);
 
            virtual bool IsImagePixelValueOnCursorVisible();
 
            virtual const CResult SetDecimalPlaceOfCoordinate(uint8_t u8DecimalPlace = 2);
 
            virtual uint8_t GetDecimalPlaceOfCoordinate() const;
 
            virtual void ShowIntensitySpectrum(bool bShow);
 
            virtual bool IsIntensitySpectrumVisible();
 
 
            virtual void ShowPixelValue(bool bShow);
 
            virtual bool IsPixelValueVisible();
 
            virtual void SetPixelNumberMode(EPixelNumberMode eMode);
 
            virtual EPixelNumberMode GetPixelNumberMode() 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(FLImaging::Foundation::ELengthUnit eLenUnit);
 
            Foundation::ELengthUnit GetPixelAccuracyUnit() const;
 
 
            virtual const CResult SelectMenuItem(FLImaging::GUI::EMenuItem eMenuItem);
 
            bool IsSynchronized(FLImaging::GUI::EViewImageSyncOption eViewImageSyncOption);
 
            CGUIViewImageWrap* GetRootSyncView(FLImaging::GUI::EViewImageSyncOption eViewImageSyncOption) const;
 
            const CResult ResignRootSyncView(FLImaging::GUI::EViewImageSyncOption eViewImageSyncOption);
 
            const CResult SynchronizePointOfView(const CGUIViewImageWrap* pViewImageTarget);
 
            const CResult DesynchronizePointOfView(const CGUIViewImageWrap* pViewImageTarget);
 
            const CResult DesynchronizePointOfViewAll();
 
            const CResult SynchronizePageIndex(const CGUIViewImageWrap* pViewImageTarget);
 
            const CResult DesynchronizePageIndex(const CGUIViewImageWrap* pViewImageTarget);
 
            const CResult DesynchronizePageIndexAll();
 
 
            const CResult ShowScrollBar(bool bShow);
 
            const CResult ShowStatusBar(bool bShow);
 
            const CResult CaptureScreen(Base::CFLImage& fliImage, bool bIncludeFrame = false);
 
            const CResult CaptureScreen(Base::CFLImage* pFliImage, bool bIncludeFrame = false);
 
 
            const CResult CopyImage();
 
            const CResult CopyPages(Base::CFLArray<int32_t>* pFlaPageIndices);
 
            const CResult PasteImage();
 
            const CResult PasteImageAt(int32_t i32PageIndex);
 
            const CResult RotateImage(FLImaging::GUI::EImageRotateAngle eAngle);
 
            const CResult FlipImage(FLImaging::GUI::EImageFlipDirection eDirection);
 
            const CResult RearrangePageOrder(int32_t i32OrigPageIndex, int32_t i32TargetPageIndex);
 
            const CResult RearrangePageOrder(Base::CFLArray<int32_t>* pFlaPageIndices, int32_t i32TargetPageIndex);
 
            virtual const CResult SetThumbnailViewHeight(double f64ThumbnailViewRatio);
 
            virtual const CResult SetThumbnailViewHeight(double f64ThumbnailViewRatio, double f64ThumbnailViewRatioMin, double f64ThumbnailViewRatioMax);
 
            virtual const CResult SetThumbnailViewHeightRange(double f64ThumbnailViewRatioMin, double f64ThumbnailViewRatioMax);
 
            virtual double GetThumbnailViewHeight() const;
 
            virtual double GetThumbnailViewHeightMin() const;
 
            virtual double GetThumbnailViewHeightMax() const;
 
            virtual const CResult SetFloatingImageValueRange(float f32Min, float f32Max);
 
            virtual const CResult GetFloatingImageValueRange(float& f32Min, float& f32Max) const;
 
            virtual const CResult SetFloatingImageValueRange(double f64Min, double f64Max);
 
            virtual const CResult GetFloatingImageValueRange(double& f64Min, double& f64Max) const;
 
            virtual void EnableSelection(bool bEnable);
 
            virtual bool IsSelectionEnabled() const;
 
            virtual void EnableDragAndDrop(bool bEnable);
 
            virtual bool IsDragAndDropEnabled() const;
 
            virtual void SetFigureObjectMagnetOption(FLImaging::GUI::EViewImageFigureObjectMagnetOption eOption);
 
            virtual FLImaging::GUI::EViewImageFigureObjectMagnetOption GetFigureObjectMagnetOption() const;
 
            virtual void SetFigureObjectName(int32_t i32FigureObjectIndex, const wchar_t* pWcsName);
 
            virtual Base::CFLString<wchar_t> GetFigureObjectName(int32_t i32FigureObjectIndex) const;
 
            virtual void SetAvailableViewImageContextMenu(EAvailableViewImageContextMenu eMenu);
 
            virtual EAvailableViewImageContextMenu GetAvailableViewImageContextMenu()const;
 
            virtual void SetAvailableViewImageContextMenuImageFigure(EAvailableViewImageContextMenuImageFigure eMenu);
 
            virtual EAvailableViewImageContextMenuImageFigure GetAvailableViewImageContextMenuImageFigure()const;
 
            virtual void EnableFigureObjectRotation(int32_t i32FigureObjectIndex, bool bEnable);
 
            virtual bool IsFigureObjectRotationEnabled(int32_t i32FigureObjectIndex) const;
 
            virtual void EnableMouseWheel(bool bEnable);
 
            virtual bool IsMouseWheelEnabled() const;
 
            virtual void EnableMouseWheelButton(bool bEnable);
 
            virtual bool IsMouseWheelButtonEnabled() const;
 
            virtual void ShowFigureObjectInformationTextGlobal(bool bShow);
 
            virtual bool IsFigureObjectInformationTextVisibleGlobal() const;
 
            virtual void SetFigureObjectInformationTextOptionGlobal(EFigureObjectInformationText eFigureObjectInformationText);
 
            virtual EFigureObjectInformationText GetFigureObjectInformationTextOptionGlobal() const;
 
            virtual void SetFigureObjectStringDecimalPlaceGlobal(uint32_t u32DecimalPlace = 2, bool bExponentialNotation = false);
 
            virtual void SetFigureObjectStringDecimalPlaceForPixelAccuracyGlobal(uint32_t u32DecimalPlace = 2, bool bExponentialNotationForPixelAccuracy = false);
 
            virtual uint32_t GetFigureObjectStringDecimalPlaceGlobal() const;
 
            virtual bool GetFigureObjectStringExponentialFlagGlobal() const;
 
            virtual uint32_t GetFigureObjectStringDecimalPlaceForPixelAccuracyGlobal() const;
 
            virtual bool GetFigureObjectStringExponentialFlagForPixelAccuracyGlobal() const;
 
            template<typename T>
            FLImaging::Base::CFLString<wchar_t> GetFigureObjectFormatStringGlobal(bool& bExponentialNotation) const;
 
            FLImaging::Base::CFLString<wchar_t> GetFigureObjectFormatStringForPixelAccuracyGlobal(bool& bExponentialNotation) const;
 
            virtual void EnableFigureObjectMagnetToImageGlobal(bool bEnable);
 
            virtual bool IsFigureObjectMagnetToImageGlobalEnabled() const;
 
            virtual void EnableFigureObjectAngleMagnetGlobal(bool bEnable);
 
            virtual bool IsFigureObjectAngleMagnetGlobalEnabled() const;
 
            virtual const CResult PopupImageFigure(int32_t i32Idx);
 
            virtual const CResult PopupImageFigure(const Base::CFLArray<int32_t>* pFlaI32Index);
 
            virtual const CResult PopupImageFigureAll();
 
            virtual const CResult PopupImageFigureByConditions(const Base::CFLString<wchar_t>& strExpression);
 
            virtual const CResult RemoveImageFigure(int32_t i32Idx, bool bPopupMsgBox = false);
 
            virtual const CResult RemoveImageFigure(const Base::CFLArray<int32_t>* pFlaI32Index, bool bPopupMsgBox = false);
 
            virtual const CResult RemoveImageFiguresByConditions(const Base::CFLString<wchar_t>& strExpression, bool bPopupMsgBox = false);
 
            virtual const CResult RemoveImageFiguresByConditionsFromAllPages(const Base::CFLString<wchar_t>& strExpression, bool bPopupMsgBox = false);
 
            virtual const CResult ClearImageFiguresAll(bool bPopupMsgBox = false);
 
            virtual const CResult ClearImageFiguresAllPages(bool bPopupMsgBox = false);
 
            virtual const CResult SetImageFigureRealSizeText(bool bRealSize = false, bool bWriteFileSystem = true);
 
            virtual bool IsImageFigureRealSizeText() const;
 
            virtual const CResult SetImageFigureTextFont(const wchar_t* pStrFontName = nullptr, int32_t i32FontSize = 12, EGUIViewImageFontWeight eFontWeight = EGUIViewImageFontWeight_BOLD, bool bItalic = false, bool bWriteFileSystem = true);
 
            virtual const CResult GetImageFigureTextFont(wchar_t** ppStrFontName, int32_t& i32FontSize, EGUIViewImageFontWeight& eFontWeight, bool& bItalic) const;
 
            virtual const CResult SetImageFigureBorderWidth(int32_t i32BorderWidth = 1, bool bWriteFileSystem = true);
 
            virtual int32_t GetImageFigureBorderWidth() const;
 
            virtual const CResult SetImageFigureOpacityBorder(float f32Opacity = 1.f, bool bWriteFileSystem = true);
 
            virtual float GetImageFigureOpacityBorder() const;
 
            virtual const CResult SetImageFigureOpacityFill(float f32Opacity = 0.3f, bool bWriteFileSystem = true);
 
            virtual float GetImageFigureOpacityFill() const;
 
            virtual const CResult SetImageFigureTextOpacityBorder(float f32Opacity = 1.f, bool bWriteFileSystem = true);
 
            virtual float GetImageFigureTextOpacityBorder() const;
 
            virtual const CResult SetImageFigureTextOpacityFill(float f32Opacity = 1.f, bool bWriteFileSystem = true);
 
            virtual float GetImageFigureTextOpacityFill() const;
 
            virtual void ShowImageFigure(bool bShow);
 
            virtual bool IsImageFigureVisible() const;
 
            virtual void ShowImageFigureText(bool bShow);
 
            virtual bool IsImageFigureTextVisible() const;
 
            virtual void EnableHoverImageFigure(bool bEnable);
 
            virtual bool IsHoverImageFigureEnabled() const;
 
            virtual bool IsPixelSegmentationModeEnabled() const;
 
            virtual void EnablePixelSegmentationMode(bool bEnable);
 
            virtual void SetSegmentationLabelText(int32_t i32Channel, double f64Value, const Base::CFLString<wchar_t>& strLabelText);
 
            virtual const CResult GetSegmentationLabelText(int32_t i32Channel, double f64Value, Base::CFLString<wchar_t>& strLabelTextResult) const;
 
            virtual const CResult ClearSegmentationLabelText();
 
            virtual bool IsReductionInterpolationEnabled() const;
 
            virtual void EnableReductionInterpolation(bool bEnable);
 
            virtual void SetPanningMode(bool bSet);
 
            virtual bool IsPanningMode() const;
 
            virtual void SetZoomMode(EZoomMode eZoomMode);
 
            virtual EZoomMode GetZoomMode() const;
 
            virtual const CResult SetTeachingMode(ETeachingMode eTeachingMode);
 
            virtual ETeachingMode GetTeachingMode() const;
 
            virtual void EnableSystemMenuOnFileDialog(bool bEnable);
 
            virtual bool IsSystemMenuOnFileDialogEnabled() const;
 
        private:
            void operator=(const CGUIViewImageWrap& rh);
            CGUIViewImageWrap(const CGUIViewImageWrap& rh);
 
            DeclareGetClassType();
        };
}
}