actiontable.h

Go to the documentation of this file.

//**************************************************************************/
// Copyright (c) 1998-2006 Autodesk, Inc.
// All rights reserved.
// 
// These coded instructions, statements, and computer programs contain
// unpublished proprietary information written by Autodesk, Inc., and are
// protected by Federal copyright law. They may not be disclosed to third
// parties or copied or duplicated in any form, in whole or in part, without
// the prior written consent of Autodesk, Inc.
//**************************************************************************/
// FILE:        ActionTable.h
// DESCRIPTION: Action Table definitions
// AUTHOR:      Scott Morrison
// HISTORY:     Created 8 February, 2000, Based on KbdAction.h.
//**************************************************************************/

#pragma once

#include "maxheap.h"
#include "stack.h"
#include "iFnPub.h"
#include "strbasic.h"
#include "actiontableTypedefs.h"
#include "Noncopyable.h"

// forward declarations
class MaxIcon;
class MacroEntry;
class IPoint2;

const ActionTableId kActionMainUI           = 0;
const ActionTableId kActionTrackView        = 1;
const ActionTableId kActionMaterialEditor   = 2;
const ActionTableId kActionVideoPost        = 3;
const ActionTableId kActionSchematicView    = 5;
const ActionTableId kActionCommonIReshade   = 6;
const ActionTableId kActionScanlineIReshade = 7;

class ActionTable;
class IMenu;


const ActionContextId kActionMainUIContext         = 0;
const ActionContextId kActionTrackViewContext      = 1;
const ActionContextId kActionMaterialEditorContext = 2;
const ActionContextId kActionVideoPostContext      = 3;
const ActionContextId kActionSchematicViewContext  = 5;
const ActionContextId kActionIReshadeContext       = 6;

struct ActionDescription {

    int mCmdID;

    int mDescriptionResourceID;

        int mShortNameResourceID;

        int mCategoryResourceID;

};



#define AO_DEFAULT 0x0001 //< Default option command to execute
#define AO_CLOSEDIALOG 0x0002 //< Execute closeDialog option


#define ACTION_OPTION_INTERFACE Interface_ID(0x3c0276f5, 0x190964f5) 
#define ACTION_OPTION_INTERFACE_OPT2 Interface_ID(0x0011dcdc, 0x0012dcdc)

class IActionOptions : public BaseInterface
{
public:
    virtual BOOL ExecuteOptions(DWORD options = AO_DEFAULT) = 0;

    // BaseInterface methods
    CoreExport virtual BaseInterface* GetInterface(Interface_ID id);
    CoreExport virtual Interface_ID GetID();
};

#define IID_ACTION_ITEM Interface_ID(0x6fbd5f3c, 0x7c5a32db)

class ActionItem : public FPMixinInterface
{
public:
    CoreExport ActionItem();
    CoreExport virtual ~ActionItem();

    virtual int    GetId() = 0;

    virtual BOOL ExecuteAction() = 0;

    CoreExport virtual void EmitMacro();

    CoreExport BOOL Execute(); 

    virtual void GetButtonText(MSTR& buttonText) = 0;

    virtual void GetMenuText(MSTR& menuText) = 0;

    virtual void GetDescriptionText(MSTR& descText) = 0;

    virtual void GetCategoryText(MSTR& catText) = 0;

    virtual BOOL IsChecked() = 0;

    virtual BOOL IsItemVisible() = 0;

    virtual BOOL IsEnabled() = 0;
        
    virtual MaxIcon* GetIcon() = 0;

    virtual void DeleteThis() = 0;

    CoreExport virtual ActionTable* GetTable();

    CoreExport virtual void SetTable(ActionTable* pTable);

    CoreExport MCHAR* GetShortcutString();

    CoreExport virtual MacroEntry* GetMacroScript();

    CoreExport virtual BOOL IsDynamicMenu();

    CoreExport virtual void SetIsDynamicMenu();

    CoreExport virtual IMenu* GetDynamicMenu(HWND hwnd, IPoint2& m);

    CoreExport virtual BOOL IsDynamicAction();

    // FPMixinInterface methods
    CoreExport virtual FPInterfaceDesc* GetDescByID(Interface_ID id);
    CoreExport virtual FPInterfaceDesc* GetDesc();

    // BaseInterface methods
    CoreExport virtual BaseInterface* GetInterface(Interface_ID id);
    CoreExport virtual Interface_ID GetID();

