/*	
 *		Rollouts.h - Rollout panel classes & functions for MAXScript
 *
 *			Copyright © John Wainwright 1996
 *
 */

#ifndef _H_ROLLOUTS
#define _H_ROLLOUTS

#include "Arrays.h"

typedef struct		// rollout control layout data
{
	int	left;
	int top;
	int	width;
	int height;
	int columns;
} layout_data;

/* some layout constants (in pixels) ... */

#define TOP_MARGIN				2
#define SIDE_MARGIN				4
#define RADIO_DOT_WIDTH			23
#define CHECK_BOX_WIDTH			24
#define LEFT_ALIGN				13
#define RIGHT_ALIGN				13
#define GROUP_BOX_Y_MARGIN		6
#define GROUP_BOX_X_MARGIN		4
#define SPACING_BEFORE			5

/* ---------------------- Rollout class ----------------------- */

/* contains the defintion of  rollout panel.  This includes:
 *     - an 'instance variable' array, these variables can be accessed as locals in rollout handlers
 *     - a control array, containing rolout control instances
 *     - a hashtable of event handler functions
 *   there are associated Thunks for the locals & controls so you can ref them as variables in
 *   handlers
 */

class RolloutControl;
class RolloutFloater;
class MSPlugin;
class RolloutChangeCallback;
class PB2Param;

visible_class (Rollout)

class Rollout : public Value
{
public:
	Value*		name;						// rollout's variable name
	Value*		title;						// title factor			
	HashTable*  local_scope;				// local name space			
	Value**		locals;						// local var array			
	Value**		local_inits;				//   "    "    "  init vals	
	int			local_count;				//   "    "  count			
	RolloutControl** controls;				// control array			
	int			control_count;				//    "    "  count			
	HashTable*	handlers;					// handler tables			
	short		flags;						// rollout flags			
	short		order;						// rollout open order no.	
	Interface*	ip;							// Interface pointer		
	HWND		page;						// my dialog HWND when visible 
	HDC			rollout_dc;					// my dialog dev. context	
	HFONT		font;						// dialog's default font	
	int			text_height;				// metrics....				
	int			default_control_leading;
	int			rollout_width;
	int			rollout_height;
	int			rollout_category;
	int			current_width;				// used for across: processing...
	int			current_left;
	int			max_y, last_y;
	int			across_count;
	WORD		close_button_ID;			// id of gen'd close button 
	BOOL		selected;					// selected to be open  
	BOOL		disabled;					// error in handler -> ro disabled 		
	CharStream* source;						// source text if available 
	BOOL		init_values;				// whether to init ctrl/local values on (re)open
	MSPlugin*	plugin;						// plugin I'm open on if non-NULL
	RolloutChangeCallback* tcb;				// timechange callback if rollout has controller-linked spinners
	IMtlParams* imp;						// MtlEditor interface if open in Mtl Editor and other stuff...
	TexDADMgr*	texDadMgr;
	MtlDADMgr*	mtlDadMgr;
	HWND		hwMtlEdit;
	RolloutFloater* rof;					// owning rolloutfloater window if present there
	WORD        next_id;					// dialog item ID allocators
	Tab<RolloutControl*> id_map;			// dialog item ID map for taking item ID's to associated RolloutControl

				Rollout(short iflags);
	void		init(Value* name, Value* title, int local_count, Value** inits, HashTable* local_scope, RolloutControl** controls, int control_count, HashTable* handlers, CharStream* source);
			   ~Rollout();

				classof_methods (Rollout, Value);
	void		collect() { delete this; }
	void		gc_trace();
	ScripterExport void		sprin1(CharStream* s);

	ScripterExport BOOL add_page(Interface *ip, HINSTANCE hInstance, int ro_flags = 0, RolloutFloater* rof = NULL);
	ScripterExport void delete_page(Interface *ip, RolloutFloater* rof = NULL);
	void		open(Interface *ip, BOOL rolled_up = FALSE);
	ScripterExport void close(Interface *ip, RolloutFloater* rof = NULL);
	ScripterExport BOOL ok_to_close(RolloutFloater* rof = NULL);
	ScripterExport void run_event_handler(Value* event, Value** arg_list, int count);
	Value*		call_event_handler(Value* event, Value** arg_list, int count);
	void		add_close_button(HINSTANCE hInstance, int& current_y);
	void		edit_script();
	void		TimeChanged(TimeValue t);

	// various open/close for scripted plug-in rollouts
	// command panel
	void		BeginEditParams(IObjParam* ip, MSPlugin* plugin, ULONG flags, Animatable *prev);
	void		EndEditParams(IObjParam* ip, MSPlugin* plugin, ULONG flags, Animatable *next);
	// mtl editor
	void		CreateParamDlg(HWND hwMtlEdit, IMtlParams* imp, MSPlugin* plugin, TexDADMgr* texDadMgr, MtlDADMgr* mtlDadMgr);
	void		SetThing(MSPlugin* plugin);
	void		ReloadDialog();
	void		SetTime(TimeValue t);
	void		DeleteThis();
	// update/reload
	void		InvalidateUI();
	void		InvalidateUI(ParamID id, int tabIndex=-1); // nominated param

