CWE-ou-minkata/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIListBoxMod.cpp

/*==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==*/
//////////////////////////////////////////////////////////////////////////////
//                                                                          //
//  pfGUIListBoxMod Definition                                              //
//                                                                          //
//////////////////////////////////////////////////////////////////////////////

#include "hsTypes.h"
#include "pfGUIListBoxMod.h"
#include "pfGUIListElement.h"
#include "pfGameGUIMgr.h"
#include "pfGUIUpDownPairMod.h"
#include "pfGUIControlHandlers.h"
#include "pfGUIDialogMod.h"

#include "pnMessage/plRefMsg.h"
#include "pfMessage/pfGameGUIMsg.h"
#include "plMessage/plAnimCmdMsg.h"
#include "plAvatar/plAGModifier.h"
#include "plGImage/plDynamicTextMap.h"
#include "plInputCore/plInputInterface.h"
#include "plgDispatch.h"
#include "hsResMgr.h"


#define kIndentAmount       16


//// plSmallRect Stuff ///////////////////////////////////////////////////////

void    pfGUIListBoxMod::plSmallRect::Set( Int16 l, Int16 t, Int16 r, Int16 b ) 
{
    fLeft = l;
    fTop = t;
    fRight = r; 
    fBottom = b; 
}

hsBool  pfGUIListBoxMod::plSmallRect::Contains( Int16 x, Int16 y )
{
    if( x < fLeft || x > fRight || y < fTop || y > fBottom )
        return false;

    return true;
}

//// Wee Little Control Proc for scrolling ///////////////////////////////////

class pfScrollProc : public pfGUICtrlProcObject
{
    protected:

        pfGUIListBoxMod *fParent;

    public:

        pfScrollProc( pfGUIListBoxMod *parent ) : fParent( parent ) {}

        virtual void    DoSomething( pfGUIControlMod *ctrl )
        {
            // Do a check here to make sure we actually changed scroll
            // positions--if not, we don't want to update, since that'll be 
            // slow as hell
            int newScrollPos = (int)fParent->fScrollControl->GetMax() - (int)fParent->fScrollControl->GetCurrValue();
            if( newScrollPos != fParent->fScrollPos )
            {
                fParent->IUpdate();
                fParent->HandleExtendedEvent( pfGUIListBoxMod::kScrollPosChanged );
            }
        }
};

//// Constructor/Destructor //////////////////////////////////////////////////

pfGUIListBoxMod::pfGUIListBoxMod()
{
    SetFlag( kWantsInterest );
    fCurrClick = -1;
    fCurrHover = -1;
    fModsAtDragTime = 0;
    fScrollControl = nil;
    fCheckScroll = false;
    fSingleSelElement = -1;
    fScrollRangeUpdateDeferred = false;
    fScrollPos = 0;
    fLocked = false;
    fReadyToRoll = false;
    fClicking = false;

    fScrollProc = nil;
}

pfGUIListBoxMod::~pfGUIListBoxMod()
{
    ClearAllElements();

    if( fScrollProc && fScrollProc->DecRef() )
        delete fScrollProc;
}

//// IEval ///////////////////////////////////////////////////////////////////

hsBool  pfGUIListBoxMod::IEval( double secs, hsScalar del, UInt32 dirty )
{
    return pfGUIControlMod::IEval( secs, del, dirty );
}

//// MsgReceive //////////////////////////////////////////////////////////////

hsBool  pfGUIListBoxMod::MsgReceive( plMessage *msg )
{
    plGenRefMsg *refMsg = plGenRefMsg::ConvertNoRef( msg );
    if( refMsg != nil )
    {
        if( refMsg->fType == kRefScrollCtrl )
        {
            if( refMsg->GetContext() & ( plRefMsg::kOnCreate | plRefMsg::kOnRequest | plRefMsg::kOnReplace ) )
            {
                fScrollControl = pfGUIValueCtrl::ConvertNoRef( refMsg->GetRef() );
                fScrollControl->SetHandler( fScrollProc );
                fScrollControl->SetStep( 1.f );
                ICalcScrollRange();
            }
            else
                fScrollControl = nil;
            return true;
        }
        else if( refMsg->fType == kRefDynTextMap )
        {
            // Capture this so we can reset our flag, but do NOT just return from it!
            if( !( refMsg->GetContext() & ( plRefMsg::kOnCreate | plRefMsg::kOnRequest | plRefMsg::kOnReplace ) ) )
                fReadyToRoll = false;
        }
    }

    return pfGUIControlMod::MsgReceive( msg );
}

//// IPostSetUpDynTextMap ////////////////////////////////////////////////////

void    pfGUIListBoxMod::IPostSetUpDynTextMap( void )
{
    ICalcWrapStarts();
    ICalcScrollRange();
    fReadyToRoll = true;
}

//// IUpdate /////////////////////////////////////////////////////////////////