    enum ActionItemFps
    {
        kGetId,
        kIsVisible,
        kIsEnabled,
        kIsChecked,
        kGetDescription,
        kGetCategory,
        kGetButtonText,
        kGetMenuText,
    };

protected:
    #pragma warning(push)
    #pragma warning(disable:4100)
    BEGIN_FUNCTION_MAP
        RO_PROP_FN(kGetId, GetId, TYPE_DWORD);
        RO_PROP_FN(kIsVisible, IsItemVisible, TYPE_BOOL);
        RO_PROP_FN(kIsEnabled, IsEnabled, TYPE_BOOL);
        RO_PROP_FN(kIsChecked, IsChecked, TYPE_BOOL);
        VFN_1(kGetDescription, GetDescriptionText, TYPE_TSTR_BR);
        VFN_1(kGetCategory, GetCategoryText, TYPE_TSTR_BR);
        VFN_1(kGetButtonText, GetButtonText, TYPE_TSTR_BR);
        VFN_1(kGetMenuText, GetMenuText, TYPE_TSTR_BR);
    END_FUNCTION_MAP
    #pragma warning(pop)

    ActionTable* mpTable;
};

#define ACTIONITEM_STANDIN_INTERFACE Interface_ID(0x108e1314, 0x5aff3138)

class IActionItemStandin : public BaseInterface
{
public:
    virtual void          SetPersistentActionId(MSTR idString) = 0;
    virtual MSTR&         GetPersistentActionId() = 0;
    virtual void          SetActionTableId( ActionTableId id ) = 0;
    virtual ActionTableId GetActionTableId() = 0;
    virtual MSTR&         GetPrefixString() = 0;

    // BaseInterface methods
    CoreExport virtual BaseInterface* GetInterface(Interface_ID id);
    CoreExport virtual Interface_ID GetID();
};

inline IActionItemStandin* GetIActionItemStandin(ActionItem* a) { return (IActionItemStandin*)a->GetInterface(ACTIONITEM_STANDIN_INTERFACE); }

class ActionItemStandin: public ActionItem, public IActionItemStandin
{
public:
    CoreExport ActionItemStandin(int cmdId );
    CoreExport virtual ~ActionItemStandin();

    CoreExport virtual int  GetId() { return mCmdId; }
    CoreExport virtual void SetId(int id) { mCmdId = id; }

    CoreExport virtual MCHAR*  GetDescription() { return mName.data();}
    CoreExport virtual void    SetDescription(MCHAR* pDesc) { mName = pDesc; }

    CoreExport virtual MCHAR*  GetShortName() { return mName.data();}
    CoreExport virtual void    SetShortName(MCHAR* pShortName) { mName = pShortName; }

    CoreExport virtual MCHAR*  GetCategory() { return mName.data();}
    CoreExport virtual void    SetCategory(MCHAR* pCategory) { mName = pCategory; }

    CoreExport virtual MaxIcon* GetIcon() { return NULL; };

    CoreExport virtual BOOL ExecuteAction() { return FALSE; };

    CoreExport virtual void GetButtonText(MSTR& buttonText) { buttonText = mName; };
    CoreExport virtual void GetMenuText(MSTR& menuText) { menuText = mName; };
    CoreExport virtual void GetDescriptionText(MSTR& descText) { descText = mName; };
    CoreExport virtual void GetCategoryText(MSTR& catText) { catText = mName; };

    CoreExport virtual BOOL IsChecked() { return FALSE; };
    CoreExport virtual BOOL IsItemVisible() { return TRUE; };
    CoreExport virtual BOOL IsEnabled() { return FALSE; };

    CoreExport virtual BOOL IsDynamicMenu() { return FALSE; }
    CoreExport virtual void SetIsDynamicMenu() { };
    #pragma warning(push)
    #pragma warning(disable:4100)
    CoreExport virtual IMenu* GetDynamicMenu(HWND hwnd, IPoint2& m) { return NULL; };
    #pragma warning(pop)

    CoreExport void DeleteThis();

    CoreExport virtual BaseInterface* GetInterface(Interface_ID id);

    CoreExport virtual void SetPersistentActionId(MSTR idString);
    CoreExport virtual MSTR& GetPersistentActionId() { return mPersistentActionId; };
    CoreExport virtual void SetActionTableId( ActionTableId id ) { mId = id; };
    CoreExport virtual ActionTableId GetActionTableId() { return mId; };
    CoreExport virtual MSTR& GetPrefixString() { return mPrefix; };

protected:
    int   mCmdId;
    MSTR  mName;
    MSTR  mPersistentActionId;
    MSTR  mPrefix;
    ActionTableId mId;
};

class ActionCallback;

#define IID_ACTION_TABLE Interface_ID(0x27ba191e, 0x4d391886)