	virtual	Value*	get_property(Value** arg_list, int count);
	virtual	Value*	set_property(Value** arg_list, int count);
	virtual	Value*	set_nested_controller(Value** arg_list, int count);
};

#define RO_NO_CLOSEBUTTON	0x0001
#define RO_HIDDEN			0x0002
#define RO_ROLLED_UP		0x0004
#define RO_IN_FLOATER		0x0008
#define RO_INSTALLED		0x0010
#define RO_UTIL_MASTER		0x0020
#define RO_SILENT_ERRORS	0x0040
#define RO_HIDDEN2			0x0080
#define RO_PLUGIN_OWNED		0x0100
#define RO_CONTROLS_INSTALLED	0x0200

/* --------------------- RolloutFloater class ------------------------ */

visible_class (RolloutFloater)

class RolloutFloater : public Value
{
public:
	HWND			window;		// modeless dialog window
	HWND			ru_window;	// host rollup winddow cust control
	IRollupWindow*	irw;
	Tab<Rollout*>	rollouts;   // my rollouts
	int				width, height; // window size...
	int				left, top; 
	bool			inDelete;

			    RolloutFloater(TCHAR* title, int left, int top, int width, int height);
				RolloutFloater() {window=ru_window=NULL;irw=NULL;width=height=left=top=0;inDelete=false;tag = class_tag(RolloutFloater);}
	 		   ~RolloutFloater();

				classof_methods (RolloutFloater, Value);
	void		collect() { delete this; }

	void		add_rollout(Rollout* ro, BOOL rolledUp);
	void		remove_rollout(Rollout* ro);

	Value*		get_property(Value** arg_list, int count);
	Value*		set_property(Value** arg_list, int count);
};

/* -------------------- RolloutControl classes ----------------------- */

/* represent controls such as buttons & spinners on rollout panels, RolloutControl is abstract
 * root of all controls */

visible_class (RolloutControl)

class RolloutControl : public Value, public ReferenceMaker
{
public:
	Value*		name;
	Value*		caption;
	Value*		init_caption;
	BOOL		enabled;
	Value**		keyparms;
	int			keyparm_count;
	Rollout*	parent_rollout;
	WORD	    control_ID;
	Control*	controller;		// optional linked animation controller
	ParamDimension*  dim;		// controllers dimension
	PB2Param*	pid;			// if non-NULL, indicates this control is associated with an MSPlugin parameter &
								//   points at ParamUIRep-like data for it
	short		flags;

	ScripterExport  RolloutControl();
	ScripterExport  RolloutControl(Value* name, Value* caption, Value** keyparms, int keyparm_count);
	ScripterExport ~RolloutControl();

				classof_methods (RolloutControl, Value);
	BOOL		_is_rolloutcontrol() { return 1; }
#	define		is_rolloutcontrol(o) ((o)->_is_rolloutcontrol())
	void		collect() { delete this; }
	ScripterExport void gc_trace();

	virtual ScripterExport void	add_control(Rollout *ro, HWND parent, HINSTANCE hInstance, int& current_y);
	virtual LPCTSTR	get_control_class() = 0;
	virtual DWORD	get_control_style() { return WS_TABSTOP; }
	virtual DWORD	get_control_ex_style() { return 0; }
	virtual void	init_control(HWND control) { }
	virtual void	compute_layout(Rollout *ro, layout_data* pos) { }
	virtual ScripterExport void	compute_layout(Rollout *ro, layout_data* pos, int& current_y);
	virtual ScripterExport void	process_layout_params(Rollout *ro, layout_data* pos, int& current_y);
	virtual ScripterExport void	setup_layout(Rollout *ro, layout_data* pos, int& current_y);
	virtual ScripterExport void	process_common_params();
	virtual ScripterExport void	call_event_handler(Rollout *ro, Value* event, Value** arg_list, int count);
	virtual ScripterExport void	run_event_handler(Rollout *ro, Value* event, Value** arg_list, int count);
	virtual BOOL	handle_message(Rollout *ro, UINT message, WPARAM wParam, LPARAM lParam) { return FALSE; }
			ScripterExport WORD	next_id();

	virtual	ScripterExport Value* get_property(Value** arg_list, int count);
	virtual	ScripterExport Value* set_property(Value** arg_list, int count);
	virtual	ScripterExport void	set_text(TCHAR* text, HWND ctl = NULL, Value* align = NULL);
	virtual	ScripterExport void	set_enable();
	virtual ScripterExport BOOL set_focus();
	virtual ScripterExport int num_controls() { return 1; }
	        ScripterExport Value* get_event_handler(Value* event);