void    pfGUIListBoxMod::IUpdate( void )
{
    int         i, j;
    UInt16      x, y, width, height, maxHeight;


    if( !fReadyToRoll )
        return;
    if( fScrollRangeUpdateDeferred )
    {
        fScrollRangeUpdateDeferred = false;
        ICalcScrollRange();
    }

    fDynTextMap->ClearToColor( GetColorScheme()->fBackColor );
    if( fElements.GetCount() == 0 )
    {
        fDynTextMap->FlushToHost();
        return;
    }

    if( fLocked )
    {
        hsStatusMessage( "WARNING: Forcing unlock on GUI list box due to call to IUpdate()\n" );
        UnlockList();
    }

    if( fScrollControl != nil )
    {
        // We reverse the value, since we want the "up" button to scroll "up", which actually
        // *decreases* the scrollPos
        fScrollPos = (int)fScrollControl->GetMax() - (int)fScrollControl->GetCurrValue();

        if( fCheckScroll )
        {
            // If this is set, we just did something to change the selection to a single item.
            // Since it makes sense to try to ensure this item is on the screen, we thus do so here.
            // We don't want to do this every time, because we could be simply clicking on the
            // scroll bars, in which case we DON'T want to do this check, since it would be
            // fighting against the user, which is a big UI design no-no.
            // To do this check, we search on either side of our scroll range (we can only
            // search past after we draw, unfortunately). If there's a selected item out
            // of our range, then we best move the scrollPos to move it into view
            for( j = 0; j < fScrollPos; j++ )
            {
                int end = ( j < fWrapStartIdxs.GetCount() - 1 ) ? fWrapStartIdxs[ j + 1 ] : fElements.GetCount();

                hsBool anySelected = false;
                for( i = fWrapStartIdxs[ j ]; i < end; i++ )
                    anySelected |= fElements[ i ]->IsSelected();

                if( anySelected )
                {
                    // Shit. Move the scrollPos up to this item at the very least
                    fScrollPos = j;
                    fScrollControl->SetCurrValue( (hsScalar)( (int)fScrollControl->GetMax() - fScrollPos ) );
                    fCheckScroll = false;
                    break;
                }
            }
        }
    }
    else
        fScrollPos = 0;

    fElementBounds.SetCountAndZero( fElements.GetCount() );

    if( !HasFlag( kScrollLeftToRight ) )
    {
        for( j = fScrollPos, y = 4; j < fWrapStartIdxs.GetCount() && y < fDynTextMap->GetVisibleHeight() - 8; j++ )
        {
            int end = ( j < fWrapStartIdxs.GetCount() - 1 ) ? fWrapStartIdxs[ j + 1 ] : fElements.GetCount();

            for( maxHeight = 0, i = fWrapStartIdxs[ j ], x = 0; i < end; i++ )
            {
                if( HasFlag( kGrowLeavesAndProcessOxygen ) && fElements[ i ]->IsCollapsed() )
                    continue;       // Skip collapsed items

                fElements[ i ]->GetSize( fDynTextMap, &width, &height );

                if( !HasFlag( kAllowMultipleElementsPerRow ) )
                    width = fDynTextMap->GetVisibleWidth();

                if( y + height >= fDynTextMap->GetVisibleHeight() - 8 )
                    height = fDynTextMap->GetVisibleHeight() - 8 - y;

                if( HasFlag( kGrowLeavesAndProcessOxygen ) )
                {
                    x += fElements[ i ]->GetIndentLevel() * kIndentAmount;
                    if( x + width > fDynTextMap->GetVisibleWidth() )
                        width = fDynTextMap->GetVisibleWidth() - x;
                }

                if( !fElements[ i ]->Draw( fDynTextMap, x, y, width, height ) )
                {
                    // Couldn't draw, so force it to be at the end of the scroll range
                    y = fDynTextMap->GetVisibleHeight() - 8;
                    j--;
                    break;
                }

                maxHeight = ( height > maxHeight ) ? height : maxHeight;
                fElementBounds[ i ].Set( x, y, x + width - 1, y + height - 1 );
                x += width;
            }

            y += maxHeight;
        }
    }
    else
    {
        for( j = fScrollPos, x = 4; j < fWrapStartIdxs.GetCount() && x < fDynTextMap->GetVisibleWidth() - 8; j++ )
        {
            int end = ( j < fWrapStartIdxs.GetCount() - 1 ) ? fWrapStartIdxs[ j + 1 ] : fElements.GetCount();

            for( maxHeight = 0, i = fWrapStartIdxs[ j ], y = 0; i < end; i++ )
            {
                fElements[ i ]->GetSize( fDynTextMap, &width, &height );

                if( !HasFlag( kAllowMultipleElementsPerRow ) )
                    height = fDynTextMap->GetVisibleHeight();

                if( x + width >= fDynTextMap->GetVisibleWidth() - 8 )
                    width = fDynTextMap->GetVisibleWidth() - 8 - x;

                if( !fElements[ i ]->Draw( fDynTextMap, x, y, width, height ) )
                {
                    // Couldn't draw, so force it to be at the end of the scroll range
                    x = fDynTextMap->GetVisibleWidth() - 8;
                    j--;
                    break;
                }

                maxHeight = ( width > maxHeight ) ? width : maxHeight;
                fElementBounds[ i ].Set( x, y, x + width - 1, y + height - 1 );
                y += height;
            }

            x += maxHeight;
        }
    }

    // Second part of our scroll check--if we got here, then there was nothing selected
    // before the viewing area. So check the rest
    if( fCheckScroll && fScrollControl != nil )
    {
        fCheckScroll = false;
        for( ; j < fWrapStartIdxs.GetCount(); j++ )
        {
            int end = ( j < fWrapStartIdxs.GetCount() - 1 ) ? fWrapStartIdxs[ j + 1 ] : fElements.GetCount();

            hsBool anySelected = false;
            for( i = fWrapStartIdxs[ j ]; i < end; i++ )
                anySelected |= fElements[ i ]->IsSelected();

            if( anySelected )
            {
                fScrollPos = j;
                fScrollControl->SetCurrValue( (hsScalar)( (int)fScrollControl->GetMax() - fScrollPos ) );
                IUpdate();      // Gotta update again, since we just changed the scrollPos after the fact
                return;
            }
        }
    }

    fDynTextMap->FlushToHost();
}

