hdicorePlugin.h

Go to the documentation of this file.

 
#ifndef __HDI_CORE_PLUGIN__
#define __HDI_CORE_PLUGIN__
 
#include <vector>
 
#include "hdicoreMain.h"
 
#define HDI_CORE_PLUGIN hdi::core::Plugin::instance()
 
namespace hdi
{
    namespace core
    {
        class Callback;
        class Dispatcher;
        class MenuItem;
        class ModalDialog;
        class Tool;
    
        class Plugin
        {
            public:
                typedef std::vector<byte> ByteVector;
            
                #if defined(HDI_CORE_AIP_MODE)
                    enum Options
                    {
                        NoOptions                           = 0,
                        AutoSelectsResultsOption            = 1 << 0,
                        RetainsPartialPathSelectionOption   = 1 << 1
                    };
                    
                    enum UndoContext
                    {
                        UnknownUndoContext  = 0,
                        
                        // A standard undo context results in the addition of a new transaction which can be undone/redone
                        // by the user
                        StandardUndoContext = 10,
                        
                        // A silent context does not cause redos to be discarded and is skipped over when undoing and
                        // redoing. An example is a selection change.
                        SilentUndoContext   = 20,
                        
                        // An appended context is like a standard context, except that it is combined with the preceding
                        // transaction. It does not appear as a separate transaction. Used, for example, to collect
                        // sequential changes to the color of an object into a single undo/redo transaction.
                        AppendUndoContext   = 30
                    };
                #endif
                // HDI_CORE_AIP_MODE
 
                static Plugin* const instance();
 
                virtual SPPluginRef spPluginRef() const;
 
                PlatformPluginPtr platformPlugin() const;
 
                virtual std::string filePath() const;
 
                virtual std::string fileName() const;
 
                virtual std::string name() const;
 
                virtual void setName(const std::string& name_);
 
                #if defined(HDI_CORE_AIP_MODE)
                    virtual Options options() const;
 
                    virtual void setOptions(const Options options_);
                #endif
                // HDI_CORE_AIP_MODE
 
                virtual Dispatcher* const dispatcher() const;
 
                #if defined(HDI_CORE_AIP_MODE)
                    virtual Tool* const currentTool() const;
 
                    virtual void undo() const;
                    
                    virtual bool setUndoKind(const UndoContext uc_);
                    
                    virtual void setUndoRedoNames(const std::string& undo_, const std::string& redo_);
                #endif
                // HDI_CORE_AIP_MODE
 
                virtual bool resourceData(const int32_t type_, const int16_t id_, ByteVector& data__) const;
 
                virtual bool resourceData(
                    const int32_t type_,
                    const std::string& name_,
                    ByteVector& data__
                ) const;
                
                #if defined(HDI_CORE_AIP_MODE)
                    virtual bool toolsSnapToArt() const;
                    
                    virtual void setToolsSnapToArt(const bool snap_);
                    
                    virtual bool toolsSnapToArtBounds() const;
                    
                    virtual void setToolsSnapToArtBounds(const bool snap_);
                    
                    virtual bool toolsSnapToArtboard() const;
                    
                    virtual void setToolsSnapToArtboard(const bool snap_);
                    
                    virtual bool toolsSnapToGrids() const;
                    
                    virtual void setToolsSnapToGrids(const bool snap_);
                #endif
                // HDI_CORE_AIP_MODE
 
                virtual bool startingUp() const;
 
                virtual bool hasStartedUp() const;
                
                virtual bool postStartingUp() const;
                
                virtual bool hasPostStartedUp() const;
                
                #if defined(HDI_CORE_AIP_MODE)
                    virtual bool preShuttingDown() const;
                    
                    virtual bool hasPreShutdown() const;
                #endif
                // HDI_CORE_AIP_MODE
                
                virtual bool shuttingDown() const;
                
                virtual bool hasShutdown() const;
 
                virtual std::ostream* const loggingStream(const std::string& name_) const;
 
                virtual void setLoggingStream(const std::string& name_, std::ostream* const str_);
                
                virtual Callback* const startupCallback() const;
                
                virtual void setStartupCallback(const Callback& cb_);
                
                virtual Callback* const postStartupCallback() const;
                
                virtual void setPostStartupCallback(const Callback& cb_);
                