	// ReferenceMaker
	int			NumRefs() { return (controller != NULL) ? 1 : 0; }
	RefTargetHandle GetReference(int i) { return controller; }
	void		SetReference(int i, RefTargetHandle rtarg) { controller = (Control*)rtarg; }
	ScripterExport RefResult NotifyRefChanged(Interval changeInt, RefTargetHandle hTarget, PartID& partID,  RefMessage message);
	virtual void controller_changed() { }
	virtual BOOL controller_ok(Control* c) { return FALSE; }

	// PB2 UI update
	ScripterExport IParamBlock2* get_pblock();
	virtual void Reload() { }
	virtual void InvalidateUI() { }
	virtual void set_pb2_value() { }
	virtual void get_pb2_value(BOOL load_UI=TRUE) { }
	virtual void SetTexDADMgr(DADMgr* dad) { }
	virtual int FindSubTexFromHWND(HWND hw) { return -1; }
	virtual void SetMtlDADMgr(DADMgr* dad) { }
	virtual int FindSubMtlFromHWND(HWND hw) { return -1; } 

};

// flag bits for RolloutControl::flags
#define ROC_FIXED_WIDTH				0x0001	// a specific width: supplied, don't resize buttons on .text =
#define ROC_MAKING_EDIT				0x0002
#define ROC_INVISIBLE				0x0004	// rollout control is set to invisible and is disabled
#define ROC_VAL_CHANGED				0x0008	// value was changed while control had focus
#define ROC_EDITTEXT_MULTILINE		0x0010	// edittext control is multiline
#define ROC_COLORSWATCH_POINT4		0x0010	// Set if color swatch is a Point4 (FRGBA)
#define ROC_PICKBUTTON_AUTODISP		0x0010	// Set if autoDisplay is turned on for pickbutton (autodisplay node name)

#define ROC_IN_HANDLER				0x0020	// Set if currently running event handler
#define ROC_HANDLER_REENTRANT		0x0040	// Set if rollout control's event handlers are re-entrant. Only case is checkbutton.
#define ROC_EDITTEXT_READONLY		0x0080	// edittext control is read-only

extern LPCTSTR cust_button_class;

/* ------------- PB2Param class -------------------- */

// present in a UI control if rollout is part of a scripted plugin
// and this control is associated with a ParamBlock2  param

class PB2Param
{
public:
	ParamID id;			// pblock param ID
	int index;			// pblock direct index of param
	int tabIndex;		// element index if param is Tab<>
	int	block_id;		// owning block's ID
	int	subobjno;		// texmap or mtl param subobjno in the block
	ParamDimension* dim;// parameter's dimension
	ParamType2 type;	// parameter's type

	PB2Param(ParamDef& pd, int index, int block_id, int subobjno, int tabIndex = -1);
}; 

/* -------------------- LabelControl  ------------------- */

visible_class (LabelControl)

class LabelControl : public RolloutControl
{
public:
				LabelControl(Value* name, Value* caption, Value** keyparms, int keyparm_count)
					: RolloutControl(name, caption, keyparms, keyparm_count) { tag = class_tag(LabelControl); }

    static RolloutControl* create(Value* name, Value* caption, Value** keyparms, int keyparm_count)
							{ return new LabelControl (name, caption, keyparms, keyparm_count); }

				classof_methods (LabelControl, RolloutControl);
	void		collect() { delete this; }
	ScripterExport void		sprin1(CharStream* s) { s->printf(_T("LabelControl:%s"), name->to_string()); }

	LPCTSTR		get_control_class() { return _T("STATIC"); }
	DWORD		get_control_style() { return 0; }
	void		compute_layout(Rollout *ro, layout_data* pos);
};

/* -------------------- ButtonControl  ------------------- */

visible_class (ButtonControl)

class ButtonControl : public RolloutControl
{
public:
	HIMAGELIST	images;
	int			image_width, image_height;
	int			iOutEn, iInEn, iOutDis, iInDis;

				ButtonControl(Value* name, Value* caption, Value** keyparms, int keyparm_count)
					: RolloutControl(name, caption, keyparms, keyparm_count)
						{
							tag = class_tag(ButtonControl);
							images = NULL;
						}
			   ~ButtonControl();

    static RolloutControl* create(Value* name, Value* caption, Value** keyparms, int keyparm_count)
							{ return new ButtonControl (name, caption, keyparms, keyparm_count); }

				classof_methods (ButtonControl, RolloutControl);
	void		collect() { delete this; }
	void		sprin1(CharStream* s) { s->printf(_T("ButtonControl:%s"), name->to_string()); }