//// ICalcWrapStarts /////////////////////////////////////////////////////////
//  Calculates the starting indexes for each row of items. Call whenever you
//  update the element list.

void    pfGUIListBoxMod::ICalcWrapStarts( void )
{
    UInt16      i, x, y, maxHeight, width, height;


    fWrapStartIdxs.Reset();

    if( HasFlag( kAllowMultipleElementsPerRow ) )
    {
        if( !HasFlag( kScrollLeftToRight ) )
        {
            for( i = 0, x = (UInt16)-1, y = 4, maxHeight = 0; i < fElements.GetCount(); i++ )
            {
                fElements[ i ]->GetSize( fDynTextMap, &width, &height );

                if( x + width >= fDynTextMap->GetVisibleWidth() )
                {
                    x = 0;
                    y += maxHeight;
                    maxHeight = 0;
                    fWrapStartIdxs.Append( i );
                }
                x += width;
                maxHeight = ( height > maxHeight ) ? height : maxHeight;
            }
        }
        else
        {
            for( i = 0, y = (UInt16)-1, x = 4, maxHeight = 0; i < fElements.GetCount(); i++ )
            {
                fElements[ i ]->GetSize( fDynTextMap, &width, &height );
                if( y + height >= fDynTextMap->GetVisibleHeight() )
                {
                    y = 0;
                    x += maxHeight;
                    maxHeight = 0;
                    fWrapStartIdxs.Append( i );
                }
                y += height;
                maxHeight = ( width > maxHeight ) ? width : maxHeight;
            }
        }
    }
    else
    {
        for( i = 0; i < fElements.GetCount(); i++ )
        {
            if( HasFlag( kGrowLeavesAndProcessOxygen ) && fElements[ i ]->IsCollapsed() )
                continue;

            fWrapStartIdxs.Append( i );
        }
    }
}

//// ICalcScrollRange ////////////////////////////////////////////////////////
//  Call whenever you update the element list

