/**********************************************************************
 *<
	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.
 **********************************************************************/

#ifndef __ITABDIALOG_H_
#define __ITABDIALOG_H_

class ITabbedDialog;
class ITabPage;

class ITabRegister;

class ITabDialogProc;
class ITabPageProc;
class ITabDialogFilter;

class IRollupWindow;

class ITabDialogPluginTab;

/***********************************************************************
 *
 * ITabDialogManager
 *
 * This interface is used to create tabbed dialogs and to register
 * tabs with dialogs that are created by the system or other plugins
 *
 **********************************************************************/
class ITabDialogManager : public FPStaticInterface {
public:

	// Create a tabbed dialog. Parent is the parent window of the dialog,
	// Instance is the instance where the dialog tempate is stored, and dlg
	// is the name of the dialog template resource. If instance is NULL,
	// then dlg is a pointer to the dialog template in memory. MainProc is
	// the object that is used to handle messages for the dialog. Mult is
	// true if the tab control should be multiline and is only applicable
	// when tabID is -1. TabID is the ID of a tab control in the dialog
	// template, that is to be used. If tabID is -1, then a tab control
	// is created. HelpID is used to bring up context sensitive help
	// when the F1 key is pressed.
	virtual ITabbedDialog* CreateTabbedDialog(
		HWND			parent,
		HINSTANCE		instance,
		LPCTSTR			dlg,
		ITabDialogProc*	mainProc,
		bool			multiline,
		DWORD			helpID=0,
		int				tabID = -1,
		const Class_ID&	dialogID = Class_ID(0,0)
	) = 0;
	
	// Register/UnRegister a tab for a dialog, DialogID is the id of the dialog
	// this tab is to be used with. Tab is the address of an object that is used
	// to add the tab when the dialog is created. Tab must remain valid while
	// it is registered.
	virtual bool RegisterTab(const Class_ID& dialogID, ITabDialogPluginTab* tab) = 0;
	virtual void UnRegisterTab(const Class_ID& dialogID, ITabDialogPluginTab* tab) = 0;

	// Set/Get the current plugin tab filter for a dialog. This filter is
	// used to determine which tabs will be present when the dialog is created.
	virtual void SetTabFilter(const Class_ID& dialogID, ITabDialogFilter* filter) = 0;
	virtual ITabDialogFilter* GetTabFilter(const Class_ID& dialogID) = 0;

	// Get the ITabbedDialog for the dialog id. Returns NULL if dialog not
	// present. Assumes that only one dialog is present for a dialog id at a time.
	// Note: NOTIFY_TABBED_DIALOG_CREATED and NOTIFY_TABBED_DIALOG_DELETED sent when 
	// a tabbed dialog is created or deleted. callparam is point to dialogID
	virtual ITabbedDialog* GetTabbedDialog(const Class_ID& dialogID) = 0;

	// The return value can be a combination of TAB_DIALOG_REMOVE_TAB and
	// TAB_DIALOG_ADD_TAB
	static int AcceptTab(
		ITabDialogFilter*		filter,
		ITabDialogPluginTab*	tab
	);
};

// These are some internally defined dialog ids
// Preferences dialog
#define TAB_DIALOG_PREFERENCES_ID	Class_ID(0x16d416fb, 0x1cdd4da5)
// Object Properties dialog
#define TAB_DIALOG_PROPERTIES_ID	Class_ID(0x777f709b, 0x44404554)
// Configure Path dilaog
#define TAB_DIALOG_PATH_ID			Class_ID(0x2c863840, 0x67b1202f)
// Render dialogs
#define TAB_DIALOG_RENDER_ID		Class_ID(0x648636a0, 0xe52086b)
#define TAB_DIALOG_VIDEO_POST_ID	Class_ID(0x41be0fad, 0x160c099c)
// Environment Dialog
#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)

// 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));
}

/***********************************************************************
 *
 * ITabDialogPluginTab
 *
 * This interface is used to add plugin tabs to a tabbed dialog.
 *
 **********************************************************************/
