ITabDialog.h

Go to the documentation of this file.

/**********************************************************************
 *<
   FILE: ITabDialog.h

   DESCRIPTION: Interface for tabbed dialogs

   CREATED BY: Cleve Ard

   HISTORY: Created 01 October 2002
      24 March 2003 - Updated for R6. This update allows the
      current renderer to control which tabs are present in the
      render dialog.

 *>   Copyright (c) 2002, All Rights Reserved.
 **********************************************************************/

#pragma once

#include "maxheap.h"
#include "3dsmaxport.h"
#include "ifnpub.h"
#include "GetCOREInterface.h"
#include "Animatable.h"
#include <CommCtrl.h>

// forward declarations
class ITabbedDialog;
class ITabPage;
class ITabRegister;
class ITabDialogProc;
class ITabPageProc;
class ITabDialogFilter;
class IRollupWindow;
class ITabDialogPluginTab;
class ReferenceMaker;

//**********************************************************************
//
// ITabDialogManager
//**********************************************************************/
class ITabDialogManager : public FPStaticInterface
{
public:

   virtual ITabbedDialog* CreateTabbedDialog(
      HWND        parent,
      HINSTANCE      instance,
      const MCHAR*        dlg,
      ITabDialogProc*   mainProc,
      bool        multiline,
      DWORD       helpID=0,
      int            tabID = -1,
      const Class_ID&   dialogID = Class_ID(0,0)
   ) = 0;
   
   virtual bool RegisterTab(const Class_ID& dialogID, ITabDialogPluginTab* tab) = 0;

   virtual void UnRegisterTab(const Class_ID& dialogID, ITabDialogPluginTab* tab) = 0;


   virtual void SetTabFilter(const Class_ID& dialogID, ITabDialogFilter* filter) = 0;


   virtual ITabDialogFilter* GetTabFilter(const Class_ID& dialogID) = 0;


   virtual ITabbedDialog* GetTabbedDialog(const Class_ID& dialogID) = 0;


   static int AcceptTab(
      ITabDialogFilter*    filter,
      ITabDialogPluginTab* tab
   );
};


#define TAB_DIALOG_PREFERENCES_ID   Class_ID(0x16d416fb, 0x1cdd4da5) //!< \brief Preferences dialog
#define TAB_DIALOG_PROPERTIES_ID Class_ID(0x777f709b, 0x44404554) //!< \brief Object Properties dialog
#define TAB_DIALOG_PATH_ID       Class_ID(0x2c863840, 0x67b1202f) //!< \brief Configure Path dialog
#define TAB_DIALOG_RENDER_ID     Class_ID(0x648636a0, 0xe52086b) //!< \brief Render dialogs
#define TAB_DIALOG_VIDEO_POST_ID Class_ID(0x41be0fad, 0x160c099c) //!< \brief Render dialogs

#if defined(ENVIRONMENT_DIALOG_IN_RENDER_DIALOG)
#define TAB_DIALOG_ENVIRONMENT_ID   TAB_DIALOG_RENDER_ID
#else // defined(environment_dialog_in_render_dialog)
#define TAB_DIALOG_ENVIRONMENT_ID   Class_ID(0x447f2d77, 0x781268a7)
#endif   // defined(environment_dialog_in_render_dialog)

#define TAB_DIALOG_CUSTOMIZE_ID     Class_ID(0x27A3F8FB, 0x8D294d77)


// These are the results of accepting a tab for a dialog
enum {
   TAB_DIALOG_REMOVE_TAB = 1,
   TAB_DIALOG_ADD_TAB = 2
};

#define TAB_DIALOG_MANAGER_INTERFACE_ID Interface_ID(0x46465ead, 0x6e3cbb)

// This inline will return the ITabDialogManager.
inline ITabDialogManager* GetTabDialogManager()
{
   return static_cast<ITabDialogManager*>(
      GetCOREInterface(TAB_DIALOG_MANAGER_INTERFACE_ID));
}

#pragma warning(push)
#pragma warning(disable:4100)

/***********************************************************************
 *
 * ITabDialogPluginTab
// **********************************************************************/
class ITabDialogPluginTab : public BaseInterface {
public:

   virtual void AddTabToDialog(ITabbedDialog* dialog) = 0;

   virtual int AcceptDialog(
      ITabDialogFilter* filter
   ) { return TAB_DIALOG_ADD_TAB; }

   virtual ReferenceMaker* GetReferenceMaker() { return NULL; }