class ActionTable : public FPMixinInterface, public MaxSDK::Util::Noncopyable 
{
public:
    CoreExport ActionTable(ActionTableId id,
                                                 ActionContextId contextId,
                                                 MSTR& name,
                                                 HACCEL hDefaults,
                                                 int numIds,
                                                 ActionDescription* pOps,
                                                 HINSTANCE hInst);
    CoreExport ActionTable(ActionTableId id,
                                                 ActionContextId contextId,
                                                 MSTR& name);

    CoreExport virtual ~ActionTable();



    CoreExport virtual HACCEL GetHAccel();

    CoreExport virtual void SetHAccel(HACCEL hAccel);

    CoreExport virtual HACCEL GetDefaultHAccel();

    CoreExport virtual void SetDefaultHAccel(HACCEL accel);

    CoreExport virtual MSTR& GetName();

    CoreExport virtual ActionTableId GetId();

    CoreExport virtual ActionContextId GetContextId();

    CoreExport virtual ActionCallback* GetCallback();

    CoreExport virtual void SetCallback(ActionCallback* pCallback);

    CoreExport virtual int Count();

    CoreExport virtual ActionItem* operator[](int i);

    CoreExport virtual ActionItem* GetAction(int cmdId);

    CoreExport virtual ActionItem* GetActionByIndex(int index); 

    CoreExport virtual void AppendOperation(ActionItem* pAction);
    
    CoreExport virtual BOOL DeleteOperation(ActionItem* pAction);

    CoreExport virtual void DeleteThis(); 

    CoreExport virtual BOOL GetButtonText(int cmdId, MSTR& buttonText);

    CoreExport virtual BOOL GetMenuText(int cmdId, MSTR& menuText);

    CoreExport virtual BOOL GetDescriptionText(int cmdId, MSTR& descText);

    CoreExport virtual BOOL IsChecked(int cmdId);
    
    CoreExport virtual BOOL IsItemVisible(int cmdId);

    CoreExport virtual BOOL IsEnabled(int cmdId);

    CoreExport virtual void WritePersistentActionId(int cmdId, MSTR& idString);
    
    CoreExport virtual int ReadPersistentActionId(MSTR& idString);

    CoreExport virtual MaxIcon* GetIcon(int cmdId);

    CoreExport void BuildActionTable(HACCEL hDefaults,
                                                            int numIds,
                                                            ActionDescription* pOps,
                                                            HINSTANCE hInst);

    CoreExport virtual ActionItem* GetCurrentAssignment(ACCEL accel);
    
    CoreExport virtual void AssignKey(int cmdId, ACCEL accel);

    CoreExport virtual void RemoveShortcutFromTable(ACCEL accel);

    // From FPMixinInterface
    CoreExport FPInterfaceDesc* GetDescByID(Interface_ID id);
    CoreExport FPInterfaceDesc* GetDesc();

    // BaseInterface methods
    CoreExport virtual BaseInterface* GetInterface(Interface_ID id);
    CoreExport virtual Interface_ID GetID();

    // Function publishing
    enum ActionTableFps
    {
        kGetId,
        kGetName,
        kGetContextId,
        kGetContextName,
        kNumActionItems,
        kGetActionItem,
    };

protected:
    #pragma warning(push)
    #pragma warning(disable:4100)
    BEGIN_FUNCTION_MAP
        RO_PROP_FN(kGetId, GetId, TYPE_DWORD);
        RO_PROP_FN(kGetName, GetName, TYPE_STRING);
        RO_PROP_FN(kGetContextId, GetContextId, TYPE_DWORD);
        RO_PROP_FN(kGetContextName, fpGetContextName, TYPE_STRING);
        RO_PROP_FN(kNumActionItems, Count, TYPE_INT);
        FN_1(kGetActionItem, TYPE_INTERFACE, GetActionByIndex, TYPE_INDEX);
    END_FUNCTION_MAP
    #pragma warning(pop)

    CoreExport const MCHAR* fpGetContextName() const;

protected:
    // Descriptors of all operations that can have Actions
    Tab<ActionItem*>  mOps; 

private:
    // These values are set by the plug-in to describe a action table

    // Unique identifier of table (like a class id)
    ActionTableId  mId;

    // An identifier to group tables use the same context.  Tables with the
    // same context cannot have overlapping keyboard shortcuts.
    ActionContextId mContextId;

    // Name to use in preference dlg drop-down
    MSTR mName;

    // The windows accelerator table in use when no keyboard shortcuts saved
    HACCEL mhDefaultAccel;
    // The windows accelerator table in use
    HACCEL mhAccel;

    // The currently active callback
    ActionCallback* mpCallback;
};


class ActionCallback : public BaseInterfaceServer {
public:
    CoreExport ActionCallback();

