RollupPanel.cpp

Go to the documentation of this file.

/*
===========================================================================

Doom 3 GPL Source Code
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company. 

This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).  

Doom 3 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 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 Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the Doom 3 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 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.

===========================================================================
*/

#include "../../idlib/precompiled.h"
#pragma hdrstop

#include "../../sys/win32/win_local.h"
#include "RollupPanel.h"

// Based on original code by Johann Nadalutti

#define RP_PGBUTTONHEIGHT               18
#define RP_SCROLLBARWIDTH               6
#define RP_GRPBOXINDENT                 6
#define RP_SCROLLBARCOLOR               RGB(150,180,180)
#define RP_ROLLCURSOR                   MAKEINTRESOURCE(32649)  // see IDC_HAND (WINVER >= 0x0500)

//Popup Menu Ids
#define RP_IDM_EXPANDALL                0x100
#define RP_IDM_COLLAPSEALL              0x101
#define RP_IDM_STARTITEMS               0x102

idList<HWND>    rvRollupPanel::mDialogs;        
HHOOK                   rvRollupPanel::mDialogHook      = NULL;

#define DEFERPOS

/*
================
rvRollupPanel::rvRollupPanel

constructor
================
*/
rvRollupPanel::rvRollupPanel ( void )
{
        mStartYPos  = 0;
        mItemHeight = 0;
        mWindow         = NULL;
}

/*
================
rvRollupPanel::~rvRollupPanel

destructor
================
*/
rvRollupPanel::~rvRollupPanel ( void )
{
        // destroy the items
        for ( ; mItems.Num(); )
        {
                _RemoveItem ( 0 );
        }
}

/*
================
rvRollupPanel::Create

Create the rollup panel window
================
*/
bool rvRollupPanel::Create ( DWORD dwStyle, const RECT& rect, HWND parent, unsigned int id )
{
        WNDCLASSEX wndClass;
        memset ( &wndClass, 0, sizeof(wndClass) );
        wndClass.cbSize            = sizeof(WNDCLASSEX);
        wndClass.lpszClassName = "ROLLUP_PANEL";
        wndClass.lpfnWndProc   = WindowProc;
        wndClass.hbrBackground = (HBRUSH)GetSysColorBrush ( COLOR_3DFACE ); 
        wndClass.hCursor       = LoadCursor((HINSTANCE) NULL, IDC_ARROW); 
        wndClass.lpszMenuName  = NULL;
        wndClass.hInstance     = win32.hInstance; 
        wndClass.style             = CS_VREDRAW | CS_HREDRAW;
        RegisterClassEx ( &wndClass );

        mWindow = CreateWindowEx ( WS_EX_TOOLWINDOW, 
                                                        "ROLLUP_PANEL", 
                                                        "", 
                                                        dwStyle|WS_CLIPSIBLINGS, 
                                                        rect.left, rect.top, rect.right-rect.left, rect.bottom-rect.top,
                                                        parent, 
                                                        NULL, 
                                                        win32.hInstance, 
                                                        this );
                                                        
        if ( !mWindow )
        {
                return false;
        }

        return true;    
}

