hdicoreMessage.h

Go to the documentation of this file.

 
#ifndef __HDI_CORE_MESSAGE__
#define __HDI_CORE_MESSAGE__
 
#include <vector>
 
#include "hdicoreAngle.h"
#include "hdicoreArtboardPoint.h"
#include "hdicoreArtColor.h"
#include "hdicoreFileFormat.h"
#include "hdicorePoint.h"
#include "hdicoreRect.h"
#include "hdicoreTypes.h"
 
namespace hdi
{
    namespace core
    {
        #if defined(HDI_CORE_AIP_MODE)
            class Annotator;
            class Art;
            class Artboard;
            class DocumentView;
            class FileFormat;
            class MenuItem;
            class Notification;
            class Notifier;
            class Timer;
            class Tool;
        #endif
        // HDI_CORE_AIP_MODE
        
        #if defined(HDI_CORE_PSP_MODE)
            class DocumentInfo;
            class PixelMap;
        #endif
        // HDI_CORE_PSP_MODE
    
        class Message
        {
            public:
                virtual ~Message();
            
                virtual MessageType type() const;
                
                virtual void* rawData() const;
            
            
            protected:
                void* _data;

                Message();
                
                Message(const Message&);
                
                Message& operator=(const Message&);
        };
        
        class ActionMessage : public Message
        {
            public:
                virtual ~ActionMessage();
 
 
            private:
                // Only Dispatcher can construct an ActionMessage object
                friend class Dispatcher;

                ActionMessage(const MessageType, void*);
                
                ActionMessage(const ActionMessage&);
                
                ActionMessage& operator=(const ActionMessage&);
        };
        
        #if defined(HDI_CORE_PSP_MODE)
            class AcquireMessage : public Message
            {
                public:
                    virtual ~AcquireMessage();
                    
 
                private:
                    // Only Dispatcher can construct an AcquireMessage object
                    friend class Dispatcher;

                    AcquireMessage(const MessageType, void*);
                    
                    AcquireMessage(const AcquireMessage&);
                    
                    AcquireMessage& operator=(const AcquireMessage&);
            };
        #endif
        // HDI_CORE_PSP_MODE
        
        #if defined(HDI_CORE_AIP_MODE)
            class AdapterMessage : public Message
            {
                public:
                    virtual ~AdapterMessage();
 
 
                private:
                    // Only Dispatcher can construct an AdapterMessage object
                    friend class Dispatcher;

                    AdapterMessage(const MessageType, void*);
                    
                    AdapterMessage(const AdapterMessage&);
                    
                    AdapterMessage& operator=(const AdapterMessage&);
            };
        
            class AnnotatorMessage : public Message
            {
                public:
                    typedef std::vector<Rect> RectVector;
                
                    typedef AIAnnotatorDrawer* ContextPtr;
            
                    virtual ~AnnotatorMessage();
                    
                    Annotator* const annotator() const;
                    
                    const ContextPtr context() const;
                    
                    DocumentView* const docView() const;
                    
                    bool triggeredByDragScroll() const;
                    
                    bool showEdges() const;

                    RectVector* const invalidationRects() const;
            
 
                private:
                    // Only Dispatcher can construct an AnnotatorMessage object
                    friend class Dispatcher;

                    AnnotatorMessage(const Annotator&, const MessageType, void*);
                    
                    AnnotatorMessage(const AnnotatorMessage&);
                    
                    AnnotatorMessage& operator=(const AnnotatorMessage&);
            };
            
            class ClipboardMessage : public Message
            {
                public:
                    virtual ~ClipboardMessage();
 
 
                private:
                    // Only Dispatcher can construct a ClipboardMessage object
                    friend class Dispatcher;

                    ClipboardMessage(const MessageType, void*);
                    
                    ClipboardMessage(const ClipboardMessage&);
                    
                    ClipboardMessage& operator=(const ClipboardMessage&);
            };
        
            class CommandMessage : public Message
            {
                public:
                    virtual ~CommandMessage();
 
 
                private:
                    // Only Dispatcher can construct a CommandMessage object
                    friend class Dispatcher;

                    CommandMessage(const MessageType, void*);
                    
                    CommandMessage(const CommandMessage&);
                    
                    CommandMessage& operator=(const CommandMessage&);
            };
        #endif
        // HDI_CORE_AIP_MODE
        
        class CustomMessage : public Message
        {
            public:
                virtual ~CustomMessage();
                
                std::string caller() const;
                
                std::string selector() const;
                
