#include "..\kernel\value.h"#include "..\foundation\streams.h"#include "..\..\custcont.h"#include "..\..\control.h"#include "..\..\maxapi.h"Go to the source code of this file.
Classes |
|
| struct | layout_data |
| class | PB2Param |
| class | PickerControlFilter |
| class | PickerControlMode |
| class | RolloutChangeCallback |
Defines |
|
| #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 |
| #define | is_rollout(v) ((DbgVerify(!is_sourcepositionwrapper(v)), (v))->tag == class_tag(Rollout)) |
| #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 |
| #define | is_rolloutfloater(v) ((DbgVerify(!is_sourcepositionwrapper(v)), (v))->tag == class_tag(RolloutFloater)) |
| #define | is_rolloutcontrol(v) ((v)->_is_rolloutcontrol()) |
| #define | ROC_FIXED_WIDTH 0x0001 |
| #define | ROC_MAKING_EDIT 0x0002 |
| #define | ROC_INVISIBLE 0x0004 |
| #define | ROC_VAL_CHANGED 0x0008 |
| #define | ROC_EDITTEXT_MULTILINE 0x0010 |
| #define | ROC_COLORSWATCH_POINT4 0x0010 |
| #define | ROC_PICKBUTTON_AUTODISP 0x0010 |
| #define | ROC_SPINNER_KEYBRACKETS 0x0010 |
| #define | ROC_IN_HANDLER 0x0020 |
| #define | ROC_HANDLER_REENTRANT 0x0040 |
| #define | ROC_EDITTEXT_READONLY 0x0080 |
| #define | ROC_DELETE_TOOLTIP 0x0100 |
| #define | CBF_EDIT_FIELD_CHANGING 0x0001 |
| #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()) |
Functions |
|
| visible_class_debug_ok (Rollout) class Rollout | |
| visible_class (RolloutFloater) class RolloutFloater | |
| visible_class (RolloutControl) class RolloutControl | |
| visible_class (LabelControl) class LabelControl | |
| visible_class (ButtonControl) class ButtonControl | |
| visible_class (CheckButtonControl) class CheckButtonControl | |
| visible_class (EditTextControl) class EditTextControl | |
| visible_class (ComboBoxControl) class ComboBoxControl | |
| visible_class (ListBoxControl) class ListBoxControl | |
| visible_class (SpinnerControl) class SpinnerControl | |
| visible_class (SliderControl) class SliderControl | |
| visible_class (PickerControl) class PickerControl | |
| visible_class (ColorPickerControl) class ColorPickerControl | |
| visible_class (RadioControl) class RadioControl | |
| visible_class (CheckBoxControl) class CheckBoxControl | |
| visible_class (BitmapControl) class BitmapControl | |
| visible_class (MapButtonControl) class MapButtonControl | |
| visible_class (MtlButtonControl) class MtlButtonControl | |
| visible_class (GroupStartControl) class GroupStartControl | |
| visible_class (GroupEndControl) class GroupEndControl | |
| ScripterExport Value * | _get_control_param (Value **keyparms, int count, Value *key_name) |
| ScripterExport Value * | _get_control_param_or_default (Value **keyparms, int count, Value *key_name, Value *def) |
Variables |
|
| LPCMSTR | cust_button_class |
Define Documentation
| #define TOP_MARGIN 2 |
Definition at line 34 of file rollouts.h.
| #define SIDE_MARGIN 4 |
Definition at line 35 of file rollouts.h.
| #define RADIO_DOT_WIDTH 23 |
Definition at line 36 of file rollouts.h.
| #define CHECK_BOX_WIDTH 24 |
Definition at line 37 of file rollouts.h.
| #define LEFT_ALIGN 13 |
Definition at line 38 of file rollouts.h.
| #define RIGHT_ALIGN 13 |
Definition at line 39 of file rollouts.h.
| #define GROUP_BOX_Y_MARGIN 6 |
Definition at line 40 of file rollouts.h.
| #define GROUP_BOX_X_MARGIN 4 |
Definition at line 41 of file rollouts.h.
| #define SPACING_BEFORE 5 |
Definition at line 42 of file rollouts.h.
| #define is_rollout | ( | v | ) | ((DbgVerify(!is_sourcepositionwrapper(v)), (v))->tag == class_tag(Rollout)) |
| #define RO_NO_CLOSEBUTTON 0x0001 |
Definition at line 151 of file rollouts.h.
| #define RO_HIDDEN 0x0002 |
Definition at line 152 of file rollouts.h.
| #define RO_ROLLED_UP 0x0004 |
Definition at line 153 of file rollouts.h.
| #define RO_IN_FLOATER 0x0008 |
Definition at line 154 of file rollouts.h.
| #define RO_INSTALLED 0x0010 |
Definition at line 155 of file rollouts.h.
| #define RO_UTIL_MASTER 0x0020 |
Definition at line 156 of file rollouts.h.
| #define RO_SILENT_ERRORS 0x0040 |
Definition at line 157 of file rollouts.h.
| #define RO_HIDDEN2 0x0080 |
Definition at line 158 of file rollouts.h.
| #define RO_PLUGIN_OWNED 0x0100 |
Definition at line 159 of file rollouts.h.
| #define RO_CONTROLS_INSTALLED 0x0200 |
Definition at line 160 of file rollouts.h.
| #define is_rolloutfloater | ( | v | ) | ((DbgVerify(!is_sourcepositionwrapper(v)), (v))->tag == class_tag(RolloutFloater)) |
| #define is_rolloutcontrol | ( | v | ) | ((v)->_is_rolloutcontrol()) |
| #define ROC_FIXED_WIDTH 0x0001 |
Definition at line 296 of file rollouts.h.
| #define ROC_MAKING_EDIT 0x0002 |
Definition at line 297 of file rollouts.h.
| #define ROC_INVISIBLE 0x0004 |
Definition at line 298 of file rollouts.h.
| #define ROC_VAL_CHANGED 0x0008 |
Definition at line 299 of file rollouts.h.
| #define ROC_EDITTEXT_MULTILINE 0x0010 |
Definition at line 300 of file rollouts.h.
| #define ROC_COLORSWATCH_POINT4 0x0010 |
Definition at line 301 of file rollouts.h.
| #define ROC_PICKBUTTON_AUTODISP 0x0010 |
Definition at line 302 of file rollouts.h.
| #define ROC_SPINNER_KEYBRACKETS 0x0010 |
Definition at line 303 of file rollouts.h.
| #define ROC_IN_HANDLER 0x0020 |
Definition at line 305 of file rollouts.h.
| #define ROC_HANDLER_REENTRANT 0x0040 |
Definition at line 306 of file rollouts.h.
| #define ROC_EDITTEXT_READONLY 0x0080 |
Definition at line 307 of file rollouts.h.
| #define ROC_DELETE_TOOLTIP 0x0100 |
Definition at line 309 of file rollouts.h.
| #define CBF_EDIT_FIELD_CHANGING 0x0001 |
Definition at line 516 of file rollouts.h.
| #define control_param | ( | key | ) | _get_control_param(keyparms, keyparm_count, n_##key) |
Definition at line 989 of file rollouts.h.
| #define control_param_or_default | ( | key, | |
| def | |||
| ) | _get_control_param_or_default(keyparms, keyparm_count, n_##key##, def) |
Definition at line 990 of file rollouts.h.
| #define int_control_param | ( | key, | |
| var, | |||
| def | |||
| ) | ((var = _get_control_param(keyparms, keyparm_count, n_##key)) == &unsupplied ? def : var->to_int()) |
Definition at line 991 of file rollouts.h.
| #define float_control_param | ( | key, | |
| var, | |||
| def | |||
| ) | ((var = _get_control_param(keyparms, keyparm_count, n_##key)) == &unsupplied ? def : var->to_float()) |
Definition at line 992 of file rollouts.h.
Function Documentation
| visible_class_debug_ok | ( | Rollout | ) |
Definition at line 61 of file rollouts.h.
: 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();
static void ColorChangeNotifyProc(void* param, NotifyInfo* pInfo);
# define is_rollout(v) ((DbgVerify(!is_sourcepositionwrapper(v)), (v))->tag == class_tag(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);
ScripterExport bool has_event_handler(Value* event); // return true if event handler defined for rollout
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);
// added 3/21/05. Used by debugger to dump locals and externals to standard out
void dump_local_vars_and_externals(int indentLevel);
};
| visible_class | ( | RolloutFloater | ) |
Definition at line 164 of file rollouts.h.
: public Value, public IRollupCallback
{
public:
//NOTE: May be null. All affected code should have null checking
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(HWND hWnd);
RolloutFloater(MCHAR* 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();
# define is_rolloutfloater(v) ((DbgVerify(!is_sourcepositionwrapper(v)), (v))->tag == class_tag(RolloutFloater))
void HandleDestroy(); // from IRollupCallback
classof_methods (RolloutFloater, Value);
void collect() { delete this; }
// Needed to solve ambiguity between Collectable's operators and MaxHeapOperators
using Collectable::operator new;
using Collectable::operator delete;
void add_rollout(Rollout* ro, BOOL rolledUp, BOOL borderless);
void remove_rollout(Rollout* ro);
Value* get_property(Value** arg_list, int count);
Value* set_property(Value** arg_list, int count);
};
| visible_class | ( | RolloutControl | ) |
Definition at line 208 of file rollouts.h.
: 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(v) ((v)->_is_rolloutcontrol())
void collect() { delete this; }
ScripterExport void gc_trace();
// Needed to solve ambiguity between Collectable's operators and MaxHeapOperators
using Collectable::operator new;
using Collectable::operator delete;
virtual ScripterExport void add_control(Rollout *ro, HWND parent, HINSTANCE hInstance, int& current_y);
virtual LPCMSTR 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(MCHAR* 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);
// Animatable
virtual Class_ID ClassID() { return Class_ID(0x3d063ac9, 0x7136487c); }
// ReferenceMaker
int NumRefs() { return 1; }
RefTargetHandle GetReference(int i) { return controller; }
protected:
virtual void SetReference(int i, RefTargetHandle rtarg) { controller = (Control*)rtarg; }
public:
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; }
// added for r8. wraps handler function in a PluginMethod pointing at scripted plugin associated with rollout
ScripterExport Value* get_wrapped_event_handler(Value* event);
// added for r11
HWND GetHWND();
};
| visible_class | ( | LabelControl | ) |
Definition at line 334 of file rollouts.h.
: 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(_M("LabelControl:%s"), name->to_string()); }
LPCMSTR get_control_class() { return _M("STATIC"); }
DWORD get_control_style();
void compute_layout(Rollout *ro, layout_data* pos);
};
| visible_class | ( | ButtonControl | ) |
Definition at line 356 of file rollouts.h.
: public RolloutControl
{
public:
HIMAGELIST images;
int image_width, image_height;
int iOutEn, iInEn, iOutDis, iInDis;
MSTR m_toolTip;
int colortheme;
MSTR images_filename;
ButtonControl(Value* name, Value* caption, Value** keyparms, int keyparm_count)
: RolloutControl(name, caption, keyparms, keyparm_count)
{
tag = class_tag(ButtonControl);
images = NULL;
colortheme = FALSE;
}
~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(_M("ButtonControl:%s"), name->to_string()); }
void ColorChangeNotifyProc(void* param, NotifyInfo* pInfo);
LPCMSTR 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();
};
| visible_class | ( | CheckButtonControl | ) |
Definition at line 396 of file rollouts.h.
: 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;
MSTR m_toolTip;
int colortheme;
MSTR images_filename;
CheckButtonControl(Value* name, Value* caption, Value** keyparms, int keyparm_count)
: RolloutControl(name, caption, keyparms, keyparm_count)
{
tag = class_tag(CheckButtonControl);
images = NULL;
colortheme = FALSE;
}
~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(_M("CheckButtonControl:%s"), name->to_string()); }
void ColorChangeNotifyProc(void* param, NotifyInfo* pInfo);
LPCMSTR 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);
};
| visible_class | ( | EditTextControl | ) |
Definition at line 442 of file rollouts.h.
: 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(_M("EditTextControl:%s"), name->to_string()); }
void gc_trace();
void add_control(Rollout *ro, HWND parent, HINSTANCE hInstance, int& current_y);
LPCMSTR 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);
};
| visible_class | ( | ComboBoxControl | ) |
Definition at line 478 of file rollouts.h.
: 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(_M("ComboBoxControl:%s"), name->to_string()); }
void gc_trace();
void add_control(Rollout *ro, HWND parent, HINSTANCE hInstance, int& current_y);
LPCMSTR get_control_class() { return _M("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);
};
| visible_class | ( | ListBoxControl | ) |
Definition at line 520 of file rollouts.h.
: 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(_M("ListBoxControl:%s"), name->to_string()); }
void gc_trace();
void add_control(Rollout *ro, HWND parent, HINSTANCE hInstance, int& current_y);
LPCMSTR get_control_class() { return _M("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);
};
| visible_class | ( | SpinnerControl | ) |
Definition at line 556 of file rollouts.h.
: 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(_M("SpinnerControl:%s"), name->to_string()); }
void add_control(Rollout *ro, HWND parent, HINSTANCE hInstance, int& current_y);
LPCMSTR 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);
};
| visible_class | ( | SliderControl | ) |
Definition at line 599 of file rollouts.h.
: 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(_M("SliderControl:%s"), name->to_string()); }
void add_control(Rollout *ro, HWND parent, HINSTANCE hInstance, int& current_y);
LPCMSTR get_control_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 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);
};
| visible_class | ( | PickerControl | ) |
Definition at line 671 of file rollouts.h.
: public RolloutControl
{
public:
PickerControlFilter* pick_filter;
PickerControlMode* pick_mode;
ICustButton* cust_button;
Value* picked_object;
MSTR m_toolTip;
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(_M("PickerControl:%s"), name->to_string()); }
LPCMSTR 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);
};
| visible_class | ( | ColorPickerControl | ) |
Definition at line 709 of file rollouts.h.
: public RolloutControl
{
public:
Value* color;
IColorSwatch* csw;
Value* title;
BOOL notifyAfterAccept;
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(_M("ColorPickerControl:%s"), name->to_string()); }
LPCMSTR 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);
};
| visible_class | ( | RadioControl | ) |
Definition at line 748 of file rollouts.h.
: 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(_M("RadioControl:%s"), name->to_string()); }
void add_control(Rollout *ro, HWND parent, HINSTANCE hInstance, int& current_y);
LPCMSTR get_control_class() { return _M("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);
};
| visible_class | ( | CheckBoxControl | ) |
Definition at line 786 of file rollouts.h.
: 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(_M("CheckBoxControl:%s"), name->to_string()); }
LPCMSTR get_control_class() { return _M("BUTTON"); }
DWORD get_control_style() { return BS_AUTO3STATE | BS_MULTILINE | 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);
};
| visible_class | ( | BitmapControl | ) |
Definition at line 820 of file rollouts.h.
: 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(_M("BitmapControl:%s"), name->to_string()); }
void gc_trace();
LPCMSTR get_control_class() { return _M("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);
};
| visible_class | ( | MapButtonControl | ) |
Definition at line 852 of file rollouts.h.
: 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(_M("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);
};
| visible_class | ( | MtlButtonControl | ) |
Definition at line 893 of file rollouts.h.
: 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(_M("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);
};
| visible_class | ( | GroupStartControl | ) |
Definition at line 935 of file rollouts.h.
: public RolloutControl
{
public:
int start_y; /* y coord of top of group */
GroupStartControl(Value* caption)
: RolloutControl(NULL, caption, NULL, 0)
{ tag = class_tag(GroupStartControl); flags |= ROC_FIXED_WIDTH; }
classof_methods (GroupStartControl, RolloutControl);
void collect() { delete this; }
void sprin1(CharStream* s) { s->printf(_M("GroupStartControl:%s"), caption->to_string()); }
void add_control(Rollout *ro, HWND parent, HINSTANCE hInstance, int& current_y);
LPCMSTR get_control_class() { return _M(""); }
void compute_layout(Rollout *ro, layout_data* pos) { }
};
| visible_class | ( | GroupEndControl | ) |
Definition at line 955 of file rollouts.h.
: 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; flags |= ROC_FIXED_WIDTH;}
classof_methods (GroupEndControl, RolloutControl);
void collect() { delete this; }
void sprin1(CharStream* s) { s->printf(_M("GroupEndControl:%s"), caption->to_string()); }
void add_control(Rollout *ro, HWND parent, HINSTANCE hInstance, int& current_y);
LPCMSTR get_control_class() { return _M(""); }
void compute_layout(Rollout *ro, layout_data* pos) { }
};