void    pfGUIListBoxMod::ICalcScrollRange( void )
{
    UInt16      ctrlHt, ctrlWd, height, width, maxHeight;
    int         i, j, end;


    if( !fReadyToRoll )
    {
        fScrollRangeUpdateDeferred = true;
        return;
    }

    // Basically, the scroll range is 0 to (numElements-1), but since if we scroll
    // that far, we won't see anything left except the last element, we have to calculate
    // how many elements away from the end we can get before we see blank space. Which means
    // counting up from the end until we have passed the height of our control.

    end = fElements.GetCount();
    if( !HasFlag( kScrollLeftToRight ) )
    {
        if( HasFlag( kGrowLeavesAndProcessOxygen ) )
        {
            // OK, that really isn't the end, the end will the count of non-collapsed elements. Haha.
            for( i = 0, end = 0; i < fElements.GetCount(); i++ )
            {
                if( !fElements[ i ]->IsCollapsed() )
                    end++;
            }
        }

        for( i = fWrapStartIdxs.GetCount() - 1, height = 0; i >= 0; i-- )
        {
            // Get the max height of this row
            maxHeight = 0;
            for( j = fWrapStartIdxs[ i ]; j < end; j++ )
            {
                fElements[ j ]->GetSize( fDynTextMap, &width, &ctrlHt );
                maxHeight = ( ctrlHt > maxHeight ) ? ctrlHt : maxHeight;
            }
            end = fWrapStartIdxs[ i ];
            height += maxHeight;

            if( height > fDynTextMap->GetVisibleHeight() - 8 )
                break;
        }
    }
    else
    {
        for( i = fWrapStartIdxs.GetCount() - 1, width = 0; i >= 0; i-- )
        {
            // Get the max width of this column
            maxHeight = 0;
            for( j = fWrapStartIdxs[ i ]; j < end; j++ )
            {
                fElements[ j ]->GetSize( fDynTextMap, &ctrlWd, &ctrlHt );
                maxHeight = ( ctrlWd > maxHeight ) ? ctrlWd : maxHeight;
            }
            end = fWrapStartIdxs[ i ];
            width += maxHeight;

            if( width > fDynTextMap->GetVisibleWidth() - 8 )
                break;
        }
    }

    // Note: i went one past, so our scroll range is really 0 to i+1
    if( fScrollControl )
    {
        // Because we reverse the position on draw, we have to do some special trick here
        // to make sure the reversed position stays the same
        fScrollPos = (int)fScrollControl->GetMax() - (int)fScrollControl->GetCurrValue();
        if( fScrollPos >= fWrapStartIdxs.GetCount() )
            fScrollPos = fWrapStartIdxs.GetCount() - 1;

        if( i < 0 )
            // Smaller than the viewing area, so we don't scroll at all
            fScrollControl->SetRange( 0.f, 0.f );
        else
            fScrollControl->SetRange( 0.f, (hsScalar)( i + 1 ) );

        fScrollControl->SetCurrValue( (hsScalar)( (int)fScrollControl->GetMax() - fScrollPos ) );
    }
}

void pfGUIListBoxMod::PurgeDynaTextMapImage()
{
    if ( fDynTextMap != nil )
        fDynTextMap->PurgeImage();
}

//// Read/Write //////////////////////////////////////////////////////////////

void    pfGUIListBoxMod::Read( hsStream *s, hsResMgr *mgr )
{
    pfGUIControlMod::Read(s, mgr);

    fScrollControl = nil;
    if( s->ReadBool() )
    {
        fScrollProc = TRACKED_NEW pfScrollProc( this );
        fScrollProc->IncRef();
        mgr->ReadKeyNotifyMe( s, TRACKED_NEW plGenRefMsg( GetKey(), plRefMsg::kOnCreate, -1, kRefScrollCtrl ), plRefFlags::kActiveRef );
    }

    if( HasFlag( kDisableSelection ) )
        ClearFlag( kWantsInterest );

}

void    pfGUIListBoxMod::Write( hsStream *s, hsResMgr *mgr )
{
    pfGUIControlMod::Write( s, mgr );

    if( fScrollControl != nil )
    {
        s->WriteBool( true );
        mgr->WriteKey( s, fScrollControl->GetKey() );
    }
    else
        s->WriteBool( false );
}

//// FilterMousePosition /////////////////////////////////////////////////////
//  Tests the mouse point and decides whether we still want to accept input
//  based on the position. This allows us to act etheral (i.e. pass mouse
//  messages through) when the mouse is over an empty portion of the list.

hsBool  pfGUIListBoxMod::FilterMousePosition( hsPoint3 &mousePt )
{
    if( !HasFlag( kAllowMousePassThrough ) )
        return true;

    Int32 hover = fCurrClick = IGetItemFromPoint( mousePt );
    if( hover == -1 )
        return false;

    return true;
}

//// HandleMouseDown /////////////////////////////////////////////////////////
//  What we do: normal click deselects all and selects the item clicked on
//  (if any). Shift-click and ctrl-click avoids the deselect and toggles
//  the item clicked on.