   virtual Animatable* GetAnimatable() { return (Animatable*)GetReferenceMaker(); }

   virtual Class_ID GetClassID() {
      Animatable* a = GetAnimatable();
      return a ? a->ClassID() : Class_ID(0, 0);
   }
   virtual SClass_ID GetSuperClassID() {
      Animatable* a = GetAnimatable();
      return a ? a->SuperClassID() : 0;
   }

   virtual BaseInterface* GetInterface(const Interface_ID& id) { return NULL; }
};

//***********************************************************************
//
// TabDialogFilter
//**********************************************************************/
class ITabDialogFilter : public BaseInterface {
public:

   virtual int AcceptTab(
      ITabDialogPluginTab* tab
   ) { return TAB_DIALOG_ADD_TAB; }

   virtual int LaunchDialog(const Class_ID& page = Class_ID(0,0)) { return IDOK; }

   virtual ReferenceMaker* GetReferenceMaker() { return NULL; }

   virtual Animatable* GetAnimatable() { return (Animatable*)GetReferenceMaker(); }

   virtual Class_ID GetClassID() {
      Animatable* a = GetAnimatable();
      return a ? a->ClassID() : Class_ID(0, 0);
   }
   virtual SClass_ID GetSuperClassID() {
      Animatable* a = GetAnimatable();
      return a ? a->SuperClassID() : 0;
   }

   virtual BaseInterface* GetInterface(const Interface_ID& id) { return NULL; }
};

// ***********************************************************************
// 
// **********************************************************************/

enum TabDialogMessages {
   TABDLG_SWITCH_FROM   = WM_USER + 1, 
   TABDLG_SWITCH_TO  = WM_USER + 2, 
   TABDLG_COMMIT     = WM_USER + 3, 
   TABDLG_PRECOMMIT  = WM_USER + 4, 


   TABDLG_CANCEL     = WM_USER + 5, 
   TABDLG_CLOSE      = WM_USER + 6, 
   TABDLG_INVALIDATE = WM_USER + 7, 
   TABDLGNOTIFY_GETINITINFO   = WM_USER + 8, 
   TABDLG_RESIZE_DIALOG= WM_USER + 9   
};

struct TABDLG_NMHDR: public MaxHeapOperators 
{
   NMHDR hdr;//the common denominator
            //we use the 
   LPARAM dwInitParam; 
};

#define TABBED_DIALOG_INTERFACE_ID Interface_ID(0x4128621b, 0x744d5789)

// ***********************************************************************
//
// ITabbedDialog
// **********************************************************************/
class ITabbedDialog: public MaxHeapOperators {
public:
   enum {
      kSystemPage = 20,
      kNormalPage = 50,
      kMaxPage = 100
   };
   
   static ITabbedDialog* GetPointer(HWND dialog) {
      return DLGetWindowLongPtr<ITabbedDialog*>(dialog);
   }

   virtual void DeleteThis() = 0;

   virtual Class_ID GetDialogID() const = 0;

    virtual ITabPage* AddPage(
      const MCHAR*              text,
      HINSTANCE            instance,
      const MCHAR*              tmplt,
      ITabPageProc*        proc,
      const Class_ID&         pageID,
      ITabDialogPluginTab* plugin = NULL,
      DWORD             helpID = 0,
      int                  order = kNormalPage,
      int                  image = -1
   ) = 0;
   
   virtual ITabPage* AddRollout(
      const MCHAR*              text,
      ITabPageProc*        proc,
      const Class_ID&         pageID,
      ITabDialogPluginTab* plugin = NULL,
      int                  controlID = -1,
      int                  width = 0,
      int                  bottomMargin = 0,
      DWORD             helpID = 0,
      int                  order = kNormalPage,
      int                  image = -1
   ) = 0;

   virtual void SyncRegisteredTabs() = 0;

   virtual ITabDialogFilter* GetTabFilter() const = 0;

   virtual ITabDialogProc* GetProc() const = 0;
   virtual ITabDialogProc* SetProc(ITabDialogProc* newProc) = 0;
   
   virtual INT_PTR DoModal(const Class_ID& page) = 0;
   
   virtual bool DoFloater(const Class_ID& page) = 0;

   virtual void Switch(const Class_ID& page) = 0;

   virtual void Invalidate() = 0;
      
   virtual void SetImageList(HIMAGELIST list) = 0;
      
   virtual int CurrentPage() const = 0;


   virtual void SetMargins(int left, int top, int right, int bottom) = 0;