    CoreExport virtual ~ActionCallback();
        
    CoreExport virtual BOOL ExecuteAction(int id);

    CoreExport virtual IMenu* GetDynamicMenu(int id, HWND hwnd, IPoint2& m);

    CoreExport ActionTable* GetTable();
    
    CoreExport void SetTable(ActionTable* pTable);

private:
    ActionTable *mpTable;
};

class ActionContext: public MaxHeapOperators {
public:
    ActionContext(ActionContextId contextId, MCHAR *pName)
            { mContextId = contextId; mName = pName; mActive = true; }

    MCHAR* GetName() { return mName.data(); }
    
    ActionContextId GetContextId() { return mContextId; }

    bool IsActive() { return mActive; }
    
    void SetActive(bool active) { mActive = active; }
        
private:
    ActionContextId  mContextId;
    MSTR             mName;
    bool             mActive;
};

#define ACTION_MGR_INTERFACE  Interface_ID(0x4bb71a79, 0x4e531e4f)

class IActionManager : public FPStaticInterface  
{
public:
    virtual void RegisterActionTable(ActionTable* pTable) = 0;

    virtual int NumActionTables() = 0;
    
    virtual ActionTable* GetTable(int i) = 0;

    virtual int ActivateActionTable(ActionCallback* pCallback, ActionTableId id) = 0;
    
    virtual int DeactivateActionTable(ActionCallback* pCallback, ActionTableId id) = 0;

    virtual ActionTable* FindTable(ActionTableId id) = 0;

    virtual BOOL GetShortcutString(ActionTableId tableId, int commandId, MCHAR* buf) = 0;
    
    virtual BOOL GetActionDescription(ActionTableId tableId, int commandId, MCHAR* buf) = 0;

    virtual BOOL RegisterActionContext(ActionContextId contextId, MCHAR* pName) = 0;
    
    virtual int NumActionContexts() = 0;
    
    virtual ActionContext* GetActionContext(int i) = 0;
    
    virtual ActionContext* FindContext(ActionContextId contextId) = 0;

    virtual BOOL IsContextActive(ActionContextId contextId) = 0;

    virtual MCHAR* GetShortcutFile() = 0;
    virtual MCHAR* GetShortcutDir() = 0;
    virtual int IdToIndex(ActionTableId id) = 0;
    virtual void SaveAllContextsToINI() = 0;
    virtual int MakeActionSetCurrent(MCHAR* pDir, MCHAR* pFile) = 0;
    virtual int LoadAccelConfig(LPACCEL *accel, int *cts, ActionTableId tableId = -1, BOOL forceDefault = FALSE) = 0;
    virtual int SaveAccelConfig(LPACCEL *accel, int *cts) = 0;
    virtual int GetCurrentActionSet(MCHAR *buf) = 0;
    virtual BOOL SaveKeyboardFile(MCHAR* pFileName) = 0;
    virtual BOOL LoadKeyboardFile(MCHAR* pFileName) = 0;
    virtual MCHAR* GetKeyboardFile() = 0;

    enum ActionManagerFps
    {
        executeAction,
#ifndef NO_CUI  // russom - 02/12/02
        saveKeyboardFile,
        loadKeyboardFile,
        getKeyboardFile,
#endif // NO_CUI
        numActionTables,
        getActionTable,
        getActionContext,
        };
};

class IActionManager10 : public BaseInterface, public MaxSDK::Util::Noncopyable {

public:
    CoreExport static const Interface_ID kActionMgr10InterfaceID;

    virtual bool DispatchMessageToApplication(MSG* message) = 0;

    CoreExport virtual Interface_ID GetID(); 

protected:
    CoreExport IActionManager10();
    CoreExport virtual ~IActionManager10();

};


class DynamicMenuCallback: public MaxHeapOperators {
public:
        virtual void MenuItemSelected(int itemId) = 0;
};

class DynamicMenu: public MaxHeapOperators {
public:

        CoreExport DynamicMenu(DynamicMenuCallback* pCallback);

        CoreExport IMenu* GetMenu();

        enum DynamicMenuFlags {
                kDisabled   = 1 << 0, //< Item is disabled (can't be selected)
                kChecked    = 1 << 1, //< Item has a check mark beside it or is pressed 
                kSeparator  = 1 << 2, //< Item is a seperator between the previous menu item and the next one.
        };

        CoreExport void AddItem(DWORD flags, UINT itemId, MCHAR* pItemTitle);

        CoreExport void BeginSubMenu(MCHAR* pTitle);

        CoreExport void EndSubMenu();

private:

        Stack<IMenu*> mMenuStack;
        DynamicMenuCallback *mpCallback;
};