                #if defined(HDI_CORE_AIP_MODE)
                    virtual Callback* const preShutdownCallback() const;
                    
                    virtual void setPreShutdownCallback(const Callback& cb_);
                #endif
                // HDI_CORE_AIP_MODE
                
                virtual Callback* const shutdownCallback() const;
                
                virtual void setShutdownCallback(const Callback& cb_);
 
                #if defined(HDI_CORE_AIP_MODE)
                    virtual Callback* const menuItemSelectedCallback() const;
 
                    virtual void setMenuItemSelectedCallback(const Callback& cb_);
 
                    virtual Callback* const menuItemsUpdateCallback() const;
 
                    virtual void setMenuItemsUpdateCallback(const Callback& cb_);
                #endif
                // HDI_CORE_AIP_MODE
 
                virtual Callback* const brightnessAdjustedCallback() const;
 
                virtual void setBrightnessAdjustedCallback(const Callback& cb_);
 
                #if defined(HDI_CORE_AIP_MODE)
                    virtual Callback* const toolPreSelectedCallback() const;
 
                    virtual void setToolPreSelectedCallback(const Callback& cb_);
 
                    virtual Callback* const toolPostSelectedCallback() const;
 
                    virtual void setToolPostSelectedCallback(const Callback& cb_);
 
                    virtual Callback* const toolPreDeselectedCallback() const;
 
                    virtual void setToolPreDeselectedCallback(const Callback& cb_);
 
                    virtual Callback* const toolPostDeselectedCallback() const;
 
                    virtual void setToolPostDeselectedCallback(const Callback& cb_);
 
                    virtual Callback* const toolPreReselectedCallback() const;
 
                    virtual void setToolPreReselectedCallback(const Callback& cb_);
 
                    virtual Callback* const toolPostReselectedCallback() const;
 
                    virtual void setToolPostReselectedCallback(const Callback& cb_);
 
                    virtual Callback* const toolPreTrackedCallback() const;
 
                    virtual void setToolPreTrackedCallback(const Callback& cb_);
 
                    virtual Callback* const toolPostTrackedCallback() const;
 
                    virtual void setToolPostTrackedCallback(const Callback& cb_);
 
                    virtual Callback* const toolPreMouseDownCallback() const;
 
                    virtual void setToolPreMouseDownCallback(const Callback& cb_);
 
                    virtual Callback* const toolPostMouseDownCallback() const;
 
                    virtual void setToolPostMouseDownCallback(const Callback& cb_);
 
                    virtual Callback* const toolPreDraggedCallback() const;
 
                    virtual void setToolPreDraggedCallback(const Callback& cb_);
 
                    virtual Callback* const toolPostDraggedCallback() const;
 
                    virtual void setToolPostDraggedCallback(const Callback& cb_);
 
                    virtual Callback* const toolPreMouseUpCallback() const;
 
                    virtual void setToolPreMouseUpCallback(const Callback& cb_);
 
                    virtual Callback* const toolPostMouseUpCallback() const;
 
                    virtual void setToolPostMouseUpCallback(const Callback& cb_);
 
                    virtual Callback* const toolPreDiameterDecreasedCallback() const;
 
                    virtual void setToolPreDiameterDecreasedCallback(const Callback& cb_);
 
                    virtual Callback* const toolPostDiameterDecreasedCallback() const;
 
                    virtual void setToolPostDiameterDecreasedCallback(const Callback& cb_);
 
                    virtual Callback* const toolPreDiameterIncreasedCallback() const;
 
                    virtual void setToolPreDiameterIncreasedCallback(const Callback& cb_);
 
                    virtual Callback* const toolPostDiameterIncreasedCallback() const;
 
                    virtual void setToolPostDiameterIncreasedCallback(const Callback& cb_);
 
                    virtual Callback* const toolPreEditedCallback() const;
 
                    virtual void setToolPreEditedCallback(const Callback& cb_);
 
                    virtual Callback* const toolPostEditedCallback() const;
 
                    virtual void setToolPostEditedCallback(const Callback& cb_);
                #endif
                // HDI_CORE_AIP_MODE
 
                virtual ModalDialog* const aboutBox() const;
                
                virtual void setAboutBox(const ModalDialog& dialog_);
 
                #if defined(HDI_CORE_PSP_MODE)
                    virtual Callback* const aboutBoxShowingCallback() const;
            