   virtual void SetTabbedRect(const RECT& rect) = 0;
      
   virtual int GetNbPages() const = 0;
   virtual ITabPage* GetPage(int index) const = 0;
   virtual ITabPage* GetPage(const Class_ID& id) const = 0;

   virtual HWND GetHWND() const = 0;

   virtual bool OkToCommit() = 0;
   virtual bool CommitPages() = 0;


   virtual void CloseDialog() = 0;

   virtual void ClosePages() = 0;

   virtual void CancelDialog() = 0;
   virtual void CancelPages() =0;

   virtual HWND GetTabHWND() const = 0;

protected:
   // Don't allow it to be deleted except through DeleteThis
   virtual ~ITabbedDialog() {}
};

// ***********************************************************************
// *
// * TabDialogPointer
// **********************************************************************/
class TabDialogPointer: public MaxHeapOperators {
public:
   TabDialogPointer() : mpDlg(NULL) { }
   explicit TabDialogPointer(ITabbedDialog* dlg) : mpDlg(dlg) { }
   explicit TabDialogPointer(TabDialogPointer& src) : mpDlg(src.mpDlg) { src.mpDlg = NULL; }
   TabDialogPointer(
      HWND        parent,
      HINSTANCE      instance,
      const MCHAR*        dlg,
      ITabDialogProc*   mainProc,
      bool        multiline,
      DWORD       helpID = 0,
      int            tabID = -1,
      const Class_ID&   dialogID = Class_ID(0,0)
   ) : mpDlg(NULL)
   {
      ITabDialogManager* i = GetTabDialogManager();
      if (i != NULL) {
         mpDlg = i->CreateTabbedDialog(parent, instance, dlg, mainProc,
            multiline, helpID, tabID, dialogID);
      }
   }

   ~TabDialogPointer() { FreeDlg(); mpDlg = NULL; }

   TabDialogPointer& operator=(ITabbedDialog* dlg) { FreeDlg(); mpDlg = dlg; return *this; }
   TabDialogPointer& operator=(TabDialogPointer& src) { FreeDlg(); mpDlg = src.mpDlg; src.mpDlg = NULL; return *this; }

   operator ITabbedDialog*() { return mpDlg; }
   ITabbedDialog& operator*() { return *mpDlg; }
   ITabbedDialog* get() { return mpDlg; }
   ITabbedDialog* release() { ITabbedDialog* dlg = mpDlg; mpDlg = NULL; return dlg; }
   ITabbedDialog* operator->() { return mpDlg; }
   ITabbedDialog** operator&() { return &mpDlg; }

   bool Create(
      HWND        parent,
      HINSTANCE      instance,
      const MCHAR*        dlg,
      ITabDialogProc*   mainProc,
      bool        multiline,
      int            tabID = -1,
      DWORD       helpID = 0,
      const Class_ID&   dialogID = Class_ID(0,0)
   )
   {
      ITabDialogManager* i = GetTabDialogManager();
      if (i != NULL) {
         ITabbedDialog* retVal = i->CreateTabbedDialog(parent, instance, dlg, mainProc,
            multiline, helpID, tabID, dialogID);
         if (retVal != NULL) {
            FreeDlg();
            mpDlg = retVal;
            return true;
         }
      }
      return false;
   }

private:
   void FreeDlg() { if (mpDlg != NULL) mpDlg->DeleteThis(); }

   ITabbedDialog*    mpDlg;
};

// ***********************************************************************
// *
// * ITabPage
// **********************************************************************/
class ITabPage : public BaseInterface {
public:
   virtual HWND GetHWND() const = 0;

   virtual Class_ID GetPageID() const = 0;
   
   virtual int GetHelpID() const = 0;
   
   virtual ITabbedDialog* GetTabDialog() const = 0;
   
   virtual ITabPageProc* GetProc() const = 0;
   
   virtual ITabPageProc* SetProc(ITabPageProc* newProc) = 0;
   
   virtual ITabDialogPluginTab* GetPlugin() const = 0;
   
   virtual int GetIndex() const = 0;

   virtual void Invalidate() = 0;


   virtual IRollupWindow* GetRollout() = 0;
};


// ***********************************************************************
// *
// * ITabDialogProc
// *
// **********************************************************************/
class ITabDialogProc : public BaseInterface {
public:
   // Construct
   ITabDialogProc() : mpDlg(NULL) {}
   