class ITabDialogPluginTab : public BaseInterface {
public:
	// Add your tab(s) to the dialog. This will only be called if
	// both this object and the dialog agree that the tab should
	// be added. Dialog is the address of the dialog.
	virtual void AddTabToDialog(ITabbedDialog* dialog) = 0;

	// Accept this tab in this dialog. Dialog is the address of the
	// dialog. Return true if the tab should be added. Return false
	// if the tab should not be added or should be removed if it
	// was added previously. Filter is the dialog filter.
	virtual int AcceptDialog(
		ITabDialogFilter*	filter
	) { return TAB_DIALOG_ADD_TAB; }

	// These return various information that is likely to be interesting
	// when deciding whether or not to use this tab.

	// If this tab is the UI for a ReferenceMaker, return it here.
	virtual ReferenceMaker* GetReferenceMaker() { return NULL; }

	// Otherwise, if this tab is the UI for an Animatable, return it here
	virtual Animatable* GetAnimatable() { return GetReferenceMaker(); }

	// Otherwise, If this tab has some known class ID and super class ID
	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;
	}

	// Otherwise, you will need to define a special interface
	virtual BaseInterface* GetInterface(const Interface_ID& id) { return NULL; }
};

/***********************************************************************
 *
 * TabDialogFilter
 *
 * This interface is used to filter plugin tabs in a tabbed dialog.
 *
 **********************************************************************/
class ITabDialogFilter : public BaseInterface {
public:
	// Return true if the tabs added by the ITabDialogPluginTab tab
	// are acceptable for this dialog. Dialog is the dialog being
	// filtered.
	virtual int AcceptTab(
		ITabDialogPluginTab*	tab
	) { return TAB_DIALOG_ADD_TAB; }

	// Launch the dialog for this filter, open the dialog at a specific page
	virtual int LaunchDialog(const Class_ID& page = Class_ID(0,0)) { return IDOK; }

	// These return various information that is likely to be interesting
	// when deciding whether or not to add a tab.

	// If this dialog is the UI for a ReferenceMaker, return it here.
	virtual ReferenceMaker* GetReferenceMaker() { return NULL; }

	// Otherwise, if this dialog is the UI for an Animatable, return it here
	virtual Animatable* GetAnimatable() { return GetReferenceMaker(); }

	// Otherwise, If this dialog has some known class ID and super class ID
	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;
	}

	// Otherwise, you will need to define a special interface
	virtual BaseInterface* GetInterface(const Interface_ID& id) { return NULL; }
};

/***********************************************************************
 *
 * TabDialogMessages
 *
 * Messages used by the tab dialog class
 *
 **********************************************************************/
enum TabDialogMessages {
	TABDLG_SWITCH_FROM	= WM_USER + 1,	// Switching from this page
	TABDLG_SWITCH_TO	= WM_USER + 2,	// Switching to this page
	TABDLG_COMMIT		= WM_USER + 3,	// Commit the page's working values for real
	TABDLG_PRECOMMIT	= WM_USER + 4,	// Check your values, but don't close the dialog;
										// if your page needs to reject an OK, set the
										// bool* in LPARAM to false.
	TABDLG_CANCEL		= WM_USER + 5,	// User is cancelling out of the dialog
	TABDLG_CLOSE		= WM_USER + 6,	// User is closing a modeless dialog
	TABDLG_INVALIDATE	= WM_USER + 7,	// The underlying data has changed
	TABDLGNOTIFY_GETINITINFO	= WM_USER + 8,	// WE need to get init, see struct TABDLG_NMHDR
	TABDLG_RESIZE_DIALOG= WM_USER + 9	// The tab is too small for the content
};

// The address of this struct passed in LPARAM when
// you get a WM_NOTIFY, with TABDLGNOTIFY_GETINITINFO
// as the notify code. This notification is sent to
// the tab dialog before each page is created. hdr.idFrom
// is the index of the page about to be created. The
// value stored in dwInitParam is passed to the InitPage
// method as lparam.
struct TABDLG_NMHDR 
{
	NMHDR	hdr;//the common denominator
				//we use the 
	LPARAM dwInitParam; //this out param contains the ptr to initialization data for the page.
};

