mirror of
https://github.com/id-Software/DOOM-3-BFG.git
synced 2026-03-20 09:00:25 +01:00
Initial commit
This commit is contained in:
Brian Harris
545
neo/d3xp/menus/MenuWidget.cpp
Normal file
545
neo/d3xp/menus/MenuWidget.cpp
Normal file
@@ -0,0 +1,545 @@
|
||||
/*
|
||||
===========================================================================
|
||||
|
||||
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.
|
||||
|
||||
===========================================================================
|
||||
*/
|
||||
|
||||
#pragma hdrstop
|
||||
#include "../../idLib/precompiled.h"
|
||||
#include "../Game_local.h"
|
||||
|
||||
/*
|
||||
========================
|
||||
idMenuWidget::idMenuWidget
|
||||
========================
|
||||
*/
|
||||
idMenuWidget::idMenuWidget() :
|
||||
boundSprite( NULL ),
|
||||
parent( NULL ),
|
||||
dataSource( NULL ),
|
||||
dataSourceFieldIndex( 0 ),
|
||||
focusIndex( 0 ),
|
||||
widgetState( WIDGET_STATE_NORMAL ),
|
||||
menuData( NULL ),
|
||||
swfObj( NULL ),
|
||||
handlerIsParent( false ),
|
||||
refCount( 0 ),
|
||||
noAutoFree( false ) {
|
||||
|
||||
eventActionLookup.SetNum( eventActionLookup.Max() );
|
||||
for ( int i = 0; i < eventActionLookup.Num(); ++i ) {
|
||||
eventActionLookup[ i ] = INVALID_ACTION_INDEX;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
idMenuWidget::~idMenuWidget
|
||||
========================
|
||||
*/
|
||||
idMenuWidget::~idMenuWidget() {
|
||||
Cleanup();
|
||||
}
|
||||
|
||||
void idMenuWidget::Cleanup() {
|
||||
for ( int j = 0; j < observers.Num(); ++j ) {
|
||||
assert( observers[j]->refCount > 0 );
|
||||
observers[ j ]->Release();
|
||||
}
|
||||
|
||||
observers.Clear();
|
||||
|
||||
// free all children
|
||||
for ( int i = 0; i < children.Num(); ++i ) {
|
||||
assert( children[i]->refCount > 0 );
|
||||
children[ i ]->Release();
|
||||
}
|
||||
|
||||
children.Clear();
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
idMenuWidget::AddChild
|
||||
========================
|
||||
*/
|
||||
void idMenuWidget::AddChild( idMenuWidget * widget ) {
|
||||
if ( !verify( children.Find( widget ) == NULL ) ) {
|
||||
return; // attempt to add a widget that was already in the list
|
||||
}
|
||||
|
||||
if ( widget->GetParent() != NULL ) {
|
||||
// take out of previous parent
|
||||
widget->GetParent()->RemoveChild( widget );
|
||||
}
|
||||
|
||||
widget->AddRef();
|
||||
widget->SetParent( this );
|
||||
children.Append( widget );
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
idMenuWidget::RemoveAllChildren
|
||||
========================
|
||||
*/
|
||||
void idMenuWidget::RemoveAllChildren() {
|
||||
|
||||
for ( int i = 0; i < children.Num(); ++ i ) {
|
||||
|
||||
assert( children[ i ]->GetParent() == this );
|
||||
|
||||
children[ i ]->SetParent( NULL );
|
||||
children[ i ]->Release();
|
||||
}
|
||||
|
||||
children.Clear();
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
idMenuWidget::RemoveChild
|
||||
========================
|
||||
*/
|
||||
void idMenuWidget::RemoveChild( idMenuWidget * widget ) {
|
||||
assert( widget->GetParent() == this );
|
||||
|
||||
children.Remove( widget );
|
||||
widget->SetParent( NULL );
|
||||
widget->Release();
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
idMenuWidget::RemoveChild
|
||||
========================
|
||||
*/
|
||||
bool idMenuWidget::HasChild( idMenuWidget * widget ) {
|
||||
for ( int i = 0; i < children.Num(); ++ i ) {
|
||||
if ( children[ i ] == widget ) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
idMenuWidget::ReceiveEvent
|
||||
|
||||
Events received through this function are passed to the innermost focused widget first, and then
|
||||
propagates back through each widget within the focus chain. The first widget that handles the
|
||||
event will stop propagation.
|
||||
|
||||
Each widget along the way will fire off an event to its observers, whether or not it actually
|
||||
handles the event.
|
||||
|
||||
Note: How the focus chain is calculated:
|
||||
Descend through GetFocus() calls until you reach a NULL focus. The terminating widget is the
|
||||
innermost widget, while *this* widget is the outermost widget.
|
||||
========================
|
||||
*/
|
||||
void idMenuWidget::ReceiveEvent( const idWidgetEvent & event ) {
|
||||
idStaticList< idMenuWidget *, 16 > focusChain;
|
||||
|
||||
int focusRunawayCounter = focusChain.Max();
|
||||
idMenuWidget * focusedWidget = this;
|
||||
while ( focusedWidget != NULL && --focusRunawayCounter != 0 ) {
|
||||
focusChain.Append( focusedWidget );
|
||||
focusedWidget = focusedWidget->GetFocus();
|
||||
}
|
||||
|
||||
// If hitting this then more than likely you have a self-referential chain. If that's not
|
||||
// the case, then you may need to increase the size of the focusChain list.
|
||||
assert( focusRunawayCounter != 0 );
|
||||
for ( int focusIndex = focusChain.Num() - 1; focusIndex >= 0; --focusIndex ) {
|
||||
idMenuWidget * const focusedWidget = focusChain[ focusIndex ];
|
||||
|
||||
if ( focusedWidget->ExecuteEvent( event ) ) {
|
||||
break; // this widget has handled the event, so stop propagation
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
========================
|
||||
idMenuWidget::ExecuteEvent
|
||||
|
||||
Handles the event directly, and doesn't pass it through the focus chain.
|
||||
|
||||
This should only be used in very specific circumstances! Most events should go to the focus.
|
||||
========================
|
||||
*/
|
||||
bool idMenuWidget::ExecuteEvent( const idWidgetEvent & event ) {
|
||||
idList< idWidgetAction, TAG_IDLIB_LIST_MENU > * const actions = GetEventActions( event.type );
|
||||
|
||||
if ( actions != NULL ) {
|
||||
for ( int actionIndex = 0; actionIndex < actions->Num(); ++actionIndex ) {
|
||||
HandleAction( ( *actions )[ actionIndex ], event, this );
|
||||
}
|
||||
}
|
||||
|
||||
SendEventToObservers( event );
|
||||
|
||||
return actions != NULL && actions->Num() > 0;
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
idMenuWidget::SendEventToObservers
|
||||
|
||||
Sends an event to all the observers
|
||||
========================
|
||||
*/
|
||||
void idMenuWidget::SendEventToObservers( const idWidgetEvent & event ) {
|
||||
for ( int i = 0; i < observers.Num(); ++i ) {
|
||||
observers[ i ]->ObserveEvent( *this, event );
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
idMenuWidget::RegisterEventObserver
|
||||
|
||||
Adds an observer to our observers list
|
||||
========================
|
||||
*/
|
||||
void idMenuWidget::RegisterEventObserver( idMenuWidget * observer ) {
|
||||
if ( !verify( observers.Find( observer ) == NULL ) ) {
|
||||
return;
|
||||
}
|
||||
|
||||
observer->AddRef();
|
||||
observers.Append( observer );
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
idMenuWidget::SetSpritePath
|
||||
========================
|
||||
*/
|
||||
void idMenuWidget::SetSpritePath( const char * arg1, const char * arg2, const char * arg3, const char * arg4, const char * arg5 ) {
|
||||
const char * args[] = { arg1, arg2, arg3, arg4, arg5 };
|
||||
const int numArgs = sizeof( args ) / sizeof( args[ 0 ] );
|
||||
spritePath.Clear();
|
||||
for ( int i = 0; i < numArgs; ++i ) {
|
||||
if ( args[ i ] == NULL ) {
|
||||
break;
|
||||
}
|
||||
spritePath.Append( args[ i ] );
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
idMenuWidget::SetSpritePath
|
||||
========================
|
||||
*/
|
||||
void idMenuWidget::SetSpritePath( const idList< idStr > & spritePath_, const char * arg1, const char * arg2, const char * arg3, const char * arg4, const char * arg5 ) {
|
||||
const char * args[] = { arg1, arg2, arg3, arg4, arg5 };
|
||||
const int numArgs = sizeof( args ) / sizeof( args[ 0 ] );
|
||||
spritePath = spritePath_;
|
||||
for ( int i = 0; i < numArgs; ++i ) {
|
||||
if ( args[ i ] == NULL ) {
|
||||
break;
|
||||
}
|
||||
spritePath.Append( args[ i ] );
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
idMenuWidget::ClearSprite
|
||||
========================
|
||||
*/
|
||||
void idMenuWidget::ClearSprite() {
|
||||
if ( GetSprite() == NULL ) {
|
||||
return;
|
||||
}
|
||||
GetSprite()->SetVisible( false );
|
||||
boundSprite = NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
idMenuWidget::GetSWFObject
|
||||
========================
|
||||
*/
|
||||
idSWF * idMenuWidget::GetSWFObject() {
|
||||
|
||||
if ( swfObj != NULL ) {
|
||||
return swfObj;
|
||||
}
|
||||
|
||||
if ( parent != NULL ) {
|
||||
return parent->GetSWFObject();
|
||||
}
|
||||
|
||||
if ( menuData != NULL ) {
|
||||
return menuData->GetGUI();
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
idMenuWidget::GetMenuData
|
||||
========================
|
||||
*/
|
||||
idMenuHandler * idMenuWidget::GetMenuData() {
|
||||
if ( parent != NULL ) {
|
||||
return parent->GetMenuData();
|
||||
}
|
||||
|
||||
return menuData;
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
idMenuWidget::BindSprite
|
||||
|
||||
Takes the sprite path strings and resolves it to an actual sprite relative to a given root.
|
||||
|
||||
This is setup in this manner, because we can't resolve from path -> sprite immediately since
|
||||
SWFs aren't necessarily loaded at the time widgets are instantiated.
|
||||
========================
|
||||
*/
|
||||
bool idMenuWidget::BindSprite( idSWFScriptObject & root ) {
|
||||
|
||||
const char * args[ 6 ] = { NULL };
|
||||
assert( GetSpritePath().Num() > 0 );
|
||||
for ( int i = 0; i < GetSpritePath().Num(); ++i ) {
|
||||
args[ i ] = GetSpritePath()[ i ].c_str();
|
||||
}
|
||||
boundSprite = root.GetNestedSprite( args[ 0 ], args[ 1 ], args[ 2 ], args[ 3 ], args[ 4 ], args[ 5 ] );
|
||||
return boundSprite != NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
idMenuWidget::Show
|
||||
========================
|
||||
*/
|
||||
void idMenuWidget::Show() {
|
||||
if ( GetSWFObject() == NULL ) {
|
||||
return;
|
||||
}
|
||||
|
||||
if ( !BindSprite( GetSWFObject()->GetRootObject() ) ) {
|
||||
return;
|
||||
}
|
||||
|
||||
GetSprite()->SetVisible( true );
|
||||
int currentFrame = GetSprite()->GetCurrentFrame();
|
||||
int findFrame = GetSprite()->FindFrame( "rollOn" );
|
||||
int idleFrame = GetSprite()->FindFrame( "idle" );
|
||||
if ( currentFrame == findFrame || ( currentFrame > 1 && currentFrame <= idleFrame ) ) {
|
||||
return;
|
||||
}
|
||||
|
||||
GetSprite()->PlayFrame( findFrame );
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
idMenuWidget::Hide
|
||||
========================
|
||||
*/
|
||||
void idMenuWidget::Hide() {
|
||||
if ( GetSWFObject() == NULL ) {
|
||||
return;
|
||||
}
|
||||
|
||||
if ( !BindSprite( GetSWFObject()->GetRootObject() ) ) {
|
||||
return;
|
||||
}
|
||||
|
||||
int currentFrame = GetSprite()->GetCurrentFrame();
|
||||
int findFrame = GetSprite()->FindFrame( "rollOff" );
|
||||
if ( currentFrame >= findFrame || currentFrame == 1 ) {
|
||||
return;
|
||||
}
|
||||
|
||||
GetSprite()->PlayFrame( findFrame );
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
idMenuWidget::SetDataSource
|
||||
========================
|
||||
*/
|
||||
void idMenuWidget::SetDataSource( idMenuDataSource * dataSource_, const int fieldIndex ) {
|
||||
dataSource = dataSource_;
|
||||
dataSourceFieldIndex = fieldIndex;
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
idMenuWidget::SetFocusIndex
|
||||
========================
|
||||
*/
|
||||
void idMenuWidget::SetFocusIndex( const int index, bool skipSound ) {
|
||||
|
||||
if ( GetChildren().Num() == 0 ) {
|
||||
return;
|
||||
}
|
||||
|
||||
const int oldIndex = focusIndex;
|
||||
|
||||
assert( index >= 0 && index < GetChildren().Num() ); //&& oldIndex >= 0 && oldIndex < GetChildren().Num() );
|
||||
|
||||
focusIndex = index;
|
||||
|
||||
if ( oldIndex != focusIndex && !skipSound ) {
|
||||
if ( menuData != NULL ) {
|
||||
menuData->PlaySound( GUI_SOUND_FOCUS );
|
||||
}
|
||||
}
|
||||
|
||||
idSWFParmList parms;
|
||||
parms.Append( oldIndex );
|
||||
parms.Append( index );
|
||||
|
||||
// need to mark the widget as having lost focus
|
||||
if ( oldIndex != index && oldIndex >= 0 && oldIndex < GetChildren().Num() && GetChildByIndex( oldIndex ).GetState() != WIDGET_STATE_HIDDEN ) {
|
||||
GetChildByIndex( oldIndex ).ReceiveEvent( idWidgetEvent( WIDGET_EVENT_FOCUS_OFF, 0, NULL, parms ) );
|
||||
}
|
||||
|
||||
//assert( GetChildByIndex( index ).GetState() != WIDGET_STATE_HIDDEN );
|
||||
GetChildByIndex( index ).ReceiveEvent( idWidgetEvent( WIDGET_EVENT_FOCUS_ON, 0, NULL, parms ) );
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
idMenuWidget_Button::SetState
|
||||
|
||||
Transitioning from the current button state to the new button state
|
||||
========================
|
||||
*/
|
||||
void idMenuWidget::SetState( const widgetState_t state ) {
|
||||
if ( GetSprite() != NULL ) {
|
||||
// FIXME: will need some more intelligence in the transitions to go from, say,
|
||||
// selected_up -> up ... but this should work fine for now.
|
||||
if ( state == WIDGET_STATE_HIDDEN ) {
|
||||
GetSprite()->SetVisible( false );
|
||||
} else {
|
||||
GetSprite()->SetVisible( true );
|
||||
if ( state == WIDGET_STATE_DISABLED ) {
|
||||
GetSprite()->PlayFrame( "disabled" );
|
||||
} else if ( state == WIDGET_STATE_SELECTING ) {
|
||||
if ( widgetState == WIDGET_STATE_NORMAL ) {
|
||||
GetSprite()->PlayFrame( "selecting" ); // transition from unselected to selected
|
||||
} else {
|
||||
GetSprite()->PlayFrame( "sel_up" );
|
||||
}
|
||||
} else if ( state == WIDGET_STATE_SELECTED ) {
|
||||
GetSprite()->PlayFrame( "sel_up" );
|
||||
} else if ( state == WIDGET_STATE_NORMAL ) {
|
||||
if ( widgetState == WIDGET_STATE_SELECTING ) {
|
||||
GetSprite()->PlayFrame( "unselecting" ); // transition from selected to unselected
|
||||
} else if ( widgetState != WIDGET_STATE_HIDDEN && widgetState != WIDGET_STATE_NORMAL ) {
|
||||
GetSprite()->PlayFrame( "out" );
|
||||
} else {
|
||||
GetSprite()->PlayFrame( "up" );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Update();
|
||||
}
|
||||
|
||||
widgetState = state;
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
idMenuWidget::HandleAction
|
||||
========================
|
||||
*/
|
||||
bool idMenuWidget::HandleAction( idWidgetAction & action, const idWidgetEvent & event, idMenuWidget * widget, bool forceHandled ) {
|
||||
|
||||
bool handled = false;
|
||||
if ( GetParent() != NULL ) {
|
||||
handled = GetParent()->HandleAction( action, event, widget );
|
||||
} else {
|
||||
|
||||
if ( forceHandled ) {
|
||||
return false;
|
||||
}
|
||||
|
||||
idMenuHandler * data = GetMenuData();
|
||||
if ( data != NULL ) {
|
||||
return data->HandleAction( action, event, widget, false );
|
||||
}
|
||||
}
|
||||
|
||||
return handled;
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
idMenuWidget::GetEventActions
|
||||
========================
|
||||
*/
|
||||
idList< idWidgetAction, TAG_IDLIB_LIST_MENU > * idMenuWidget::GetEventActions( const widgetEvent_t eventType ) {
|
||||
if ( eventActionLookup[ eventType ] == INVALID_ACTION_INDEX ) {
|
||||
return NULL;
|
||||
}
|
||||
return &eventActions[ eventActionLookup[ eventType ] ];
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
idMenuWidget::AddEventAction
|
||||
========================
|
||||
*/
|
||||
idWidgetAction & idMenuWidget::AddEventAction( const widgetEvent_t eventType ) {
|
||||
if ( eventActionLookup[ eventType ] == INVALID_ACTION_INDEX ) {
|
||||
eventActionLookup[ eventType ] = eventActions.Num();
|
||||
eventActions.Alloc();
|
||||
}
|
||||
return eventActions[ eventActionLookup[ eventType ] ].Alloc();
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
idMenuWidget::ClearEventActions
|
||||
========================
|
||||
*/
|
||||
void idMenuWidget::ClearEventActions() {
|
||||
eventActions.Clear();
|
||||
eventActionLookup.Clear();
|
||||
eventActionLookup.SetNum( eventActionLookup.Max() );
|
||||
for ( int i = 0; i < eventActionLookup.Num(); ++i ) {
|
||||
eventActionLookup[ i ] = INVALID_ACTION_INDEX;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user