/*
================
rvRollupPanel::InsertItem

Insert and item into the rollup panel.  Return -1 if an error occured
================
*/
int rvRollupPanel::InsertItem ( const char* caption, HWND dialog, bool autoDestroy, int index )
{
        assert ( caption );
        assert ( dialog );

        // -1 means add to the end      
        if ( index > 0 && index >= mItems.Num() )
        {
                index = -1;
        }

        // Get client rect
        RECT r;
        GetClientRect(mWindow,&r);

        // Create the GroupBox control
        HWND groupbox = CreateWindow ( "BUTTON", "", WS_CHILD|BS_GROUPBOX, 
                                                                   r.left, r.top, r.right-r.left, r.bottom-r.top,
                                                                   mWindow, 0, win32.hInstance, NULL );
                                                                   
        // Create the expand button
        HWND button = CreateWindow ( "BUTTON", caption, WS_CHILD|BS_AUTOCHECKBOX|BS_PUSHLIKE|BS_FLAT, 
                                                                   r.left, r.top, r.right-r.left, r.bottom-r.top,
                                                                   mWindow, 0, win32.hInstance, NULL );

        // Change the button's font
        SendMessage ( button, WM_SETFONT, (WPARAM) GetStockObject(DEFAULT_GUI_FONT), 0 );

        // Add item to the item list
        RPITEM* item = new RPITEM; 
        item->mExpanded          = false;
        item->mEnable            = true;
        item->mDialog            = dialog;
        item->mButton            = button;
        item->mGroupBox          = groupbox;
        item->mOldDlgProc        = (WNDPROC) GetWindowLong ( dialog, DWL_DLGPROC );
        item->mOldButtonProc = (WNDPROC) GetWindowLong ( button, GWL_WNDPROC );
        item->mAutoDestroy       = autoDestroy;
        strcpy ( item->mCaption, caption );

        if ( index < 0 )
        {
                index = mItems.Append ( item );
        }
        else
        { 
                mItems.Insert ( item, index );
        }

        // Store data with the dialog window in its user data 
        SetWindowLong ( dialog, GWL_USERDATA,   (LONG)item );

        // Attach item to button through user data
        SetWindowLong ( button, GWL_USERDATA,   (LONG)item );
        SetWindowLong ( button, GWL_ID,                 index );

        // Subclass dialog
        SetWindowLong ( dialog, DWL_DLGPROC, (LONG)DialogProc );

        // SubClass button
        SetWindowLong ( button, GWL_WNDPROC, (LONG)ButtonProc );

        // Update
        mItemHeight += RP_PGBUTTONHEIGHT+(RP_GRPBOXINDENT/2);
        RecallLayout ( );

        // One hook for all panel dialogs
        if ( !mDialogHook )
        {
                mDialogHook = SetWindowsHookEx( WH_GETMESSAGE, GetMsgProc, NULL, GetCurrentThreadId() );
        }
        
        mDialogs.Append ( dialog );

        return index;
}

/*
================
rvRollupPanel::RemoveItem

Remove the item at the given index from the rollup panel
================
*/
void rvRollupPanel::RemoveItem ( int index )
{
        // safety check
        if ( index >= mItems.Num() || index < 0 )
        {
                return;
        }

        // remove the item
        _RemoveItem( index );

        // update the layout
        RecallLayout ( );       
}

/*
================
rvRollupPanel::RemoveAllItems

Remove all items from the control
================
*/
void rvRollupPanel::RemoveAllItems()
{
        for ( ; mItems.Num(); )
        {
                _RemoveItem ( 0 );
        }

        // update layout
        RecallLayout ( );
}

/*
================
rvRollupPanel::_RemoveItem

called by RemoveItem and RemoveAllItems methods to acutally remove the item
================
*/
void rvRollupPanel::_RemoveItem ( int index )
{
        RPITEM* item = mItems[index];

        // get the item rect
        RECT ir;
        GetWindowRect ( item->mDialog, &ir );

        // update item height
        mItemHeight -= RP_PGBUTTONHEIGHT+(RP_GRPBOXINDENT/2);
        if ( item->mExpanded )
        {
                mItemHeight -= (ir.bottom-ir.top);
        }

        // destroy windows
        if ( item->mButton ) 
        {
                DestroyWindow ( item->mButton );
        }
        if ( item->mGroupBox )
        {
                DestroyWindow ( item->mGroupBox );
        }
        if ( item->mDialog && item->mAutoDestroy )
        {
                DestroyWindow ( item->mDialog );
                mDialogs.Remove ( item->mDialog );              
        }

        if ( mDialogs.Num () <= 0 )
        {
                UnhookWindowsHookEx( mDialogHook );
                mDialogHook = NULL;
        }

        // finish up
        mItems.RemoveIndex ( index );
        delete item;            
}

/*
================
rvRollupPanel::ExpandItem

expand or collapse the item at the given index
================
*/
void rvRollupPanel::ExpandItem( int index, bool expand )
{
        // safety check
        if ( index >= mItems.Num() || index < 0 )
        {
                return;
        }

        _ExpandItem ( mItems[index], expand );

        RecallLayout ( );

        // scroll to this page (automatic page visibility)
        if ( expand )
        {
                ScrollToItem ( index, false );
        }
}