   void SetTabDialog(ITabbedDialog* dlg) { mpDlg = dlg; }
   ITabbedDialog* GetTabDialog() const { return mpDlg; }


   virtual void DeleteThis() {}

   INT_PTR InitDialog(HWND focus) {
      return dialogProc(WM_INITDIALOG, reinterpret_cast<WPARAM>(focus), 0);
   }
   
   void Invalidate() {
      dialogProc(TABDLG_INVALIDATE, 0, 0);
   }
      
   bool OkToCommit() {
      bool commit = true;
      dialogProc(TABDLG_PRECOMMIT, 0, reinterpret_cast<LPARAM>(&commit));
      return commit;
   }

   void Commit() {
      dialogProc(TABDLG_COMMIT, 0, 0);
   }


   void Close() {
      dialogProc(TABDLG_CLOSE, 0, 0);
   }

   void Cancel() {
      dialogProc(TABDLG_CANCEL, 0, 0);
   }


   bool ResizeDialog(SIZE* delta) {
      return dialogProc(TABDLG_RESIZE_DIALOG, 0,
         reinterpret_cast<LPARAM>(delta)) != 0;

   };


   virtual INT_PTR dialogProc(
      UINT  msg,
      WPARAM   wParam,
      LPARAM   lParam
   ) { return FALSE; }

   virtual BaseInterface* GetInterface(const Interface_ID& id) { return NULL; }
   
private:
   ITabbedDialog*    mpDlg;
};


// ***********************************************************************
// *
// * ITabPageProc
// **********************************************************************/
class ITabPageProc: public MaxHeapOperators {
public:
   // Construct
   ITabPageProc() : mpPage(NULL) {}
     virtual ~ITabPageProc() {;}
   
   void SetTabPage(ITabPage* page) { mpPage = page; }
   ITabPage* GetTabPage() const { return mpPage; }


   virtual void DeleteThis() {}

   INT_PTR InitPage(HWND focus, LPARAM lparam) {
      return dialogProc(WM_INITDIALOG, reinterpret_cast<WPARAM>(focus), lparam);
   }
   
   void Invalidate() {
      dialogProc(TABDLG_INVALIDATE, 0, 0);
   }
      
   bool OkToCommit() {
      bool commit = true;
      dialogProc(TABDLG_PRECOMMIT, 0, reinterpret_cast<LPARAM>(&commit));
      return commit;
   }
   void Commit() {
      dialogProc(TABDLG_COMMIT, 0, 0);
   }

   void Close() {
      dialogProc(TABDLG_CLOSE, 0, 0);
   }

   void Cancel() {
      dialogProc(TABDLG_CANCEL, 0, 0);
   }

   void SwitchFrom() {
      dialogProc(TABDLG_SWITCH_FROM, 0, 0);
   }
   
   void SwitchTo() {
      dialogProc(TABDLG_SWITCH_TO, 0, 0);
   }


   virtual INT_PTR dialogProc(
      UINT  msg,
      WPARAM   wParam,
      LPARAM   lParam
   ) { return FALSE; }
   
private:
   ITabPage*      mpPage;
};


/***********************************************************************
 *
 * ITabDialogObject
// **********************************************************************/
class ITabDialogObject : public BaseInterface {
public:
   virtual void Activate(ITabbedDialog* dialog) { }
   virtual void Deactivate(ITabbedDialog* dialog) { }


   virtual void AddTabToDialog(ITabbedDialog* dialog, ITabDialogPluginTab* tab) { }

   virtual int AcceptTab(
      ITabDialogPluginTab* tab
   ) { return TAB_DIALOG_ADD_TAB; }
};

#pragma warning(pop)

#define TAB_DIALOG_OBJECT_INTERFACE_ID Interface_ID(0x313c6db9, 0x42890bb3)

inline ITabDialogObject* GetTabDialogObject(InterfaceServer* obj)
{
   return static_cast<ITabDialogObject*>(obj->GetInterface(
      TAB_DIALOG_OBJECT_INTERFACE_ID));
}


inline int ITabDialogManager::AcceptTab(
   ITabDialogFilter*    filter,
   ITabDialogPluginTab* tab
)
{
   int dlgResult = filter == NULL ? TAB_DIALOG_ADD_TAB : filter->AcceptTab(tab);
   if (dlgResult & TAB_DIALOG_ADD_TAB) {
      dlgResult &= ~TAB_DIALOG_ADD_TAB;
      dlgResult |= tab->AcceptDialog(filter);
   }
   return dlgResult;
}