                    virtual void setAboutBoxShowingCallback(const Callback& cb_);
                #endif
                // HDI_CORE_PSP_MODE
 
                virtual ModalDialog* const prefsDialog() const;
                
                virtual void setPrefsDialog(const ModalDialog& dialog_);
 
                #if defined(HDI_CORE_AIP_MODE)
                    virtual MenuItem* const aboutMenuItem() const;
                    
                    virtual void setAboutMenuItem(const MenuItem& mi_);
                #endif
                // HDI_CORE_AIP_MODE
 
                virtual MenuItem* const prefsMenuItem() const;
                
                virtual void setPrefsMenuItem(const MenuItem& mi_);
 
 
            private:
                #if defined(HDI_CORE_AIP_MODE)
                    friend __MainError (::PluginMain) (const char*, const char*, void*);
                #elif defined(HDI_CORE_PSP_MODE)
                    #if defined(MAC_ENV)
                        friend void (::hdicoreDylibUnloading) ();
                    #endif
                    
                    friend __MainError (::ActionsPluginMain) (const char*, const char*, void*);
                    friend void (::AcquirePluginMain) (const int16_t, void*, intptr_t*, int16_t*);
                    friend void (::ExportPluginMain) (const int16_t, void*, intptr_t*, int16_t*);
                    friend void (::ExtensionPluginMain) (const int16_t, void*, intptr_t*, int16_t*);
                    friend void (::FilterPluginMain) (const int16_t, void*, intptr_t*, int16_t*);
                    friend void (::FormatPluginMain) (const int16_t, void*, intptr_t*, int16_t*);
                    friend void (::MeasurementPluginMain) (const int16_t, void*, intptr_t*, int16_t*);
                    friend void (::PickerPluginMain) (const int16_t, void*, intptr_t*, int16_t*);
                    friend void (::SelectionPluginMain) (const int16_t, void*, intptr_t*, int16_t*);
                #endif
 
                enum __StartupError
                {
                    __NoStartupError                = 0,
                    __CantLockPluginError           = 1000,
                    __CantSetPluginNameError        = 1010,
                    __BadApplicationVersionError    = 1020,
                    __WrongPluginBinaryError        = 1030,
                    __WrongInstallLocationError     = 1040,
                    __CantLoadPrefsError            = 1050,
                    __CantSetupToolsError           = 1060,
                    __CantSetupNotifiersError       = 1070,
                    __CantSetupAnnotatorsError      = 1080,
                    __CantSetupTimersError          = 1090,
                    __CustomStartupErrorOffset      = 1000000
                };
                
                enum __PostStartupError
                {
                    __NoPostStartupError            = 0,
                    __CustomPostStartupErrorOffset  = 2000000
                };
                
                enum __PreShutdownError
                {
                    __NoPreShutdownError            = 0,
                    __CustomPreShutdownErrorOffset  = 3000000
                };
                
                enum __ShutdownError
                {
                    __NoShutdownError           = 0,
                    __CantUnlockPluginError     = 4000,
                    __CustomShutdownErrorOffset = 4000000
                };
            
                static Plugin* __instance;
 
                void* __data;
                
                Plugin();
                
                Plugin(const Plugin&);
 
                Plugin(const void*, const std::string&);
            
                virtual ~Plugin();
                
                Plugin& operator=(const Plugin& rhs_);
 
                __StartupError __startup();
                
                __PostStartupError __postStartup();
 
                #if defined(HDI_CORE_AIP_MODE)
                    __PreShutdownError __preShutdown();
                #endif
                // HDI_CORE_AIP_MODE
 
                __ShutdownError __shutdown();
            
                #if defined(HDI_CORE_PSP_MODE)
                    void __aboutBoxShow();
                #endif
                // HDI_CORE_PSP_MODE
        };
    }
}
 
#if defined(HDI_CORE_AIP_MODE)
    hdi::core::Plugin::Options operator|(
        const hdi::core::Plugin::Options lhs_,
        const hdi::core::Plugin::Options rhs_
    );
 
    hdi::core::Plugin::Options& operator|=(
        hdi::core::Plugin::Options& lhs__,
        const hdi::core::Plugin::Options rhs_
    );
#endif
// HDI_CORE_AIP_MODE
 
#endif
// __HDI_CORE_PLUGIN__