                #if defined(HDI_CORE_PSP_MODE)
                    CallerType callerNumeric() const;
                    
                    int16_t selectorNumeric() const;
                #endif
 
 
            private:
                // Only Dispatcher can construct a CustomMessage object
                friend class Dispatcher;

                CustomMessage(const std::string&, const std::string&, const MessageType, void*);
 
                #if defined(HDI_CORE_PSP_MODE)
                    CustomMessage(const CallerType, const int16_t, const MessageType, void*);
                #endif
                
                CustomMessage(const CustomMessage&);
                
                CustomMessage& operator=(const CustomMessage&);
        };
        
        #if defined(HDI_CORE_PSP_MODE)
            class ExportMessage : public Message
            {
                public:
                    virtual ~ExportMessage();
 
 
                private:
                    // Only Dispatcher can construct an ExportMessage object
                    friend class Dispatcher;

                    ExportMessage(const MessageType, void*);
                    
                    ExportMessage(const ExportMessage&);
                    
                    ExportMessage& operator=(const ExportMessage&);
            };
        #endif
        // HDI_CORE_PSP_MODE
        
        #if defined(HDI_CORE_AIP_MODE)
            class FileFormatMessage : public Message
            {
                public:
                    typedef std::vector< std::shared_ptr<Artboard> > ArtboardVector;
                
                    virtual ~FileFormatMessage();
                    
                    FileFormat* const fileFormat() const;
                    
                    FileFormat::Options operation() const;
                    
                    FileFormat::ExtendedOptions extendedOperation() const;
                    
                    std::string filePath() const;
                    
                    void setFilePath(const std::string& path_);
                    
                    void* actionParam() const;
                    
                    ArtboardVector artboards() const;
 
 
                private:
                    // Only Dispatcher can construct a FileFormatMessage object
                    friend class Dispatcher;

                    FileFormatMessage(const MessageType, void*);
                    
                    FileFormatMessage(const FileFormatMessage&);
                    
                    FileFormatMessage& operator=(const FileFormatMessage&);
            };
        #endif
        // HDI_CORE_AIP_MODE
        
        #if defined(HDI_CORE_PSP_MODE)
            class FileFormatMessage : public Message
            {
                public:
                    virtual ~FileFormatMessage();
                
 
                private:
                    // Only Dispatcher can construct a FileFormatMessage object
                    friend class Dispatcher;

                    FileFormatMessage(const MessageType, void*);
                    
                    FileFormatMessage(const FileFormatMessage&);
                    
                    FileFormatMessage& operator=(const FileFormatMessage&);
            };
        #endif
        // HDI_CORE_AIP_MODE
        
        class FilterMessage : public Message
        {
            public:
                virtual ~FilterMessage();
                
                #if defined(HDI_CORE_PSP_MODE)
                    bool shouldAbort() const;
                    
                    void setProgress(const int32_t completed_, const int32_t total_);
            
                    int16_t planes() const;
            
                    int32_t maxSpace() const;
            
                    int32_t bufferSpace() const;
            
                    void setBufferSpace(const int32_t bs_);
            
                    int16_t inLoPlane() const;
            
                    void setInLoPlane(const int16_t ilp_);
            
                    int16_t inHiPlane() const;
            
                    void setInHiPlane(const int16_t ihp_);
            
                    int16_t outLoPlane() const;
            
                    void setOutLoPlane(const int16_t olp_);
            
                    int16_t outHiPlane() const;
            
                    void setOutHiPlane(const int16_t ohp_);
            
                    void* const inData() const;
            
                    int32_t inRowBytes() const;
            
                    void* const outData() const;
            
                    int32_t outRowBytes() const;
            
                    bool advanceState();
            
                    bool drawPixelData(
                        const PlatformDrawingContextPtr dc_,
                        const PixelMap& srcPM_,
                        const Rect& srcArea_,
                        const Point& dstTL_,
                        const Rect& dstArea_
                    );
            
                    bool isFloating() const;
            
                    bool hasMask() const;
            
                    bool autoMask() const;
            
                    void setAutoMask(const bool masked_);
            
                    void* const maskData() const;
            
                    int32_t maskRowBytes() const;
            
                    ArtColor backColor() const;
            
                    ArtColor foreColor() const;
            
                    ColorSpace imageMode() const;
            
                    double hRes() const;
            
                    double vRes() const;
            
                    MonitorSpecs* const monitor() const;
            
                    bool supportsDummyChannels() const;
            
                    bool supportsAlternateLayouts() const;
            