void    pfGUIListBoxMod::HandleMouseDown( hsPoint3 &mousePt, UInt8 modifiers )
{
    Int32   i;

    int lastSelection = -1;
    if (HasFlag(kForbidNoSelection))
    {
        // grab the last item we had selected just in case they clicked outside the list of selectable objects
        for (i=0; i<fElements.GetCount(); i++)
            if (fElements[i]->IsSelected())
            {
                lastSelection = i;
                break;
            }
    }
    
    if( HasFlag(kSingleSelect) || ( !( modifiers & ( pfGameGUIMgr::kShiftDown | pfGameGUIMgr::kCtrlDown ) ) && !HasFlag( kHandsOffMultiSelect ) ) )
    {
        // Deselect everyone!
        for( i = 0; i < fElements.GetCount(); i++ )
            fElements[ i ]->SetSelected( false );
        fSingleSelElement = -1;
    }
    else if( modifiers & pfGameGUIMgr::kShiftDown )
    {
        IFindSelectionRange( &fMinSel, &fMaxSel );
    }

    fCurrHover = fCurrClick = IGetItemFromPoint( mousePt );
    if( fCurrClick != -1 )
    {
        if( ( ( modifiers & pfGameGUIMgr::kShiftDown ) && !HasFlag( kSingleSelect ) ) )
        {
            // Select our new range, deselect everything outside
            if( fCurrClick <= fMaxSel )
            {
                ISelectRange( 0, (Int8)(fCurrClick - 1), false );
                ISelectRange( (Int8)fCurrClick, (Int8)fMaxSel, true );
                ISelectRange( (Int8)(fMaxSel + 1), -1, false );
            }
            else if( fCurrClick >= fMinSel )
            {
                ISelectRange( 0, (Int8)(fMinSel - 1), false );
                ISelectRange( (Int8)fMinSel, (Int8)fCurrClick, true );
                ISelectRange( (Int8)(fCurrClick + 1), -1, false );
            }
            fElements[ fCurrClick ]->SetSelected( true );
        }
        else
        {
            fElements[ fCurrClick ]->SetSelected( true );
            fSingleSelElement = fCurrClick;
        }
    }
    else
    {
        if (HasFlag(kForbidNoSelection) && (lastSelection != -1))
        {
            fElements[ lastSelection ]->SetSelected(true);
            fSingleSelElement = lastSelection;
        }
    }

    // We want drag/up events to be processed with the modifiers we had on
    // mouse down, not the current ones. So store 'em for reference
    fModsAtDragTime = modifiers;
    fClicking = true;
    IUpdate();
}

//// HandleMouseUp ///////////////////////////////////////////////////////////

void    pfGUIListBoxMod::HandleMouseUp( hsPoint3 &mousePt, UInt8 modifiers )
{
    fClicking = false;
    if( !( fModsAtDragTime & ( pfGameGUIMgr::kShiftDown | pfGameGUIMgr::kCtrlDown ) ) && !HasFlag( kHandsOffMultiSelect ) )
    {
        // No modifiers--simply select whatever item we're on
        Int32   item = IGetItemFromPoint( mousePt );
        if( item != fCurrClick )
        {
            if( fCurrClick >= 0 && fCurrClick < fElements.GetCount() )
                fElements[ fCurrClick ]->SetSelected( false );
            fCurrHover = fCurrClick = item;
            if( fCurrClick >= 0 && fCurrClick < fElements.GetCount() )
                fElements[ fCurrClick ]->SetSelected( true );
            else if (HasFlag(kForbidNoSelection) && fCurrClick == -1)
            {
                fElements[fSingleSelElement]->SetSelected(true);
                fCurrClick = fSingleSelElement;
            }
            fCheckScroll = true;
            fSingleSelElement = fCurrClick;
            IUpdate();
        }
        else
        {
            // We didn't change selection, so go ahead and pass the click on to
            // the item, in case it wants to do something
            if( fCurrClick >= 0 && fCurrClick < fElements.GetCount() )
            {
                hsPoint3 localPt = mousePt;
                IScreenToLocalPt( localPt );

                UInt16 lX = (UInt16)(( localPt.fX * ( fDynTextMap->GetVisibleWidth() - 1 ) ) - fElementBounds[ fCurrClick ].fLeft);
                UInt16 lY = (UInt16)(( localPt.fY * ( fDynTextMap->GetVisibleHeight() - 1 ) )- fElementBounds[ fCurrClick ].fTop);

                if( fElements[ fCurrClick ]->MouseClicked( lX, lY ) )
                {
                    ICalcWrapStarts();
                    ICalcScrollRange();
                    IUpdate();
                }
            }
        }
    }

    DoSomething();  // Change in selection triggers our DoSomething() call
}

//// HandleMouseHover ////////////////////////////////////////////////////////
//  Just updates our currHover item so we can update the mouse appropriately

void    pfGUIListBoxMod::HandleMouseHover( hsPoint3 &mousePt, UInt8 modifiers )
{
    fCurrHover = IGetItemFromPoint( mousePt );
}

//// HandleMouseDrag /////////////////////////////////////////////////////////