	LPCTSTR		get_control_class() { return cust_button_class; }
	void		init_control(HWND control);
	void		compute_layout(Rollout *ro, layout_data* pos);
	BOOL		handle_message(Rollout *ro, UINT message, WPARAM wParam, LPARAM lParam);
	Value*		get_property(Value** arg_list, int count);
	Value*		set_property(Value** arg_list, int count);
	void		set_enable();
};	

/* -------------------- CheckButtonControl  ------------------- */

visible_class (CheckButtonControl)

class CheckButtonControl : public RolloutControl
{
public:
	int			checked;	// LAM - 2/11/02 - changed from BOOL (which is actually an int) since now tristate
	HIMAGELIST	images;
	int			image_width, image_height;
	int			iOutEn, iInEn, iOutDis, iInDis;

				CheckButtonControl(Value* name, Value* caption, Value** keyparms, int keyparm_count)
					: RolloutControl(name, caption, keyparms, keyparm_count)
						{
							tag = class_tag(CheckButtonControl);
							images = NULL;
						}
			   ~CheckButtonControl();

    static RolloutControl* create(Value* name, Value* caption, Value** keyparms, int keyparm_count)
							{ return new CheckButtonControl (name, caption, keyparms, keyparm_count); }

				classof_methods (CheckButtonControl, RolloutControl);
	void		collect() { delete this; }
	void		sprin1(CharStream* s) { s->printf(_T("CheckButtonControl:%s"), name->to_string()); }

	LPCTSTR		get_control_class() { return cust_button_class; }
	void		init_control(HWND control);
	void		compute_layout(Rollout *ro, layout_data* pos);
	BOOL		handle_message(Rollout *ro, UINT message, WPARAM wParam, LPARAM lParam);
	Value*		get_property(Value** arg_list, int count);
	Value*		set_property(Value** arg_list, int count);
	void		set_enable();

	void		Reload();
	void		InvalidateUI();
	void		set_pb2_value();
	void		get_pb2_value(BOOL load_UI=TRUE);
};	

/* -------------------- EditTextControl  ------------------- */

visible_class (EditTextControl)

class EditTextControl : public RolloutControl
{
public:
	Value*		text;
	Value*		bold;
	bool		in_setvalue;

				EditTextControl(Value* name, Value* caption, Value** keyparms, int keyparm_count);

    static RolloutControl* create(Value* name, Value* caption, Value** keyparms, int keyparm_count)
							{ return new EditTextControl (name, caption, keyparms, keyparm_count); }

				classof_methods (EditTextControl, RolloutControl);
	void		collect() { delete this; }
	void		sprin1(CharStream* s) { s->printf(_T("EditTextControl:%s"), name->to_string()); }
	void		gc_trace();

	void		add_control(Rollout *ro, HWND parent, HINSTANCE hInstance, int& current_y);
	LPCTSTR		get_control_class() { return CUSTEDITWINDOWCLASS; }
	void		compute_layout(Rollout *ro, layout_data* pos, int& current_y);
	BOOL		handle_message(Rollout *ro, UINT message, WPARAM wParam, LPARAM lParam);
	Value*		get_property(Value** arg_list, int count);
	Value*		set_property(Value** arg_list, int count);
	void		set_enable();
	int			num_controls() { return 2; }

	void		Reload();
	void		InvalidateUI();
	void		set_pb2_value();
	void		get_pb2_value(BOOL load_UI=TRUE);
};

/* -------------------- ComboBoxControl  ------------------- */

visible_class (ComboBoxControl)

class ComboBoxControl : public RolloutControl
{
public:
	Array*		item_array;
	int			selection;
	short		type;
	short		flags;

				ComboBoxControl(Value* name, Value* caption, Value** keyparms, int keyparm_count, int type = CBS_SIMPLE);

    static RolloutControl* create_cb(Value* name, Value* caption, Value** keyparms, int keyparm_count)
							{ return new ComboBoxControl (name, caption, keyparms, keyparm_count); }
    static RolloutControl* create_dd(Value* name, Value* caption, Value** keyparms, int keyparm_count)
							{ return new ComboBoxControl (name, caption, keyparms, keyparm_count, CBS_DROPDOWNLIST); }

				classof_methods (ComboBoxControl, RolloutControl);
	void		collect() { delete this; }
	void		sprin1(CharStream* s) { s->printf(_T("ComboBoxControl:%s"), name->to_string()); }
	void		gc_trace();

	void		add_control(Rollout *ro, HWND parent, HINSTANCE hInstance, int& current_y);
	LPCTSTR		get_control_class() { return _T("COMBOBOX"); }
	DWORD		get_control_style() { return CBS_DROPDOWNLIST | CBS_NOINTEGRALHEIGHT | WS_TABSTOP; }
	void		compute_layout(Rollout *ro, layout_data* pos, int& current_y);
	BOOL		handle_message(Rollout *ro, UINT message, WPARAM wParam, LPARAM lParam);
	Value*		get_property(Value** arg_list, int count);
	Value*		set_property(Value** arg_list, int count);
	void		set_enable();
	int			num_controls() { return 2; }