                    DataLayout wantLayout() const;
            
                    void setWantLayout(const DataLayout wl_);
            
                    FilterCase filterCase() const;
            
                    int16_t dummyPlaneValue() const;
            
                    void setDummyPlaneValue(const int16_t dpv_);
            
                    bool supportsAbsolute() const;
            
                    bool wantsAbsolute() const;
            
                    bool cannotUndo() const;
            
                    void setCannotUndo(const bool undo_);
            
                    bool supportsPadding() const;
            
                    int16_t inputPadding() const;
            
                    void setInputPadding(const int16_t pad_);
            
                    int16_t outputPadding() const;
            
                    void setOutputPadding(const int16_t pad_);
            
                    int16_t maskPadding() const;
            
                    void setMaskPadding(const int16_t pad_);
            
                    bool samplingSupport() const;
            
                    double inputRate() const;
            
                    void setInputRate(const double rate_);
            
                    double maskRate() const;
            
                    void setMaskRate(const double rate_);
            
                    int16_t inLayerPlanes() const;
            
                    int16_t inTransparencyMask() const;
            
                    int16_t inLayerMasks() const;
            
                    int16_t inInvertedLayerMasks() const;
            
                    int16_t inNonLayerPlanes() const;
            
                    int16_t outLayerPlanes() const;
            
                    int16_t outTransparencyMask() const;
            
                    int16_t outLayerMasks() const;
            
                    int16_t outInvertedLayerMasks() const;
            
                    int16_t outNonLayerPlanes() const;
            
                    int16_t absLayerPlanes() const;
            
                    int16_t absTransparencyMask() const;
            
                    int16_t absLayerMasks() const;
            
                    int16_t absInvertedLayerMasks() const;
            
                    int16_t absNonLayerPlanes() const;
            
                    int16_t inPreDummyPlanes() const;
            
                    int16_t inPostDummyPlanes() const;
            
                    int16_t outPreDummyPlanes() const;
            
                    int16_t outPostDummyPlanes() const;
            
                    int32_t inColumnBytes() const;
            
                    int32_t inPlaneBytes() const;
            
                    int32_t outColumnBytes() const;
            
                    int32_t outPlaneBytes() const;
            
                    int16_t inTileHeight() const;
            
                    int16_t inTileWidth() const;
            
                    Point inTileOrigin() const;
            
                    int16_t absTileHeight() const;
            
                    int16_t absTileWidth() const;
            
                    Point absTileOrigin() const;
            
                    int16_t outTileHeight() const;
            
                    int16_t outTileWidth() const;
            
                    Point outTileOrigin() const;
            
                    int16_t maskTileHeight() const;
            
                    int16_t maskTileWidth() const;
            
                    Point maskTileOrigin() const;
            
                    std::string errorString() const;
            
                    void setErrorString(const std::string& error_);
            
                    DocumentInfo* const documentInfo() const;
            
                    int32_t depth() const;
            
                    int32_t hasImageScrap() const;
            
                    Size imageSize() const;
            
                    Rect filterRect() const;
            
                    Rect inRect() const;
            
                    void setInRect(const Rect& ir_);
            
                    Rect outRect() const;
            
                    void setOutRect(const Rect& or_);
            
                    Rect maskRect() const;
            
                    void setMaskRect(const Rect& mr_);
            
                    Point floatCoordinate() const;
            
                    Size wholeSize() const;
                #endif
                // HDI_CORE_PSP_MODE
 
 
            private:
                // Only Dispatcher can construct a FilterMessage object
                friend class Dispatcher;

                FilterMessage(const MessageType, void*);
                
                FilterMessage(const FilterMessage&);
                
                FilterMessage& operator=(const FilterMessage&);
        };
        
        #if defined(HDI_CORE_AIP_MODE)
            class LayerListMessage : public Message
            {
                public:
                    virtual ~LayerListMessage();
 
 
                private:
                    // Only Dispatcher can construct a LayerListMessage object
                    friend class Dispatcher;

                    LayerListMessage(const MessageType, void*);
                    
                    LayerListMessage(const LayerListMessage&);
                    
                    LayerListMessage& operator=(const LayerListMessage&);
            };
            
            class LiveEffectMessage : public Message
            {
                public:
                    virtual ~LiveEffectMessage();
 
 
                protected:
                    LiveEffectMessage(const MessageType, void*);
                    
                    LiveEffectMessage(const LiveEffectMessage&);
                    
                    LiveEffectMessage& operator=(const LiveEffectMessage&);
            };
            
