You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 

996 lines
28 KiB

/*==LICENSE==*
CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011 Cyan Worlds, Inc.
This program 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.
This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
You can contact Cyan Worlds, Inc. by email legal@cyan.com
or by snail mail at:
Cyan Worlds, Inc.
14617 N Newport Hwy
Mead, WA 99021
*==LICENSE==*/
//////////////////////////////////////////////////////////////////////////////
// //
// pfGUIControlMod Definition //
// //
//////////////////////////////////////////////////////////////////////////////
#include "hsTypes.h"
#include "pfGUIControlMod.h"
#include "pfGameGUIMgr.h"
#include "pfGUIDialogMod.h"
#include "pfGUIControlHandlers.h"
#include "pfGUIDialogHandlers.h"
#include "pfGUIListElement.h" // Includes dropTargetProc
#include "pnMessage/plRefMsg.h"
#include "pnMessage/plEnableMsg.h"
#include "pfMessage/pfGameGUIMsg.h"
#include "pnSceneObject/plDrawInterface.h"
#include "pnSceneObject/plCoordinateInterface.h"
#include "pnSceneObject/plAudioInterface.h"
#include "plGImage/plDynamicTextMap.h"
#include "plSurface/plLayer.h"
#include "plMessage/plRenderMsg.h"
#include "pnMessage/plSoundMsg.h"
#include "plPipeline.h"
#include "plDrawable/plAccessGeometry.h"
#include "plDrawable/plAccessSpan.h"
#include "plDrawable/plAccessVtxSpan.h"
#include "pfGUIPopUpMenu.h" // For skin, can we move that please? Thank you
#include "plgDispatch.h"
#include "hsResMgr.h"
//// pfGUIColorScheme Functions //////////////////////////////////////////////
void pfGUIColorScheme::IReset( void )
{
fForeColor.Set( 1, 1, 1, 1 );
fBackColor.Set( 0, 0, 0, 1 );
fSelForeColor.Set( 1, 1, 1, 1 );
fSelBackColor.Set( 0, 0, 1, 1 );
fTransparent = false;
fFontFace = hsStrcpy( "Times New Roman" );
fFontSize = 10;
fFontFlags = 0;
}
pfGUIColorScheme::pfGUIColorScheme()
{
IReset();
}
pfGUIColorScheme::~pfGUIColorScheme()
{
delete [] fFontFace;
}
pfGUIColorScheme::pfGUIColorScheme( hsColorRGBA &foreColor, hsColorRGBA &backColor )
{
IReset();
fForeColor = foreColor;
fBackColor = backColor;
}
pfGUIColorScheme::pfGUIColorScheme( const char *face, UInt8 size, UInt8 fontFlags )
{
IReset();
fFontFace = hsStrcpy( face );
fFontSize = size;
fFontFlags = fontFlags;
}
void pfGUIColorScheme::SetFontFace( const char *face )
{
delete [] fFontFace;
fFontFace = hsStrcpy( face );
}
void pfGUIColorScheme::Read( hsStream *s )
{
fForeColor.Read( s );
fBackColor.Read( s );
fSelForeColor.Read( s );
fSelBackColor.Read( s );
s->ReadSwap( &fTransparent );
delete [] fFontFace;
fFontFace = s->ReadSafeString();
s->ReadSwap( &fFontSize );
s->ReadSwap( &fFontFlags );
}
void pfGUIColorScheme::Write( hsStream *s )
{
fForeColor.Write( s );
fBackColor.Write( s );
fSelForeColor.Write( s );
fSelBackColor.Write( s );
s->WriteSwap( fTransparent );
s->WriteSafeString( fFontFace );
s->WriteSwap( fFontSize );
s->WriteSwap( fFontFlags );
}
//// Constructor/Destructor //////////////////////////////////////////////////
pfGUIControlMod::pfGUIControlMod()
{
fEnabled = true;
fDialog = nil;
fBoundsValid = false;
fCenterValid = false;
fFocused = false;
fInteresting = false;
fVisible = true;
fHandler = nil;
fTagID = 0;
fDropTargetHdlr = nil;
fDynTextMap = nil;
fProxy = nil;
fColorScheme = nil;
fSkin = nil;
fNotifyOnInteresting = false;
}
pfGUIControlMod::~pfGUIControlMod()
{
ISetHandler( nil );
SetDropTargetHdlr( nil );
SetColorScheme( nil );
}
//// IEval ///////////////////////////////////////////////////////////////////
hsBool pfGUIControlMod::IEval( double secs, hsScalar del, UInt32 dirty )
{
// UpdateBounds();
return false;
}
//// GetBounds ///////////////////////////////////////////////////////////////
const hsBounds3 &pfGUIControlMod::GetBounds( void )
{
UpdateBounds();
return fBounds;
}
//// SetTransform ////////////////////////////////////////////////////////////
// Override from plModifier so we can update our bounds
void pfGUIControlMod::SetTransform( const hsMatrix44 &l2w, const hsMatrix44 &w2l )
{
fBoundsValid = false;
}
//// GetVectorAngle //////////////////////////////////////////////////////////
static hsScalar GetVectorAngle( const hsPoint3 &basePt, const hsPoint3 &pointA, const hsPoint3 &pointB )
{
hsVector3 vectorA( &pointA, &basePt ), vectorB( &pointB, &basePt );
hsScalar dot = vectorA * vectorB;
hsVector3 cross = vectorA % vectorB;
hsScalar crossLen = cross.fZ;
return atan2( crossLen, dot );
}
//// CreateConvexHull ////////////////////////////////////////////////////////
// Algorithm is Graham's scan algorithm:
// R.L. Graham, "An efficient algorithm for determining the convex hull of a finite
// planar set", Info. Proc. Lett. 1, 132-133 (1972).
// Note: THIS WILL DESTROY YOUR INPOINTS ARRAY.
static hsBool CreateConvexHull( hsPoint3 *inPoints, int &numPoints )
{
int i, j, pointA, pointB, pointC;
hsScalar *angles;
if( numPoints < 3 )
return false;
// Step 1: Find a point interior to our hull. Easiest is average of all our input points...
// (plus: set the Zs of all the points to the Z of the first point, since we want to be
// working in 2D)
hsPoint3 avgPoint = inPoints[ 0 ];
for( i = 1; i < numPoints; i++ )
{
avgPoint += inPoints[ i ];
inPoints[ i ].fZ = inPoints[ 0 ].fZ;
}
avgPoint.fX /= numPoints;
avgPoint.fY /= numPoints;
avgPoint.fZ /= numPoints;
// Step 2: Sort all the in points by the angle to the X axis (vector <1,0>).
// Step A: Calculate all the angles
angles = TRACKED_NEW hsScalar[ numPoints ];
hsPoint3 xAxisPoint( avgPoint.fX + 1, avgPoint.fY, avgPoint.fZ );
for( i = 0; i < numPoints; i++ )
angles[ i ] = GetVectorAngle( avgPoint, inPoints[ i ], xAxisPoint );
// Step B: Bubble sort by the angles
for( i = 0; i < numPoints - 1; i++ )
{
for( j = i + 1; j < numPoints; j++ )
{
if( angles[ j ] < angles[ i ] )
{
hsScalar tempAngle = angles[ j ];
angles[ j ] = angles[ i ];
angles[ i ] = tempAngle;
hsPoint3 tempPt = inPoints[ j ];
inPoints[ j ] = inPoints[ i ];
inPoints[ i ] = tempPt;
}
}
}
// Step 3: Eliminate non-convex points to form the hull
for( pointA = 0, pointB = 1, pointC = 2; pointA < numPoints && numPoints > 3; )
{
// Two cases of wrap-around...
if( pointC >= numPoints )
pointC -= numPoints;
else if( pointC < 0 )
pointC += numPoints;
if( pointB >= numPoints )
pointB -= numPoints;
else if( pointB < 0 )
pointB += numPoints;
// For points A, B, and C, find the interior angle between them
hsScalar angle = GetVectorAngle( inPoints[ pointB ], inPoints[ pointA ], inPoints[ pointC ] );
// If the angle is < 180, then it's a good angle and we can advance all our points by 1...
// Note: we have a tolerance so that we don't get points that form edges that are pretty darned close...
const hsScalar tolerance = hsScalarPI / 90.f;
if( angle > tolerance && angle < hsScalarPI - tolerance )
{
pointA++;
pointB++;
pointC++;
}
else
{
// Angle is > 180 degrees, this is bad. This means our middle point doesn't belong,
// so we need to remove it
for( i = pointB; i < numPoints - 1; i++ )
inPoints[ i ] = inPoints[ i + 1 ];
numPoints--;
if( pointC > pointB )
pointC--;
// There's one case where point B and C could've wrapped around and so deleting that point
// actually moves point A down by 1...
if( pointA > pointB )
pointA--;
// Back up the points by 1 if possible (so we can keep checking to make sure we're still convex).
// If not, just increment C up
if( pointA > 0 )
{
pointA--;
pointB--;
}
else
pointC++;
}
}
delete [] angles;
return true;
}
//// GetObjectPoints /////////////////////////////////////////////////////////
// Retrieves ALL of the points of a sceneObject's meshes. And I mean ALL of
// 'em...
static void GetObjectPoints( plSceneObject *so, hsTArray<hsPoint3> &outPoints )
{
const plDrawInterface* di = so->GetDrawInterface();
if( !di )
return;
// The following uses mf's spiffy plAccessGeometry/Spans stuff, which, in
// one word, kicksAss.
hsTArray<plAccessSpan> spans;
plAccessGeometry::Instance()->OpenRO( di, spans );
int i;
outPoints.Reset();
for( i = 0; i < spans.GetCount(); i++ )
{
plAccessVtxSpan& vtxSrc = spans[ i ].AccessVtx();
plAccPositionIterator iterSrc( &vtxSrc );
for( iterSrc.Begin(); iterSrc.More(); iterSrc.Advance() )
outPoints.Append( *iterSrc.Position() );
}
if (plAccessGeometry::Instance())
plAccessGeometry::Instance()->Close( spans );
}
//// PointsOnSameSide ////////////////////////////////////////////////////////
// Given two ends of a line segment and two points, tells you whether the
// two points are on the same side of the line. Used in PointInTriangle().
static hsBool PointsOnSameSide( const hsPoint3 &line1, const hsPoint3 &line2, const hsPoint3 &pointA, const hsPoint3 &pointB )
{
hsVector3 baseVec( &line2, &line1 );
hsVector3 cp1 = hsVector3( &pointA, &line1 ) % baseVec;
hsVector3 cp2 = hsVector3( &pointB, &line1 ) % baseVec;
return ( cp1.fZ * cp2.fZ > 0 ) ? true : false;
}
//// PointInTriangle /////////////////////////////////////////////////////////
// Given three points that define a triangle and a fourth point, tells you
// whether the fourth point is inside the triangle.
static hsBool PointInTriangle( hsPoint3 tri1, hsPoint3 tri2, hsPoint3 tri3, const hsPoint3 &testPoint )
{
tri1.fZ = tri2.fZ = tri3.fZ = testPoint.fZ;
if( PointsOnSameSide( tri1, tri2, testPoint, tri3 ) &&
PointsOnSameSide( tri2, tri3, testPoint, tri1 ) &&
PointsOnSameSide( tri3, tri1, testPoint, tri2 ) )
return true;
return false;
}
//// PointInBounds ///////////////////////////////////////////////////////////
// Tells you whether said point is in the control's bounds.
hsBool pfGUIControlMod::PointInBounds( const hsPoint3 &point )
{
UpdateBounds();
if( fBounds.GetType() != kBoundsEmpty && fBounds.GetType() != kBoundsUninitialized && fBounds.IsInside( &point ) )
{
if( fBoundsPoints.GetCount() > 0 )
{
// We have a more-accurate bounds set, so use it
int i;
for( i = 1; i < fBoundsPoints.GetCount() - 1; i++ )
{
// Test the triangle (0,i,i+1)
if( PointInTriangle( fBoundsPoints[ 0 ], fBoundsPoints[ i ], fBoundsPoints[ i + 1 ], point ) )
return true;
}
return false;
}
else
return true;
}
return false;
}
//// CalcInitialBounds ///////////////////////////////////////////////////////
// Called by the dialog once as soon as the dialog adds the control, so that
// initial bounds for the control can be calced. This is used for initing
// any dynmaic text maps, since we want to use the initial bounds to do so
// instead of any currently animated state of the bounds.
void pfGUIControlMod::CalcInitialBounds( void )
{
UpdateBounds( nil, true );
fInitialBounds = fBounds;
}
//// UpdateBounds ////////////////////////////////////////////////////////////
void pfGUIControlMod::UpdateBounds( hsMatrix44 *invXformMatrix, hsBool force )
{
hsMatrix44 xformMatrix, projMatrix;
hsPoint3 corners[ 8 ];
int i;
if( ( !fBoundsValid || force ) && fDialog && GetTarget() )
{
plDrawInterface *DI = IGetTargetDrawInterface( 0 );
if( DI == nil )
return;
if( HasFlag( kBetterHitTesting ) )
{
hsTArray<hsPoint3> scrnPoints;
// Create a list of points to make a 2D convex hull from
GetObjectPoints( GetTarget(), scrnPoints );
hsMatrix44 l2w = GetTarget()->GetLocalToWorld();
for( i = 0; i < scrnPoints.GetCount(); i++ )
{
scrnPoints[ i ] = l2w * scrnPoints[ i ];
scrnPoints[ i ] = fDialog->WorldToScreenPoint( scrnPoints[ i ] );
}
// Now create a convex hull from them, assuming the Zs are all the same
int numPoints = scrnPoints.GetCount();
if( !CreateConvexHull( scrnPoints.AcquireArray(), numPoints ) )
return;
// Copy & store. Also recalc our bounding box just for fun
fBounds.MakeEmpty();
fBoundsPoints.SetCount( numPoints );
for( i = 0; i < numPoints; i++ )
{
fBoundsPoints[ i ] = scrnPoints[ i ];
fBounds.Union( &fBoundsPoints[ i ] );
}
}
else
{
fBounds.MakeEmpty();
hsBounds3Ext worldBounds = DI->GetLocalBounds();
hsMatrix44 l2w = GetTarget()->GetLocalToWorld();
worldBounds.Transform( &l2w );
worldBounds.GetCorners( corners );
for( i = 0; i < 8; i++ )
{
hsPoint3 scrnPt = fDialog->WorldToScreenPoint( corners[ i ] );
fBounds.Union( &scrnPt );
}
}
// Calc center Z
// if( !fCenterValid )
{
#if 0
corners[ 1 ] = GetTarget()->GetLocalToWorld().GetTranslate();
float w = corners[ 1 ].fX * fXformMatrix.fMap[3][0]
+ corners[ 1 ].fY * fXformMatrix.fMap[3][1]
+ corners[ 1 ].fZ * fXformMatrix.fMap[3][2]
+ 1.f * fXformMatrix.fMap[3][3];
corners[ 1 ] = fXformMatrix * corners[ 1 ];
corners[ 1 ].fX = ( ( corners[ 1 ].fX / corners[ 1 ].fZ ) + 1.f ) / 2.f;
corners[ 1 ].fY = ( ( corners[ 1 ].fY / corners[ 1 ].fZ ) + 1.f ) / 2.f;
fScreenCenter = corners[ 1 ];
// fScreenCenter.fZ = w;
corners[ 1 ] = GetTarget()->GetLocalToWorld().GetTranslate();
fDialog->WorldToScreenPoint( corners[ 1 ].fX, corners[ 1 ].fY, corners[ 1 ].fZ, fScreenCenter );
fCenterValid = true;
#else
corners[ 1 ] = GetTarget()->GetLocalToWorld().GetTranslate();
fScreenCenter = fDialog->WorldToScreenPoint( corners[ 1 ] );
corners[ 1 ] = fScreenCenter;
fCenterValid = true;
#endif
}
fScreenMinZ = fBounds.GetMins().fZ;
// Manually change the bounds so we know the z ranges from at least -1 to 1, suitable for us testing against for clicks
corners[ 0 ] = fBounds.GetCenter();
corners[ 0 ].fZ = -1.f;
fBounds.Union( &corners[ 0 ] );
corners[ 0 ].fZ = 1.f;
fBounds.Union( &corners[ 0 ] );
fBoundsValid = true;
}
}
//// SetObjectCenter /////////////////////////////////////////////////////////
// Given the x/y coordinates in 0..1 space, recalcs the sceneObject position
// and moves the object to match, retaining the stored fCenterZ coordinate
void pfGUIControlMod::SetObjectCenter( hsScalar x, hsScalar y )
{
hsMatrix44 xformMatrix, l2p, p2l;
hsPoint3 center, corners[ 8 ];
if( x > 1.f )
x = 1.f;
else if( x < 0.f )
x = 0.f;
if( y > 1.f )
y = 1.f;
else if( y < 0.f )
y = 0.f;
if( fDialog && GetTarget() )
{
plCoordinateInterface *CI = IGetTargetCoordinateInterface( 0 );
if( CI == nil )
return;
// if( !fInvXformValid )
// UpdateBounds();
l2p = GetTarget()->GetLocalToWorld();
hsPoint3 oldPt = l2p.GetTranslate();
hsPoint3 oldScrnPt = fDialog->WorldToScreenPoint( oldPt );
hsPoint3 oldPtRedux;
fDialog->ScreenToWorldPoint( oldScrnPt.fX, oldScrnPt.fY, oldScrnPt.fZ, oldPtRedux );
fDialog->ScreenToWorldPoint( x, y, fScreenCenter.fZ, center );
l2p.SetTranslate( &center );
l2p.GetInverse( &p2l );
GetTarget()->SetTransform( l2p, p2l );
fScreenCenter.fX = x;
fScreenCenter.fY = y;
}
}
void pfGUIControlMod::SetTarget( plSceneObject *object )
{
plSingleModifier::SetTarget( object );
UpdateBounds();
}
//// MsgReceive //////////////////////////////////////////////////////////////
#include "plProfile.h"
plProfile_CreateTimer("Gui", "RenderSetup", GUITime);
hsBool pfGUIControlMod::MsgReceive( plMessage *msg )
{
plRenderMsg* rend = plRenderMsg::ConvertNoRef( msg );
if( rend )
{
plProfile_BeginLap(GUITime, this->GetKey()->GetUoid().GetObjectName());
// Only need it once
if( ISetUpDynTextMap( rend->Pipeline() ) )
plgDispatch::Dispatch()->UnRegisterForExactType( plRenderMsg::Index(), GetKey() );
plProfile_EndLap(GUITime, this->GetKey()->GetUoid().GetObjectName());
return true;
}
plGenRefMsg *refMsg = plGenRefMsg::ConvertNoRef( msg );
if( refMsg != nil )
{
if( refMsg->fType == kRefDynTextMap )
{
if( refMsg->GetContext() & ( plRefMsg::kOnCreate | plRefMsg::kOnRequest | plRefMsg::kOnReplace ) )
{
fDynTextMap = plDynamicTextMap::ConvertNoRef( refMsg->GetRef() );
// Register for a render msg so we can leech the material when we finally
// have a pipeline to work with
plgDispatch::Dispatch()->RegisterForExactType( plRenderMsg::Index(), GetKey() );
}
else
fDynTextMap = nil;
return true;
}
else if( refMsg->fType == kRefDynTextLayer )
{
if( refMsg->GetContext() & ( plRefMsg::kOnCreate | plRefMsg::kOnRequest | plRefMsg::kOnReplace ) )
fDynTextLayer = plLayerInterface::ConvertNoRef( refMsg->GetRef() );
else
fDynTextLayer = nil;
return true;
}
else if( refMsg->fType == kRefProxy )
{
if( refMsg->GetContext() & ( plRefMsg::kOnCreate | plRefMsg::kOnRequest | plRefMsg::kOnReplace ) )
fProxy = plSceneObject::ConvertNoRef( refMsg->GetRef() );
else
fProxy = nil;
return true;
}
else if( refMsg->fType == kRefSkin )
{
if( refMsg->GetContext() & ( plRefMsg::kOnCreate | plRefMsg::kOnRequest | plRefMsg::kOnReplace ) )
fSkin = pfGUISkin::ConvertNoRef( refMsg->GetRef() );
else
fSkin = nil;
return true;
}
}
return plSingleModifier::MsgReceive( msg );
}
//// ISetUpDynTextMap ////////////////////////////////////////////////////////
// Given a pointer to a dynamic text map, regurgitates it so it matches our
// screen res and fun stuff like that. Also sets the layer transform to give
// us a 1:1 textel-pixel ratio, which we like.
hsBool pfGUIControlMod::ISetUpDynTextMap( plPipeline *pipe )
{
if( fDynTextMap == nil )
{
hsAssert( false, "Trying to set up a nil dynamicTextMap in a GUI control" );
return true;
}
if( fDynTextLayer == nil || fInitialBounds.GetType() == kBoundsUninitialized )//|| fDialog == nil )
return false;
UInt32 scrnWidth, scrnHeight;
if( !HasFlag( kScaleTextWithResolution ) )
{
// Scale so that there is a 1:1 pixel:textel ratio
scrnWidth = pipe->Width();
scrnHeight = pipe->Height();
}
else
{
// Scale with the resolution so that we take up the same % of screen space no matter what resolution
// Assume a base "resolution" of 1024xX, where X is such that the ratio "1024/X = scrnWidth/scrnHt" holds
const int kBaseScaleRes = 1024;
const int kBaseScaleHeightRes = 768;
scrnWidth = kBaseScaleRes;
scrnHeight = kBaseScaleHeightRes;
// we are going to just force things to be in 4 by 3 ratio...
// ...cause it seems to work better.
/////// scrnHeight = ( pipe->Height() * kBaseScaleRes ) / pipe->Width();
}
const hsBounds3 &bounds = fInitialBounds;//GetBounds();
UInt16 width = (UInt16)(( bounds.GetMaxs().fX - bounds.GetMins().fX ) * scrnWidth);
UInt16 height = (UInt16)(( bounds.GetMaxs().fY - bounds.GetMins().fY ) * scrnHeight);
// Allow derived controls to allocate some extra scratch space if desired
// (Do it this way so we can pass in our current calculated dimensions for them to play with)
UInt16 extraW = width, extraH = height;
IGrowDTMDimsToDesiredSize( extraW, extraH );
extraW -= width;
extraH -= height;
fDynTextMap->Reset();
fDynTextMap->Create( width, height, HasFlag( kXparentBgnd ), extraW, extraH );
fDynTextMap->SetFont( GetColorScheme()->fFontFace, GetColorScheme()->fFontSize, GetColorScheme()->fFontFlags,
HasFlag( kXparentBgnd ) ? false : true );
fDynTextMap->SetTextColor( GetColorScheme()->fForeColor,
( HasFlag( kXparentBgnd ) && GetColorScheme()->fBackColor.a == 0.f ) ? true : false );
// Now we gotta set the texture transform on the layer so our texture comes
// out with 1:1 mapping from textel to pixel
plLayer *layer = (plLayer *)fDynTextLayer;
layer->SetTransform( fDynTextMap->GetLayerTransform() );
// Let the derived classes do their things
IPostSetUpDynTextMap();
// Do our first update
IUpdate();
return true;
}
//// Get/SetColorScheme //////////////////////////////////////////////////////
pfGUIColorScheme *pfGUIControlMod::GetColorScheme( void ) const
{
if( fColorScheme == nil )
return fDialog->GetColorScheme();
return fColorScheme;
}
void pfGUIControlMod::SetColorScheme( pfGUIColorScheme *newScheme )
{
if( fColorScheme != nil )
{
hsRefCnt_SafeUnRef( fColorScheme );
fColorScheme = nil;
}
fColorScheme = newScheme;
if( fColorScheme != nil )
hsRefCnt_SafeRef( fColorScheme );
}
//// SetDynTextMap ///////////////////////////////////////////////////////////
// EXPORT ONLY
void pfGUIControlMod::SetDynTextMap( plLayerInterface *layer, plDynamicTextMap *dynText )
{
hsgResMgr::ResMgr()->AddViaNotify( layer->GetKey(), TRACKED_NEW plGenRefMsg( GetKey(), plRefMsg::kOnCreate, -1, pfGUIControlMod::kRefDynTextLayer ), plRefFlags::kActiveRef );
hsgResMgr::ResMgr()->AddViaNotify( dynText->GetKey(), TRACKED_NEW plGenRefMsg( GetKey(), plRefMsg::kOnCreate, -1, pfGUIControlMod::kRefDynTextMap ), plRefFlags::kActiveRef );
}
//// SetEnabled //////////////////////////////////////////////////////////////
void pfGUIControlMod::SetEnabled( hsBool e )
{
if( e == fEnabled )
return;
fEnabled = e;
IUpdate();
}
//// SetFocused //////////////////////////////////////////////////////////////
void pfGUIControlMod::SetFocused( hsBool e )
{
if( e == fFocused )
return;
fFocused = e;
IUpdate();
}
//// SetInteresting //////////////////////////////////////////////////////////
void pfGUIControlMod::SetInteresting( hsBool i )
{
if( i == fInteresting )
return;
fInteresting = i;
IUpdate();
if ( fNotifyOnInteresting && fDialog && fDialog->GetHandler() )
fDialog->GetHandler()->OnInterestingEvent(this);
}
//// SetVisible //////////////////////////////////////////////////////////////
void pfGUIControlMod::SetVisible( hsBool vis )
{
if( vis == fVisible )
return;
fVisible = vis;
if (fTarget)
{
plEnableMsg *msg = TRACKED_NEW plEnableMsg();
msg->SetCmd( fVisible ? plEnableMsg::kEnable : plEnableMsg::kDisable );
msg->SetCmd( plEnableMsg::kDrawable );
msg->AddReceiver( fTarget->GetKey() );
plgDispatch::MsgSend( msg );
}
if( !fVisible && fFocused )
fDialog->SetFocus( nil );
}
void pfGUIControlMod::Refresh( void )
{
IUpdate();
}
//// Read/Write //////////////////////////////////////////////////////////////
void pfGUIControlMod::Read( hsStream *s, hsResMgr *mgr )
{
plSingleModifier::Read(s, mgr);
s->ReadSwap( &fTagID );
fVisible = s->ReadBool();
// Read the handler in
ISetHandler( pfGUICtrlProcWriteableObject::Read( s ) );
// Read in the dynTextMap if there is one
if( s->ReadBool() )
{
mgr->ReadKeyNotifyMe( s, TRACKED_NEW plGenRefMsg( GetKey(), plRefMsg::kOnCreate, -1, kRefDynTextLayer ), plRefFlags::kActiveRef );
mgr->ReadKeyNotifyMe( s, TRACKED_NEW plGenRefMsg( GetKey(), plRefMsg::kOnCreate, -1, kRefDynTextMap ), plRefFlags::kActiveRef );
}
else
{
fDynTextLayer = nil;
fDynTextMap = nil;
}
if( s->ReadBool() )
{
SetColorScheme( nil );
fColorScheme = TRACKED_NEW pfGUIColorScheme();
fColorScheme->Read( s );
}
// Read in our sound indices
UInt8 i, count = s->ReadByte();
if( count == 0 )
fSoundIndices.Reset();
else
{
fSoundIndices.SetCountAndZero( count );
for( i = 0; i < count; i++ )
fSoundIndices[ i ] = (int)s->ReadSwap32();
}
if( HasFlag( kHasProxy ) )
mgr->ReadKeyNotifyMe( s, TRACKED_NEW plGenRefMsg( GetKey(), plRefMsg::kOnCreate, -1, kRefProxy ), plRefFlags::kActiveRef );
mgr->ReadKeyNotifyMe( s, TRACKED_NEW plGenRefMsg( GetKey(), plRefMsg::kOnCreate, -1, kRefSkin ), plRefFlags::kActiveRef );
}
void pfGUIControlMod::Write( hsStream *s, hsResMgr *mgr )
{
if( HasFlag( kHasProxy ) && !fProxy )
ClearFlag( kHasProxy );
plSingleModifier::Write( s, mgr );
s->WriteSwap( fTagID );
s->WriteBool( fVisible );
// Write the handler out (if it's not a writeable, damn you)
pfGUICtrlProcWriteableObject::Write( (pfGUICtrlProcWriteableObject *)fHandler, s );
// Write out the dynTextMap
if( fDynTextMap != nil )
{
s->WriteBool( true );
mgr->WriteKey( s, fDynTextLayer->GetKey() );
mgr->WriteKey( s, fDynTextMap->GetKey() );
}
else
s->WriteBool( false );
if( fColorScheme != nil )
{
s->WriteBool( true );
fColorScheme->Write( s );
}
else
s->WriteBool( false );
// Write out our sound indices
s->WriteByte( fSoundIndices.GetCount() );
UInt8 i;
for( i = 0; i < fSoundIndices.GetCount(); i++ )
s->WriteSwap32( fSoundIndices[ i ] );
if( HasFlag( kHasProxy ) )
mgr->WriteKey( s, fProxy->GetKey() );
mgr->WriteKey( s, fSkin );
}
//// HandleKeyPress/Event ////////////////////////////////////////////////////
hsBool pfGUIControlMod::HandleKeyPress( char key, UInt8 modifiers )
{
return false;
}
hsBool pfGUIControlMod::HandleKeyEvent( pfGameGUIMgr::EventType event, plKeyDef key, UInt8 modifiers )
{
return false;
}
//// IScreenToLocalPt ////////////////////////////////////////////////////////
void pfGUIControlMod::IScreenToLocalPt( hsPoint3 &pt )
{
const hsBounds3 &bnds = GetBounds();
pt.fX -= bnds.GetMins().fX;
pt.fY -= bnds.GetMins().fY;
pt.fX /= bnds.GetMaxs().fX - bnds.GetMins().fX;
pt.fY /= bnds.GetMaxs().fY - bnds.GetMins().fY;
}
//// ISetHandler /////////////////////////////////////////////////////////////
void pfGUIControlMod::ISetHandler( pfGUICtrlProcObject *h, hsBool clearInheritFlag )
{
if( fHandler && fHandler->DecRef() )
delete fHandler;
fHandler = h;
if( fHandler )
fHandler->IncRef();
if( clearInheritFlag )
ClearFlag( kInheritProcFromDlg );
}
//// DoSomething /////////////////////////////////////////////////////////////
void pfGUIControlMod::DoSomething( void )
{
if( fEnabled && fHandler != nil )
fHandler->DoSomething( this );
}
//// HandleExtendedEvent /////////////////////////////////////////////////////
void pfGUIControlMod::HandleExtendedEvent( UInt32 event )
{
if( fEnabled && fHandler != nil )
fHandler->HandleExtendedEvent( this, event );
}
//// SetDropTargetHdlr ///////////////////////////////////////////////////////
void pfGUIControlMod::SetDropTargetHdlr( pfGUIDropTargetProc *h )
{
if( fDropTargetHdlr && fDropTargetHdlr->DecRef() )
delete fDropTargetHdlr;
fDropTargetHdlr = h;
if( fDropTargetHdlr )
fDropTargetHdlr->IncRef();
}
//// SetSoundIndex ///////////////////////////////////////////////////////////
// Associates the given GUI event with an index of a sound on the target SO's
// audioInterface. The guiCtrlEvent is specific to each type of control.
void pfGUIControlMod::SetSoundIndex( UInt8 guiCtrlEvent, int soundIndex )
{
if( fSoundIndices.GetCount() < guiCtrlEvent + 1 )
fSoundIndices.ExpandAndZero( guiCtrlEvent + 1 );
fSoundIndices[ guiCtrlEvent ] = soundIndex + 1; // We +1, since 0 means no sound
}
//// IPlaySound //////////////////////////////////////////////////////////////
// Sends a sound play message with the soundIndex associated with the given
// event.
void pfGUIControlMod::IPlaySound( UInt8 guiCtrlEvent, hsBool loop /* = false */ )
{
if( guiCtrlEvent >= fSoundIndices.GetCount() || fSoundIndices[ guiCtrlEvent ] == 0 )
return;
if( GetTarget() == nil || GetTarget()->GetAudioInterface() == nil )
return;
plSoundMsg *msg = TRACKED_NEW plSoundMsg;
msg->fIndex = fSoundIndices[ guiCtrlEvent ] - 1;
msg->SetCmd( plSoundMsg::kGoToTime );
msg->fTime = 0.f;
msg->SetCmd( plSoundMsg::kPlay );
if (loop)
{
msg->fLoop = true;
msg->SetCmd( plSoundMsg::kSetLooping );
}
msg->Send( GetTarget()->GetAudioInterface()->GetKey() );
}
void pfGUIControlMod::IStopSound(UInt8 guiCtrlEvent)
{
if (guiCtrlEvent >= fSoundIndices.GetCount() || fSoundIndices[guiCtrlEvent] == 0)
return;
if (GetTarget() == nil || GetTarget()->GetAudioInterface() == nil )
return;
plSoundMsg *msg = TRACKED_NEW plSoundMsg;
msg->fIndex = fSoundIndices[guiCtrlEvent] - 1;
msg->SetCmd(plSoundMsg::kStop);
msg->Send(GetTarget()->GetAudioInterface()->GetKey());
}