/*
================
rvRollupPanel::ExpandItem

expand or collapse the item at the given index
================
*/
void rvRollupPanel::ExpandAllItems( bool expand )
{
        int i;
        
        // expand all items
        for ( i=0; i < mItems.Num(); i ++ )
        {
                _ExpandItem ( mItems[i], expand );
        }

        RecallLayout();
}

/*
================
rvRollupPanel::ExpandItem

expand or collapse the item at the given index
================
*/
void rvRollupPanel::_ExpandItem ( RPITEM* item, bool expand )
{
        // check if we need to change state
        if ( item->mExpanded == expand || !item->mEnable )
        {
                return;
        }

        RECT ir;
        GetWindowRect ( item->mDialog, &ir );

        // Expand-collapse
        item->mExpanded = expand;

        if ( expand )
        {
                mItemHeight += (ir.bottom - ir.top);
        }
        else
        {
                mItemHeight -= (ir.bottom - ir.top);
        }
}

/*
================
rvRollupPanel::EnableItem

enable/disable the item at the given index
================
*/
void rvRollupPanel::EnableItem ( int index, bool enable )
{
        // safety check
        if ( index >= mItems.Num() || index < 0 )
        {
                return;
        }

        _EnableItem ( mItems[index], enable );
        RecallLayout ( );
}

/*
================
rvRollupPanel::EnableAllItems

enable/disable all items in the panel
================
*/
void rvRollupPanel::EnableAllItems ( bool enable )
{
        int i;
        
        for ( i=0; i < mItems.Num(); i++ )
        {
                _EnableItem ( mItems[i], enable );
        }
        
        RecallLayout ( );
}

/*
================
rvRollupPanel::_EnableItem

Called by EnableItem and EnableAllItems to do the work of enabling/disablgin
the window
================
*/
void rvRollupPanel::_EnableItem ( RPITEM* item, bool enable )
{
        // check if we need to change state
        if ( item->mEnable == enable )
        {
                return;
        }

        RECT ir;
        GetWindowRect ( item->mDialog, &ir );

        item->mEnable = enable;

        if ( item->mExpanded )
        { 
                mItemHeight -= (ir.bottom-ir.top); 
                item->mExpanded = false;
        }
}

/*
================
rvRollupPanel::ScrollToItem

Scroll a page at the top of the Rollup Panel if top = true or just ensure 
item visibility into view if top = false 
================
*/
void rvRollupPanel::ScrollToItem ( int index, bool top )
{
        // safety check
        if ( index >= mItems.Num() || index < 0 ) 
        {
                return;
        }

        RPITEM* item = mItems[index];

        // get rects
        RECT r;
        RECT ir;
        GetWindowRect ( mWindow, &r );
        GetWindowRect ( item->mDialog, &ir );

        // check page visibility
        if ( top || ((ir.bottom > r.bottom) || (ir.top < r.top)))
        {
                // compute new mStartYPos
                GetWindowRect( item->mButton, &ir );
                mStartYPos -= (ir.top-r.top);

                RecallLayout();
        }
}

/*
================
rvRollupPanel::MoveItemAt

newIndex can be equal to -1 (move at end)
return -1 if an error occurs
================
*/
int rvRollupPanel::MoveItemAt ( int index, int newIndex )
{
        if ( index == newIndex || index >= mItems.Num() || index < 0 )
        {
                return -1;
        }

        // remove page from its old position
        RPITEM* item = mItems[index];
        mItems.RemoveIndex ( index );

        // insert at its new position
        if ( newIndex < 0 )
        {
                index = mItems.Append( item );
        }
        else
        { 
                mItems.Insert ( item, newIndex );
                index = newIndex;
        }

        RecallLayout ( );
        
        return index;
}