            class LiveEffectGoMessage : public LiveEffectMessage
            {
                public:
                    virtual ~LiveEffectGoMessage();
 
 
                private:
                    // Only Dispatcher can construct a LiveEffectGoMessage object
                    friend class Dispatcher;

                    LiveEffectGoMessage(const MessageType, void*);
                    
                    LiveEffectGoMessage(const LiveEffectGoMessage&);
                    
                    LiveEffectGoMessage& operator=(const LiveEffectGoMessage&);
            };
            
            class LiveEffectEditParamsMessage : public LiveEffectMessage
            {
                public:
                    virtual ~LiveEffectEditParamsMessage();
 
 
                private:
                    // Only Dispatcher can construct a LiveEffectEditParamsMessage object
                    friend class Dispatcher;

                    LiveEffectEditParamsMessage(const MessageType, void*);
                    
                    LiveEffectEditParamsMessage(const LiveEffectEditParamsMessage&);
                    
                    LiveEffectEditParamsMessage& operator=(const LiveEffectEditParamsMessage&);
            };
            
            class LiveEffectInterpolateMessage : public LiveEffectMessage
            {
                public:
                    virtual ~LiveEffectInterpolateMessage();
 
 
                private:
                    // Only Dispatcher can construct a LiveEffectInterpolateMessage object
                    friend class Dispatcher;

                    LiveEffectInterpolateMessage(const MessageType, void*);
                    
                    LiveEffectInterpolateMessage(const LiveEffectInterpolateMessage&);
                    
                    LiveEffectInterpolateMessage& operator=(const LiveEffectInterpolateMessage&);
            };
            
            class LiveEffectInputMessage : public LiveEffectMessage
            {
                public:
                    virtual ~LiveEffectInputMessage();
 
 
                private:
                    // Only Dispatcher can construct a LiveEffectInputMessage object
                    friend class Dispatcher;

                    LiveEffectInputMessage(const MessageType, void*);
                    
                    LiveEffectInputMessage(const LiveEffectInputMessage&);
                    
                    LiveEffectInputMessage& operator=(const LiveEffectInputMessage&);
            };
            
            class LiveEffectConvertColorSpaceMessage : public LiveEffectMessage
            {
                public:
                    virtual ~LiveEffectConvertColorSpaceMessage();
 
 
                private:
                    // Only Dispatcher can construct a LiveEffectConvertColorSpaceMessage object
                    friend class Dispatcher;

                    LiveEffectConvertColorSpaceMessage(const MessageType, void*);
                    
                    LiveEffectConvertColorSpaceMessage(const LiveEffectConvertColorSpaceMessage&);
                    
                    LiveEffectConvertColorSpaceMessage& operator=(const LiveEffectConvertColorSpaceMessage&);
            };
            
            class LiveEffectAdjustColorsMessage : public LiveEffectMessage
            {
                public:
                    virtual ~LiveEffectAdjustColorsMessage();
 
 
                private:
                    // Only Dispatcher can construct a LiveEffectAdjustColorsMessage object
                    friend class Dispatcher;

                    LiveEffectAdjustColorsMessage(const MessageType, void*);
                    
                    LiveEffectAdjustColorsMessage(const LiveEffectAdjustColorsMessage&);
                    
                    LiveEffectAdjustColorsMessage& operator=(const LiveEffectAdjustColorsMessage&);
            };
            
            class LiveEffectScaleParamsMessage : public LiveEffectMessage
            {
                public:
                    virtual ~LiveEffectScaleParamsMessage();
 
 
                private:
                    // Only Dispatcher can construct a LiveEffectScaleParamsMessage object
                    friend class Dispatcher;

                    LiveEffectScaleParamsMessage(const MessageType, void*);
                    
                    LiveEffectScaleParamsMessage(const LiveEffectScaleParamsMessage&);
                    
                    LiveEffectScaleParamsMessage& operator=(const LiveEffectScaleParamsMessage&);
            };
            
            class LiveEffectMergeMessage : public LiveEffectMessage
            {
                public:
                    virtual ~LiveEffectMergeMessage();
 
 
                private:
                    // Only Dispatcher can construct a LiveEffectMergeMessage object
                    friend class Dispatcher;

                    LiveEffectMergeMessage(const MessageType, void*);
                    
                    LiveEffectMergeMessage(const LiveEffectMergeMessage&);
                    
                    LiveEffectMergeMessage& operator=(const LiveEffectMergeMessage&);
            };
            