/***********************************************************************
 *
 * ITabbedDialog
 *
 * This interface is used to manage a tabbed dialog. You can add pages
 * and either display a modal or modeless dialog.
 * You can add a rollout page, that can contain MAX rollouts
 *
 **********************************************************************/

#define TABBED_DIALOG_INTERFACE_ID Interface_ID(0x4128621b, 0x744d5789)

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

	// Delete yourself
	virtual void DeleteThis() = 0;

	// Return the dialogID for this dialog
	virtual Class_ID GetDialogID() const = 0;

	// Add a page to the dialog. Text is the tab text. Instance and
	// tmplt are the instance and resource for the dialog template
	// for the page. If instance is NULL, the tmplt is a pointer to
	// the dialog template in memory. Proc is the message handler for
	// the page. Image is an image for the tab in the image list set
	// by SetImageList. Order is the order that the tab will appear
	// in the tabs. Two pages with the same order are ordered
	// by the order they are added. HelpID is ID used for context
	// sensitive help.
	virtual ITabPage* AddPage(
		LPCTSTR					text,
		HINSTANCE				instance,
		LPCTSTR					tmplt,
		ITabPageProc*			proc,
		const Class_ID&			pageID,
		ITabDialogPluginTab*	plugin = NULL,
		DWORD					helpID = 0,
		int						order = kNormalPage,
		int						image = -1
	) = 0;
	
	// Add a rollout page to the dialog. Text is the tab text. Proc is
	// the message handler for the page. The margins give additional
	// space between the rollout control and the client are of the tab.
	// Image is an image for the tab in the image list set by SetImageList.
	// Order is the order that the tab will appear in the tabs. Two
	// pages with the same order are ordered by the order they are added.
	// HelpID is ID used for context sensitive help.
	virtual ITabPage* AddRollout(
		LPCTSTR					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;

	// Add and remove registered tabs to the dialog.
	virtual void SyncRegisteredTabs() = 0;

	// Get the filter for this dialog
	virtual ITabDialogFilter* GetTabFilter() const = 0;

	// Get/Set the dialog proc. The previous
	// value is returned when setting the proc
	virtual ITabDialogProc* GetProc() const = 0;
	virtual ITabDialogProc* SetProc(ITabDialogProc* newProc) = 0;
	
	// Display and process modal dialog
	virtual INT_PTR DoModal(const Class_ID& page) = 0;
	
	// Display and process modeless dialog
	virtual bool DoFloater(const Class_ID& page) = 0;

	// Switch to the given page.
	virtual void Switch(const Class_ID& page) = 0;

	// Invalidate all pages in the dialog.
	virtual void Invalidate() = 0;
		
	// Set the image list for the tab control
	virtual void SetImageList(HIMAGELIST list) = 0;
		
	// Get the index of the current page
	virtual int CurrentPage() const = 0;

	// Set the margins for the tab in the dialog. This is
	// only applicable if the tabCtrl is not part of the
	// dialog template. If SetTabbedRect is called with
	// a nonempty rectangle, it is used, otherwise the
	// margins are used.
	virtual void SetMargins(int left, int top, int right, int bottom) = 0;
	virtual void SetTabbedRect(const RECT& rect) = 0;
		
	// Convert indices to pages
	virtual int GetNbPages() const = 0;
	virtual ITabPage* GetPage(int index) const = 0;
	virtual ITabPage* GetPage(const Class_ID& id) const = 0;

	// Get the window for the tabbed dialog
	virtual HWND GetHWND() const = 0;

	// Used for modal dialogs with IDOK and IDCANCEL
	virtual bool OkToCommit() = 0;
	virtual bool CommitPages() = 0;

	// Used for modeless dialogs; note that if the user hits the X in the upper right
	// corner, a cancel message will be sent.
	virtual void CloseDialog() = 0;
	virtual void ClosePages() = 0;

	// Used for both.
	virtual void CancelDialog() = 0;
	virtual void CancelPages() =0;

	// Get the window for the tab control
	virtual HWND GetTabHWND() const = 0;

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

/***********************************************************************
 *
 * TabDialogPointer
 *
 * This smart pointer is used to simplify scope management
 *
 **********************************************************************/
class TabDialogPointer {
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,
		LPCTSTR			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() { free(); mpDlg = NULL; }

	TabDialogPointer& operator=(ITabbedDialog* dlg) { free(); mpDlg = dlg; return *this; }
	TabDialogPointer& operator=(TabDialogPointer& src) { free(); 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,
		LPCTSTR			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) {
				free();
				mpDlg = retVal;
				return true;
			}
		}
		return false;
	}

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

	ITabbedDialog*		mpDlg;
};