/*
================
rvRollupPanel::RecallLayout

Update the layout of the control based on current states
================
*/
void rvRollupPanel::RecallLayout ( void )
{
        int      bottomPagePos;
        RECT r;
        int  posy;
        int      i;
        
        // check StartPosY
        GetClientRect ( mWindow, &r );
        bottomPagePos = mStartYPos + mItemHeight;

        if ( bottomPagePos < r.bottom-r.top )
        {
                mStartYPos = (r.bottom-r.top) - mItemHeight;
        }
        if ( mStartYPos > 0 )
        {
                mStartYPos = 0;
        }

        // update layout
#ifdef DEFERPOS                 
        HDWP hdwp;
        hdwp = BeginDeferWindowPos ( mItems.Num() * 3 );
#endif
        posy = mStartYPos;

        for ( i=0; i < mItems.Num(); i++ )
        {
                RPITEM* item = mItems[i];

                // enable / disable button
                SendMessage ( item->mButton, BM_SETCHECK, (item->mEnable&item->mExpanded)?BST_CHECKED:BST_UNCHECKED, 0 );
                EnableWindow ( item->mButton, item->mEnable );

                // Expanded
                if ( item->mExpanded && item->mEnable ) 
                {
                        RECT ir;
                        GetWindowRect ( item->mDialog, &ir );

                        // update GroupBox position and size
#ifdef DEFERPOS                 
                        DeferWindowPos ( hdwp, 
#else
                        SetWindowPos (   
#endif
                                                         item->mGroupBox, 0, 2, posy, 
                                                         (r.right-r.left)-3-RP_SCROLLBARWIDTH, 
                                                         (ir.bottom-ir.top)+RP_PGBUTTONHEIGHT+RP_GRPBOXINDENT-4, 
                                                         SWP_NOZORDER|SWP_SHOWWINDOW);

                        //Update Dialog position and size
#ifdef DEFERPOS                 
                        DeferWindowPos ( hdwp, 
#else
                        SetWindowPos (   
#endif
                                                         item->mDialog, 0, RP_GRPBOXINDENT, posy+RP_PGBUTTONHEIGHT, 
                                                         (r.right-r.left)-RP_SCROLLBARWIDTH-(RP_GRPBOXINDENT*2), 
                                                         ir.bottom-ir.top, SWP_NOZORDER|SWP_SHOWWINDOW);

                        //Update Button's position and size
#ifdef DEFERPOS                 
                        DeferWindowPos ( hdwp, 
#else
                        SetWindowPos (   
#endif
                                                         item->mButton, 0, RP_GRPBOXINDENT, posy, 
                                                         (r.right-r.left)-RP_SCROLLBARWIDTH-(RP_GRPBOXINDENT*2), 
                                                         RP_PGBUTTONHEIGHT, SWP_NOZORDER|SWP_SHOWWINDOW);

                        posy += (ir.bottom-ir.top) + RP_PGBUTTONHEIGHT;
                } 
                // collapsed
                else 
                {
                        // update GroupBox position and size
#ifdef DEFERPOS                 
                        DeferWindowPos ( hdwp, 
#else
                        SetWindowPos (   
#endif
                                                         item->mGroupBox, 0, 2, posy, 
                                                         (r.right-r.left)-3-RP_SCROLLBARWIDTH, 16, SWP_NOZORDER|SWP_SHOWWINDOW);

                        // update Dialog position and size
#ifdef DEFERPOS                 
                        DeferWindowPos ( hdwp, 
#else
                        SetWindowPos (   
#endif
                                                        item->mDialog, 0, RP_GRPBOXINDENT, 0, 0, 0,SWP_NOZORDER|SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE);

                        // update Button's position and size
#ifdef DEFERPOS                 
                        DeferWindowPos ( hdwp, 
#else
                        SetWindowPos (   
#endif
                                                        item->mButton, 0, RP_GRPBOXINDENT, posy, 
                                                        (r.right-r.left)-RP_SCROLLBARWIDTH-(RP_GRPBOXINDENT*2), 
                                                        RP_PGBUTTONHEIGHT, SWP_NOZORDER|SWP_SHOWWINDOW);

                        posy += RP_PGBUTTONHEIGHT;
                }

                posy += (RP_GRPBOXINDENT/2);

        }
        
#ifdef DEFERPOS                 
        EndDeferWindowPos ( hdwp );
#endif

        // update Scroll Bar
        RECT br;
        SetRect ( &br, r.right-RP_SCROLLBARWIDTH,r.top,r.right,r.bottom);               
        InvalidateRect( mWindow, &br, FALSE );
        UpdateWindow ( mWindow );
}

/*
================
rvRollupPanel::GetItemIndex

Return -1 if no matching item was found, otherwise the index of the item
================
*/
int rvRollupPanel::GetItemIndex ( HWND wnd )
{
        int i;
        
        //Search matching button's hwnd
        for ( i=0; i < mItems.Num(); i++ )
        {
                if ( wnd == mItems[i]->mButton )
                {
                        return i;
                }
        }

        return -1;
}

int rvRollupPanel::GetItemIndex ( const char* caption )
{
        int i;
        
        //Search matching button's hwnd
        for ( i=0; i < mItems.Num(); i++ )
        {
                if ( !idStr::Icmp ( caption, mItems[i]->mCaption ) )
                {
                        return i;
                }
        }

        return -1;
}

/*
================
rvRollupPanel::GetItem

Return NULL if the index is invalid
================
*/
RPITEM* rvRollupPanel::GetItem ( int index )
{
        // safety check
        if ( index >= mItems.Num() || index < 0 ) 
        {
                return NULL;
        }

        return mItems[index];
}

/*
================
rvRollupPanel::DialogProc

Dialog procedure for items
================
*/
LRESULT CALLBACK rvRollupPanel::DialogProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
        RPITEM*                 item  = (RPITEM*)GetWindowLong ( hWnd, GWL_USERDATA );
        rvRollupPanel*  _this = (rvRollupPanel*)GetWindowLong ( GetParent ( hWnd ), GWL_USERDATA );

        RECT r;
        GetClientRect ( _this->mWindow, &r );

        if ( _this->mItemHeight > r.bottom-r.top )
        {
                switch (uMsg) 
                {
                        case WM_LBUTTONDOWN:
                        case WM_MBUTTONDOWN:
                        {
                                POINT pos;
                                GetCursorPos ( &pos );
                                _this->mOldMouseYPos = pos.y;
                                ::SetCapture(hWnd);
                                return 0;
                        }

                        case WM_LBUTTONUP:
                        case WM_MBUTTONUP:
                        {
                                if ( ::GetCapture() == hWnd )
                                { 
                                        ::ReleaseCapture(); 
                                        return 0; 
                                }
                                break;
                        }

                        case WM_MOUSEMOVE:
                                if ( (::GetCapture() == hWnd) && (wParam==MK_LBUTTON || wParam==MK_MBUTTON)) 
                                {
                                        POINT pos;
                                        GetCursorPos(&pos);
                                        _this->mStartYPos += (pos.y-_this->mOldMouseYPos);
                                        _this->RecallLayout();
                                        _this->mOldMouseYPos = pos.y;
                                        InvalidateRect ( _this->mWindow, NULL, TRUE );
                                        return 0;
                                }

                                break;

                        case WM_SETCURSOR:
                                if ( (HWND)wParam == hWnd)
                                { 
                                        SetCursor ( LoadCursor (NULL, RP_ROLLCURSOR) ); 
                                        return TRUE; 
                                }
                                break;
                }
        }

        return ::CallWindowProc ( item->mOldDlgProc, hWnd, uMsg, wParam, lParam );
}

/*
================
rvRollupPanel::DialogProc

Button procedure for items
================
*/
LRESULT CALLBACK rvRollupPanel::ButtonProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
        if ( uMsg == WM_SETFOCUS )
        {
                return FALSE;
        }

        RPITEM* item = (RPITEM*)GetWindowLong(hWnd, GWL_USERDATA);      
        return ::CallWindowProc( item->mOldButtonProc, hWnd, uMsg, wParam, lParam );
}

/*
================
rvRollupPanel::WindowProc

Window procedure for rollup panel
================
*/
LRESULT CALLBACK rvRollupPanel::WindowProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
        rvRollupPanel* panel;
        panel = (rvRollupPanel*)GetWindowLong (hWnd, GWL_USERDATA);     
        
        switch ( uMsg )
        {
                case WM_CREATE:
                {
                        LPCREATESTRUCT  cs;

                        // Attach the class to the window first
                        cs = (LPCREATESTRUCT) lParam;
                        panel = (rvRollupPanel*) cs->lpCreateParams;
                        SetWindowLong ( hWnd, GWL_USERDATA, (LONG)panel );
                        break;
                }
                
                case WM_COMMAND:
                        panel->HandleCommand ( wParam, lParam );
                        break;
                        
                case WM_PAINT:
                        return panel->HandlePaint ( wParam, lParam );                   
                        
                case WM_SIZE:
                        return panel->HandleSize ( wParam, lParam );
                        
                case WM_LBUTTONDOWN:
                        panel->HandleLButtonDown ( wParam, lParam );
                        break;
                        
                case WM_LBUTTONUP:
                        panel->HandleLButtonUp ( wParam, lParam );
                        break;
                
                case WM_MOUSEMOVE:
                        panel->HandleMouseMove ( wParam, lParam );
                        break;
                        
                case WM_MOUSEWHEEL:
                        panel->HandleMouseWheel ( wParam, lParam );
                        break;
                
                case WM_MOUSEACTIVATE:
                        panel->HandleMouseActivate ( wParam, lParam );
                        break;
                        
                case WM_CONTEXTMENU:
                        return panel->HandleContextMenu ( wParam, lParam );                     
        }
                        
        return DefWindowProc ( hWnd, uMsg, wParam, lParam );
}

/*
================
rvRollupPanel::HandleCommand

Handle the WM_COMMAND message
================
*/
int rvRollupPanel::HandleCommand ( WPARAM wParam, LPARAM lParam ) 
{
        // popup menu command to expand or collapse pages
        if ( LOWORD(wParam) == RP_IDM_EXPANDALL )
        {
                ExpandAllItems ( true );
        }
        else if ( LOWORD(wParam) == RP_IDM_COLLAPSEALL )
        {
                ExpandAllItems ( false );
        }

        // popupMenu command to expand page
        else if ( LOWORD(wParam) >= RP_IDM_STARTITEMS && 
                          LOWORD(wParam) <  RP_IDM_STARTITEMS + GetItemCount ( ) )
        {
                int index = LOWORD(wParam)-RP_IDM_STARTITEMS;
                ExpandItem ( index, !IsItemExpanded(index) );
        }

        // button command
        else if ( HIWORD(wParam) == BN_CLICKED )
        {
                int index = GetItemIndex ((HWND)lParam);
                if ( index != -1 ) 
                {
                        ExpandItem ( index, !IsItemExpanded ( index ) );
                        return 0;
                }
        }

        return 0;
}

/*
================
rvRollupPanel::HandlePaint

Handle the WM_PAINT message
================
*/
int rvRollupPanel::HandlePaint( WPARAM wParam, LPARAM lParam ) 
{
        HDC                     dc;
        PAINTSTRUCT ps;
        RECT            r;
        RECT            br;
        int                     sbPos;
        int                     sbSize;
        int                     clientHeight;
        
        dc = BeginPaint ( mWindow, &ps );

        // scrollbar
        GetClientRect ( mWindow, &r );
        SetRect ( &br, r.right-RP_SCROLLBARWIDTH, r.top, r.right, r.bottom );
        DrawEdge ( dc, &br, EDGE_RAISED, BF_RECT  );

        sbPos = 0;
        sbSize = 0;
        clientHeight = (r.bottom-r.top) - 4;

        if ( mItemHeight > (r.bottom-r.top) ) 
        {
                sbSize = clientHeight - (((mItemHeight-(r.bottom-r.top)) * clientHeight ) / mItemHeight );
                sbPos  = -(mStartYPos * clientHeight) / mItemHeight;
        } 
        else 
        {
                sbSize = clientHeight;
        }

        br.left         +=2;
        br.right        -=1;
        br.top          = sbPos+2;
        br.bottom       = br.top+sbSize;

        HBRUSH brush;
        brush = CreateSolidBrush ( RP_SCROLLBARCOLOR );
        FillRect ( dc, &br, brush );
        DeleteObject ( brush );

        SetRect ( &r, br.left,2,br.right,br.top );
        FillRect ( dc, &r, (HBRUSH)GetStockObject ( BLACK_BRUSH ) );

        SetRect ( &r, br.left,br.bottom,br.right,2+clientHeight );
        FillRect ( dc, &r, (HBRUSH)GetStockObject ( BLACK_BRUSH ) );
        
        return 0;
}

/*
================
rvRollupPanel::HandleSize

Handle the WM_SIZE message
================
*/
int rvRollupPanel::HandleSize ( WPARAM wParam, LPARAM lParam )
{
        DefWindowProc ( mWindow, WM_SIZE, wParam, lParam );
        RecallLayout();
        return 0;
}

/*
================
rvRollupPanel::HandleLButtonDown

Handle the WM_LBUTTONDOWN message
================
*/
int rvRollupPanel::HandleLButtonDown ( WPARAM wParam, LPARAM lParam ) 
{
        RECT    r;
        RECT    br;
        POINT   point;
        
        GetClientRect ( mWindow, &r );
        if ( mItemHeight <= r.bottom - r.top )
        {
                return 0;
        }

        point.x = LOWORD(lParam);
        point.y = HIWORD(lParam);

        SetRect ( &br, r.right - RP_SCROLLBARWIDTH, r.top, r.right, r.bottom );

        if ( (wParam & MK_LBUTTON) && PtInRect ( &br, point ) ) 
        {
                SetCapture( mWindow );

                int clientHeight = (r.bottom-r.top) - 4;

                int sbSize = clientHeight - (((mItemHeight - (r.bottom-r.top)) * clientHeight) / mItemHeight );
                int     sbPos  = -(mStartYPos * clientHeight) / mItemHeight;

                // click inside scrollbar cursor
                if ( (point.y < (sbPos + sbSize)) && (point.y > sbPos )) 
                {
                        mSBOffset = sbPos - point.y + 1;                
                } 
                // click outside scrollbar cursor (2 cases => above or below cursor)
                else 
                {
                        int distup       = point.y - sbPos;     
                        int distdown = (sbPos + sbSize) - point.y;
                        
                        if ( distup < distdown )
                        {
                                //above
                                mSBOffset = 0;
                        }
                        else
                        {
                                //below
                                mSBOffset = -sbSize;
                        }
                }

                // calc new m_nStartYPos from mouse pos
                int targetPos = point.y + mSBOffset;
                mStartYPos =- (targetPos * mItemHeight) / clientHeight;

                // update
                RecallLayout();
        }
        
        return 0;
}

/*
================
rvRollupPanel::HandleLButtonUp

Handle the WM_LBUTTONUP message
================
*/
int rvRollupPanel::HandleLButtonUp ( WPARAM wParam, LPARAM lParam ) 
{
        if ( GetCapture() == mWindow )
        {
                ReleaseCapture();
        }
        
        return 0;
}

/*
================
rvRollupPanel::HandleMouseMove

Handle the WM_MOUSEMOVE message
================
*/
int rvRollupPanel::HandleMouseMove ( WPARAM wParam, LPARAM lParam ) 
{
        RECT  r;
        RECT  br;
        POINT point;
        
        GetClientRect ( mWindow, &r );
        if ( mItemHeight <= r.bottom - r.top )
        {
                return 0;
        }

        point.x = LOWORD(lParam);
        point.y = HIWORD(lParam);

        SetRect ( &br, r.right - RP_SCROLLBARWIDTH, r.top, r.right, r.bottom );

        if ( (wParam & MK_LBUTTON) && (GetCapture() == mWindow )) 
        {
                // calc new m_nStartYPos from mouse pos
                int clientHeight        = (r.bottom-r.top) - 4;
                int targetPos           = point.y + mSBOffset;
                
                mStartYPos =- (targetPos * mItemHeight) / clientHeight;

                RecallLayout ( );
                
                InvalidateRect ( mWindow, NULL, FALSE );                
//              UpdateWindow ( mWindow );
        }

        return 0;
}

/*
================
rvRollupPanel::HandleMouseWheel

Handle the WM_MOUSEWHEEL message
================
*/
int rvRollupPanel::HandleMouseWheel ( WPARAM wParam, LPARAM lParam ) 
{
        // calc new m_nStartYPos
        mStartYPos += (HIWORD(wParam) / 4);

        RecallLayout();

        return 0;
}

/*
================
rvRollupPanel::HandleMouseActivate

Handle the WM_MOUSEACTIVATE message
================
*/
int rvRollupPanel::HandleMouseActivate  ( WPARAM wParam, LPARAM lParam ) 
{
        SetFocus ( mWindow );
        return 0;
}

/*
================
rvRollupPanel::HandleContextMenu

Handle the WM_CONTEXTMENU message
================
*/
int rvRollupPanel::HandleContextMenu ( WPARAM wParam, LPARAM lParam )
{
        HMENU menu;
        int       i;
        POINT point;
        
        menu = CreatePopupMenu ( );
        if ( !menu )
        {
                return 0;
        }

        point.x = LOWORD(lParam);
        point.y = HIWORD(lParam);

        AppendMenu ( menu, MF_STRING,           RP_IDM_EXPANDALL,       "Expand all"    );
        AppendMenu ( menu, MF_STRING,           RP_IDM_COLLAPSEALL,     "Collapse all"  );
        AppendMenu ( menu, MF_SEPARATOR,        0,                                      ""                              );

        //Add all pages with checked style for expanded ones
        for ( i=0; i < mItems.Num(); i++ )
        {
                char itemName[1024];
                GetWindowText ( mItems[i]->mButton, itemName, 1023 );
                AppendMenu ( menu, MF_STRING, RP_IDM_STARTITEMS + i, itemName );        

                if ( mItems[i]->mExpanded )
                {
                        CheckMenuItem ( menu, RP_IDM_STARTITEMS + i, MF_CHECKED);
                }

                TrackPopupMenu ( menu, TPM_LEFTALIGN|TPM_LEFTBUTTON, point.x, point.y, 0, mWindow, NULL );
        }
        
        return 0;
}

/*
================
rvRollupPanel::GetMsgProc

Ensures normal dialog functions work in the alpha select dialog
================
*/
LRESULT FAR PASCAL rvRollupPanel::GetMsgProc ( int nCode, WPARAM wParam, LPARAM lParam )
{
        LPMSG lpMsg = (LPMSG) lParam;

        if ( nCode >= 0 && PM_REMOVE == wParam )
        {
                // Don't translate non-input events.
                if ( (lpMsg->message >= WM_KEYFIRST && lpMsg->message <= WM_KEYLAST) )
                {
                        int i;
                        for ( i = 0; i < mDialogs.Num(); i ++ )
                        {
                                if ( IsDialogMessage( mDialogs[i], lpMsg) )
                                {
                                        // The value returned from this hookproc is ignored, 
                                        // and it cannot be used to tell Windows the message has been handled.
                                        // To avoid further processing, convert the message to WM_NULL 
                                        // before returning.
                                        lpMsg->message = WM_NULL;
                                        lpMsg->lParam  = 0;
                                        lpMsg->wParam  = 0;
                                        break;
                                }
                        }
                }
        }

        return CallNextHookEx ( mDialogHook, nCode, wParam, lParam);
} 

/*
================
rvRollupPanel::AutoSize

Automatically set the width of the control based on the dialogs it contains
================
*/
void rvRollupPanel::AutoSize ( void )
{
        int i;
        int width = 0;
        for ( i = 0; i < mItems.Num(); i ++ )
        {
                RECT r;
                int  w;
                GetWindowRect ( mItems[i]->mDialog, &r );
                w = (r.right-r.left)+RP_SCROLLBARWIDTH+(RP_GRPBOXINDENT*2);
                if ( w > width )
                {
                        width = w;
                }
        }
        
        RECT cr;
        GetWindowRect ( mWindow, &cr );
        SetWindowPos ( mWindow, NULL, 0, 0, width, cr.bottom-cr.top, SWP_NOMOVE|SWP_NOZORDER );
}