	void		Reload();
	void		InvalidateUI();
	void		set_pb2_value();
	void		get_pb2_value(BOOL load_UI=TRUE);
};

#define CBF_EDIT_FIELD_CHANGING		0x0001

/* -------------------- ListBoxControl  ------------------- */

visible_class (ListBoxControl)

class ListBoxControl : public RolloutControl
{
public:
	Array*		item_array;
	int			selection;

				ListBoxControl(Value* name, Value* caption, Value** keyparms, int keyparm_count);

    static RolloutControl* create(Value* name, Value* caption, Value** keyparms, int keyparm_count)
							{ return new ListBoxControl (name, caption, keyparms, keyparm_count); }

				classof_methods (ListBoxControl, RolloutControl);
	void		collect() { delete this; }
	void		sprin1(CharStream* s) { s->printf(_T("ListBoxControl:%s"), name->to_string()); }
	void		gc_trace();

	void		add_control(Rollout *ro, HWND parent, HINSTANCE hInstance, int& current_y);
	LPCTSTR		get_control_class() { return _T("LISTBOX"); }
	DWORD		get_control_style() { return WS_TABSTOP; }
	void		compute_layout(Rollout *ro, layout_data* pos, int& current_y);
	BOOL		handle_message(Rollout *ro, UINT message, WPARAM wParam, LPARAM lParam);
	Value*		get_property(Value** arg_list, int count);
	Value*		set_property(Value** arg_list, int count);
	void		set_enable();
	int			num_controls() { return 2; }

	void		Reload();
	void		InvalidateUI();
	void		set_pb2_value();
	void		get_pb2_value(BOOL load_UI=TRUE);
};

/* -------------------- SpinnerControl  ------------------- */

visible_class (SpinnerControl)

class SpinnerControl : public RolloutControl
{
public:
	float		fvalue;
	int			ivalue;
	float		max, min;
	float		scale;
	EditSpinnerType spin_type;

				SpinnerControl(Value* name, Value* caption, Value** keyparms, int keyparm_count)
					: RolloutControl(name, caption, keyparms, keyparm_count)  { tag = class_tag(SpinnerControl); }

    static RolloutControl* create(Value* name, Value* caption, Value** keyparms, int keyparm_count)
							{ return new SpinnerControl (name, caption, keyparms, keyparm_count); }

				classof_methods (SpinnerControl, RolloutControl);
	void		collect() { delete this; }
	void		sprin1(CharStream* s) { s->printf(_T("SpinnerControl:%s"), name->to_string()); }

	void		add_control(Rollout *ro, HWND parent, HINSTANCE hInstance, int& current_y);
	LPCTSTR		get_control_class() { return SPINNERWINDOWCLASS; }
	void		compute_layout(Rollout *ro, layout_data* pos, int& current_y);
	BOOL		handle_message(Rollout *ro, UINT message, WPARAM wParam, LPARAM lParam);

	Value*		get_property(Value** arg_list, int count);
	Value*		set_property(Value** arg_list, int count);
	void		set_enable();
	BOOL		set_focus();
	int			num_controls() { return 3; }

	void		controller_changed();
	BOOL		controller_ok(Control* c) { return c->SuperClassID() == CTRL_FLOAT_CLASS_ID; }

	void		Reload();
	void		InvalidateUI();
	void		set_pb2_value();
	void		get_pb2_value(BOOL load_UI=TRUE);
};

/* -------------------- SliderControl  ------------------- */

visible_class (SliderControl)

class SliderControl : public RolloutControl
{
public:
	float		value;
	float		max, min;
	int			ticks;
	int			slider_type;
	bool		vertical;
	bool		sliding;

				SliderControl(Value* name, Value* caption, Value** keyparms, int keyparm_count)
					: RolloutControl(name, caption, keyparms, keyparm_count), sliding(false)  { tag = class_tag(SliderControl); }

    static RolloutControl* create(Value* name, Value* caption, Value** keyparms, int keyparm_count)
							{ return new SliderControl (name, caption, keyparms, keyparm_count); }

				classof_methods (SliderControl, RolloutControl);
	void		collect() { delete this; }
	void		sprin1(CharStream* s) { s->printf(_T("SliderControl:%s"), name->to_string()); }

	void		add_control(Rollout *ro, HWND parent, HINSTANCE hInstance, int& current_y);
	LPCTSTR		get_control_class() { return TRACKBAR_CLASS; }
	void		compute_layout(Rollout *ro, layout_data* pos, int& current_y);
	BOOL		handle_message(Rollout *ro, UINT message, WPARAM wParam, LPARAM lParam);

