hdicoreTool.h

Go to the documentation of this file.

 
#ifndef __HDI_CORE_TOOL__
#define __HDI_CORE_TOOL__
 
#if defined(HDI_CORE_AIP_MODE)
 
#include <vector>
 
#include "hdicoreArtboardPoint.h"
#include "hdicoreTypes.h"
 
namespace hdi
{
    namespace aip
    {
        class BaseTool;
    }
 
    namespace core
    {
        class BuiltinTool;
        class Callback;
        class HitData;
        class ModalDialog;
 
        class Tool
        {
            public:
                typedef std::vector<ArtboardPoint> ArtboardPointVector;
            
                enum Options
                {
                    NoOptions                       = 0,
                    TracksCursorOption              = 1 << 0,
                    DoesntAutoScrollOption          = 1 << 1,
                    BufferedDraggingOption          = 1 << 2,
                    MaintainsEditContextOption      = 1 << 3,
                    WantsToEditTextOption           = 1 << 4,
                    WantsToChangeDiameterOption     = 1 << 5,
                    WantsAlternateSelectionOption   = 1 << 6,
                    HiddenOption                    = 1 << 7,
                    DoesntAllowSoftSelectionOption  = 1 << 8,
                    DefaultOptions                  = (TracksCursorOption | WantsToChangeDiameterOption)
                };
 
                Tool();
            
                Tool(const Tool& tool_);
 
                Tool(
                    const Tool& sameGroupAs_,
                    const Tool* const sameSetAs_,
                    const std::string& title_,
                    const std::string& tip_,
                    const IconResourceType iconType_,
                    const int16_t lightIconID_,
                    const int16_t darkIconID_,
                    const Options options_ = DefaultOptions
                );
 
                Tool(
                    const BuiltinTool& sameGroupAs_,
                    const BuiltinTool* const sameSetAs_,
                    const std::string& title_,
                    const std::string& tip_,
                    const IconResourceType iconType_,
                    const int16_t lightIconID_,
                    const int16_t darkIconID_,
                    const Options options_ = DefaultOptions
                );
 
                explicit Tool(
                    const int16_t sameGroupAs_,
                    const int16_t sameSetAs_,
                    const std::string& title_,
                    const std::string& tip_,
                    const IconResourceType iconType_,
                    const int16_t lightIconID_,
                    const int16_t darkIconID_,
                    const Options options_ = DefaultOptions
                );
 
                virtual ~Tool();
 
                virtual void destroy();
                
                virtual Tool& operator=(const Tool& rhs_);
                
                virtual bool operator==(const Tool& rhs_) const;
                
                virtual bool operator!=(const Tool& rhs_) const;
 
                virtual AIToolHandle aiToolHandle() const;
 
                virtual int16_t number() const;
 
                virtual bool isEmpty() const;
                
                virtual bool selected() const;
                
                virtual void setSelected();
 
                virtual Options options() const;
 
                virtual void setOptions(const Options options_);
 
                virtual std::string title() const;
 
                virtual void setTitle(const std::string& title_);
 
                virtual std::string tip() const;
 
                virtual void setTip(const std::string& tip_);
            
                virtual IconResourceType iconType() const;
                
                virtual int16_t lightIconID() const;
                
                virtual void setLightIconID(const int16_t imgID_);
                
                virtual int16_t darkIconID() const;
                
                virtual void setDarkIconID(const int16_t imgID_);
 
                virtual ArtboardPoint cursorLoc() const;
 
                virtual void setCursorLoc(const ArtboardPoint& loc_);
 
                virtual ArtboardPointVector mouseDownLocs() const;
 
                virtual ArtboardPointVector mouseUpLocs() const;
 
                virtual std::unique_ptr<HitData> mouseDownHitData(
                    const uint32_t index_,
                    const HitRequest request_,
                    const double tolerance_ = 2.0
                ) const;
 
                virtual std::unique_ptr<HitData> mouseUpHitData(
                    const uint32_t index_,
                    const HitRequest request_,
                    const double tolerance_ = 2.0
                ) const;
 
                virtual std::unique_ptr<HitData> cursorHitData(
                    const HitRequest request_,
                    const double tolerance_ = 2.0
                ) const;
 
                virtual Callback* const selectionCallback() const;
 
                virtual void setSelectionCallback(const Callback& cb_);
 
                virtual Callback* const reselectionCallback() const;
 
                virtual void setReselectionCallback(const Callback& cb_);
 
                virtual Callback* const deselectionCallback() const;
 
                virtual void setDeselectionCallback(const Callback& cb_);
 
                virtual Callback* const trackCallback() const;
 
                virtual void setTrackCallback(const Callback& cb_);
 
                virtual Callback* const mouseDownCallback() const;
 
                virtual void setMouseDownCallback(const Callback& cb_);
 
                virtual Callback* const dragCallback() const;
 
                virtual void setDragCallback(const Callback& cb_);
 
                virtual Callback* const mouseUpCallback() const;
 
                virtual void setMouseUpCallback(const Callback& cb_);
 
                virtual Callback* const decreaseDiameterCallback() const;
 
                virtual void setDecreaseDiameterCallback(const Callback& cb_);
 
                virtual Callback* const increaseDiameterCallback() const;
 
                virtual void setIncreaseDiameterCallback(const Callback& cb_);
 
                virtual Callback* const editCallback() const;
 
                virtual void setEditCallback(const Callback& cb_);
 
                virtual void resetCursorLocs();
 
                virtual bool wasDragged() const;
 
                virtual bool shiftKeyDown() const;
 
                virtual bool commandKeyDown() const;
 
                virtual bool optionKeyDown() const;
 
                virtual bool controlKeyDown() const;
 
                virtual ModalDialog* const inputDialog() const;
                
                virtual void setInputDialog(const ModalDialog& dialog_);
 
                virtual ModalDialog* const prefsDialog() const;
                
                virtual void setPrefsDialog(const ModalDialog& dialog_);
 
                virtual bool autoShowPrefsDialog() const;
                
                virtual void setAutoShowPrefsDialog(const bool show_);
 
 
            private:
                friend aip::BaseTool* __accessImpl(const Tool&);
                friend Tool __accessCtorTool(const void*);
 
                void* __data;
                
                void* __impl() const;
 
                Tool(const void*);
        };
        
        typedef std::unique_ptr<Tool> ToolUP;
        typedef std::shared_ptr<Tool> ToolSP;
        typedef std::weak_ptr<Tool> ToolWP;
        
        extern aip::BaseTool* __accessImpl(const Tool&);
        extern Tool __accessCtorTool(const void*);
    }
}
 
hdi::core::Tool::Options operator|(
    const hdi::core::Tool::Options lhs_,
    const hdi::core::Tool::Options rhs_
);
 
hdi::core::Tool::Options& operator|=(
    hdi::core::Tool::Options& lhs__,
    const hdi::core::Tool::Options rhs_
);
 
#endif
// HDI_CORE_AIP_MODE
 
#endif
// __HDI_CORE_TOOL__