/***********************************************************************
 *
 * ITabPage
 *
 * This interface is used to manage a page in a tabbed dialog.
 *
 **********************************************************************/
class ITabPage : public BaseInterface {
public:
	// Get the window for this page
	virtual HWND GetHWND() const = 0;

	// Get the pageID for this page
	virtual Class_ID GetPageID() const = 0;
	
	// Get the help ID for the page
	virtual int GetHelpID() const = 0;
	
	// Get the tab dialog containing this page
	virtual ITabbedDialog* GetTabDialog() const = 0;
	
	// Get/Set the tab dialog page proc. The previous
	// value is returned when setting the proc
	virtual ITabPageProc* GetProc() const = 0;
	virtual ITabPageProc* SetProc(ITabPageProc* newProc) = 0;
	
	// Get the Plugin that added this page
	virtual ITabDialogPluginTab* GetPlugin() const = 0;
	
	// Convert pages to indices
	virtual int GetIndex() const = 0;

	// Refresh your UI.
	virtual void Invalidate() = 0;

	// Get the IRollupWindow interface for the rollout
	// This interface should not be released, because
	// it is release by this object when the rollout
	// is destroyed. NULL is returned if the page is
	// not a rollout.
	virtual IRollupWindow* GetRollout() = 0;
};


/***********************************************************************
 *
 * ITabDialogProc
 *
 * This interface is implemented by the code that wants to use the
 * tab dialog. The implementer can choose whether to respond to
 * the methods or to messages
 *
 **********************************************************************/
class ITabDialogProc : public BaseInterface {
public:
	// Construct
	ITabDialogProc() : mpDlg(NULL) {}
	
	// Set the dialog proc
	void SetTabDialog(ITabbedDialog* dlg) { mpDlg = dlg; }
	ITabbedDialog* GetTabDialog() const { return mpDlg; }

	// Delete this dialog proc. This method does nothing, because most
	// dialog procs are not scoped by their dialog, but you can override
	// it if you want your dialog proc deleted when the dialog is deleted.
	virtual void DeleteThis() {}

	// Initialize the dialog
	INT_PTR InitDialog(HWND focus) {
		return dialogProc(WM_INITDIALOG, reinterpret_cast<WPARAM>(focus), 0);
	}
	
	// Invalidate the dialog
	void Invalidate() {
		dialogProc(TABDLG_INVALIDATE, 0, 0);
	}
		
	// Used for modal dialogs with IDOK and IDCANCEL
	bool OkToCommit() {
		bool commit = true;
		dialogProc(TABDLG_PRECOMMIT, 0, reinterpret_cast<LPARAM>(&commit));
		return commit;
	}
	void Commit() {
		dialogProc(TABDLG_COMMIT, 0, 0);
	}

	// The dialog is being closed. This is called after
	// all of the pages have been committed.
	void Close() {
		dialogProc(TABDLG_CLOSE, 0, 0);
	}

	// The dialog is being canceled
	void Cancel() {
		dialogProc(TABDLG_CANCEL, 0, 0);
	}

	// Resize the dialog. Delta is the required
	// change in size. This method is only called
	// if the size needs to be increased.
	// Return true if the dialog was resized.
	// If the dialog was resize, the dialog manager
	// will resize the tab control and the content.
	// The dialog proc may change the delta values
	// to correspond the the amount the dialog was resized.
	bool ResizeDialog(SIZE* delta) {
		return dialogProc(TABDLG_RESIZE_DIALOG, 0,
			reinterpret_cast<LPARAM>(delta)) != 0;

	};