	Value*		get_property(Value** arg_list, int count);
	Value*		set_property(Value** arg_list, int count);
	void		set_enable();
	int			num_controls() { return 2; }

	void		Reload();
	void		InvalidateUI();
	void		set_pb2_value();
	void		get_pb2_value(BOOL load_UI=TRUE);
};

/* -------------------- PickerControl  ------------------- */

class PickerControl;

class PickerControlFilter : public PickNodeCallback
{
public:
		Value*	filter_fn;
		PickerControl*  picker;

			    PickerControlFilter(Value* filter, PickerControl* picker) : filter_fn(filter), picker(picker) { }
		BOOL	Filter(INode *node);
};

class PickerControlMode : public PickModeCallback
{
public:
		PickerControlFilter* pick_filter;
		TCHAR*			msg;
		PickerControl*  picker;

		PickerControlMode(PickerControlFilter* ifilter, TCHAR* imsg, PickerControl* ipick);

		BOOL	HitTest(IObjParam *ip, HWND hWnd, ViewExp *vpt, IPoint2 m, int flags);
		BOOL	Pick(IObjParam *ip, ViewExp *vpt);
		PickNodeCallback *GetFilter() { return pick_filter; }
		BOOL	RightClick(IObjParam *ip, ViewExp *vpt) { return TRUE; }
		void	EnterMode(IObjParam *ip);
		void	ExitMode(IObjParam *ip);
};

visible_class (PickerControl)

class PickerControl : public RolloutControl
{
public:
	PickerControlFilter* pick_filter;
	PickerControlMode*   pick_mode;
    ICustButton*		 cust_button; 
	Value*				 picked_object;

				PickerControl(Value* name, Value* caption, Value** keyparms, int keyparm_count);
			   ~PickerControl();

    static RolloutControl* create(Value* name, Value* caption, Value** keyparms, int keyparm_count)
							{ return new PickerControl (name, caption, keyparms, keyparm_count); }

				classof_methods (PickerControl, RolloutControl);
	void		collect() { delete this; }
	void		gc_trace();
	void		sprin1(CharStream* s) { s->printf(_T("PickerControl:%s"), name->to_string()); }

	LPCTSTR		get_control_class() { return cust_button_class; }
	void		compute_layout(Rollout *ro, layout_data* pos);
	void		init_control(HWND control);
	BOOL		handle_message(Rollout *ro, UINT message, WPARAM wParam, LPARAM lParam);
	Value*		get_property(Value** arg_list, int count);
	Value*		set_property(Value** arg_list, int count);
	void		set_enable();

	void		Reload();
	void		InvalidateUI();
	void		set_pb2_value();
	void		get_pb2_value(BOOL load_UI=TRUE);
};

/* -------------------- ColorPickerControl  ------------------- */

visible_class (ColorPickerControl)

class ColorPickerControl : public RolloutControl
{
public:
	Value*		  color;
    IColorSwatch* csw;
	Value*		  title;

				ColorPickerControl(Value* name, Value* caption, Value** keyparms, int keyparm_count);
			   ~ColorPickerControl();

    static RolloutControl* create(Value* name, Value* caption, Value** keyparms, int keyparm_count)
							{ return new ColorPickerControl (name, caption, keyparms, keyparm_count); }

				classof_methods (ColorPickerControl, RolloutControl);
	void		collect() { delete this; }
	void		gc_trace();
	void		sprin1(CharStream* s) { s->printf(_T("ColorPickerControl:%s"), name->to_string()); }

	LPCTSTR		get_control_class() { return COLORSWATCHWINDOWCLASS; }
	void		init_control(HWND control);
	void		add_control(Rollout *ro, HWND parent, HINSTANCE hInstance, int& current_y);
	void		compute_layout(Rollout *ro, layout_data* pos, int& current_y);
	BOOL		handle_message(Rollout *ro, UINT message, WPARAM wParam, LPARAM lParam);
	Value*		get_property(Value** arg_list, int count);
	Value*		set_property(Value** arg_list, int count);
	void		set_enable();
	int			num_controls() { return 2; }

	void		Reload();
	void		InvalidateUI();
	void		set_pb2_value();
	void		get_pb2_value(BOOL load_UI=TRUE);
};

/* -------------------- RadioControl  ------------------- */

visible_class (RadioControl)

class RadioControl : public RolloutControl
{
public:
	int			state;
	int			btn_count;

				RadioControl(Value* name, Value* caption, Value** keyparms, int keyparm_count)
					: RolloutControl(name, caption, keyparms, keyparm_count)  { tag = class_tag(RadioControl); }

    static RolloutControl* create(Value* name, Value* caption, Value** keyparms, int keyparm_count)
							{ return new RadioControl (name, caption, keyparms, keyparm_count); }