            class LiveEffectGetSVGFilterMessage : public LiveEffectMessage
            {
                public:
                    virtual ~LiveEffectGetSVGFilterMessage();
 
 
                private:
                    // Only Dispatcher can construct a LiveEffectGetSVGFilterMessage object
                    friend class Dispatcher;

                    LiveEffectGetSVGFilterMessage(const MessageType, void*);
                    
                    LiveEffectGetSVGFilterMessage(const LiveEffectGetSVGFilterMessage&);
                    
                    LiveEffectGetSVGFilterMessage& operator=(const LiveEffectGetSVGFilterMessage&);
            };
            
            class LiveEffectIsCompatibleMessage : public LiveEffectMessage
            {
                public:
                    virtual ~LiveEffectIsCompatibleMessage();
 
 
                private:
                    // Only Dispatcher can construct a LiveEffectIsCompatibleMessage object
                    friend class Dispatcher;

                    LiveEffectIsCompatibleMessage(const MessageType, void*);
                    
                    LiveEffectIsCompatibleMessage(const LiveEffectIsCompatibleMessage&);
                    
                    LiveEffectIsCompatibleMessage& operator=(const LiveEffectIsCompatibleMessage&);
            };
        #endif
        // HDI_CORE_AIP_MODE
        
        #if defined(HDI_CORE_PSP_MODE)
            class MeasurementMessage : public Message
            {
                public:
                    virtual ~MeasurementMessage();
 
 
                private:
                    // Only Dispatcher can construct a MeasurementMessage object
                    friend class Dispatcher;

                    MeasurementMessage(const MessageType, void*);
                    
                    MeasurementMessage(const MeasurementMessage&);
                    
                    MeasurementMessage& operator=(const MeasurementMessage&);
            };
        #endif
        // HDI_CORE_PSP_MODE
        
        #if defined(HDI_CORE_AIP_MODE)
            class MenuMessage : public Message
            {
                public:
                    virtual ~MenuMessage();
                    
                    MenuItem* const menuItem() const;
 
 
                private:
                    // Only Dispatcher can construct a MenuMessage object
                    friend class Dispatcher;

                    MenuMessage(const MenuItem&, const MessageType, void*);
                    
                    MenuMessage(const MenuMessage&);
                    
                    MenuMessage& operator=(const MenuMessage&);
            };
            
            class NotifyMessage : public Message
            {
                public:
                    virtual ~NotifyMessage();
                    
                    Notifier* const notifier() const;
                
                    Notification* const notification() const;
 
 
                private:
                    // Only Dispatcher can construct a NotifyMessage object
                    friend class Dispatcher;

                    NotifyMessage(const Notifier&, const MessageType, void*);
                    
                    NotifyMessage(const NotifyMessage&);
                    
                    NotifyMessage& operator=(const NotifyMessage&);
            };
            
            class ObjectSetMessage : public Message
            {
                public:
                    virtual ~ObjectSetMessage();
 
 
                private:
                    // Only Dispatcher can construct a ObjectSetMessage object
                    friend class Dispatcher;

                    ObjectSetMessage(const MessageType, void*);
                    
                    ObjectSetMessage(const ObjectSetMessage&);
                    
                    ObjectSetMessage& operator=(const ObjectSetMessage&);
            };
        #endif
        // HDI_CORE_AIP_MODE
        
        class PluginMessage : public Message
        {
            public:
                virtual ~PluginMessage();
 
 
            private:
                // Only Dispatcher can construct a PluginMessage object
                friend class Dispatcher;

                PluginMessage(const MessageType, void*);
                
                PluginMessage(const PluginMessage&);
                
                PluginMessage& operator=(const PluginMessage&);
        };
        
        #if defined(HDI_CORE_AIP_MODE)
            class CustomArtMessage : public Message
            {
                public:
                    virtual ~CustomArtMessage();
                
                    std::unique_ptr<Art> customArt() const;
 
 
                private:
                    // Only Dispatcher can construct a CustomArtMessage object
                    friend class Dispatcher;

                    CustomArtMessage(const MessageType, void*);
                    
                    CustomArtMessage(const CustomArtMessage&);
                    
                    CustomArtMessage& operator=(const CustomArtMessage&);
            };
        #endif
        // HDI_CORE_AIP_MODE
        
        #if defined(HDI_CORE_PSP_MODE)
            class PickerMessage : public Message
            {
                public:
                    virtual ~PickerMessage();
                
 
                private:
                    // Only Dispatcher can construct a PickerMessage object
                    friend class Dispatcher;