void    pfGUIListBoxMod::HandleMouseDrag( hsPoint3 &mousePt, UInt8 modifiers )
{
    int     i;


    if( ( fModsAtDragTime & pfGameGUIMgr::kShiftDown && !HasFlag( kSingleSelect ) ) )
    {
        // Select our new range, deselect everything outside
        if( fCurrClick <= fMaxSel )
        {
            ISelectRange( 0, (Int8)(fCurrClick - 1), false );
            ISelectRange( (Int8)fCurrClick, (Int8)fMaxSel, true );
            ISelectRange( (Int8)(fMaxSel + 1), -1, false );
        }
        else if( fCurrClick >= fMinSel )
        {
            ISelectRange( 0, (Int8)(fMinSel - 1), false );
            ISelectRange( (Int8)fMinSel, (Int8)fCurrClick, true );
            ISelectRange( (Int8)(fCurrClick + 1), -1, false );
        }
        IUpdate();
    }
    else if( !( fModsAtDragTime & ( pfGameGUIMgr::kShiftDown | pfGameGUIMgr::kCtrlDown ) ) )
    {
        // No modifiers--simply select whatever item we're on
        if( HasFlag( kDragAndDropCapable ) )
        {
            // If we're drag and drop capable, then a mouse drag function results in
            // the dialog entering Drag Mode(tm). Basically, we tell our parent dialog
            // which items to drag and it'll run with the rest
            fDialog->ClearDragList();
            for( i = 0; i < fElements.GetCount(); i++ )
            {
                if( fElements[ i ]->IsSelected() )
                    fDialog->AddToDragList( fElements[ i ] );
            }
            fDialog->EnterDragMode( this );
        }
        else
        {
            Int32   item = IGetItemFromPoint( mousePt );
            if( item != fCurrClick )
            {
                if( fCurrClick >= 0 && fCurrClick < fElements.GetCount() )
                    fElements[ fCurrClick ]->SetSelected( false );
                fCurrHover = fCurrClick = item;
                if( fCurrClick >= 0 && fCurrClick < fElements.GetCount() )
                    fElements[ fCurrClick ]->SetSelected( true );
                fCheckScroll = true;
                fSingleSelElement = fCurrClick;
                IUpdate();
            }
        }
    }
}

//// HandleMouseDblClick /////////////////////////////////////////////////////

void    pfGUIListBoxMod::HandleMouseDblClick( hsPoint3 &mousePt, UInt8 modifiers )
{
    if( !HasFlag( kGrowLeavesAndProcessOxygen ) )
        return;     // We only care about double clicks if we make oxygen

    Int32 item = IGetItemFromPoint( mousePt );
    if( item != -1 )
    {
        if( fElements[ item ]->GetType() == pfGUIListElement::kTreeRoot )
        {
            pfGUIListTreeRoot *root = (pfGUIListTreeRoot *)fElements[ item ];

            root->ShowChildren( !root->IsShowingChildren() );
            if( !fLocked )
            {
                ICalcWrapStarts();
                ICalcScrollRange();
                IUpdate();
            }
        }
    }
}

//// IGetItemFromPoint ///////////////////////////////////////////////////////

Int32   pfGUIListBoxMod::IGetItemFromPoint( hsPoint3 &mousePt )
{
    if( !fBounds.IsInside( &mousePt ) )
        return -1;

    hsPoint3    localPt = mousePt; // despite getting a ref to the point (why?) we do NOT want to modify it
    IScreenToLocalPt( localPt );
    UInt32      i;
    Int16       clickItem = -1 , clickY = (Int16)( localPt.fY * ( fDynTextMap->GetVisibleHeight() - 1 ) );
    Int16       clickX = (Int16)( localPt.fX * ( fDynTextMap->GetVisibleWidth() - 1 ) );

    // We have a nice array that has the starting (top) Y's of each visible element. So we just
    // check against that.
    UInt32 startAt = 0;
    // make sure that we have a valid fScrollPos
    if ( fScrollPos != -1 )
    {
        // make sure that there is an Idx at fScrollPos
        if ( fWrapStartIdxs.GetCount() > fScrollPos )
        {
            startAt = fWrapStartIdxs[ fScrollPos ];
            clickItem = -1;
        }
    }
    for( i = startAt; i < fElements.GetCount(); i++ )
    {
        if( i<fElementBounds.GetCount() && fElementBounds[ i ].Contains( clickX, clickY ) )
        {
            clickItem = (Int16)i;
            break;
        }
    }

    if( clickItem > fElements.GetCount() - 1 )
        clickItem = -1;

    return clickItem;
}

//// IFindSelectionRange /////////////////////////////////////////////////////
//  Find the min and max item that's selected. Returns -1 for both if nobody
//  is selected

void    pfGUIListBoxMod::IFindSelectionRange( Int32 *min, Int32 *max )
{
    Int32       i;


    *min = *max = -1;

    for( i = 0; i < fElements.GetCount(); i++ )
    {
        if( fElements[ i ]->IsSelected() )
        {
            *min = i;
            break;
        }
    }

    for( i = fElements.GetCount() - 1; i >= 0; i-- )
    {
        if( fElements[ i ]->IsSelected() )
        {
            *max = i;
            break;
        }
    }
}

//// ISelectRange ////////////////////////////////////////////////////////////

void    pfGUIListBoxMod::ISelectRange( Int8 min, Int8 max, hsBool select )
{
    Int16   i;


    if( max == -1 )
        max = fElements.GetCount() - 1;

    for( i = min; i <= max; i++ )
        fElements[ i ]->SetSelected( select );
}

//// SetSelection ////////////////////////////////////////////////////////////