				classof_methods (RadioControl, RolloutControl);
	void		collect() { delete this; }
	void		sprin1(CharStream* s) { s->printf(_T("RadioControl:%s"), name->to_string()); }

	void		add_control(Rollout *ro, HWND parent, HINSTANCE hInstance, int& current_y);
	LPCTSTR		get_control_class() { return _T("BUTTON"); }
	DWORD		get_control_style() {  return BS_AUTORADIOBUTTON; }
	void		compute_layout(Rollout *ro, layout_data* pos, int& current_y);
	BOOL		handle_message(Rollout *ro, UINT message, WPARAM wParam, LPARAM lParam);

	Value*		get_property(Value** arg_list, int count);
	Value*		set_property(Value** arg_list, int count);
	void		set_enable();
	BOOL		set_focus();
	int			num_controls() { return btn_count + 1; } // buttons and caption. don't count 1 dummy button that ends group

	void		Reload();
	void		InvalidateUI();
	void		set_pb2_value();
	void		get_pb2_value(BOOL load_UI=TRUE);
};

/* -------------------- CheckBoxControl  ------------------- */

visible_class (CheckBoxControl)

class CheckBoxControl : public RolloutControl
{
public:
	int			checked; // LAM - 2/11/02 - added 3rd state (indeterminate). Changed from BOOL to int just for clarity.

				CheckBoxControl(Value* name, Value* caption, Value** keyparms, int keyparm_count)
					: RolloutControl(name, caption, keyparms, keyparm_count)  { tag = class_tag(CheckBoxControl); }

    static RolloutControl* create(Value* name, Value* caption, Value** keyparms, int keyparm_count)
							{ return new CheckBoxControl (name, caption, keyparms, keyparm_count); }

				classof_methods (CheckBoxControl, RolloutControl);
	void		collect() { delete this; }
	void		sprin1(CharStream* s) { s->printf(_T("CheckBoxControl:%s"), name->to_string()); }

	LPCTSTR		get_control_class() { return _T("BUTTON"); }
	DWORD		get_control_style() {  return BS_AUTO3STATE | WS_TABSTOP; }
	void		init_control(HWND control);
	void		compute_layout(Rollout *ro, layout_data* pos);
	BOOL		handle_message(Rollout *ro, UINT message, WPARAM wParam, LPARAM lParam);

	Value*		get_property(Value** arg_list, int count);
	Value*		set_property(Value** arg_list, int count);

	void		Reload();
	void		InvalidateUI();
	void		set_pb2_value();
	void		get_pb2_value(BOOL load_UI=TRUE);
};

/* -------------------- BitmapControl  ------------------- */

visible_class (BitmapControl)

class BitmapControl : public RolloutControl
{
public:
	Value*		file_name;
	Value*		max_bitmap;    // if supplied
	HBITMAP		bitmap;

				BitmapControl(Value* name, Value* caption, Value** keyparms, int keyparm_count);
			   ~BitmapControl();

    static RolloutControl* create(Value* name, Value* caption, Value** keyparms, int keyparm_count)
							{ return new BitmapControl (name, caption, keyparms, keyparm_count); }

				classof_methods (BitmapControl, RolloutControl);
	void		collect() { delete this; }
	void		sprin1(CharStream* s) { s->printf(_T("BitmapControl:%s"), name->to_string()); }
	void		gc_trace();

	LPCTSTR		get_control_class() { return _T("STATIC"); }
	DWORD		get_control_style() { return SS_BITMAP + SS_CENTERIMAGE; }
	DWORD		get_control_ex_style() { return WS_EX_CLIENTEDGE; }
	void		compute_layout(Rollout *ro, layout_data* pos);
	void		process_layout_params(Rollout *ro, layout_data* pos, int& current_y);
	void		init_control(HWND control);
	Value*		get_property(Value** arg_list, int count);
	Value*		set_property(Value** arg_list, int count);
};

/* -------------------- MapButtonControl  ------------------- */

visible_class (MapButtonControl)

class MapButtonControl : public ButtonControl
{
public:
		Value*       map;
		ICustButton* btn;

				MapButtonControl(Value* name, Value* caption, Value** keyparms, int keyparm_count)
					: ButtonControl(name, caption, keyparms, keyparm_count)
						{
							tag = class_tag(MapButtonControl);
							btn = NULL;
							map = NULL;
						}
				~MapButtonControl() { if (btn != NULL) ReleaseICustButton(btn); }

    static RolloutControl* create(Value* name, Value* caption, Value** keyparms, int keyparm_count)
							{ return new MapButtonControl (name, caption, keyparms, keyparm_count); }

				classof_methods (MapButtonControl, RolloutControl);
	void		gc_trace();
	void		collect() { delete this; }
	void		sprin1(CharStream* s) { s->printf(_T("MapButtonControl:%s"), name->to_string()); }

