DOOM-3-BFG

MenuWidget.h (40639B)

---

 /*
 ===========================================================================
 
 Doom 3 BFG Edition GPL Source Code
 Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company. 
 
 This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").  
 
 Doom 3 BFG Edition Source Code is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.
 
 Doom 3 BFG Edition Source Code is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with Doom 3 BFG Edition Source Code.  If not, see <http://www.gnu.org/licenses/>.
 
 In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code.  If not, please request a copy in writing from id Software at the address below.
 
 If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
 
 ===========================================================================
 */
 #ifndef __MENU_WIDGET_H__
 #define __MENU_WIDGET_H__
 
 class idMenuHandler;
 class idMenuWidget;
 
 enum menuOption_t {
 	OPTION_INVALID = -1,
 	OPTION_BUTTON_TEXT,
 	OPTION_SLIDER_BAR,
 	OPTION_SLIDER_TEXT,
 	OPTION_SLIDER_TOGGLE,
 	OPTION_BUTTON_INFO,
 	OPTION_BUTTON_FULL_TEXT_SLIDER,
 	MAX_MENU_OPTION_TYPES
 };
 
 enum widgetEvent_t {
 	WIDGET_EVENT_PRESS,
 	WIDGET_EVENT_RELEASE,
 	WIDGET_EVENT_ROLL_OVER,
 	WIDGET_EVENT_ROLL_OUT,
 	WIDGET_EVENT_FOCUS_ON,
 	WIDGET_EVENT_FOCUS_OFF,
 	
 	WIDGET_EVENT_SCROLL_UP_LSTICK,
 	WIDGET_EVENT_SCROLL_UP_LSTICK_RELEASE,
 	WIDGET_EVENT_SCROLL_DOWN_LSTICK,
 	WIDGET_EVENT_SCROLL_DOWN_LSTICK_RELEASE,
 	WIDGET_EVENT_SCROLL_LEFT_LSTICK,
 	WIDGET_EVENT_SCROLL_LEFT_LSTICK_RELEASE,
 	WIDGET_EVENT_SCROLL_RIGHT_LSTICK,
 	WIDGET_EVENT_SCROLL_RIGHT_LSTICK_RELEASE,
 
 	WIDGET_EVENT_SCROLL_UP_RSTICK,
 	WIDGET_EVENT_SCROLL_UP_RSTICK_RELEASE,
 	WIDGET_EVENT_SCROLL_DOWN_RSTICK,
 	WIDGET_EVENT_SCROLL_DOWN_RSTICK_RELEASE,
 	WIDGET_EVENT_SCROLL_LEFT_RSTICK,
 	WIDGET_EVENT_SCROLL_LEFT_RSTICK_RELEASE,
 	WIDGET_EVENT_SCROLL_RIGHT_RSTICK,
 	WIDGET_EVENT_SCROLL_RIGHT_RSTICK_RELEASE,
 
 	WIDGET_EVENT_SCROLL_UP,
 	WIDGET_EVENT_SCROLL_UP_RELEASE,
 	WIDGET_EVENT_SCROLL_DOWN,
 	WIDGET_EVENT_SCROLL_DOWN_RELEASE,
 	WIDGET_EVENT_SCROLL_LEFT,
 	WIDGET_EVENT_SCROLL_LEFT_RELEASE,
 	WIDGET_EVENT_SCROLL_RIGHT,
 	WIDGET_EVENT_SCROLL_RIGHT_RELEASE,
 
 	WIDGET_EVENT_DRAG_START,
 	WIDGET_EVENT_DRAG_STOP,
 
 	WIDGET_EVENT_SCROLL_PAGEDWN,
 	WIDGET_EVENT_SCROLL_PAGEDWN_RELEASE,
 	WIDGET_EVENT_SCROLL_PAGEUP,
 	WIDGET_EVENT_SCROLL_PAGEUP_RELEASE,
 
 	WIDGET_EVENT_SCROLL,
 	WIDGET_EVENT_SCROLL_RELEASE,
 	WIDGET_EVENT_BACK,
 	WIDGET_EVENT_COMMAND,
 	WIDGET_EVENT_TAB_NEXT,
 	WIDGET_EVENT_TAB_PREV,
 	MAX_WIDGET_EVENT
 };
 
 enum scrollType_t {
 	SCROLL_SINGLE,		// scroll a single unit
 	SCROLL_PAGE,		// scroll a page
 	SCROLL_FULL,		// scroll all the way to the end
 	SCROLL_TOP,			// scroll to the first selection
 	SCROLL_END,			// scroll to the last selection
 };
 
 enum widgetAction_t {
 	WIDGET_ACTION_NONE,
 	WIDGET_ACTION_COMMAND,
 	WIDGET_ACTION_FUNCTION,					// call the SWF function
 	WIDGET_ACTION_SCROLL_VERTICAL,			// scroll something. takes one param = amount to scroll (can be negative)
 	WIDGET_ACTION_SCROLL_VERTICAL_VARIABLE,
 	WIDGET_ACTION_SCROLL_PAGE,
 	WIDGET_ACTION_SCROLL_HORIZONTAL,		// scroll something. takes one param = amount to scroll (can be negative)
 	WIDGET_ACTION_SCROLL_TAB,
 	WIDGET_ACTION_START_REPEATER,
 	WIDGET_ACTION_STOP_REPEATER,
 	WIDGET_ACTION_ADJUST_FIELD,
 	WIDGET_ACTION_PRESS_FOCUSED,
 	WIDGET_ACTION_JOY3_ON_PRESS,
 	WIDGET_ACTION_JOY4_ON_PRESS,
 	//
 	WIDGET_ACTION_GOTO_MENU,
 	WIDGET_ACTION_GO_BACK,
 	WIDGET_ACTION_EXIT_GAME,
 	WIDGET_ACTION_LAUNCH_MULTIPLAYER,
 	WIDGET_ACTION_MENU_BAR_SELECT,
 	WIDGET_ACTION_EMAIL_HOVER,
 	// PDA USER DATA ACTIONS
 	WIDGET_ACTION_PDA_SELECT_USER,
 	WIDGET_ACTION_SELECT_GAMERTAG,
 	WIDGET_ACTION_PDA_SELECT_NAV,
 	WIDGET_ACTION_SELECT_PDA_AUDIO,
 	WIDGET_ACTION_SELECT_PDA_VIDEO,
 	WIDGET_ACTION_SELECT_PDA_ITEM,
 	WIDGET_ACTION_SCROLL_DRAG,
 	// PDA EMAIL ACTIONS
 	WIDGET_ACTION_PDA_SELECT_EMAIL,
 	WIDGET_ACTION_PDA_CLOSE,
 	WIDGET_ACTION_REFRESH,
 	WIDGET_ACTION_MUTE_PLAYER,
 	MAX_WIDGET_ACTION
 };
 
 enum actionHandler_t {
 	WIDGET_ACTION_EVENT_SCROLL_UP_START_REPEATER,
 	WIDGET_ACTION_EVENT_SCROLL_UP_START_REPEATER_VARIABLE,
 	WIDGET_ACTION_EVENT_SCROLL_DOWN_START_REPEATER,
 	WIDGET_ACTION_EVENT_SCROLL_DOWN_START_REPEATER_VARIABLE,
 	WIDGET_ACTION_EVENT_SCROLL_LEFT_START_REPEATER,
 	WIDGET_ACTION_EVENT_SCROLL_RIGHT_START_REPEATER,
 	WIDGET_ACTION_EVENT_SCROLL_PAGE_DOWN_START_REPEATER,
 	WIDGET_ACTION_EVENT_SCROLL_PAGE_UP_START_REPEATER,
 	WIDGET_ACTION_EVENT_STOP_REPEATER,
 	WIDGET_ACTION_EVENT_TAB_NEXT,
 	WIDGET_ACTION_EVENT_TAB_PREV,
 	WIDGET_ACTION_EVENT_DRAG_START,
 	WIDGET_ACTION_EVENT_DRAG_STOP,
 	WIDGET_ACTION_EVENT_JOY3_ON_PRESS,
 };
 
 struct widgetTransition_t {
 	widgetTransition_t() :
 		animationName( NULL ) {
 
 	}
 
 	const char *						animationName;			// name of the animation to run
 	idStaticList< const char *, 4 >		prefixes;				// prefixes to try to use for animation
 };
 
 
 /*
 ================================================
 scoreboardInfo_t
 ================================================
 */
 struct scoreboardInfo_t {
 	scoreboardInfo_t() :
 		index( -1 ),
 		voiceState( VOICECHAT_DISPLAY_NONE ) {
 	}
 
 	idList< idStr, TAG_IDLIB_LIST_MENU> values;
 	int						index;
 	voiceStateDisplay_t		voiceState;
 };
 
 /*
 ================================================
 idSort_SavesByDate
 ================================================
 */
 class idSort_SavesByDate : public idSort_Quick< idSaveGameDetails, idSort_SavesByDate > {
 public:
 	int Compare( const idSaveGameDetails & a, const idSaveGameDetails & b ) const {
 		return b.date - a.date;
 	}
 };
 
 /*
 ================================================
 idMenuDataSource
 ================================================
 */
 class idMenuDataSource {
 public:
 	virtual ~idMenuDataSource() { }
 
 	virtual void				LoadData()							= 0;
 	virtual void				CommitData()						= 0;
 	virtual bool				IsDataChanged() const				= 0;
 	virtual idSWFScriptVar		GetField( const int fieldIndex ) const	= 0;
 	virtual void				AdjustField( const int fieldIndex, const int adjustAmount ) = 0;
 };
 
 /*
 ================================================
 idWidgetEvent
 ================================================
 */
 class idWidgetEvent {
 public:
 	idWidgetEvent() :
 		type( WIDGET_EVENT_PRESS ),
 		arg( 0 ),
 		thisObject( NULL ) {
 
 	}
 
 	idWidgetEvent( const widgetEvent_t type_, const int arg_, idSWFScriptObject * thisObject_, const idSWFParmList & parms_ ) :
 		type( type_  ),
 		arg( arg_ ),
 		thisObject( thisObject_ ),
 		parms( parms_ ) {
 	}
 
 	widgetEvent_t			type;
 	int						arg;
 	idSWFScriptObject *		thisObject;
 	idSWFParmList 			parms;
 };
 
 /*
 ================================================
 idWidgetAction
 ================================================
 */
 class idWidgetAction {
 public:
 	idWidgetAction() :
 		action( WIDGET_ACTION_NONE ),
 		scriptFunction( NULL ) {
 	}
 
 	idWidgetAction( const idWidgetAction & src ) {
 		action = src.action;
 		parms = src.parms;
 		scriptFunction = src.scriptFunction;
 		if ( scriptFunction != NULL ) {
 			scriptFunction->AddRef();
 		}
 	}
 
 	~idWidgetAction() {
 		if ( scriptFunction != NULL ) {
 			scriptFunction->Release();
 		}
 	}
 
 	void operator=( const idWidgetAction & src ) {
 		action = src.action;
 		parms = src.parms;
 		scriptFunction = src.scriptFunction;
 		if ( scriptFunction != NULL ) {
 			scriptFunction->AddRef();
 		}
 	}
 
 	bool operator==( const idWidgetAction & otherAction ) const {
 		if ( GetType() != otherAction.GetType()
 				|| GetParms().Num() != otherAction.GetParms().Num() ) {
 			return false;
 		}
 
 		// everything else is equal, so check all parms. NOTE: this assumes we are only sending
 		// integral types.
 		for ( int i = 0; i < GetParms().Num(); ++i ) {
 			if ( GetParms()[ i ].GetType() != otherAction.GetParms()[ i ].GetType() 
 				|| GetParms()[ i ].ToInteger() != otherAction.GetParms()[ i ].ToInteger() ) {
 				return false;
 			}
 		}
 
 		return true;
 	}
 
 	void Set( idSWFScriptFunction * function ) {
 		action = WIDGET_ACTION_FUNCTION;
 		if ( scriptFunction != NULL ) {
 			scriptFunction->Release();
 		}
 		scriptFunction = function;
 		scriptFunction->AddRef();
 	}
 
 	void Set( widgetAction_t action_ ) {
 		action = action_;
 		parms.Clear();
 	}
 
 	void Set( widgetAction_t action_, const idSWFScriptVar & var1 ) {
 		action = action_;
 		parms.Clear();
 		parms.Append( var1 );
 	}
 
 	void Set( widgetAction_t action_, const idSWFScriptVar & var1, const idSWFScriptVar & var2 ) {
 		action = action_;
 		parms.Clear();
 		parms.Append( var1 );
 		parms.Append( var2 );
 	}
 
 	void Set( widgetAction_t action_, const idSWFScriptVar & var1, const idSWFScriptVar & var2, const idSWFScriptVar & var3 ) {
 		action = action_;
 		parms.Clear();
 		parms.Append( var1 );
 		parms.Append( var2 );
 		parms.Append( var3 );
 	}
 
 	void Set( widgetAction_t action_, const idSWFScriptVar & var1, const idSWFScriptVar & var2, const idSWFScriptVar & var3, const idSWFScriptVar & var4 ) {
 		action = action_;
 		parms.Clear();
 		parms.Append( var1 );
 		parms.Append( var2 );
 		parms.Append( var3 );
 		parms.Append( var4 );
 	}
 
 	idSWFScriptFunction *	GetScriptFunction() { return scriptFunction; }
 	const widgetAction_t	GetType() const { return action; }
 	const idSWFParmList &	GetParms() const { return parms; }
 
 private:
 	widgetAction_t			action;
 	idSWFParmList			parms;
 	idSWFScriptFunction *	scriptFunction;
 };
 
 typedef idList< idMenuWidget *, TAG_IDLIB_LIST_MENU > idMenuWidgetList;
 
 /*
 ================================================
 idMenuWidget
 
 We're using a model/view architecture, so this is the combination of both model and view.  The
 other part of the view is the SWF itself.
 ================================================
 */
 class idMenuWidget {
 public:
 
 	/*
 	================================================
 	WrapWidgetSWFEvent
 	================================================
 	*/
 	class WrapWidgetSWFEvent : public idSWFScriptFunction_RefCounted {
 	public:
 		WrapWidgetSWFEvent( idMenuWidget * widget, const widgetEvent_t event, const int eventArg ) :
 			targetWidget( widget ),
 			targetEvent( event ),
 			targetEventArg( eventArg ) {
 		}
 
 		idSWFScriptVar Call( idSWFScriptObject * thisObject, const idSWFParmList & parms ) {
 				targetWidget->ReceiveEvent( idWidgetEvent( targetEvent, targetEventArg, thisObject, parms ) );
 			return idSWFScriptVar();
 		}
 
 	private:
 		idMenuWidget *	targetWidget;
 		widgetEvent_t	targetEvent;
 		int				targetEventArg;
 	};
 
 
 	enum widgetState_t {
 		WIDGET_STATE_HIDDEN,	// hidden
 		WIDGET_STATE_NORMAL,	// normal
 		WIDGET_STATE_SELECTING,	// going into the selected state
 		WIDGET_STATE_SELECTED,	// fully selected
 		WIDGET_STATE_DISABLED,	// disabled
 		WIDGET_STATE_MAX
 	};
 
 										idMenuWidget();
 
 	virtual								~idMenuWidget();
 
 	void								Cleanup();
 	// typically this is where the allocations for a widget will occur: sub widgets, etc.
 	// Note that SWF sprite objects may not be accessible at this point.
 	virtual void						Initialize( idMenuHandler * data ) { menuData = data; }
 
 	// takes the information described in this widget and applies it to a given script object.
 	// the script object should point to the root that you want to run from. Running this will
 	// also create the sprite binding, if any.
 	virtual void						Update() {}
 	virtual void						Show();
 	virtual void						Hide();
 
 	widgetState_t						GetState() const { return widgetState; }
 	void								SetState( const widgetState_t state );
 
 	// actually binds the sprite. this must be called after setting sprite path!
 	idSWFSpriteInstance *				GetSprite() { return boundSprite; }
 	idSWF *								GetSWFObject();
 	idMenuHandler *						GetMenuData();
 	bool								BindSprite( idSWFScriptObject & root );
 	void								ClearSprite();
 
 	void								SetSpritePath( const char * arg1, const char * arg2 = NULL, const char * arg3 = NULL, const char * arg4 = NULL, const char * arg5 = NULL );
 	void								SetSpritePath( const idList< idStr > & spritePath_, const char * arg1 = NULL, const char * arg2 = NULL, const char * arg3 = NULL, const char * arg4 = NULL, const char * arg5 = NULL );
 	idList< idStr, TAG_IDLIB_LIST_MENU > &					GetSpritePath() { return spritePath; }
 	int									GetRefCount() const { return refCount; }
 	void						AddRef() { refCount++; }
 	void						Release() { assert( refCount > 0 ); if ( --refCount == 0 && !noAutoFree ) { delete this; } }
 
 	//------------------------
 	// Event Handling
 	//------------------------
 	virtual bool						HandleAction( idWidgetAction & action, const idWidgetEvent & event, idMenuWidget * widget, bool forceHandled = false );
 	virtual void						ObserveEvent( const idMenuWidget & widget, const idWidgetEvent & event ) { }
 	void								SendEventToObservers( const idWidgetEvent & event );
 	void								RegisterEventObserver( idMenuWidget * observer );
 	void								ReceiveEvent( const idWidgetEvent & event );
 
 	// Executes an event in the context of this widget.  Only rarely should this be called
 	// directly.  Instead calls should go through ReceiveEvent which will propagate the event
 	// through the standard focus order.
 	virtual bool						ExecuteEvent( const idWidgetEvent & event );
 
 	// returns the list of actions for a given event, or NULL if no actions are registered for
 	// that event.  Events should not be directly added to the returned list.  Instead use
 	// AddEventAction for adding new events.
 	idList< idWidgetAction, TAG_IDLIB_LIST_MENU > *			GetEventActions( const widgetEvent_t eventType );
 
 	// allocates an action for the given event
 	idWidgetAction &					AddEventAction( const widgetEvent_t eventType );
 	void								ClearEventActions();
 
 	//------------------------
 	// Data modeling
 	//------------------------
 	void								SetDataSource( idMenuDataSource * dataSource, const int fieldIndex );
 	idMenuDataSource *					GetDataSource() { return dataSource; }
 	void								SetDataSourceFieldIndex( const int dataSourceFieldIndex_ ) { dataSourceFieldIndex = dataSourceFieldIndex_; }
 	int									GetDataSourceFieldIndex() const { return dataSourceFieldIndex; }
 
 	idMenuWidget *						GetFocus() { return ( focusIndex >= 0 && focusIndex < children.Num() ) ? children[ focusIndex ] : NULL; }
 	int									GetFocusIndex() const { return focusIndex; }
 	void								SetFocusIndex( const int index, bool skipSound = false );
 
 	//------------------------
 	// Hierarchy
 	//------------------------
 	idMenuWidgetList &					GetChildren() { return children; }
 	const idMenuWidgetList &			GetChildren() const { return children; }
 	idMenuWidget &						GetChildByIndex( const int index ) const { return *children[ index ]; }
 
 	void								AddChild( idMenuWidget * widget );
 	void								RemoveChild( idMenuWidget * widget );
 	bool								HasChild( idMenuWidget * widget );
 	void								RemoveAllChildren();
 
 	idMenuWidget *						GetParent() { return parent; }
 	const idMenuWidget *				GetParent() const { return parent; }
 	void								SetParent( idMenuWidget * parent_ ) { parent = parent_; }
 	void								SetSWFObj( idSWF * obj ) { swfObj = obj; }
 	bool								GetHandlerIsParent() { return handlerIsParent; }
 	void								SetHandlerIsParent( bool val ) { handlerIsParent = val; }
 	void								SetNoAutoFree( bool b ) { noAutoFree = b; }
 
 protected:
 	void								ForceFocusIndex( const int index ) { focusIndex = index; }
 
 protected:
 	bool								handlerIsParent;
 	idMenuHandler *						menuData;
 	idSWF *								swfObj;
 	idSWFSpriteInstance *				boundSprite;
 	idMenuWidget *						parent;
 	idList< idStr, TAG_IDLIB_LIST_MENU >						spritePath;
 	idMenuWidgetList											children;
 	idMenuWidgetList											observers;
 
 	static const int INVALID_ACTION_INDEX = -1;
 	idList< idList< idWidgetAction, TAG_IDLIB_LIST_MENU >, TAG_IDLIB_LIST_MENU >		eventActions;
 	idStaticList< int, MAX_WIDGET_EVENT >	eventActionLookup;
 
 	idMenuDataSource *					dataSource;
 	int									dataSourceFieldIndex;
 
 	int									focusIndex;
 
 	widgetState_t						widgetState;
 	int									refCount;
 	bool								noAutoFree;
 };
 
 /*
 ================================================
 idMenuWidget_Button
 
 This might be better named "ComboButton", as it contains behavior for several controls along
 with standard button behavior.
 ================================================
 */
 class idMenuWidget_Button : public idMenuWidget {
 public:
 
 	enum animState_t {
 		ANIM_STATE_UP,			// standard
 		ANIM_STATE_DOWN,		// pressed down
 		ANIM_STATE_OVER,		// hovered over this
 		ANIM_STATE_MAX
 	};
 
 	idMenuWidget_Button() :
 		animState( ANIM_STATE_UP ),
 		img( NULL ),
 		ignoreColor( false ) {
 	}
 
 	virtual ~idMenuWidget_Button() {}
 
 	virtual bool			ExecuteEvent( const idWidgetEvent & event );
 	virtual void			Update();
 
 	//---------------
 	// Model
 	//---------------
 	void					SetLabel( const idStr & label ) { btnLabel = label; }
 	const idStr &			GetLabel() const { return btnLabel; }
 	void					SetValues( idList< idStr > & list );
 	const idStr &			GetValue( int index ) const;
 	void					SetImg( const idMaterial * val ) { img = val; }
 	const idMaterial *		GetImg() { return img; }
 	void					SetDescription( const char * desc_ ) { description = desc_; }
 	const idStr &			GetDescription() const { return description; }
 
 	void					SetIgnoreColor( const bool b ) { ignoreColor = b; }
 
 	animState_t				GetAnimState() const { return animState; }
 	void					SetAnimState( const animState_t state ) { animState = state; }
 	void					SetOnPressFunction( idSWFScriptFunction * func ) { scriptFunction = func; }
 
 protected:
 	void					SetupTransitionInfo( widgetTransition_t & trans, const widgetState_t buttonState, const animState_t sourceAnimState, const animState_t destAnimState ) const;
 	void					AnimateToState( const animState_t targetState, const bool force = false );
 
 	idList< idStr, TAG_IDLIB_LIST_MENU >			values;
 	idStr					btnLabel;
 	idStr					description;
 	animState_t				animState;
 	const idMaterial * 		img;
 	idSWFScriptFunction *	scriptFunction;
 	bool					ignoreColor;
 };
 
 /*
 ================================================
 idMenuWidget_LobbyButton
 ================================================
 */
 class idMenuWidget_LobbyButton : public idMenuWidget_Button {
 public:	
 	idMenuWidget_LobbyButton() :
 		voiceState( VOICECHAT_DISPLAY_NONE ) {
 	}
 
 	virtual void			Update();
 	void					SetButtonInfo( idStr name_, voiceStateDisplay_t voiceState_ );
 	bool					IsValid() { return !name.IsEmpty(); }
 
 protected:
 	idStr					name;
 	voiceStateDisplay_t		voiceState;
 };
 
 /*
 ================================================
 idMenuWidget_ScoreboardButton
 ================================================
 */
 class idMenuWidget_ScoreboardButton : public idMenuWidget_Button {
 public:	
 	idMenuWidget_ScoreboardButton() :
 		voiceState( VOICECHAT_DISPLAY_NONE ),
 		index( -1 ) {
 	}
 
 	virtual void			Update();
 	void					SetButtonInfo( int index_, idList< idStr > & list, voiceStateDisplay_t voiceState_ );
 
 protected:
 	voiceStateDisplay_t		voiceState;
 	int						index;
 };
 
 /*
 ================================================
 idMenuWidget_ControlButton
 ================================================
 */
 class idMenuWidget_ControlButton : public idMenuWidget_Button {
 public:
 	idMenuWidget_ControlButton() : 
 		optionType( OPTION_BUTTON_TEXT ),
 		disabled( false ) {
 	}
 
 	virtual void			Update();
 	void					SetOptionType( const menuOption_t type ) { optionType = type; }
 	menuOption_t			GetOptionType() const { return optionType; }
 	void					SetupEvents( int delay, int index );
 	void					SetDisabled( bool disable ) { disabled = disable; }
 
 protected:
 	menuOption_t			optionType;
 	bool					disabled;
 };
 
 /*
 ================================================
 idMenuWidget_ServerButton
 ================================================
 */
 class idMenuWidget_ServerButton : public idMenuWidget_Button {
 public:
 
 	idMenuWidget_ServerButton() :
 		players( 0 ),
 		index( 0 ),
 		maxPlayers( 0 ),
 		joinable( false ),
 		validMap( false ) {
 	}
 
 	virtual void			Update();
 	void					SetButtonInfo( idStr name_, idStrId mapName_, idStr modeName_, int index_ = 0, int players_ = 0, int maxPlayers_ = 0, bool joinable_ = false, bool validMap_ = false );
 	bool					IsValid() { return !serverName.IsEmpty(); }
 	bool					CanJoin() { return ( joinable && validMap ); }
 
 protected:
 	idStr					serverName;
 	int						index;
 	int						players;
 	int						maxPlayers;
 	bool					joinable;
 	bool					validMap;
 	idStrId					mapName;
 	idStr					modeName;	
 };
 
 /*
 ================================================
 idMenuWidget_NavButton
 ================================================
 */
 class idMenuWidget_NavButton : public idMenuWidget_Button {
 public:
 
 	enum navWidgetState_t {
 		NAV_WIDGET_LEFT,		// option on left side
 		NAV_WIDGET_RIGHT,		// option on right side
 		NAV_WIDGET_SELECTED		// option is selected
 	};
 
 	idMenuWidget_NavButton() : 
 		navIndex( 0 ),
 		xPos( 0 ) {
 	}
 
 	virtual bool			ExecuteEvent( const idWidgetEvent & event );
 	virtual void			Update();
 
 	void					SetNavIndex( int i, const navWidgetState_t type ) { navIndex = i; navState = type; }
 	void					SetPosition( float pos ) { xPos = pos; }
 
 private:
 
 	int						navIndex;
 	float					xPos;
 	navWidgetState_t		navState;
 
 };
 
 /*
 ================================================
 idMenuWidget_NavButton
 ================================================
 */
 class idMenuWidget_MenuButton : public idMenuWidget_Button {
 public:
 
 	idMenuWidget_MenuButton() : 
 		xPos( 0 ) {
 	}
 
 	virtual void			Update();
 	void					SetPosition( float pos ) { xPos = pos; }
 
 private:
 
 	float					xPos;
 
 };
 
 /*
 ================================================
 idMenuWidget_List
 
 Stores a list of widgets but displays only a segment of them at a time.
 ================================================
 */
 class idMenuWidget_List : public idMenuWidget {
 public:
 	idMenuWidget_List() :
 		numVisibleOptions( 0 ),
 		viewOffset( 0 ),
 		viewIndex( 0 ),
 		allowWrapping( false ) {
 
 	}
 
 	virtual void				Update();
 	virtual bool				HandleAction( idWidgetAction & action, const idWidgetEvent & event, idMenuWidget * widget, bool forceHandled = false );
 	virtual void				ObserveEvent( const idMenuWidget & widget, const idWidgetEvent & event );
 	virtual void				Scroll( const int scrollIndexAmount, const bool wrapAround = false );
 	virtual void				ScrollOffset( const int scrollIndexAmount );
 	virtual int					GetTotalNumberOfOptions() const { return GetChildren().Num(); }
 	virtual bool				PrepareListElement( idMenuWidget & widget, const int childIndex ) { return true; }
 
 	bool						IsWrappingAllowed() const { return allowWrapping; }
 	void						SetWrappingAllowed( const bool allow ) { allowWrapping = allow; }
 
 	void						SetNumVisibleOptions( const int numVisibleOptions_ ) { numVisibleOptions = numVisibleOptions_; }
 	int							GetNumVisibleOptions() const { return numVisibleOptions; }
 
 	int							GetViewOffset() const { return viewOffset; }
 	void						SetViewOffset( const int offset ) { viewOffset = offset; }
 
 	int							GetViewIndex() const { return viewIndex; }
 	void						SetViewIndex( const int index ) { viewIndex = index; }
 
 	void						CalculatePositionFromIndexDelta( int & outIndex, int & outOffset, const int currentIndex, const int currentOffset, const int windowSize, const int maxSize, const int indexDelta, const bool allowWrapping, const bool wrapAround = false ) const;
 	void						CalculatePositionFromOffsetDelta( int & outIndex, int & outOffset, const int currentIndex, const int currentOffset, const int windowSize, const int maxSize, const int offsetDelta ) const;
 
 private:
 	int							numVisibleOptions;
 	int							viewOffset;
 	int							viewIndex;
 	bool						allowWrapping;
 };
 
 class idBrowserEntry_t {
 public:
 	idStr serverName;
 	int	index;
 	int players;
 	int maxPlayers;
 	bool joinable;
 	bool validMap;
 	idStrId mapName;
 	idStr modeName;
 };
 
 /*
 ================================================
 idMenuWidget_GameBrowserList
 ================================================
 */
 class idMenuWidget_GameBrowserList : public idMenuWidget_List {
 public:
 	virtual void				Update();
 	virtual bool				PrepareListElement( idMenuWidget & widget, const int childIndex );
 	virtual int					GetTotalNumberOfOptions() const;
 	void						ClearGames();
 	void						AddGame( idStr name_, idStrId mapName_, idStr modeName_, int index_ = 0, int players_ = 0, int maxPlayers_ = 0, bool joinable_ = false, bool validMap_ = false );
 	int							GetServerIndex();
 private:
 	idList< idBrowserEntry_t >	games;
 };
 
 /*
 ================================================
 idMenuWidget_Carousel
 Displays a list of items in a looping carousel pattern 
 ================================================
 */
 class idMenuWidget_Carousel : public idMenuWidget {
 public:
 
 	idMenuWidget_Carousel() :
 		numVisibleOptions( 0 ),
 		viewIndex( 0 ),
 		moveToIndex( 0 ),
 		scrollLeft( false ),
 		fastScroll( false ),
 		moveDiff( 0 ) {
 	}
 
 	virtual void				Initialize( idMenuHandler * data );
 	virtual void				Update();
 	virtual bool				HandleAction( idWidgetAction & action, const idWidgetEvent & event, idMenuWidget * widget, bool forceHandled = false );
 	virtual int					GetTotalNumberOfOptions() const { return imgList.Num(); }
 	virtual bool				PrepareListElement( idMenuWidget & widget, const int childIndex ) { return true; }
 
 	void						SetNumVisibleOptions( const int numVisibleOptions_ ) { numVisibleOptions = numVisibleOptions_; }
 	int							GetNumVisibleOptions() const { return numVisibleOptions; }
 		
 	void						MoveToIndex( int index, bool instant = false );
 	void						MoveToFirstItem( bool instant = true );
 	void						MoveToLastItem( bool instant = true );
 	int							GetMoveToIndex() { return moveToIndex; }
 	void						SetMoveToIndex( int index ) { moveToIndex = index; }
 	void						SetViewIndex( int index ) { viewIndex = index; }
 	int							GetViewIndex() const { return viewIndex; }
 	void						SetListImages( idList<const idMaterial *> & list );
 	void						SetMoveDiff( int val ) { moveDiff = val; }
 	int							GetMoveDiff() { return moveDiff; }
 	bool						GetScrollLeft() { return scrollLeft; }
 
 private:
 
 	int							numVisibleOptions;
 	int							viewIndex;
 	int							moveToIndex;
 	int							moveDiff;
 	bool						fastScroll;
 	bool						scrollLeft;
 	idList<const idMaterial *>	imgList;
 
 };
 
 /*
 ================================================
 idMenuWidget_Help
 
 Knows how to display help tooltips by observing events from other widgets
 ================================================
 */
 class idMenuWidget_Help : public idMenuWidget {
 public:
 	virtual void Update();
 	virtual void ObserveEvent( const idMenuWidget & widget, const idWidgetEvent & event );
 
 private:
 	idStr		lastFocusedMessage;		// message from last widget that had focus
 	idStr		lastHoveredMessage;		// message from last widget that was hovered over
 	bool		hideMessage;
 };
 
 /*
 ================================================
 idMenuWidget_CommandBar
 ================================================
 */
 class idMenuWidget_CommandBar : public idMenuWidget {
 public:
 	enum button_t {
 		BUTTON_JOY1,
 		BUTTON_JOY2,
 		BUTTON_JOY3,
 		BUTTON_JOY4,
 		BUTTON_JOY10,
 		BUTTON_TAB,
 		MAX_BUTTONS
 	};
 
 	enum alignment_t {
 		LEFT,
 		RIGHT
 	};
 
 	struct buttonInfo_t {
 		idStr			label;			// empty labels are treated as hidden buttons
 		idWidgetAction	action;
 	};
 
 	idMenuWidget_CommandBar() :
 		alignment( LEFT ) {
 
 		buttons.SetNum( MAX_BUTTONS );
 	}
 
 	virtual void		Update();
 	virtual bool		ExecuteEvent( const idWidgetEvent & event );
 
 	buttonInfo_t *		GetButton( const button_t button ) { return &buttons[ button ]; }
 	void				ClearAllButtons();
 
 	alignment_t			GetAlignment() const { return alignment; }
 	void				SetAlignment( const alignment_t alignment_ ) { alignment = alignment_; }
 
 private:
 	idStaticList< buttonInfo_t, MAX_BUTTONS >	buttons;
 	alignment_t									alignment;
 };
 
 /*
 ================================================
 	idMenuWidget_DynamicList
 ================================================
 */
 class idMenuWidget_LobbyList : public idMenuWidget_List {
 public:
 	idMenuWidget_LobbyList() :
 		numEntries( 0 ) {
 	}
 	  
 	virtual void				Update();
 	virtual bool				PrepareListElement( idMenuWidget & widget, const int childIndex );
 	virtual int					GetTotalNumberOfOptions() const { return numEntries; }
 	void						SetEntryData( int index, idStr name, voiceStateDisplay_t voiceState );
 	void						SetHeadingInfo( idList< idStr > & list );
 	void						SetNumEntries( int num ) { numEntries = num; }
 	int							GetNumEntries() { return numEntries; }
 	void						SetRefreshFunction( const char* func );
 private:
 	idList< idStr, TAG_IDLIB_LIST_MENU >	headings;
 	int							numEntries;
 };
 
 /*
 ================================================
 idMenuWidget_DynamicList
 ================================================
 */
 class idMenuWidget_DynamicList : public idMenuWidget_List {
 public:
 
 	idMenuWidget_DynamicList() : 
 		controlList( false ),
 		ignoreColor( false ) {
 	}
 
 	virtual void				Update();
 	virtual void				Initialize( idMenuHandler * data );
 	virtual int					GetTotalNumberOfOptions() const;
 	virtual bool				PrepareListElement( idMenuWidget & widget, const int childIndex );
 
 	virtual void				Recalculate();
 	virtual void				SetListData( idList< idList< idStr, TAG_IDLIB_LIST_MENU >, TAG_IDLIB_LIST_MENU > & list );
 	
 	void						SetControlList( bool val ) { controlList = val; }
 	void						SetIgnoreColor( bool val ) { ignoreColor = val; }
 
 protected:
 	idList< idList< idStr, TAG_IDLIB_LIST_MENU >, TAG_IDLIB_LIST_MENU >	listItemInfo;
 	bool						controlList;
 	bool						ignoreColor;
 };
 
 /*
 ================================================
 idMenuWidget_ScoreboardList
 ================================================
 */
 class idMenuWidget_ScoreboardList : public idMenuWidget_DynamicList {
 public:
 	  virtual void				Update();
 	  virtual int				GetTotalNumberOfOptions() const;
 };
 
 /*
 ================================================
 idMenuWidget_NavBar
 
 The nav bar is set up with the main option being at the safe frame line.
 ================================================
 */
 class idMenuWidget_NavBar : public idMenuWidget_DynamicList {
 public:
 
 			idMenuWidget_NavBar() : 
 				initialPos( 0.0f ),
 				buttonPos( 0.0f ),
 				leftSpacer( 0.0f ),
 				rightSpacer( 0.0f ),
 				selectedSpacer( 0.0f ) {		
 			}
 
 	virtual void				Update();
 	virtual void				Initialize( idMenuHandler * data );
 	virtual void				SetInitialXPos( float pos ) { initialPos = pos; }
 	virtual void				SetButtonSpacing( float lSpace, float rSpace, float sSpace ) { leftSpacer = lSpace; rightSpacer = rSpace; selectedSpacer = sSpace; }
 	virtual bool				PrepareListElement( idMenuWidget & widget, const int navIndex );
 	virtual void				SetListHeadings( idList< idStr > & list );
 	virtual int					GetTotalNumberOfOptions() const;
 
 private:
 
 	idList< idStr, TAG_IDLIB_LIST_MENU >		headings;
 	float				initialPos;
 	float				buttonPos;
 	float				leftSpacer;
 	float				rightSpacer;
 	float				selectedSpacer;
 
 };
 
 /*
 ================================================
 idMenuWidget_NavBar
 
 The nav bar is set up with the main option being at the safe frame line.
 ================================================
 */
 class idMenuWidget_MenuBar : public idMenuWidget_DynamicList {
 public:
 
 	idMenuWidget_MenuBar() :
 		totalWidth( 0.0f ),
 		buttonPos( 0.0f ),
 		rightSpacer( 0.0f ) {
 	}
 
 	virtual void				Update();
 	virtual void				Initialize( idMenuHandler * data );
 	virtual void				SetButtonSpacing( float rSpace ) { rightSpacer = rSpace; }
 	virtual bool				PrepareListElement( idMenuWidget & widget, const int navIndex );
 	virtual void				SetListHeadings( idList< idStr > & list );
 	virtual int					GetTotalNumberOfOptions() const;
 
 private: 
 
 	idList< idStr, TAG_IDLIB_LIST_MENU >				headings;
 	float						totalWidth;
 	float						buttonPos;
 	float						rightSpacer;
 		
 };
 
 /*
 ================================================
 idMenuWidget_PDA_UserData
 ================================================
 */
 class idMenuWidget_PDA_UserData : public idMenuWidget {
 public:
 					idMenuWidget_PDA_UserData() : 
 						pdaIndex( 0 ) {
 					}
 virtual ~idMenuWidget_PDA_UserData() {}
 	virtual void	Update();
 	virtual void	ObserveEvent( const idMenuWidget & widget, const idWidgetEvent & event );
 
 private:
 	int		pdaIndex;
 };
 
 /*
 ================================================
 idMenuWidget_DynamicList
 ================================================
 */
 class idMenuWidget_ScrollBar : public idMenuWidget {
 public:
 	idMenuWidget_ScrollBar() : 
 		yTop( 0.0f ),
 		yBot( 0.0f ),
 		dragging( false ) {
 	}
 
 	virtual void	Initialize( idMenuHandler * data );
 	virtual void	Update();
 	virtual bool	HandleAction( idWidgetAction & action, const idWidgetEvent & event, idMenuWidget * widget, bool forceHandled = false );
 	virtual void	ObserveEvent( const idMenuWidget & widget, const idWidgetEvent & event );
 
 	void			CalcTopAndBottom();
 	void			CalculatePosition( float x, float y );
 
 	float			yTop;
 	float			yBot;
 	bool			dragging;
 };
 
 /*
 ================================================
 idMenuWidget_InfoBox
 ================================================
 */
 class idMenuWidget_InfoBox: public idMenuWidget {
 public:
 	idMenuWidget_InfoBox() :
 		scrollbar( NULL ) {
 	}
 
 	virtual void	Initialize( idMenuHandler * data );
 	virtual void	Update();
 	virtual bool	HandleAction( idWidgetAction & action, const idWidgetEvent & event, idMenuWidget * widget, bool forceHandled = false );
 	virtual void	ObserveEvent( const idMenuWidget & widget, const idWidgetEvent & event );
 	void			SetHeading( idStr val ) { heading = val; }
 	void			SetBody( idStr val ) { info = val; }
 	void			ResetInfoScroll();
 	void			Scroll( int d );
 	int				GetScroll();
 	int				GetMaxScroll();
 	void			SetScroll( int scroll );
 	void			SetScrollbar( idMenuWidget_ScrollBar * bar );
 private:
 	idMenuWidget_ScrollBar *	scrollbar;
 	idStr						heading;
 	idStr						info;
 };
 
 /*
 ================================================
 idMenuWidget_PDA_Objective
 ================================================
 */
 class idMenuWidget_PDA_Objective: public idMenuWidget {
 public:
 	idMenuWidget_PDA_Objective() :
 		pdaIndex( 0 ) {
 		}
 	virtual void	Update();
 	virtual void	ObserveEvent( const idMenuWidget & widget, const idWidgetEvent & event );
 private:
 	int		pdaIndex;
 };
 
 /*
 ================================================
 idMenuWidget_Shell_SaveInfo
 ================================================
 */
 class idMenuWidget_Shell_SaveInfo: public idMenuWidget {
 public:
 	idMenuWidget_Shell_SaveInfo() :
 		loadIndex( 0 ),
 		forSaveScreen( false ) {
 	}
 	virtual void	Update();
 	virtual void	ObserveEvent( const idMenuWidget & widget, const idWidgetEvent & event );
 
 	void			SetForSaveScreen( bool val ) { forSaveScreen = val; }
 private:
 	int		loadIndex;
 	bool	forSaveScreen;
 };
 
 /*
 ================================================
 idMenuWidget_PDA_AudioFiles
 ================================================
 */
 class idMenuWidget_PDA_AudioFiles: public idMenuWidget {
 public:
 	idMenuWidget_PDA_AudioFiles() :
 		pdaIndex( 0 ) {
 		}
 	virtual ~idMenuWidget_PDA_AudioFiles();
 	virtual void	Update();
 	virtual void	Initialize( idMenuHandler * data );
 	virtual void	ObserveEvent( const idMenuWidget & widget, const idWidgetEvent & event );
 private:
 	int								pdaIndex;
 	idList< idList< idStr, TAG_IDLIB_LIST_MENU >, TAG_IDLIB_LIST_MENU >		audioFileNames;
 };
 
 /*
 ================================================
 idMenuWidget_PDA_AudioFiles
 ================================================
 */
 class idMenuWidget_PDA_EmailInbox: public idMenuWidget {
 public:
 	idMenuWidget_PDA_EmailInbox() :
 		pdaIndex( 0 ),
 		emailList( NULL ),
 		scrollbar( NULL ) {
 	}
 	virtual void	Update();
 	virtual void	Initialize( idMenuHandler * data );
 	virtual void	ObserveEvent( const idMenuWidget & widget, const idWidgetEvent & event );
 
 	idMenuWidget_DynamicList *	GetEmailList() { return emailList; }
 	idMenuWidget_ScrollBar *	GetScrollbar() { return scrollbar; }
 private:
 	idMenuWidget_DynamicList *		emailList;
 	idMenuWidget_ScrollBar *		scrollbar;
 	int								pdaIndex;
 	idList< idList< idStr, TAG_IDLIB_LIST_MENU >, TAG_IDLIB_LIST_MENU >		emailInfo;
 };
 
 /*
 ================================================
 	idMenuWidget_PDA_AudioFiles
 ================================================
 */
 class idMenuWidget_ItemAssignment: public idMenuWidget {
 public:
 	idMenuWidget_ItemAssignment() : 
 		slotIndex( 0 ) {
 	}
 
 	virtual void	Update();
 	void			SetIcon( int index, const idMaterial * icon );
 	void			FindFreeSpot();
 	int				GetSlotIndex() { return slotIndex; }
 	void			SetSlotIndex( int num ) { slotIndex = num; }
 private:
 	const idMaterial * images[ NUM_QUICK_SLOTS ];
 	int				slotIndex;
 
 };
 
 
 /*
 ================================================
 idMenuWidget_PDA_AudioFiles
 ================================================
 */
 class idMenuWidget_PDA_VideoInfo: public idMenuWidget {
 public:
 	virtual void	Update();
 	virtual void	ObserveEvent( const idMenuWidget & widget, const idWidgetEvent & event );
 private:
 	int				videoIndex;
 };
 
 
 /*
 ================================================
 idWidgetActionHandler
 ================================================
 */
 class idWidgetActionHandler : public idSWFScriptFunction_RefCounted {
 public:
 	idWidgetActionHandler( idMenuWidget * widget, actionHandler_t actionEventType, widgetEvent_t _event ) :
 		targetWidget( widget ),
 		type( actionEventType ),
 		targetEvent( _event ) {
 
 	}
 
 	idSWFScriptVar Call( idSWFScriptObject * thisObject, const idSWFParmList & parms ) {
 
 		idWidgetAction action;
 		bool handled = false;
 		switch ( type ) {
 			case WIDGET_ACTION_EVENT_SCROLL_DOWN_START_REPEATER: {
 				action.Set( (widgetAction_t)WIDGET_ACTION_START_REPEATER, WIDGET_ACTION_SCROLL_VERTICAL, 1 );
 				handled = true;
 				break;
 			}
 			case WIDGET_ACTION_EVENT_SCROLL_UP_START_REPEATER: {
 				action.Set( (widgetAction_t)WIDGET_ACTION_START_REPEATER, WIDGET_ACTION_SCROLL_VERTICAL, -1 );
 				handled = true;
 				break;
 			}
 			case WIDGET_ACTION_EVENT_SCROLL_DOWN_START_REPEATER_VARIABLE: {
 				action.Set( (widgetAction_t)WIDGET_ACTION_START_REPEATER, WIDGET_ACTION_SCROLL_VERTICAL_VARIABLE, 1 );
 				handled = true;
 				break;
 			}
 			case WIDGET_ACTION_EVENT_SCROLL_UP_START_REPEATER_VARIABLE: {
 				action.Set( (widgetAction_t)WIDGET_ACTION_START_REPEATER, WIDGET_ACTION_SCROLL_VERTICAL_VARIABLE, -1 );
 				handled = true;
 				break;
 			}
 			case WIDGET_ACTION_EVENT_SCROLL_PAGE_DOWN_START_REPEATER: {
 				action.Set( (widgetAction_t)WIDGET_ACTION_START_REPEATER, WIDGET_ACTION_SCROLL_PAGE, 1 );
 				handled = true;
 				break;
 			}
 			case WIDGET_ACTION_EVENT_SCROLL_PAGE_UP_START_REPEATER: {
 				action.Set( (widgetAction_t)WIDGET_ACTION_START_REPEATER, WIDGET_ACTION_SCROLL_PAGE, -1 );
 				handled = true;
 				break;
 			}
 			case WIDGET_ACTION_EVENT_STOP_REPEATER: {
 				action.Set( (widgetAction_t)WIDGET_ACTION_STOP_REPEATER );
 				handled = true;
 				break;
 			}
 	   		case WIDGET_ACTION_EVENT_TAB_NEXT: {
 				action.Set( (widgetAction_t)WIDGET_ACTION_SCROLL_TAB, 1 );
 				handled = true;				
 				break;
 			}
 			case WIDGET_ACTION_EVENT_TAB_PREV: {
 				action.Set( (widgetAction_t)WIDGET_ACTION_SCROLL_TAB, -1 );
 				handled = true;				
 				break;
 			}
 			case WIDGET_ACTION_EVENT_JOY3_ON_PRESS: {
 				action.Set( (widgetAction_t)WIDGET_ACTION_JOY3_ON_PRESS );
 				handled = true;
 				break;
 			}
 			case WIDGET_ACTION_EVENT_SCROLL_LEFT_START_REPEATER: {
 				action.Set( (widgetAction_t)WIDGET_ACTION_START_REPEATER, WIDGET_ACTION_SCROLL_HORIZONTAL, -1 );
 				handled = true;
 				break;
 			}
 			case WIDGET_ACTION_EVENT_SCROLL_RIGHT_START_REPEATER: {
 				action.Set( (widgetAction_t)WIDGET_ACTION_START_REPEATER, WIDGET_ACTION_SCROLL_HORIZONTAL, 1 );
 				handled = true;
 				break;
 			}
 			case WIDGET_ACTION_EVENT_DRAG_START: {
 				action.Set( (widgetAction_t)WIDGET_ACTION_SCROLL_DRAG );
 				handled = true;
 				break;
 			}
 			case WIDGET_ACTION_EVENT_DRAG_STOP: {
 				action.Set( (widgetAction_t)WIDGET_ACTION_EVENT_DRAG_STOP );
 				handled = true;
 				break;
 			}
 		}
 
 		if ( handled ) {
 			targetWidget->HandleAction( action, idWidgetEvent( targetEvent, 0, thisObject, parms ), targetWidget );
 		}
 
 		return idSWFScriptVar();
 	}
 
 private:
 	idMenuWidget *	targetWidget;
 	actionHandler_t type;
 	widgetEvent_t targetEvent;
 };
 
 #endif