void    pfGUIListBoxMod::SetSelection( Int32 item )
{
    if( HasFlag( kSingleSelect ) )
    {
        // Easy, only one item selected
        if( fSingleSelElement != -1 )
            fElements[ fSingleSelElement ]->SetSelected( false );

        fSingleSelElement = item;
    }
    else
        ISelectRange( 0, -1, false );

    if( item != -1 && item < fElements.GetCount() )
        fElements[ item ]->SetSelected( true );

    fCheckScroll = true;
    IUpdate();
}

void    pfGUIListBoxMod::RemoveSelection( Int32 item )
{
    // make sure the item is valid
    if ( item != -1 && item < fElements.GetCount() )
    {
        // if single select and its what is selected
        if ( HasFlag( kSingleSelect) && fSingleSelElement == item )
        {
            // then remove the selection and make nothing selected
            fElements[ fSingleSelElement ]->SetSelected( false );
            fSingleSelElement = item;
        }
        // else if multiple selection
        else
            // just remove the selection
            fElements[ item ]->SetSelected( false );
    }
    fCheckScroll = true;
    IUpdate();
}

void    pfGUIListBoxMod::AddSelection( Int32 item )
{
    // make sure the item is valid (can't add a non-selection!)
    if ( item != -1 && item < fElements.GetCount() )
    {
        // if single select then just like SetSelection
        if ( HasFlag( kSingleSelect) )
        {
            SetSelection(item);
        }
        // else if multiple selection
        else
            // just set its selection
            fElements[ item ]->SetSelected( true );
    }
    fCheckScroll = true;
    IUpdate();
}

//// HandleKeyPress //////////////////////////////////////////////////////////

hsBool  pfGUIListBoxMod::HandleKeyPress( char key, UInt8 modifiers )
{
    return false;
}

hsBool  pfGUIListBoxMod::HandleKeyEvent( pfGameGUIMgr::EventType event, plKeyDef key, UInt8 modifiers )
{
    if( key == KEY_CAPSLOCK )
        return false;

    if( HasFlag( kDisableKeyActions ) )
        return false;

    if( event == pfGameGUIMgr::kKeyDown || event == pfGameGUIMgr::kKeyRepeat )
    {
        // Use arrow keys to do our dirty work
        if( key == KEY_UP )
        {
            if( fCurrClick == -1 && fElements.GetCount() > 0 )
                fCurrClick = 0;
            else while( fCurrClick > 0 )
            {
                fCurrClick--;
                if( !HasFlag( kGrowLeavesAndProcessOxygen ) || !fElements[ fCurrClick ]->IsCollapsed() )
                    break;
            }
        }
        else if( key == KEY_DOWN )
        {
            if( fCurrClick == -1 && fElements.GetCount() > 0 )
                fCurrClick = fElements.GetCount() - 1;
            else while( fCurrClick < fElements.GetCount() - 1 )
            {
                fCurrClick++;
                if( !HasFlag( kGrowLeavesAndProcessOxygen ) || !fElements[ fCurrClick ]->IsCollapsed() )
                    break;
            }
        }
        else if( key == KEY_HOME )
        {
            if( fElements.GetCount() > 0 )
                fCurrClick = 0;         
        }
        else if( key == KEY_END )
        {
            if( fElements.GetCount() > 0 )
                fCurrClick = fElements.GetCount() - 1;          
        }
        else if( key == KEY_ENTER && HasFlag( kGrowLeavesAndProcessOxygen ) )
        {
            if( fCurrClick != -1 && fElements[ fCurrClick ]->GetType() == pfGUIListElement::kTreeRoot )
            {
                pfGUIListTreeRoot *root = (pfGUIListTreeRoot *)fElements[ fCurrClick ];
                root->ShowChildren( !root->IsShowingChildren() );

                if( !fLocked )
                {
                    ICalcWrapStarts();
                    ICalcScrollRange();
                }
            }
        }
        else
        {
            return false;
        }

        ISelectRange( 0, -1, false );
        if( fCurrClick != -1 )
            fElements[ fCurrClick ]->SetSelected( true );
        fSingleSelElement = fCurrClick;

        DoSomething();  // Change in selection triggers our DoSomething() call

        fCheckScroll = true;
        IUpdate();
        return true;
    }

    return false;
}

//// ScrollToEnd /////////////////////////////////////////////////////////////

void    pfGUIListBoxMod::ScrollToEnd( void )
{
    if( fScrollControl != nil )
    {
        fScrollPos = (int)fScrollControl->GetMin();
        fScrollControl->SetCurrValue( fScrollControl->GetMax() );
    }
    IUpdate();
}

//// ScrollToBegin ///////////////////////////////////////////////////////////

void    pfGUIListBoxMod::ScrollToBegin( void )
{
    if( fScrollControl != nil )
    {
        fScrollPos = (int)fScrollControl->GetMax();
        fScrollControl->SetCurrValue( fScrollControl->GetMin() );
    }
    IUpdate();
}