	// The general message proc. This proc is like a
	// dialog proc, not a window proc
	virtual INT_PTR dialogProc(
		UINT	msg,
		WPARAM	wParam,
		LPARAM	lParam
	) { return FALSE; }

	// Get extension interfaces, if there are any
	virtual BaseInterface* GetInterface(const Interface_ID& id) { return NULL; }
	
private:
	ITabbedDialog*		mpDlg;
};


/***********************************************************************
 *
 * ITabPageProc
 *
 * This interface is used to filter plugin tabs in a tabbed dialog.
 *
 **********************************************************************/
class ITabPageProc {
public:
	// Construct
	ITabPageProc() : mpPage(NULL) {}
	
	// Set the dialog proc
	void SetTabPage(ITabPage* page) { mpPage = page; }
	ITabPage* GetTabPage() const { return mpPage; }

	// Delete this page proc. This method does nothing, because most
	// page procs are not scoped by their page, but you can override
	// it if you want your page proc deleted when the page is deleted.
	virtual void DeleteThis() {}

	// Initialize the dialog
	INT_PTR InitPage(HWND focus, LPARAM lparam) {
		return dialogProc(WM_INITDIALOG, reinterpret_cast<WPARAM>(focus), lparam);
	}
	
	// Invalidate the dialog
	void Invalidate() {
		dialogProc(TABDLG_INVALIDATE, 0, 0);
	}
		
	// Used for modal dialogs with IDOK and IDCANCEL
	bool OkToCommit() {
		bool commit = true;
		dialogProc(TABDLG_PRECOMMIT, 0, reinterpret_cast<LPARAM>(&commit));
		return commit;
	}
	void Commit() {
		dialogProc(TABDLG_COMMIT, 0, 0);
	}

	// The dialog is being closed. This is called after
	// all of the pages have been committed.
	void Close() {
		dialogProc(TABDLG_CLOSE, 0, 0);
	}

	// The dialog is being canceled
	void Cancel() {
		dialogProc(TABDLG_CANCEL, 0, 0);
	}

	// Switch from this page
	void SwitchFrom() {
		dialogProc(TABDLG_SWITCH_FROM, 0, 0);
	}
	
	// Switch to this page
	void SwitchTo() {
		dialogProc(TABDLG_SWITCH_TO, 0, 0);
	}

	// The general message proc. This proc is like a
	// dialog proc, not a window proc
	virtual INT_PTR dialogProc(
		UINT	msg,
		WPARAM	wParam,
		LPARAM	lParam
	) { return FALSE; }
	
private:
	ITabPage*		mpPage;
};


/***********************************************************************
 *
 * ITabDialogObject
 *
 * This interface is used to allow plugins to interact with a tabbed dialog.
 * Objects can expose this interface when they want to participate
 * in tab selection in a tabbed dialog.
 *
 * The dialog defines how objects can participate:
 *
 * The Render dialog allows the renderer to participate in the dialog tabs.
 * 
 * If the renderer doesn't expose this interface, a single separate
 * tab is created for the renderer's paramters, and the renderer is
 * allowed to create rollouts in this tab.
 *
 * If the renderer does expose this interface, its filter is assigned
 * to the dialog, to allow it to reject tabs that are not applicable
 * to its user interface, and it is informed of different actions
 * that are taking place.
 *
 **********************************************************************/
class ITabDialogObject : public BaseInterface {
public:
	// Notify the object that the dialog is activated 
	// or deactivated in a tabbed dialog
	virtual void Activate(ITabbedDialog* dialog) { }
	virtual void Deactivate(ITabbedDialog* dialog) { }

	// Add your tab(s) to the dialog. This will only be called if
	// both this object and the dialog agree that the tab should
	// be added. Dialog is the address of the dialog.
	virtual void AddTabToDialog(ITabbedDialog* dialog, ITabDialogPluginTab* tab) { }

	// Return true if the tabs added by the ITabDialogPluginTab tab
	// are acceptable for this dialog. Dialog is the dialog being
	// filtered.
	virtual int AcceptTab(
		ITabDialogPluginTab*	tab
	) { return TAB_DIALOG_ADD_TAB; }
};

#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;
}

#endif