	void		init_control(HWND control);
	BOOL		handle_message(Rollout *ro, UINT message, WPARAM wParam, LPARAM lParam);
	Value*		get_property(Value** arg_list, int count);
	Value*		set_property(Value** arg_list, int count);

	void		Reload();
	void		InvalidateUI();
	void		set_pb2_value();
	void		get_pb2_value(BOOL load_UI=TRUE);

	void		SetTexDADMgr(DADMgr* dad) { if (btn) btn->SetDADMgr(dad); }
	int			FindSubTexFromHWND(HWND hw);
};	

/* -------------------- MtlButtonControl  ------------------- */

visible_class (MtlButtonControl)

class MtlButtonControl : public ButtonControl
{
public:
		Value*		 mtl;
		ICustButton* btn;

				MtlButtonControl(Value* name, Value* caption, Value** keyparms, int keyparm_count)
					: ButtonControl(name, caption, keyparms, keyparm_count)
						{
							tag = class_tag(MtlButtonControl);
							btn = NULL;
							mtl = NULL;
						}
				~MtlButtonControl() { if (btn != NULL) ReleaseICustButton(btn); }

    static RolloutControl* create(Value* name, Value* caption, Value** keyparms, int keyparm_count)
							{ return new MtlButtonControl (name, caption, keyparms, keyparm_count); }

				classof_methods (MtlButtonControl, RolloutControl);
	void		gc_trace();
	void		collect() { delete this; }
	void		sprin1(CharStream* s) { s->printf(_T("MtlButtonControl:%s"), name->to_string()); }

	void		init_control(HWND control);
	BOOL		handle_message(Rollout *ro, UINT message, WPARAM wParam, LPARAM lParam);
	Value*		get_property(Value** arg_list, int count);
	Value*		set_property(Value** arg_list, int count);
	void		set_enable();

	void		Reload();
	void		InvalidateUI();
	void		set_pb2_value();
	void		get_pb2_value(BOOL load_UI=TRUE);

	void		SetMtlDADMgr(DADMgr* dad) { if (btn) btn->SetDADMgr(dad); }
	int			FindSubMtlFromHWND(HWND hw);
};	

/* ----------------------- GroupControls  ---------------------- */

visible_class (GroupStartControl)

class GroupStartControl : public RolloutControl
{
public:
	int		start_y;			/* y coord of top of group */

			GroupStartControl(Value* caption)
				: RolloutControl(NULL, caption, NULL, 0)  { tag = class_tag(GroupStartControl); }

			classof_methods (GroupStartControl, RolloutControl);
	void	collect() { delete this; }
	void	sprin1(CharStream* s) { s->printf(_T("GroupStartControl:%s"), caption->to_string()); }

	void	add_control(Rollout *ro, HWND parent, HINSTANCE hInstance, int& current_y);
	LPCTSTR	get_control_class() { return _T(""); }
	void	compute_layout(Rollout *ro, layout_data* pos) { }
};

visible_class (GroupEndControl)

class GroupEndControl : public RolloutControl
{
	GroupStartControl* my_start;			/* link back to my group start control */
public:
			GroupEndControl(GroupStartControl* starter)
				: RolloutControl(NULL, starter->caption, NULL, 0) { tag = class_tag(GroupEndControl); my_start = starter; }

			classof_methods (GroupEndControl, RolloutControl);
	void	collect() { delete this; }
	void	sprin1(CharStream* s) { s->printf(_T("GroupEndControl:%s"), caption->to_string()); }

	void	add_control(Rollout *ro, HWND parent, HINSTANCE hInstance, int& current_y);
	LPCTSTR	get_control_class() { return _T(""); }
	void	compute_layout(Rollout *ro, layout_data* pos) { }
};

// ---- time change callback for rollouts with controller-linked spinners in them ----

class RolloutChangeCallback : public TimeChangeCallback
{
public:
	Rollout*	ro;
				RolloutChangeCallback(Rollout* iro) { ro = iro; }
	void		TimeChanged(TimeValue t) { ro->TimeChanged(t); }
};

/* control keyword parameter access macros... */

extern ScripterExport Value* _get_control_param(Value** keyparms, int count, Value* key_name);
extern ScripterExport Value* _get_control_param_or_default(Value** keyparms, int count, Value* key_name, Value* def);

#define control_param(key)					_get_control_param(keyparms, keyparm_count, n_##key)
#define control_param_or_default(key, def)	_get_control_param_or_default(keyparms, keyparm_count, n_##key##, def)
#define int_control_param(key, var, def)	((var = _get_control_param(keyparms, keyparm_count, n_##key)) == &unsupplied ? def : var->to_int())
#define float_control_param(key, var, def)	((var = _get_control_param(keyparms, keyparm_count, n_##key)) == &unsupplied ? def : var->to_float())

#endif