1216 lines
25 KiB
C++
1216 lines
25 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
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 );
|
|
}
|
|
|