void        pfGUIListBoxMod::SetColorScheme( pfGUIColorScheme *newScheme )
{
    UInt16  i;

    pfGUIControlMod::SetColorScheme( newScheme );

    for( i = 0; i < fElements.GetCount(); i++ )
    {
        fElements[ i ]->SetColorScheme( newScheme );
        fElements[ i ]->SetSkin( fSkin );
    }
}

void pfGUIListBoxMod::SetScrollPos( Int32 pos )
{
    if ( pos >= (int)fScrollControl->GetMin() && pos <= (int)fScrollControl->GetMax() )
    {
        fScrollControl->SetCurrValue( (hsScalar)pos );
        fScrollPos = (int)fScrollControl->GetMax() - pos;
    }
    IUpdate();
}

Int32 pfGUIListBoxMod::GetScrollPos( void )
{
    return (int)fScrollControl->GetCurrValue();
}

Int32 pfGUIListBoxMod::GetScrollRange( void )
{
    return (int)fScrollControl->GetMax() - (int)fScrollControl->GetMin();
}


//////////////////////////////////////////////////////////////////////////////
//// Element Manipulation ////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

UInt16  pfGUIListBoxMod::AddElement( pfGUIListElement *el )
{
    UInt16  idx = fElements.GetCount();
    fElements.Append( el );
    el->SetColorScheme( GetColorScheme() );
    el->SetSkin( fSkin );
    if( !fLocked )
    {
        ICalcWrapStarts();
        ICalcScrollRange();
        IUpdate();
        HandleExtendedEvent( pfGUIListBoxMod::kItemAdded );
    }
    return idx;
}

void    pfGUIListBoxMod::RemoveElement( UInt16 index )
{
    // Make sure no other elements care about this one
    UInt16 i, j;
    for( i = 0; i < fElements.GetCount(); i++ )
    {
        if( fElements[ i ]->GetType() == pfGUIListElement::kTreeRoot )
        {
            pfGUIListTreeRoot *root = (pfGUIListTreeRoot *)fElements[ i ];
            for( j = 0; j < root->GetNumChildren(); )
            {
                if( root->GetChild( j ) == fElements[ index ] )
                    root->RemoveChild( j );
                else
                    j++;
            }
        }
    }

    delete fElements[ index ];
    fElements.Remove( index );

    if( index == fSingleSelElement )
        fSingleSelElement = -1;
    else if( index < fSingleSelElement )
        fSingleSelElement--;
    fCurrHover = fCurrClick = -1;

    if( !fLocked )
    {
        ICalcWrapStarts();
        ICalcScrollRange();
        IUpdate();
        HandleExtendedEvent( pfGUIListBoxMod::kItemRemoved );
    }
}

Int16   pfGUIListBoxMod::FindElement( pfGUIListElement *toCompareTo )
{
    int     i;


    for( i = 0; i < fElements.GetCount(); i++ )
    {
        if( fElements[ i ]->CompareTo( toCompareTo ) == 0 )
            return i;
    }

    return (Int16)-1;
}

void    pfGUIListBoxMod::ClearAllElements( void )
{
    int     i;


    for( i = 0; i < fElements.GetCount(); i++ )
        delete fElements[ i ];
    fElements.Reset();
    fSingleSelElement = -1;

    if( !fLocked )
    {
        ICalcWrapStarts();
        ICalcScrollRange();
        IUpdate();
    }

    HandleExtendedEvent( pfGUIListBoxMod::kListCleared );
}

UInt16  pfGUIListBoxMod::AddString( const char *string )
{
    return AddElement( TRACKED_NEW pfGUIListText( string ) );
}

UInt16  pfGUIListBoxMod::AddString( const wchar_t *string )
{
    return AddElement( TRACKED_NEW pfGUIListText( string ) );
}

Int16   pfGUIListBoxMod::FindString( const char *toCompareTo )
{
    pfGUIListText   text( toCompareTo );
    return FindElement( &text );
}

Int16   pfGUIListBoxMod::FindString( const wchar_t *toCompareTo )
{
    pfGUIListText   text( toCompareTo );
    return FindElement( &text );
}

UInt16  pfGUIListBoxMod::GetNumElements( void )
{
    return fElements.GetCount();
}

pfGUIListElement    *pfGUIListBoxMod::GetElement( UInt16 idx )
{
    return fElements[ idx ];
}

void    pfGUIListBoxMod::LockList( void )
{
    fLocked = true;
}

void    pfGUIListBoxMod::UnlockList( void )
{
    fLocked = false;
    ICalcWrapStarts();
    ICalcScrollRange();
    IUpdate();
}

//// IGetDesiredCursor ///////////////////////////////////////////////////////

UInt32      pfGUIListBoxMod::IGetDesiredCursor( void ) const
{
    if( fCurrHover == -1 )
        return plInputInterface::kNullCursor;

    if( fClicking )
        return plInputInterface::kCursorClicked;

    return plInputInterface::kCursorPoised;
}