                    PickerMessage(const MessageType, void*);
                    
                    PickerMessage(const PickerMessage&);
                    
                    PickerMessage& operator=(const PickerMessage&);
            };
        #endif
        // HDI_CORE_PSP_MODE
        
        #if defined(HDI_CORE_AIP_MODE)
            class PreferencesMessage : public Message
            {
                public:
                    virtual ~PreferencesMessage();
 
 
                private:
                    // Only Dispatcher can construct a PreferencesMessage object
                    friend class Dispatcher;

                    PreferencesMessage(const MessageType, void*);
                    
                    PreferencesMessage(const PreferencesMessage&);
                    
                    PreferencesMessage& operator=(const PreferencesMessage&);
            };
            
            class PropertiesMessage : public Message
            {
                public:
                    virtual ~PropertiesMessage();
 
 
                private:
                    // Only Dispatcher can construct a PropertiesMessage object
                    friend class Dispatcher;

                    PropertiesMessage(const MessageType, void*);
                    
                    PropertiesMessage(const PropertiesMessage&);
                    
                    PropertiesMessage& operator=(const PropertiesMessage&);
            };
        #endif
        // HDI_CORE_AIP_MODE
        
        #if defined(HDI_CORE_PSP_MODE)
            class SelectionMessage : public Message
            {
                public:
                    virtual ~SelectionMessage();
                
 
                private:
                    // Only Dispatcher can construct a SelectionMessage object
                    friend class Dispatcher;

                    SelectionMessage(const MessageType, void*);
                    
                    SelectionMessage(const SelectionMessage&);
                    
                    SelectionMessage& operator=(const SelectionMessage&);
            };
        #endif
        // HDI_CORE_PSP_MODE
        
        #if defined(HDI_CORE_AIP_MODE)
            class TimerMessage : public Message
            {
                public:
                    virtual ~TimerMessage();
                    
                    Timer* const timer() const;
 
 
                private:
                    // Only Dispatcher can construct a TimerMessage object
                    friend class Dispatcher;

                    TimerMessage(const Timer&, const MessageType, void*);
                    
                    TimerMessage(const TimerMessage&);
                    
                    TimerMessage& operator=(const TimerMessage&);
            };
            
            class ToolMessage : public Message
            {
                public:
                    static const double normalPressure;
                    
                    static Angle normalTilt();
                    
                    static Angle normalBearing();
                    
                    static Angle normalRotation();
                
                    virtual ~ToolMessage();
                    
                    Tool* const tool() const;

                    ArtboardPoint cursor() const;
                    
                    double pressure() const;

                    double stylusWheel() const;

                    Angle tilt() const;

                    Angle bearing() const;

                    Angle rotation() const;
                    
                    ModifierKey modifiers() const;
 
 
                private:
                    // Only Dispatcher can construct a ToolMessage object
                    friend class Dispatcher;

                    ToolMessage(const Tool&, const MessageType, void*);
                    
                    ToolMessage(const ToolMessage&);
                    
                    ToolMessage& operator=(const ToolMessage&);
            };
            
            class ToolboxMessage : public Message
            {
                public:
                    virtual ~ToolboxMessage();
 
 
                private:
                    // Only Dispatcher can construct a ToolboxMessage object
                    friend class Dispatcher;

                    ToolboxMessage(const MessageType, void*);
                    
                    ToolboxMessage(const ToolboxMessage&);
                    
                    ToolboxMessage& operator=(const ToolboxMessage&);
            };
            
            class TransformAgainMessage : public Message
            {
                public:
                    virtual ~TransformAgainMessage();
 
 
                private:
                    // Only Dispatcher can construct a TransformAgainMessage object
                    friend class Dispatcher;

                    TransformAgainMessage(const MessageType, void*);
                    
                    TransformAgainMessage(const TransformAgainMessage&);
                    
                    TransformAgainMessage& operator=(const TransformAgainMessage&);
            };
            
            class WorkspaceMessage : public Message
            {
                public:
                    virtual ~WorkspaceMessage();
 
 
                private:
                    // Only Dispatcher can construct a WorkspaceMessage object
                    friend class Dispatcher;

                    WorkspaceMessage(const MessageType, void*);
                    
                    WorkspaceMessage(const WorkspaceMessage&);
                    
                    WorkspaceMessage& operator=(const WorkspaceMessage&);
            };
        #endif
        // HDI_CORE_AIP_MODE
    }
}
 
#endif
// __HDI_CORE_MESSAGE__