Zero Hour rebuilt from EA's source: x64, Direct3D 11, VS2022/CMake, ~60 original bugs fixed, an AI that builds a base. Bring your own game.
C++ cmakecnccommand-and-conquercppdirectx11game-enginegame-preservationgeneralsrtssage-enginex64zero-hour
/*
** Command & Conquer Generals Zero Hour(tm)
** Copyright 2025 Electronic Arts 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/>.
*/
// Modified 2025-2026 by Olcay Seygan for Zero Hour Reforged; see the git history.
// Modified 2026 by İlyas Akın for the macOS/Linux port; see NOTICE.md and the git history.
////////////////////////////////////////////////////////////////////////////////
// //
// (c) 2001-2003 Electronic Arts Inc. //
// //
////////////////////////////////////////////////////////////////////////////////
// FILE: GameWindowManager.cpp ////////////////////////////////////////////////////////////////////
// Created: Colin Day, June 2001
// Dean Iverson, March 1998 (Original window code)
// Desc: The game window manager is the singleton class that we interface
// with to interact with the game windowing system.
///////////////////////////////////////////////////////////////////////////////////////////////////
#include "PreRTS.h" // This must go first in EVERY cpp file int the GameEngine
#include "Common/Debug.h"
#include "Common/Language.h"
#include "GameClient/Display.h"
#include "GameClient/GameWindowManager.h"
#include "GameClient/GameWindow.h"
#include "GameClient/Mouse.h"
#include "GameClient/DisplayStringManager.h"
#include "GameClient/WindowLayout.h"
#include "GameClient/Gadget.h"
#include "GameClient/GameWindowGlobal.h"
#include "GameClient/GadgetListBox.h"
#include "GameClient/GadgetComboBox.h"
#include "GameClient/GadgetTabControl.h"
#include "GameClient/GadgetProgressBar.h"
#include "GameClient/GadgetStaticText.h"
#include "GameClient/GadgetTextEntry.h"
#include "GameClient/GadgetSlider.h"
#include "GameClient/GadgetRadioButton.h"
#include "GameClient/GadgetCheckBox.h"
#include "GameClient/GlobalLanguage.h"
#include "GameClient/GameWindowTransitions.h"
#include "GameClient/Shell.h"
#include "Common/NameKeyGenerator.h"
// PUBLIC DATA ////////////////////////////////////////////////////////////////////////////////////
GameWindowManager *TheWindowManager = NULL;
UnsignedInt WindowLayoutCurrentVersion = 2;
///////////////////////////////////////////////////////////////////////////////////////////////////
// PRIVATE FUNCTIONS //////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef _INTERNAL
// for occasional debugging...
//#pragma optimize("", off)
//#pragma MESSAGE("************************************** WARNING, optimization disabled for debugging purposes")
#endif
//
// with this statis set to true, the window system will propogate mouse position
// messages to windows. You may want to disable this if you feel the mouse position
// messages are "spamming" your window and making a particular debuggin situation
// difficult. Make sure you do enable this before you check in again tho because
// it is necessary for any code that needs to look at objects or anything under
// the radar cursor
//
static Bool sendMousePosMessages = TRUE;
//-------------------------------------------------------------------------------------------------
/** Process windows waiting to be destroyed */
//-------------------------------------------------------------------------------------------------
void GameWindowManager::processDestroyList( void )
{
GameWindow *next;
GameWindow *doDestroy;
//
// we need to pass the ownership of the destroy list so
// if, while destroying a window, we need to add other windows
// to the destroy list it won't cause problems.
//
doDestroy = m_destroyList;
// set the list to empty
m_destroyList = NULL;
// do the destroys
for( ; doDestroy; doDestroy = next )
{
next = doDestroy->m_next;
// Check to see if this window is "special"
if( m_mouseCaptor == doDestroy )
winRelease( doDestroy );
if( m_keyboardFocus == doDestroy )
winSetFocus( NULL );
m_modalHead = ModalStack_removeWindow( m_modalHead, doDestroy );
if( m_currMouseRgn == doDestroy )
m_currMouseRgn = NULL;
if( m_grabWindow == doDestroy )
m_grabWindow = NULL;
// send the destroy message to the window we're about to kill
winSendSystemMsg( doDestroy, GWM_DESTROY, 0, 0 );
// free the memory
if (doDestroy)
doDestroy->deleteInstance();
} // end for
} // end processDestroyList
///////////////////////////////////////////////////////////////////////////////////////////////////
// PUBLIC FUNCTIONS ///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
//-------------------------------------------------------------------------------------------------
/** Generic function to simply propagate only button press messages to parent and let it deal with it */
//-------------------------------------------------------------------------------------------------
WindowMsgHandledType PassSelectedButtonsToParentSystem( GameWindow *window, UnsignedInt msg,
WindowMsgData mData1, WindowMsgData mData2 )
{
// sanity
if( window == NULL )
return MSG_IGNORED;
if( (msg == GBM_SELECTED) || (msg == GBM_SELECTED_RIGHT) || (msg == GBM_MOUSE_ENTERING) || (msg == GBM_MOUSE_LEAVING) || (msg == GEM_EDIT_DONE))
{
GameWindow *parent = window->winGetParent();
if( parent )
return TheWindowManager->winSendSystemMsg( parent, msg, mData1, mData2 );
} // end if
return MSG_IGNORED;
} // end PassSelectedButtonsToParentSystem
//-------------------------------------------------------------------------------------------------
/** Generic function to simply propagate only button press messages to parent and let it deal with it */
//-------------------------------------------------------------------------------------------------
WindowMsgHandledType PassMessagesToParentSystem( GameWindow *window, UnsignedInt msg,
WindowMsgData mData1, WindowMsgData mData2 )
{
// sanity
if( window == NULL )
return MSG_IGNORED;
GameWindow *parent = window->winGetParent();
if( parent )
return TheWindowManager->winSendSystemMsg( parent, msg, mData1, mData2 );
return MSG_IGNORED;
} // end PassSelectedButtonsToParentSystem
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
GameWindowManager::GameWindowManager( void )
{
m_windowList = NULL; // list of all top level windows
m_windowTail = NULL; // last in windowList
m_destroyList = NULL; // list of windows to destroy
m_currMouseRgn = NULL; // window that mouse is over
m_mouseCaptor = NULL; // window that captured mouse
m_keyboardFocus = NULL; // window that has input focus
m_modalHead = NULL; // top of windows in the modal stack
m_grabWindow = NULL; // window that grabbed the last down event
m_loneWindow = NULL; // Set if we just opened a combo box
m_loggedCaptor = NULL;
m_loggedLone = NULL;
m_loggedFocus = NULL;
m_loggedModal = NULL;
m_cursorBitmap = NULL;
m_captureFlags = 0;
} // end GameWindowManger
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
GameWindowManager::~GameWindowManager( void )
{
// destroy all windows
winDestroyAll();
freeStaticStrings();
if(TheTransitionHandler)
delete TheTransitionHandler;
TheTransitionHandler = NULL;
} // end ~GameWindowManager
//-------------------------------------------------------------------------------------------------
/** Initialize the game window manager system */
//-------------------------------------------------------------------------------------------------
void GameWindowManager::init( void )
{
if(!TheTransitionHandler)
TheTransitionHandler = NEW GameWindowTransitionsHandler;
TheTransitionHandler->load();
TheTransitionHandler->init();
} // end init
//-------------------------------------------------------------------------------------------------
/** Reset window system */
//-------------------------------------------------------------------------------------------------
void GameWindowManager::reset( void )
{
// destroy all windows left
winDestroyAll();
if(TheTransitionHandler)
TheTransitionHandler->reset();
} // end reset
//-------------------------------------------------------------------------------------------------
/** Update cycle for game widnow manager */
//-------------------------------------------------------------------------------------------------
void GameWindowManager::update( void )
{
// Process windows waiting to be destroyed
processDestroyList();
// after the destroy pass, so a pointer left holding a freed window reads as DESTROYED here
logInputOwnersOnChange();
if(TheTransitionHandler)
TheTransitionHandler->update();
} // end update
//-------------------------------------------------------------------------------------------------
/** Puts a window at the head of the window list */
//-------------------------------------------------------------------------------------------------
void GameWindowManager::linkWindow( GameWindow *window )
{
GameWindow *lastModalWindow = NULL;
GameWindow *tmp = m_windowList;
while (tmp)
{
const ModalWindow *modal = m_modalHead;
while (modal)
{
if (modal->window == tmp && modal->window != window)
{
lastModalWindow = tmp;
}
modal = modal->next;
}
tmp = tmp->m_next;
}
if (!lastModalWindow)
{
// Add to head of the top level window list
window->m_prev = NULL;
window->m_next = m_windowList;
if( m_windowList )
m_windowList->m_prev = window;
else
{
// first on list is also the tail
m_windowTail = window;
}
m_windowList = window;
}
else
{
// lastModalWindow points to a modal window - add behind it
window->m_prev = lastModalWindow;
window->m_next = lastModalWindow->m_next;
lastModalWindow->m_next = window;
if (window->m_next)
{
window->m_next->m_prev = window;
}
}
} // end linkWindow
//-------------------------------------------------------------------------------------------------
/** Insert the window ahead of the the 'aheadOf' window. 'aheadOf' can
* be a window in the master list or a child of any window in that master
* list */
//-------------------------------------------------------------------------------------------------
void GameWindowManager::insertWindowAheadOf( GameWindow *window,
GameWindow *aheadOf )
{
// sanity
if( window == NULL )
return;
// we'll say that an aheadOf window means at the head of the list
if( aheadOf == NULL )
{
linkWindow( window );
return;
} // end if
// get parent of aheadOf
GameWindow *aheadOfParent = aheadOf->winGetParent();
//
// if ahead of has no parent insert it in the master list just before
// ahead of
//
if( aheadOfParent == NULL )
{
window->m_prev = aheadOf->m_prev;
if( aheadOf->m_prev )
aheadOf->m_prev->m_next = window;
else
m_windowList = window;
aheadOf->m_prev = window;
window->m_next = aheadOf;
} // end if
else
{
window->m_prev = aheadOf->m_prev;
if( aheadOf->m_prev )
aheadOf->m_prev->m_next = window;
else
aheadOfParent->m_child = window;
aheadOf->m_prev = window;
window->m_next = aheadOf;
window->m_parent = aheadOfParent;
} // end else
} // end insertWindowAheadOf
//-------------------------------------------------------------------------------------------------
/** Takes a window off the window list */
//-------------------------------------------------------------------------------------------------
void GameWindowManager::unlinkWindow( GameWindow *window )
{
if( window->m_next )
window->m_next->m_prev = window->m_prev;
else
{
// no next means this is the tail
m_windowTail = window->m_prev;
}
if( window->m_prev )
window->m_prev->m_next = window->m_next;
else
m_windowList = window->m_next;
} // end unlinkWindow
//-------------------------------------------------------------------------------------------------
/** Takes a child window off its parent's window list */
//-------------------------------------------------------------------------------------------------
void GameWindowManager::unlinkChildWindow( GameWindow *window )
{
if( window->m_prev )
{
window->m_prev->m_next = window->m_next;
if( window->m_next )
window->m_next->m_prev = window->m_prev;
}
else
{
if( window->m_next )
{
window->m_parent->m_child = window->m_next;
window->m_next->m_prev = window->m_prev;
window->m_next = NULL;
}
else
{
window->m_parent->m_child = NULL;
}
} // end else
// remove the parent reference from this window
window->m_parent = NULL;
} // end unlinkChildWindow
//-------------------------------------------------------------------------------------------------
/** Check window and parents to see if this window is enabled */
//-------------------------------------------------------------------------------------------------
Bool GameWindowManager::isEnabled( GameWindow *win )
{
// sanity
if( win == NULL )
return FALSE;
if( BitTest( win->m_status, WIN_STATUS_ENABLED ) == FALSE )
{
return FALSE;
}
while( win->m_parent )
{
win = win->m_parent;
if( BitTest( win->m_status, WIN_STATUS_ENABLED ) == FALSE )
{
return FALSE;
}
}
return TRUE;
} // end isEnabled
//-------------------------------------------------------------------------------------------------
/** Check window and parents to see if this window is hidden */
//-------------------------------------------------------------------------------------------------
Bool GameWindowManager::isHidden( GameWindow *win )
{
// we'll allow for the idea that if a window doesn't exist it is hidden
if( win == NULL )
return TRUE;
if( BitTest( win->m_status, WIN_STATUS_HIDDEN ))
{
return TRUE;
}
while( win->m_parent )
{
win = win->m_parent;
if( BitTest( win->m_status, WIN_STATUS_HIDDEN ))
{
return TRUE;
}
}
return FALSE;
} // end isHidden
//-------------------------------------------------------------------------------------------------
// Adds a child window to its parent.
//-------------------------------------------------------------------------------------------------
void GameWindowManager::addWindowToParent( GameWindow *window,
GameWindow *parent )
{
if( parent )
{
// add to parent's list of children
window->m_prev = NULL;
window->m_next = parent->m_child;
if( parent->m_child )
parent->m_child->m_prev = window;
parent->m_child = window;
window->m_parent = parent;
}
} // end addWindowToParent
//-------------------------------------------------------------------------------------------------
/** Add a child window to the parent, put place it at the end of the
* parent window child list */
//-------------------------------------------------------------------------------------------------
void GameWindowManager::addWindowToParentAtEnd( GameWindow *window,
GameWindow *parent )
{
if( parent )
{
window->m_prev = NULL;
window->m_next = NULL;
if( parent->m_child )
{
GameWindow *last;
// wind down to last child in list
last = parent->m_child;
while( last->m_next != NULL )
last = last->m_next;
// tie to list
last->m_next = window;
window->m_prev = last;
} // end if
else
parent->m_child = window;
// assign the parent to the window
window->m_parent = parent;
} // end if
} // end addWindowToParentAtEnd
//-------------------------------------------------------------------------------------------------
/** this gets called from winHide() when a window hides itself */
//-------------------------------------------------------------------------------------------------
void GameWindowManager::windowHiding( GameWindow *window )
{
// if this window has keyboard focus remove it
if( m_keyboardFocus == window )
m_keyboardFocus = NULL;
// if this is the modal head, unset it
if( m_modalHead && m_modalHead->window == window )
winUnsetModal( window );
// if this is the captor, it shall no longer be
if( m_mouseCaptor == window )
winCapture( NULL );
//
// since hiding a parent will also hide the children, when a parent
// hides we must call this same method for all the children so they
// each have a chance to go through this logic
//
GameWindow *child;
for( child = window->winGetChild(); child; child = child->winGetNext() )
windowHiding( child );
} // end windowHiding
//-------------------------------------------------------------------------------------------------
/** Hide all windows in a certain range of id's (inclusive) */
//-------------------------------------------------------------------------------------------------
void GameWindowManager::hideWindowsInRange( GameWindow *baseWindow,
Int first, Int last,
Bool hideFlag )
{
Int i;
GameWindow *window;
for( i = first; i <= last; i++ )
{
window = winGetWindowFromId( baseWindow, i );
if( window )
window->winHide( hideFlag );
} // end for i
} // end hideWindowsInRange
//-------------------------------------------------------------------------------------------------
// Enable all windows in a certain range of id's (inclusive)
//-------------------------------------------------------------------------------------------------
void GameWindowManager::enableWindowsInRange( GameWindow *baseWindow,
Int first, Int last,
Bool enableFlag )
{
Int i;
GameWindow *window;
for( i =first; i <= last; i++ )
{
window = winGetWindowFromId( baseWindow, i );
if( window )
window->winEnable( enableFlag );
} // end for i
} // end enableWindowsInRange
//-------------------------------------------------------------------------------------------------
/** Captures the mouse capture. */
//-------------------------------------------------------------------------------------------------
Int GameWindowManager::winCapture( GameWindow *window )
{
if( m_mouseCaptor != NULL)
return WIN_ERR_MOUSE_CAPTURED;
m_mouseCaptor = window;
return WIN_ERR_OK;
} // end WinCapture
//-------------------------------------------------------------------------------------------------
/** Releases the mouse capture. */
//-------------------------------------------------------------------------------------------------
Int GameWindowManager::winRelease( GameWindow *window )
{
if( window == m_mouseCaptor )
m_mouseCaptor = NULL;
return WIN_ERR_OK;
} // end WinRelease
//-------------------------------------------------------------------------------------------------
/** Returns the current mouse captor. */
//-------------------------------------------------------------------------------------------------
GameWindow *GameWindowManager::winGetCapture( void )
{
return m_mouseCaptor;
} // end WinGetCapture
//-------------------------------------------------------------------------------------------------
/** Gets the window pointer from its id */
//-------------------------------------------------------------------------------------------------
GameWindow *GameWindowManager::winGetWindowFromId( GameWindow *window, Int id )
{
if( window == NULL )
window = m_windowList;
for( ; window; window = window->m_next )
{
if( window->winGetWindowId() == id)
return window;
else if( window->m_child )
{
GameWindow *child = winGetWindowFromId( window->m_child, id );
if( child )
return child;
} // end else if
} // end for
return NULL;
} // end WinGetWindowFromId
//-------------------------------------------------------------------------------------------------
/** Gets the Window List Pointer */
//-------------------------------------------------------------------------------------------------
GameWindow *GameWindowManager::winGetWindowList( void )
{
return m_windowList;
} // end winGetWindowList
//-------------------------------------------------------------------------------------------------
/** Send a system message to the specified window */
//-------------------------------------------------------------------------------------------------
WindowMsgHandledType GameWindowManager::winSendSystemMsg( GameWindow *window,
UnsignedInt msg,
WindowMsgData mData1,
WindowMsgData mData2 )
{
if( window == NULL)
return MSG_IGNORED;
if( msg != GWM_DESTROY && BitTest( window->m_status, WIN_STATUS_DESTROYED ) )
return MSG_IGNORED;
return window->m_system( window, msg, mData1, mData2 );
} // end winSendSystemMsg
//-------------------------------------------------------------------------------------------------
/** Send a system message to the specified window */
//-------------------------------------------------------------------------------------------------
WindowMsgHandledType GameWindowManager::winSendInputMsg( GameWindow *window,
UnsignedInt msg,
WindowMsgData mData1,
WindowMsgData mData2 )
{
if( window == NULL )
return MSG_IGNORED;
if( msg != GWM_DESTROY && BitTest( window->m_status, WIN_STATUS_DESTROYED ) )
return MSG_IGNORED;
return window->m_input( window, msg, mData1, mData2 );
} // end winSendInputMsg
//-------------------------------------------------------------------------------------------------
/** Get the current input focus */
//-------------------------------------------------------------------------------------------------
GameWindow *GameWindowManager::winGetFocus( void )
{
return m_keyboardFocus;
} // end WinGetFocus
//-------------------------------------------------------------------------------------------------
/** Set the current input focus */
//-------------------------------------------------------------------------------------------------
Int GameWindowManager::winSetFocus( GameWindow *window )
{
Bool wantsFocus = FALSE;
// if a window doesn't want keyboard focus don't give it
if( window )
if( BitTest( window->winGetStatus(), WIN_STATUS_NO_FOCUS) )
return 0;
//
// Tell current focus window that it's losing focus
// unless we are trying to give focus to the current focus window
//
if( (m_keyboardFocus) && (m_keyboardFocus != window) )
{
Bool wf; // dummy var, ignored, but must be passed
winSendSystemMsg( m_keyboardFocus, GWM_INPUT_FOCUS, FALSE, (WindowMsgData)&wf );
}
// Set focus to new window
m_keyboardFocus = window;
// Tell new focus window that it has focus
if( m_keyboardFocus )
{
for (;;)
{
winSendSystemMsg( window, GWM_INPUT_FOCUS, TRUE, (WindowMsgData)&wantsFocus );
if (wantsFocus)
break;
window = window->winGetParent();
if( window == NULL )
break;
}
} // end if
// If new window doesn't want focus, set focus to NULL
if( wantsFocus == FALSE )
m_keyboardFocus = NULL;
return WIN_ERR_OK;
} // end WinSetFocus
//-------------------------------------------------------------------------------------------------
/** Front-end menus only: a game's own windows keep their animations whatever is pressed. */
static void cutShellAnimations( void )
{
if( TheShell && TheShell->isShellActive() )
TheShell->cutAnimations();
}
//-------------------------------------------------------------------------------------------------
/** Process key press through the GUI. */
//-------------------------------------------------------------------------------------------------
WinInputReturnCode GameWindowManager::winProcessKey( UnsignedByte key,
UnsignedByte state )
{
WinInputReturnCode returnCode = WIN_INPUT_NOT_USED;
if( BitTest( state, KEY_STATE_DOWN ) )
cutShellAnimations();
// Check for keyboard focus and a legal key for sanity
if( m_keyboardFocus && (key != KEY_NONE) )
{
GameWindow *win = m_keyboardFocus;
returnCode = WIN_INPUT_USED; // assume input will be used
//
// Pass the keystroke up the window hierarchy until it is
// processed or we reach the top level window
//
while( winSendInputMsg( win, GWM_CHAR, key, state ) == MSG_IGNORED )
{
win = win->winGetParent();
if( win == NULL )
{
returnCode = WIN_INPUT_NOT_USED; // oops, it wasn't used after all
break;
} // end if
} // end while
} // end if
return returnCode;
} // end winProcessKey
//-------------------------------------------------------------------------------------------------
/** Process a single mouse event through the window system */
//-------------------------------------------------------------------------------------------------
Bool OpenWindowOwnsPoint( Bool isOpen, Int originX, Int originY, Int width, Int height, Int x, Int y );
WinInputReturnCode GameWindowManager::winProcessMouseEvent( GameWindowMessage msg,
ICoord2D *mousePos,
void *data )
{
WinInputReturnCode returnCode = WIN_INPUT_NOT_USED;
Bool objectTooltip = FALSE;
UnsignedInt packedMouseCoords;
GameWindow *window = NULL;
GameWindow *toolTipWindow = NULL;
GameWindow *childWindow;
Int dx, dy;
Bool clearGrabWindow = FALSE;
// Only right-button events may reach disabled production buttons. Left clicks and
// hotkeys still obey the normal availability check.
Bool allowDisabledCancel = msg == GWM_RIGHT_DOWN || msg == GWM_RIGHT_UP;
// a press lands on where the menu is going, not where its animation has got to
if( msg == GWM_LEFT_DOWN || msg == GWM_RIGHT_DOWN || msg == GWM_MIDDLE_DOWN )
cutShellAnimations();
// pack mouse coords into one entity for message passing
packedMouseCoords = SHORTTOLONG( mousePos->x, mousePos->y );
// clear tooltip ... it will be reset if necessary
TheMouse->setCursorTooltip( UnicodeString::TheEmptyString );
// Check for mouse capture
if( m_mouseCaptor )
{
// no window grabbed as of yet
m_grabWindow = NULL;
// what what window within the captured window are we in
window = m_mouseCaptor->winPointInChild( mousePos->x, mousePos->y, FALSE, FALSE, allowDisabledCancel );
//
// send buttons, drags, wheels to the windows, we don't continually
// send mouse positions
//
if( sendMousePosMessages == TRUE || msg != GWM_MOUSE_POS )
{
GameWindow *win = window;
if( win )
{
while( win != NULL )
{
if( winSendInputMsg( win, msg, packedMouseCoords, 0 ) == MSG_HANDLED )
{
// if used clear the event
returnCode = WIN_INPUT_USED;
break;
}
// if we just tested mouseCaptor don't go any higher in the chain
if( win == m_mouseCaptor )
break;
win = win->winGetParent();
} // end while
} // end if
else
{
// if used clear the event
if( winSendInputMsg( m_mouseCaptor, msg, packedMouseCoords, 0 ) == MSG_HANDLED )
returnCode = WIN_INPUT_USED;
} // end else
} // end if
} // end if, mouse captor window present
else
{
if( m_grabWindow )
{
GameWindow *parent;
switch( msg )
{
// --------------------------------------------------------------------
case GWM_LEFT_UP:
{
//Play a beep sound if the window is disabled.
m_grabWindow->winPointInChild( mousePos->x, mousePos->y, FALSE, TRUE );
BitClear( m_grabWindow->m_status, WIN_STATUS_ACTIVE );
if( m_grabWindow->winPointInWindow( mousePos->x, mousePos->y ) )
winSendInputMsg( m_grabWindow, GWM_LEFT_UP, packedMouseCoords, 0 );
else if( BitTest( m_grabWindow->m_status, WIN_STATUS_DRAGABLE ))
{
winSendInputMsg( m_grabWindow, GWM_LEFT_UP, packedMouseCoords, 0 );
}
clearGrabWindow = TRUE;
break;
} // end left up
// --------------------------------------------------------------------
case MOUSE_EVENT_NONE:
case GWM_LEFT_DRAG:
{
if( BitTest( m_grabWindow->m_status, WIN_STATUS_DRAGABLE ) )
{
ICoord2D *mouseDelta = (ICoord2D *)data;
dx = mouseDelta->x;
dy = mouseDelta->y;
// Clip window to parent
if( m_grabWindow->winGetParent() )
{
parent = m_grabWindow->winGetParent();
if( m_grabWindow->m_region.lo.x + dx < 0 )
dx = 0 - m_grabWindow->m_region.lo.x;
else if( m_grabWindow->m_region.hi.x + dx > parent->m_size.x )
dx = parent->m_size.x - m_grabWindow->m_region.hi.x;
if( m_grabWindow->m_region.lo.y + dy < 0 )
dy = 0 - m_grabWindow->m_region.lo.y;
else if( m_grabWindow->m_region.hi.y + dy > parent->m_size.y )
dy = parent->m_size.y - m_grabWindow->m_region.hi.y;
}
// Move the window, but keep it completely visible within screen boundaries
IRegion2D newRegion;
ICoord2D grabSize;
m_grabWindow->winGetPosition( &newRegion.lo.x, &newRegion.lo.y );
m_grabWindow->winGetSize( &grabSize.x, &grabSize.y );
newRegion.lo.x += dx;
newRegion.lo.y += dy;
if( newRegion.lo.x < 0 )
newRegion.lo.x = 0;
if( newRegion.lo.y < 0 )
newRegion.lo.y = 0;
newRegion.hi.x = newRegion.lo.x + grabSize.x;
newRegion.hi.y = newRegion.lo.y + grabSize.y;
if( newRegion.hi.x > (Int)TheDisplay->getWidth() )
newRegion.hi.x = (Int)TheDisplay->getWidth();
if( newRegion.hi.y > (Int)TheDisplay->getHeight() )
newRegion.hi.y = (Int)TheDisplay->getHeight();
newRegion.lo.x = newRegion.hi.x - grabSize.x;
newRegion.lo.y = newRegion.hi.y - grabSize.y;
m_grabWindow->winSetPosition( newRegion.lo.x, newRegion.lo.y );
} // end if, draggable window
// Send mouse drag message
winSendInputMsg( m_grabWindow, msg, packedMouseCoords, 0 );
break;
} // end mouse event none or left drag
} // end switch
// mark event handled
returnCode = WIN_INPUT_USED;
} // end if, m_grabWindow
else
{
// the rows of an open dropdown that hang past its panel; see OpenWindowOwnsPoint
if( m_loneWindow )
{
ICoord2D origin, size;
m_loneWindow->winGetScreenPosition( &origin.x, &origin.y );
m_loneWindow->winGetSize( &size.x, &size.y );
if( OpenWindowOwnsPoint( !m_loneWindow->winIsHidden(), origin.x, origin.y,
size.x, size.y, mousePos->x, mousePos->y ) )
window = m_loneWindow->winPointInChild( mousePos->x, mousePos->y, FALSE, FALSE, allowDisabledCancel );
}
if( window == NULL && m_modalHead && m_modalHead->window )
{
window = m_modalHead->window->winPointInChild( mousePos->x, mousePos->y, FALSE, FALSE, allowDisabledCancel );
}
else if( window == NULL )
{
/**@todo Colin, there are 3 cases here that are nearly identical code,
break them up into functions with parameters */
// search for top-level window which contains pointer
for( window = m_windowList; window; window = window->m_next )
{
if( BitTest( window->m_status, WIN_STATUS_ABOVE ) &&
!BitTest( window->m_status, WIN_STATUS_HIDDEN ) &&
mousePos->x >= window->m_region.lo.x &&
mousePos->x <= window->m_region.hi.x &&
mousePos->y >= window->m_region.lo.y &&
mousePos->y <= window->m_region.hi.y)
{
childWindow = window->winPointInAnyChild( mousePos->x, mousePos->y, TRUE, TRUE );
if( toolTipWindow == NULL )
{
if( childWindow->m_tooltip ||
childWindow->m_instData.getTooltipTextLength() )
{
toolTipWindow = childWindow;
}
}
if( BitTest( window->m_status, WIN_STATUS_ENABLED ) )
{
// determine which child window the mouse is in
window = window->winPointInChild( mousePos->x, mousePos->y, FALSE, FALSE, allowDisabledCancel );
break; // exit for
}
} // end if
} // end for window
// check !above, below and hidden
if( window == NULL )
{
for( window = m_windowList; window; window = window->m_next )
{
if( !BitTest( window->m_status, WIN_STATUS_ABOVE |
WIN_STATUS_BELOW |
WIN_STATUS_HIDDEN ) &&
mousePos->x >= window->m_region.lo.x &&
mousePos->x <= window->m_region.hi.x &&
mousePos->y >= window->m_region.lo.y &&
mousePos->y <= window->m_region.hi.y)
{
childWindow = window->winPointInAnyChild( mousePos->x, mousePos->y, TRUE, TRUE );
if( toolTipWindow == NULL )
{
if( childWindow->m_tooltip ||
childWindow->m_instData.getTooltipTextLength() )
{
toolTipWindow = childWindow;
}
}
if( BitTest( window->m_status, WIN_STATUS_ENABLED ))
{
// determine which child window the mouse is in
window = window->winPointInChild( mousePos->x, mousePos->y, FALSE, FALSE, allowDisabledCancel );
break; // exit for
}
}
}
} // end if, window == NULL
// check below and !hidden
if( window == NULL )
{
for( window = m_windowList; window; window = window->m_next )
{
if( BitTest( window->m_status, WIN_STATUS_BELOW ) &&
!BitTest( window->m_status, WIN_STATUS_HIDDEN ) &&
mousePos->x >= window->m_region.lo.x &&
mousePos->x <= window->m_region.hi.x &&
mousePos->y >= window->m_region.lo.y &&
mousePos->y <= window->m_region.hi.y)
{
childWindow = window->winPointInAnyChild( mousePos->x, mousePos->y, TRUE, TRUE );
if( toolTipWindow == NULL )
{
if( childWindow->m_tooltip ||
childWindow->m_instData.getTooltipTextLength() )
{
toolTipWindow = childWindow;
}
}
if( BitTest( window->m_status, WIN_STATUS_ENABLED ))
{
// determine which child window the mouse is in
window = window->winPointInChild( mousePos->x, mousePos->y, FALSE, FALSE, allowDisabledCancel );
break; // exit for
}
}
}
} // end if
} // end else, no modal head
if( window )
if( BitTest( window->m_status, WIN_STATUS_NO_INPUT ) )
{
if(window->winGetParent() && BitTest( window->winGetParent()->winGetInstanceData()->getStyle(), GWS_COMBO_BOX ))
window = window->winGetParent();
else
window = NULL;
}
if( window )
{
GameWindow *tempWin;
//
// only send messages for button states, wheel states, we do not
// continually send messages for mouse positions
//
if( sendMousePosMessages == TRUE || msg != GWM_MOUSE_POS )
{
tempWin = window;
// Give everyone a chance to do something with the clicks
GameWindow *oldLoneWindow = m_loneWindow;
while( winSendInputMsg( tempWin, msg, packedMouseCoords, 0 ) == MSG_IGNORED )
{
tempWin = tempWin->m_parent;
if( tempWin == NULL )
break;
} // end while
// First check to see if m_loneWindow is set if so, close the window
if( m_loneWindow && m_loneWindow == oldLoneWindow
&&( msg == GWM_LEFT_UP || msg == GWM_MIDDLE_UP || msg == GWM_RIGHT_UP || tempWin))
{
if(!m_loneWindow->winIsChild(tempWin))
winSetLoneWindow( NULL );
/*
ComboBoxData *cData = (ComboBoxData *)m_comboBoxOpen->winGetUserData();
// verify that the window that ate the message wasn't one of our own
if(cData->dropDownButton != tempWin &&
cData->editBox != tempWin &&
cData->listBox != tempWin &&
cData->listboxData->upButton != tempWin &&
cData->listboxData->downButton != tempWin &&
cData->listboxData->slider != tempWin &&
cData->listboxData->slider != tempWin->winGetParent())
winSetOpenComboBoxWindow( NULL );*/
}
if( tempWin )
{
//
// Someone cares, if this is a left button down event
// it should get "grabbed"
/// @todo should allow for left handed mouse configs here?
//
if( msg == GWM_LEFT_DOWN )
{
// if( tempWin != windowList )
// WinActivate( tempWin );
m_grabWindow = tempWin;
} // end if
// event is used
returnCode = WIN_INPUT_USED;
} // end if, tempWin
} // end if
} // end if( window )
if( toolTipWindow == NULL )
{
if( isHidden( window ) == FALSE )
toolTipWindow = window;
} // end if
// if tooltips are on set them into the window
Bool tooltipsOn = TRUE;
if( tooltipsOn )
{
// if( toolTipWindow && toolTipWindow->winGetParent() && BitTest( toolTipWindow->winGetParent()->winGetInstanceData()->getStyle(), GWS_COMBO_BOX ))
// toolTipWindow = toolTipWindow->winGetParent();
if( toolTipWindow )
{
// do we have a callback to call for the tooltip
if( toolTipWindow->m_tooltip )
toolTipWindow->m_tooltip( toolTipWindow,
&toolTipWindow->m_instData,
packedMouseCoords );
// else, do we have a normal tooltip to set
else if( toolTipWindow->m_instData.getTooltipTextLength() )
TheMouse->setCursorTooltip( toolTipWindow->m_instData.getTooltipText(), toolTipWindow->m_instData.m_tooltipDelay );
} // end if
else
{
//
// not pointing at a window... perhaps we are pointing at a valid
// tooltip-able object in the game world ... let's set a flag so
// during the object testing we can set the tooltip, we can do
// whatever we like now that we know no other tooltip was set from
// a window
//
objectTooltip = TRUE;
} // end else
} // end if
} // end if grabWindow not present
} // end else (mouseCaptor)
//
// check if new current window is different from the last
// but only if both windows fall within the mouseCaptor if one exists
//
if( (m_grabWindow == NULL) && (window != m_currMouseRgn) )
{
if( m_mouseCaptor )
{
if( m_mouseCaptor->winIsChild( m_currMouseRgn ) )
winSendInputMsg( m_currMouseRgn, GWM_MOUSE_LEAVING, packedMouseCoords, 0 );
}
else if( m_currMouseRgn )
winSendInputMsg( m_currMouseRgn, GWM_MOUSE_LEAVING, packedMouseCoords, 0 );
if( window )
winSendInputMsg( window, GWM_MOUSE_ENTERING, packedMouseCoords, 0 );
m_currMouseRgn = window;
} // end if
// clear grabWindow if necessary
if( clearGrabWindow == TRUE )
{
m_grabWindow = NULL;
clearGrabWindow = FALSE;
} // end if
return returnCode;
} // end winProcessMouseEvent
//-------------------------------------------------------------------------------------------------
/** Draw a window and its children, in parent-first order.
* Children's coordinates are relative to their parents.
* Note that hidden windows automatically will not draw any
* of their children ... but see-thru windows only will not
* draw themselves, but will give their children an
* opportunity to draw */
//-------------------------------------------------------------------------------------------------
Int GameWindowManager::drawWindow( GameWindow *window )
{
GameWindow *child;
if( window == NULL )
return WIN_ERR_INVALID_WINDOW;
if( BitTest( window->m_status, WIN_STATUS_HIDDEN ) == FALSE )
{
if( !BitTest( window->m_status, WIN_STATUS_SEE_THRU ) && window->m_draw )
window->m_draw( window, &window->m_instData );
/// @todo visit list boxes and borders, this is stupid!
// for list boxes only draw the borders BEFORE the children
if( BitTest( window->winGetStyle(), GWS_SCROLL_LISTBOX ) )
if( BitTest( window->m_status, WIN_STATUS_BORDER ) == TRUE &&
!BitTest( window->m_status, WIN_STATUS_SEE_THRU ) )
window->winDrawBorder();
// draw children in reverse order just like the window list
child = window->m_child;
while( child && child->m_next )
child = child->m_next;
for( ; child; child = child->m_prev )
drawWindow( child );
//
// draw the border for the window AFTER the window contents AND the
// children contents have drawn
//
if( !BitTest( window->winGetStyle(), GWS_SCROLL_LISTBOX ) )
if( BitTest( window->m_status, WIN_STATUS_BORDER ) == TRUE &&
!BitTest( window->m_status, WIN_STATUS_SEE_THRU ) )
window->winDrawBorder();
} // end if
return WIN_ERR_OK;
} // end drawWindow
//-------------------------------------------------------------------------------------------------
/** Draw the GUI in reverse order to correlate with clicking priority */
//-------------------------------------------------------------------------------------------------
void GameWindowManager::winRepaint( void )
{
GameWindow *window, *next;
// draw below windows
for( window = m_windowTail; window; window = next )
{
next = window->m_prev;
if( BitTest( window->m_status, WIN_STATUS_BELOW ) )
drawWindow( window );
}
// draw non-above and non-below windows
for( window = m_windowTail; window; window = next )
{
next = window->m_prev;
if (BitTest( window->m_status, WIN_STATUS_ABOVE |
WIN_STATUS_BELOW ) == FALSE)
drawWindow( window );
}
// draw above windows
for( window = m_windowTail; window; window = next )
{
next = window->m_prev;
if( BitTest( window->m_status, WIN_STATUS_ABOVE ) )
drawWindow( window );
}
if(TheTransitionHandler)
TheTransitionHandler->draw();
} // end WinRepaint
//-------------------------------------------------------------------------------------------------
/** Dump information about all the windows for resource problems */
//-------------------------------------------------------------------------------------------------
void GameWindowManager::dumpWindow( GameWindow *window )
{
#ifndef FINAL
GameWindow *child;
if( window == NULL )
return;
DEBUG_LOG(( "ID: %d\tRedraw: 0x%08X\tUser Data: %d\n",
window->winGetWindowId(), window->m_draw, window->m_userData ));
for( child = window->m_child; child; child = child->m_next )
dumpWindow( child );
return;
#endif
} // end dumpWindow
//-------------------------------------------------------------------------------------------------
/** Create a new window by setting up its parameters and callbacks. */
//-------------------------------------------------------------------------------------------------
GameWindow *GameWindowManager::winCreate( GameWindow *parent,
UnsignedInt status,
Int x, Int y,
Int width, Int height,
GameWinSystemFunc system,
WinInstanceData *instData )
{
GameWindow *window;
// allocate new window
window = allocateNewWindow();
if( window == NULL )
{
DEBUG_LOG(( "WinCreate error: Could not allocate new window\n" ));
#ifndef FINAL
{
GameWindow *win;
for( win = m_windowList; win; win = win->m_next )
dumpWindow( win );
}
#endif
return NULL;
} // endif
// If this is a child window add it to the parent's window list
if( parent )
addWindowToParent( window, parent );
else
linkWindow( window );
window->m_status = status;
window->m_size.x = width;
window->m_size.y = height;
window->m_region.lo.x = x;
window->m_region.lo.y = y;
window->m_region.hi.x = x + width;
window->m_region.hi.y = y + height;
window->normalizeWindowRegion();
// set the system function and send a create message to window
window->winSetSystemFunc( system );
winSendSystemMsg( window, GWM_CREATE, 0, 0 );
// copy over instance data if present
if( instData )
window->winSetInstanceData( instData );
// set default font
if (TheGlobalLanguageData && TheGlobalLanguageData->m_defaultWindowFont.name.isNotEmpty())
{ window->winSetFont( winFindFont(
TheGlobalLanguageData->m_defaultWindowFont.name,
TheGlobalLanguageData->m_defaultWindowFont.size,
TheGlobalLanguageData->m_defaultWindowFont.bold) );
}
else
window->winSetFont( winFindFont( AsciiString("Times New Roman"), 14, FALSE ) );
return window;
} // end WinCreate
//-------------------------------------------------------------------------------------------------
/** Take a window and its children off the top level list and free
* their allocation class data. */
//-------------------------------------------------------------------------------------------------
Int GameWindowManager::winDestroy( GameWindow *window )
{
GameWindow *child, *next;
if( window == NULL )
return WIN_ERR_INVALID_WINDOW;
//
// we should never have edit data allocated in the window code, it's
// completely handled by the editor ONLY
//
DEBUG_ASSERTCRASH( window->winGetEditData() == NULL,
("winDestroy(): edit data should NOT be present!\n") );
if( BitTest( window->m_status, WIN_STATUS_DESTROYED ) )
return WIN_ERR_OK;
BitSet( window->m_status, WIN_STATUS_DESTROYED );
window->freeImages();
if( m_mouseCaptor == window )
winRelease( window );
if( m_keyboardFocus == window )
winSetFocus( NULL );
m_modalHead = ModalStack_removeWindow( m_modalHead, window );
if( m_currMouseRgn == window )
m_currMouseRgn = NULL;
if( m_grabWindow == window )
m_grabWindow = NULL;
// a menu closed mid-transition: the transition must not run on the window once it is freed
if( TheTransitionHandler )
TheTransitionHandler->forgetWindow( window );
for( child = window->m_child; child; child = next )
{
next = child->m_next;
winDestroy( child );
}
// Remove the top level window from list
if( window->m_parent == NULL )
unlinkWindow( window );
else
unlinkChildWindow( window );
// Add to head of the destroy list
window->m_prev = NULL;
window->m_next = m_destroyList;
m_destroyList = window;
//
// if this window is part of a layout screen, notify the screen that
// this window is going away
//
if( window->m_layout )
window->m_layout->removeWindow( window );
return WIN_ERR_OK;
} // winDestroy
//-------------------------------------------------------------------------------------------------
/** Destroy all windows on the window list IMMEDIATELY */
//-------------------------------------------------------------------------------------------------
Int GameWindowManager::winDestroyAll( void )
{
GameWindow *win, *next;
//
// NOTE that it is CRITICAL that the windows be destroyed this way,
// the editor has windows that are not on this main list that must
// exist throughout a reset of the system (copy/paste for instance)
// so DO NOT ever change this to a clever pool of memory for the
// windows and reset the _pool_ ... I will have to kill you! CBD
//
for( next = win = m_windowList; next; win = next)
{
next = win->m_next;
winDestroy( win );
} // end for
// Destroy All Windows just added to destroy list
processDestroyList();
return WIN_ERR_OK;
} // end WinDestroyAll
//-------------------------------------------------------------------------------------------------
/** Sets selected window into a modal state. This window will get
* put at the top of a modal stack */
//-------------------------------------------------------------------------------------------------
/**
* Drop every entry for this window from a modal stack, wherever in it they sit, and return the new
* head. Removed entries are freed.
*
* With no GameWindowManager involved so test_gameengine can link straight to it, and because the
* window pointer is only ever compared here - it belongs to a window that is being destroyed and
* must not be dereferenced.
*
* winUnsetModal only ever pops the top of the stack, so a window destroyed while another modal
* window sat above it left its entry behind pointing at freed memory. Everything that walks the
* stack afterwards - the mouse hit test in winPointInAnyChild, the tab list, the modal check on
* every input message - reads that pointer.
*/
ModalWindow *ModalStack_removeWindow( ModalWindow *head, const GameWindow *window )
{
ModalWindow **link = &head;
while( *link )
{
ModalWindow *entry = *link;
if( entry->window == window )
{
*link = entry->next;
entry->deleteInstance();
}
else
{
link = &entry->next;
}
}
return head;
}
//-------------------------------------------------------------------------------------------------
Int GameWindowManager::winSetModal( GameWindow *window )
{
ModalWindow *modal;
if( window == NULL )
return WIN_ERR_INVALID_WINDOW;
// verify requesting window is a root window
if( window->m_parent != NULL )
{
DEBUG_LOG(( "WinSetModal: Non Root window attempted to go modal." ));
return WIN_ERR_INVALID_PARAMETER; // return error if not
}
// A window already on the stack moves to the top instead of going on twice. winUnsetModal and
// windowHiding pop one entry, so a second one stayed behind and went on swallowing input for a
// window that had closed.
ModalWindow *previous = NULL;
for( ModalWindow *existing = m_modalHead; existing != NULL; previous = existing, existing = existing->next )
{
if( existing->window != window )
continue;
if( previous != NULL )
{
previous->next = existing->next;
existing->next = m_modalHead;
m_modalHead = existing;
}
return WIN_ERR_OK;
}
// Allocate new Modal Window Entry
modal = newInstance(ModalWindow);
if( modal == NULL )
{
DEBUG_LOG(( "WinSetModal: Unable to allocate space for Modal Entry." ));
return WIN_ERR_GENERAL_FAILURE;
}
// Put new entry at top of list
modal->window = window;
modal->next = m_modalHead;
m_modalHead = modal;
return WIN_ERR_OK;
} // end WinSetModal
//-------------------------------------------------------------------------------------------------
/** pops window off of the modal stack. If this window is not the top
* of the modal stack an error will occur. */
//-------------------------------------------------------------------------------------------------
Int GameWindowManager::winUnsetModal( GameWindow *window )
{
ModalWindow *next;
if( window == NULL )
return WIN_ERR_INVALID_WINDOW;
// verify entry is at top of list
if( (m_modalHead == NULL) || (m_modalHead->window != window) )
{
// return error if not
DEBUG_LOG(( "WinUnsetModal: Invalid window attempting to unset modal (%d)\n",
window->winGetWindowId() ));
return WIN_ERR_GENERAL_FAILURE;
} // end if
// remove from top of list
next = m_modalHead->next;
m_modalHead->deleteInstance();
m_modalHead = next;
return WIN_ERR_OK;
} // end WinUnsetModal
//-------------------------------------------------------------------------------------------------
/** Get the grabbed window */
//-------------------------------------------------------------------------------------------------
GameWindow *GameWindowManager::winGetGrabWindow( void )
{
return m_grabWindow;
} // end WinGetGrabWindow
//-------------------------------------------------------------------------------------------------
/** Explicitly set the grab window */
//-------------------------------------------------------------------------------------------------
void GameWindowManager::winSetGrabWindow( GameWindow *window )
{
m_grabWindow = window;
} // end winSetGrabWindow
//-------------------------------------------------------------------------------------------------
/** Explicitly set the grab window */
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
/** Five pointers decide where a click goes before the window list is ever walked, and any one of
* them left holding a window that has been destroyed swallows every click and every key on the
* way to it. processDestroyList clears four of them; the lone window, which a combo box sets
* when its list drops down, is not one of the four. A "DESTROYED" here is the interface gone
* deaf. */
//-------------------------------------------------------------------------------------------------
const char *GameWindowManager::inputOwnerName( GameWindow *window )
{
if( window == NULL )
return "none";
if( BitTest( window->m_status, WIN_STATUS_DESTROYED ) )
return "DESTROYED";
return window->winGetInstanceData()->m_decoratedNameString.str();
}
void GameWindowManager::logInputOwners( const char *tag )
{
DEBUG_LOG(("WINOWNERS: %s, captor %s, grab %s, lone %s, focus %s, modal %s\n",
tag,
inputOwnerName( m_mouseCaptor ),
inputOwnerName( m_grabWindow ),
inputOwnerName( m_loneWindow ),
inputOwnerName( m_keyboardFocus ),
inputOwnerName( m_modalHead ? m_modalHead->window : NULL )));
}
//
// Called every pass. A player who says the game stopped answering him has one of these holding a
// window he cannot see or cannot reach, and the line that says which one has to already be in the
// log by the time he says it - there is no asking him to reproduce it with a switch on. Only a
// change writes a line, so a quiet game writes none.
//
// The grab window is printed but not compared: it is set on every button press and cleared on the
// release, so testing it would put two lines in the log for every click anyone makes. It also
// cannot be what is holding a game deaf, for the same reason - the release clears it.
//
void GameWindowManager::logInputOwnersOnChange( void )
{
GameWindow *modalWindow = m_modalHead ? m_modalHead->window : NULL;
if( m_loggedCaptor == m_mouseCaptor && m_loggedLone == m_loneWindow
&& m_loggedFocus == m_keyboardFocus && m_loggedModal == modalWindow )
return;
m_loggedCaptor = m_mouseCaptor;
m_loggedLone = m_loneWindow;
m_loggedFocus = m_keyboardFocus;
m_loggedModal = modalWindow;
logInputOwners( "changed" );
}
//-------------------------------------------------------------------------------------------------
void GameWindowManager::winSetLoneWindow( GameWindow *window )
{
// ignore if we're trying to set the same window
if( m_loneWindow == window )
return;
if( m_loneWindow )
TheWindowManager->winSendSystemMsg( m_loneWindow, GGM_CLOSE, 0, 0 );
m_loneWindow = window;
} // end winSetGrabWindow
//-------------------------------------------------------------------------------------------------
/** Create a Modal Message Box */
//-------------------------------------------------------------------------------------------------
GameWindow *GameWindowManager::gogoMessageBox(Int x, Int y, Int width, Int height, UnsignedShort buttonFlags,
UnicodeString titleString, UnicodeString bodyString,
GameWinMsgBoxFunc yesCallback,
GameWinMsgBoxFunc noCallback,
GameWinMsgBoxFunc okCallback,
GameWinMsgBoxFunc cancelCallback )
{
return gogoMessageBox(x,y, width,height,buttonFlags,titleString,bodyString,yesCallback,noCallback,okCallback,cancelCallback, FALSE);
}
GameWindow *GameWindowManager::gogoMessageBox(Int x, Int y, Int width, Int height, UnsignedShort buttonFlags,
UnicodeString titleString, UnicodeString bodyString,
GameWinMsgBoxFunc yesCallback,
GameWinMsgBoxFunc noCallback,
GameWinMsgBoxFunc okCallback,
GameWinMsgBoxFunc cancelCallback, Bool useLogo )
{
// first check to make sure we have some buttons to display
if(buttonFlags == 0 )
{
return NULL;
}
GameWindow *trueParent = NULL;
//Changed by Chris
if(useLogo)
trueParent = winCreateFromScript( AsciiString("Menus/QuitMessageBox.wnd") );
else
trueParent = winCreateFromScript( AsciiString("Menus/MessageBox.wnd") );
//Added By Chris
AsciiString menuName;
if(useLogo)
menuName.set("QuitMessageBox.wnd:");
else
menuName.set("MessageBox.wnd:");
AsciiString tempName;
GameWindow *parent = NULL;
tempName = menuName;
tempName.concat("MessageBoxParent");
parent = TheWindowManager->winGetWindowFromId(trueParent, TheNameKeyGenerator->nameToKey( tempName ));
TheWindowManager->winSetModal( trueParent );
TheWindowManager->winSetFocus( NULL ); // make sure we lose focus from other windows even if we refuse focus ourselves
TheWindowManager->winSetFocus( parent );
// If the user wants the size to be different then the default
float ratioX, ratioY = 1;
if( width > 0 && height > 0 )
{
ICoord2D temp;
//First grab the percent increase/decrease compaired to the default size
parent->winGetSize( &temp.x, &temp.y);
ratioX = (float)width / (float)temp.x;
ratioY = (float)height / (float)temp.y;
//Set the window's new size
parent->winSetSize( width, height);
//Resize/reposition all the children windows based off the ratio
GameWindow *child;
for( child = parent->winGetChild(); child; child = child->winGetNext() )
{
child->winGetSize(&temp.x, &temp.y);
temp.x =Int(temp.x * ratioX);
temp.y =Int(temp.y * ratioY);
child->winSetSize(temp.x, temp.y);
child->winGetPosition(&temp.x, &temp.y);
temp.x =Int(temp.x * ratioX);
temp.y =Int(temp.y * ratioY);
child->winSetPosition(temp.x, temp.y);
}
}
// If the user wants to position the message box somewhere other then default
if( x >= 0 && y >= 0)
parent->winSetPosition(x, y);
// Reposition the buttons
Int buttonX[3], buttonY[3];
//In the layout, buttonOk will be in the first button position
NameKeyType buttonOkID = NAMEKEY_INVALID;
tempName = menuName;
tempName.concat("ButtonOk");
buttonOkID = TheNameKeyGenerator->nameToKey( tempName );
GameWindow *buttonOk = TheWindowManager->winGetWindowFromId(parent, buttonOkID);
buttonOk->winGetPosition(&buttonX[0], &buttonY[0]);
tempName = menuName;
tempName.concat("ButtonYes");
NameKeyType buttonYesID = TheNameKeyGenerator->nameToKey( tempName );
GameWindow *buttonYes = TheWindowManager->winGetWindowFromId(parent, buttonYesID);
//buttonNo in the second position
tempName = menuName;
tempName.concat("ButtonNo");
NameKeyType buttonNoID = TheNameKeyGenerator->nameToKey(tempName);
GameWindow *buttonNo = TheWindowManager->winGetWindowFromId(parent, buttonNoID);
buttonNo->winGetPosition(&buttonX[1], &buttonY[1]);
//and buttonCancel in the third
tempName = menuName;
tempName.concat("ButtonCancel");
NameKeyType buttonCancelID = TheNameKeyGenerator->nameToKey( tempName );
GameWindow *buttonCancel = TheWindowManager->winGetWindowFromId(parent, buttonCancelID);
buttonCancel->winGetPosition(&buttonX[2], &buttonY[2]);
//we shouldn't have button OK and Yes on the same dialog
if((buttonFlags & (MSG_BOX_OK | MSG_BOX_YES)) == (MSG_BOX_OK | MSG_BOX_YES) )
{
DEBUG_ASSERTCRASH(false, ("Passed in MSG_BOX_OK and MSG_BOX_YES. Big No No."));
}
//Position the OK button if we have one
if( (buttonFlags & MSG_BOX_OK) == MSG_BOX_OK)
{
buttonOk->winSetPosition(buttonX[0], buttonY[0]);
buttonOk->winHide(FALSE);
}
else if( (buttonFlags & MSG_BOX_YES) == MSG_BOX_YES)
{
//Position the Yes if we have one
buttonYes->winSetPosition(buttonX[0], buttonY[0]);
buttonYes->winHide(FALSE);
}
if((buttonFlags & (MSG_BOX_NO | MSG_BOX_CANCEL)) == (MSG_BOX_NO | MSG_BOX_CANCEL) )
{
//If we have both the No and Cancel button, then the no should go in the middle position
buttonNo->winSetPosition(buttonX[1], buttonY[1]);
buttonCancel->winSetPosition(buttonX[2], buttonY[2]);
buttonNo->winHide(FALSE);
buttonCancel->winHide(FALSE);
}
else if( (buttonFlags & MSG_BOX_NO) == MSG_BOX_NO)
{
//if we just have the no button, then position it in the right most spot
buttonNo->winSetPosition(buttonX[2], buttonY[2]);
buttonNo->winHide(FALSE);
}
else if( (buttonFlags & MSG_BOX_CANCEL) == MSG_BOX_CANCEL)
{
//else if we just have the Cancel button, well, it should always go in the right spot
buttonCancel->winSetPosition(buttonX[2], buttonY[2]);
buttonCancel->winHide(FALSE);
}
// Fill the text into the text boxes
tempName = menuName;
tempName.concat("StaticTextTitle");
NameKeyType staticTextTitleID = TheNameKeyGenerator->nameToKey( tempName );
GameWindow *staticTextTitle = TheWindowManager->winGetWindowFromId(parent, staticTextTitleID);
GadgetStaticTextSetText(staticTextTitle,titleString);
tempName = menuName;
tempName.concat("StaticTextMessage");
NameKeyType staticTextMessageID = TheNameKeyGenerator->nameToKey( tempName );
GameWindow *staticTextMessage = TheWindowManager->winGetWindowFromId(parent, staticTextMessageID);
GadgetStaticTextSetText(staticTextMessage,bodyString);
// create a structure that will pass the functions to
WindowMessageBoxData *MsgBoxCallbacks = NEW WindowMessageBoxData;
MsgBoxCallbacks->cancelCallback = cancelCallback;
MsgBoxCallbacks->noCallback = noCallback;
MsgBoxCallbacks->okCallback = okCallback;
MsgBoxCallbacks->yesCallback = yesCallback;
//pass the structure to the dialog
trueParent->winSetUserData( MsgBoxCallbacks );
//make sure the dialog is showing and bring it to the top
parent->winHide(FALSE);
parent->winBringToTop();
//Changed By Chris
return trueParent;
}// gogoMessageBox
//-------------------------------------------------------------------------------------------------
/** Create a button GUI control */
//-------------------------------------------------------------------------------------------------
GameWindow *GameWindowManager::gogoGadgetPushButton( GameWindow *parent,
UnsignedInt status,
Int x, Int y,
Int width, Int height,
WinInstanceData *instData,
GameFont *defaultFont,
Bool defaultVisual )
{
GameWindow *button;
// we MUST have a push button style window to do this
if( BitTest( instData->getStyle(), GWS_PUSH_BUTTON ) == FALSE )
{
DEBUG_LOG(( "Cann't create button gadget, instance data not button type\n" ));
assert( 0 );
return NULL;
} // end if
// create the button window
button = TheWindowManager->winCreate( parent, status,
x, y, width, height,
GadgetPushButtonSystem,
instData );
if( button == NULL )
{
DEBUG_LOG(( "Unable to create button for push button gadget\n" ));
assert( 0 );
return NULL;
} // end if
// assign input function
button->winSetInputFunc( GadgetPushButtonInput );
//
// assign draw function, the draw functions must actually be implemented
// on the device level of the engine
//
if( BitTest( button->winGetStatus(), WIN_STATUS_IMAGE ) )
button->winSetDrawFunc( getPushButtonImageDrawFunc() );
else
button->winSetDrawFunc( getPushButtonDrawFunc() );
// set the owner to the parent, or if no parent it will be itself
button->winSetOwner( parent );
// Init the userdata to NULL
button->winSetUserData(NULL);
// assign the default images/colors
assignDefaultGadgetLook( button, defaultFont, defaultVisual );
// assign text from label
UnicodeString text = winTextLabelToText( instData->m_textLabelString );
if( text.getLength() )
GadgetButtonSetText( button, text );
return button;
} // end gogoGadgetPushButton
//-------------------------------------------------------------------------------------------------
/** Create a checkbox UI element */
//-------------------------------------------------------------------------------------------------
GameWindow *GameWindowManager::gogoGadgetCheckbox( GameWindow *parent,
UnsignedInt status,
Int x, Int y,
Int width, Int height,
WinInstanceData *instData,
GameFont *defaultFont,
Bool defaultVisual )
{
GameWindow *checkbox;
// we MUST have a push button style window to do this
if( BitTest( instData->getStyle(), GWS_CHECK_BOX ) == FALSE )
{
DEBUG_LOG(( "Cann't create checkbox gadget, instance data not checkbox type\n" ));
assert( 0 );
return NULL;
} // end if
// create the button window
checkbox = TheWindowManager->winCreate( parent, status,
x, y, width, height,
GadgetCheckBoxSystem,
instData );
if( checkbox == NULL )
{
DEBUG_LOG(( "Unable to create checkbox window\n" ));
assert( 0 );
return NULL;
} // end if
// assign input function
checkbox->winSetInputFunc( GadgetCheckBoxInput );
//
// assign draw function, the draw functions must actually be implemented
// on the device level of the engine
//
if( BitTest( checkbox->winGetStatus(), WIN_STATUS_IMAGE ) )
checkbox->winSetDrawFunc( getCheckBoxImageDrawFunc() );
else
checkbox->winSetDrawFunc( getCheckBoxDrawFunc() );
// set the owner to the parent, or if no parent it will be itself
checkbox->winSetOwner( parent );
// assign the default images/colors
assignDefaultGadgetLook( checkbox, defaultFont, defaultVisual );
// assign text from label
UnicodeString text = winTextLabelToText( instData->m_textLabelString );
if( text.getLength() )
GadgetCheckBoxSetText( checkbox, text );
return checkbox;
} // end gogoGadgetCheckbox
//-------------------------------------------------------------------------------------------------
/** Create a radio button GUI element */
//-------------------------------------------------------------------------------------------------
GameWindow *GameWindowManager::gogoGadgetRadioButton( GameWindow *parent,
UnsignedInt status,
Int x, Int y,
Int width, Int height,
WinInstanceData *instData,
RadioButtonData *rData,
GameFont *defaultFont,
Bool defaultVisual )
{
GameWindow *radioButton;
RadioButtonData *radioData;
// we MUST have a push button style window to do this
if( BitTest( instData->getStyle(), GWS_RADIO_BUTTON ) == FALSE )
{
DEBUG_LOG(( "Cann't create radioButton gadget, instance data not radioButton type\n" ));
assert( 0 );
return NULL;
} // end if
// create the button window
radioButton = TheWindowManager->winCreate( parent, status,
x, y, width, height,
GadgetRadioButtonSystem,
instData );
if( radioButton == NULL )
{
DEBUG_LOG(( "Unable to create radio button window\n" ));
assert( 0 );
return NULL;
} // end if
// allocate and store the radio button user data
radioData = NEW RadioButtonData;
memcpy( radioData, rData, sizeof( RadioButtonData ) );
radioButton->winSetUserData( radioData );
// assign input function
radioButton->winSetInputFunc( GadgetRadioButtonInput );
//
// assign draw function, the draw functions must actually be implemented
// on the device level of the engine
//
if( BitTest( radioButton->winGetStatus(), WIN_STATUS_IMAGE ) )
radioButton->winSetDrawFunc( getRadioButtonImageDrawFunc() );
else
radioButton->winSetDrawFunc( getRadioButtonDrawFunc() );
// set the owner to the parent, or if no parent it will be itself
radioButton->winSetOwner( parent );
// assign the default images/colors
assignDefaultGadgetLook( radioButton, defaultFont, defaultVisual );
// assign text from label
UnicodeString text = winTextLabelToText( instData->m_textLabelString );
if( text.getLength() )
GadgetRadioSetText( radioButton, text );
return radioButton;
} // end gogoGadgetRadioButton
//-------------------------------------------------------------------------------------------------
/** Create a tab control GUI element */
//-------------------------------------------------------------------------------------------------
GameWindow *GameWindowManager::gogoGadgetTabControl( GameWindow *parent,
UnsignedInt status,
Int x, Int y,
Int width, Int height,
WinInstanceData *instData,
TabControlData *tData,
GameFont *defaultFont,
Bool defaultVisual )
{
GameWindow *tabControl;
TabControlData *tabData;
// we MUST have a tab control style window to do this
if( BitTest( instData->getStyle(), GWS_TAB_CONTROL ) == FALSE )
{
DEBUG_LOG(( "Cann't create tabControl gadget, instance data not tabControl type\n" ));
assert( 0 );
return NULL;
} // end if
// create the tab control window
tabControl = TheWindowManager->winCreate( parent, status,
x, y, width, height,
GadgetTabControlSystem,
instData );
if( tabControl == NULL )
{
DEBUG_LOG(( "Unable to create tab control window\n" ));
assert( 0 );
return NULL;
} // end if
// allocate and store the tab control user data
tabData = NEW TabControlData;
memcpy( tabData, tData, sizeof( TabControlData ) );
tabControl->winSetUserData( tabData );
GadgetTabControlComputeTabRegion( tabControl );
GadgetTabControlCreateSubPanes( tabControl );
GadgetTabControlShowSubPane( tabControl, 0 );
// assign input function
tabControl->winSetInputFunc( GadgetTabControlInput );
//
// assign draw function, the draw functions must actually be implemented
// on the device level of the engine
//
if( BitTest( tabControl->winGetStatus(), WIN_STATUS_IMAGE ) )
tabControl->winSetDrawFunc( getTabControlImageDrawFunc() );
else
tabControl->winSetDrawFunc( getTabControlDrawFunc() );
// set the owner to the parent, or if no parent it will be itself
tabControl->winSetOwner( parent );
// assign the default images/colors
assignDefaultGadgetLook( tabControl, defaultFont, defaultVisual );
return tabControl;
} // end gogoGadgetTabControl
//-------------------------------------------------------------------------------------------------
/** Create a list box GUI control */
//-------------------------------------------------------------------------------------------------
GameWindow *GameWindowManager::gogoGadgetListBox( GameWindow *parent,
UnsignedInt status,
Int x, Int y,
Int width, Int height,
WinInstanceData *instData,
ListboxData *listboxDataTemplate,
GameFont *defaultFont,
Bool defaultVisual )
{
GameWindow *listbox;
ListboxData *listboxData;
Bool title = FALSE;
// we MUST have a push button style window to do this
if( BitTest( instData->getStyle(), GWS_SCROLL_LISTBOX ) == FALSE )
{
DEBUG_LOG(( "Cann't create listbox gadget, instance data not listbox type\n" ));
assert( 0 );
return NULL;
} // end if
// create the listbox
listbox = winCreate( parent, status, x, y, width, height,
GadgetListBoxSystem, instData );
if( listbox == NULL )
{
DEBUG_LOG(( "Unable to create listbox window\n" ));
assert( 0 );
return NULL;
} // end if
// allocate the listbox data, copy template data over and set it into box
listboxData = NEW ListboxData;
DEBUG_ASSERTCRASH(listboxDataTemplate, ("listboxDataTemplate not initialized"));
memcpy( listboxData, listboxDataTemplate, sizeof( ListboxData ) );
// Add the list box data struct to the window's class data
listbox->winSetUserData( listboxData );
// set the owner to the parent, or if no parent it will be itself
listbox->winSetOwner( parent );
// Adjust for list title if present
if( instData->getTextLength() )
title = TRUE;
// Set up list box redraw callbacks
if( BitTest( listbox->winGetStatus(), WIN_STATUS_IMAGE ))
listbox->winSetDrawFunc( getListBoxImageDrawFunc() );
else
listbox->winSetDrawFunc( getListBoxDrawFunc() );
// Set up list box input callbacks
if( listboxData->multiSelect )
listbox->winSetInputFunc( GadgetListBoxMultiInput );
else
listbox->winSetInputFunc( GadgetListBoxInput );
//
// allocate and set the list length, note that setting the list length will
// automatically allocate the selection entries that are needed for multi
// select list boxes etc.
//
Int length = listboxData->listLength;
listboxData->listLength = 0; // hacky!
GadgetListBoxSetListLength( listbox, length );
// store display height
listboxData->displayHeight = height;
if( title )
listboxData->displayHeight -= winFontHeight( instData->getFont() );
// Set display position to the top of the list
listboxData->displayPos = 0;
listboxData->selectPos = -1;
listboxData->doubleClickTime = 0;
listboxData->insertPos = 0;
listboxData->endPos = 0;
listboxData->totalHeight = 0;
// if this listbox has multiple selections prep it
//if( listboxData->multiSelect )
// GadgetListBoxAddMultiSelect( listbox );
// If ScrollBar was requested ... create it.
if( listboxData->scrollBar )
GadgetListboxCreateScrollbar( listbox );
//
// Setup listbox Columns
//
if( listboxData->columns == 1 )
{
listboxData->columnWidth = NEW Int;
listboxData->columnWidth[0] = width;
if( listboxData->slider )
{
ICoord2D sliderSize;
listboxData->slider->winGetSize( &sliderSize.x, &sliderSize.y );
listboxData->columnWidth[0] -= (sliderSize.x + 2);
} // end if
}// if
else
{
if( !listboxData->columnWidthPercentage )
return NULL;
listboxData->columnWidth = NEW Int[listboxData->columns];
if(!listboxData->columnWidth)
return NULL;
Int totalWidth = width;
if( listboxData->slider )
{
ICoord2D sliderSize;
listboxData->slider->winGetSize( &sliderSize.x, &sliderSize.y );
totalWidth -= (sliderSize.x + 2);
} // end if
for(Int i = 0; i < listboxData->columns; i++ )
{
listboxData->columnWidth[i] = listboxData->columnWidthPercentage[i] * totalWidth / 100;
}// for
}// else
// assign the default images/colors
assignDefaultGadgetLook( listbox, defaultFont, defaultVisual );
return listbox;
} // end gogoGadgetListBox
//-------------------------------------------------------------------------------------------------
/** Does all generic window creation, calls appropriate slider create
* function to set up slider-specific data */
//-------------------------------------------------------------------------------------------------
GameWindow *GameWindowManager::gogoGadgetSlider( GameWindow *parent,
UnsignedInt status,
Int x, Int y,
Int width, Int height,
WinInstanceData *instData,
SliderData *sliderData,
GameFont *defaultFont,
Bool defaultVisual )
{
GameWindow *slider;
GameWindow *button;
SliderData *data;
//
// All sliders need to have the tab stop status in order for
// the focus chain to work correctly.
//
BitSet( status, WIN_STATUS_TAB_STOP );
if( BitTest( instData->getStyle(), GWS_HORZ_SLIDER ) )
{
slider = winCreate( parent, status, x, y, width, height,
GadgetHorizontalSliderSystem, instData );
// Set up horizontal slider callbacks
slider->winSetInputFunc( GadgetHorizontalSliderInput );
if( BitTest( slider->winGetStatus(), WIN_STATUS_IMAGE ) )
slider->winSetDrawFunc( getHorizontalSliderImageDrawFunc() );
else
slider->winSetDrawFunc( getHorizontalSliderDrawFunc() );
} // end if
else if ( BitTest( instData->getStyle(), GWS_VERT_SLIDER ) )
{
slider = winCreate( parent, status, x, y, width, height,
GadgetVerticalSliderSystem, instData );
// Set up vertical slider callbacks
slider->winSetInputFunc( GadgetVerticalSliderInput );
if( BitTest( slider->winGetStatus(), WIN_STATUS_IMAGE ) && !(parent && BitTest(parent->winGetStyle(), GWS_SCROLL_LISTBOX)))
slider->winSetDrawFunc( getVerticalSliderImageDrawFunc() );
else
slider->winSetDrawFunc( getVerticalSliderDrawFunc() );
} // end else if
else
{
DEBUG_LOG(( "gogoGadgetSlider warning: unrecognized slider style.\n" ));
assert( 0 );
return NULL;
} // end else
// sanity
if( slider == NULL )
{
DEBUG_LOG(( "Unable to create slider control window\n" ));
assert( 0 );
return NULL;
} // end if
// set the owner to the parent, or if no parent it will be itself
slider->winSetOwner( parent );
// create the slider thumb button
WinInstanceData buttonInstData;
UnsignedInt statusFlags = status | WIN_STATUS_ENABLED | WIN_STATUS_DRAGABLE;
buttonInstData.init();
// if parent is hidden we don't need to be.
BitClear( statusFlags, WIN_STATUS_HIDDEN );
buttonInstData.m_owner = slider;
buttonInstData.m_style = GWS_PUSH_BUTTON;
// if slider tracks, so will this sub control
if( BitTest( instData->getStyle(), GWS_MOUSE_TRACK ) )
BitSet( buttonInstData.m_style, GWS_MOUSE_TRACK );
if( BitTest( instData->getStyle(), GWS_HORZ_SLIDER ) )
button = gogoGadgetPushButton( slider, statusFlags, 0, HORIZONTAL_SLIDER_THUMB_POSITION,
HORIZONTAL_SLIDER_THUMB_WIDTH, HORIZONTAL_SLIDER_THUMB_HEIGHT, &buttonInstData, NULL, TRUE );
else
button = gogoGadgetPushButton( slider, statusFlags, 0, 0,
width, width+1, &buttonInstData, NULL, TRUE );
// Protect against divide by zero
if( sliderData->maxVal == sliderData->minVal )
sliderData->maxVal = sliderData->minVal + 1;
if( BitTest( instData->getStyle(), GWS_HORZ_SLIDER ) )
{
sliderData->numTicks = (float)(width - HORIZONTAL_SLIDER_THUMB_WIDTH) /
(float)(sliderData->maxVal - sliderData->minVal);
} else
{
sliderData->numTicks = (float)(height - GADGET_SIZE) /
(float)(sliderData->maxVal - sliderData->minVal);
}
data = NEW SliderData;
memcpy( data, sliderData, sizeof(SliderData) );
// Add the slider data struct to the window's class data
slider->winSetUserData( data );
// assign the default images/colors
assignDefaultGadgetLook( slider, defaultFont, defaultVisual );
return slider;
} // end gogoGadgetSlider
//-------------------------------------------------------------------------------------------------
/** Create a Combo Box GUI element */
//-------------------------------------------------------------------------------------------------
GameWindow *GameWindowManager::gogoGadgetComboBox( GameWindow *parent,
UnsignedInt status,
Int x, Int y,
Int width, Int height,
WinInstanceData *instData,
ComboBoxData *comboBoxDataTemplate,
GameFont *defaultFont,
Bool defaultVisual )
{
GameWindow *comboBox;
ComboBoxData *comboBoxData;
Bool title = FALSE;
// we MUST have a push button style window to do this
if( BitTest( instData->getStyle(), GWS_COMBO_BOX) == FALSE )
{
DEBUG_LOG(( "Cann't create ComboBox gadget, instance data not ComboBox type\n" ));
assert( 0 );
return NULL;
} // end if
// create the listbox
comboBox = winCreate( parent, status, x, y, width, height,
GadgetComboBoxSystem, instData );
if( comboBox == NULL )
{
DEBUG_LOG(( "Unable to create ComboBox window\n" ));
assert( 0 );
return NULL;
} // end if
// begin here
// allocate the listbox data, copy template data over and set it into box
comboBoxData = NEW ComboBoxData;
memcpy( comboBoxData, comboBoxDataTemplate, sizeof( ComboBoxData ) );
// Add the list box data struct to the window's class data
comboBox->winSetUserData( comboBoxData );
// set the owner to the parent, or if no parent it will be itself
comboBox->winSetOwner( parent );
// Adjust for list title if present
if( instData->getTextLength() )
title = TRUE;
// Set up list box redraw callbacks
if( BitTest( comboBox->winGetStatus(), WIN_STATUS_IMAGE ))
comboBox->winSetDrawFunc( getComboBoxImageDrawFunc() );
else
comboBox->winSetDrawFunc( getComboBoxDrawFunc() );
// Set up list box input callbacks
comboBox->winSetInputFunc( GadgetComboBoxInput );
//Create the windows that make up
WinInstanceData winInstData;
Int buttonWidth, buttonHeight;
Int fontHeight;
Int top;
Int bottom;
// do we have a title
if( comboBox->winGetTextLength() )
title = TRUE;
// remove unwanted status bits.
status &= ~(WIN_STATUS_BORDER | WIN_STATUS_HIDDEN);
fontHeight = TheWindowManager->winFontHeight( comboBox->winGetFont() );
top = title ? (fontHeight + 1):0;
bottom = title ? (height - (fontHeight + 1)):height;
// intialize instData
winInstData.init();
//
// Size of button. It used to be a flat 21x22 - the pixels the arrow was drawn at on the
// 800x600 the layouts were made for - while the combo box around it is stretched to the running
// resolution. So the taller the screen, the taller and thinner the slot the arrow was squeezed
// into: at 1080 it is nearly twice as tall as it is wide and the arrow comes out stretched.
// The art is square, so take the width from the height the box actually has.
//
buttonHeight = height;
buttonWidth = height;
if( buttonWidth > width / 2 )
buttonWidth = width / 2; // a very narrow box keeps some room for its own text
if( buttonWidth < 8 )
buttonWidth = 8;
// ----------------------------------------------------------------------
// Create Drop Down Button
// ----------------------------------------------------------------------
winInstData.m_owner = comboBox;
winInstData.m_style = GWS_PUSH_BUTTON;
// if listbox tracks, so will this sub control
if( BitTest( comboBox->winGetStyle(), GWS_MOUSE_TRACK ) )
BitSet( winInstData.m_style, GWS_MOUSE_TRACK );
comboBoxData->dropDownButton =
TheWindowManager->gogoGadgetPushButton( comboBox,
status | WIN_STATUS_ACTIVE | WIN_STATUS_ENABLED,
width - buttonWidth, 0,
buttonWidth, height,
&winInstData, NULL, TRUE );
comboBoxData->dropDownButton->winSetTooltipFunc(comboBox->winGetTooltipFunc());
comboBoxData->dropDownButton->winSetTooltip(instData->getTooltipText());
comboBoxData->dropDownButton->setTooltipDelay(comboBox->getTooltipDelay());
// ----------------------------------------------------------------------
// Create text entry
// ----------------------------------------------------------------------
UnsignedInt statusTextEntry;
winInstData.init();
winInstData.m_owner = comboBox;
winInstData.m_style |= GWS_ENTRY_FIELD;
winInstData.m_textLabelString = "Entry";
if( BitTest( comboBox->winGetStyle(), GWS_MOUSE_TRACK ) )
BitSet( winInstData.m_style, GWS_MOUSE_TRACK );
if( comboBoxData->isEditable)
{
statusTextEntry = status;
}
else
{
statusTextEntry = status | WIN_STATUS_NO_INPUT ;//| WIN_STATUS_NO_FOCUS;
comboBoxData->entryData->drawTextFromStart = TRUE;
}
comboBoxData->editBox = TheWindowManager->gogoGadgetTextEntry( comboBox, statusTextEntry ,
0,0 ,
width - buttonWidth , height ,
&winInstData, comboBoxData->entryData,
winInstData.m_font, FALSE );
comboBoxData->editBox->winSetTooltipFunc(comboBox->winGetTooltipFunc());
comboBoxData->editBox->winSetTooltip(instData->getTooltipText());
comboBoxData->editBox->setTooltipDelay(comboBox->getTooltipDelay());
delete (comboBoxData->entryData);
comboBoxData->entryData = (EntryData *)comboBoxData->editBox->winGetUserData();
// ----------------------------------------------------------------------
// Create list box
// ----------------------------------------------------------------------
winInstData.init();
winInstData.m_owner = comboBox;
if( BitTest( comboBox->winGetStyle(), GWS_MOUSE_TRACK ) )
BitSet( winInstData.m_style, GWS_MOUSE_TRACK );
BitSet( winInstData.m_style, WIN_STATUS_HIDDEN );
winInstData.m_style |= GWS_SCROLL_LISTBOX;
status &= ~(WIN_STATUS_IMAGE);
comboBoxData->listBox = TheWindowManager->gogoGadgetListBox( comboBox, status | WIN_STATUS_ABOVE | WIN_STATUS_ONE_LINE, 0, height,
width, height,
&winInstData, comboBoxData->listboxData,
winInstData.m_font, FALSE );
comboBoxData->listBox->winHide(TRUE);
delete(comboBoxData->listboxData);
comboBoxData->listboxData = (ListboxData *)comboBoxData->listBox->winGetUserData();
comboBoxData->listBox->winSetTooltipFunc(comboBox->winGetTooltipFunc());
comboBoxData->listBox->winSetTooltip(instData->getTooltipText());
comboBoxData->listBox->setTooltipDelay(comboBox->getTooltipDelay());
GadgetListBoxSetAudioFeedback(comboBoxData->listBox, TRUE);
// Initialize the ComboBox's variables and the controls with them
GadgetComboBoxSetIsEditable(comboBox, comboBoxData->isEditable);
GadgetComboBoxSetMaxChars( comboBox, comboBoxData->maxChars );
GadgetComboBoxSetMaxDisplay( comboBox, comboBoxData->maxDisplay );
//Initialize the control's text colors
Color color, border;
color = comboBox->winGetEnabledTextColor();
border = comboBox->winGetEnabledTextBorderColor();
if(comboBoxData->listBox)
comboBoxData->listBox->winSetEnabledTextColors( color,border);
if(comboBoxData->editBox)
comboBoxData->editBox->winSetEnabledTextColors(color,border);
color = comboBox->winGetDisabledTextColor();
border = comboBox->winGetDisabledTextBorderColor();
if(comboBoxData->listBox)
comboBoxData->listBox->winSetDisabledTextColors( color,border);
if(comboBoxData->editBox)
comboBoxData->editBox->winSetDisabledTextColors(color,border);
color = comboBox->winGetHiliteTextColor();
border = comboBox->winGetHiliteTextBorderColor();
if(comboBoxData->listBox)
comboBoxData->listBox->winSetHiliteTextColors( color,border);
if(comboBoxData->editBox)
comboBoxData->editBox->winSetHiliteTextColors(color,border);
comboBoxData->dontHide = FALSE;
// assign the default images/colors
assignDefaultGadgetLook( comboBox, defaultFont, defaultVisual );
return comboBox;
}
//-------------------------------------------------------------------------------------------------
/** Create a progress bar GUI element */
//-------------------------------------------------------------------------------------------------
GameWindow *GameWindowManager::gogoGadgetProgressBar( GameWindow *parent,
UnsignedInt status,
Int x, Int y,
Int width, Int height,
WinInstanceData *instData,
GameFont *defaultFont,
Bool defaultVisual )
{
GameWindow *progressBar;
// we MUST have a push button style window to do this
if( BitTest( instData->getStyle(), GWS_PROGRESS_BAR ) == FALSE )
{
DEBUG_LOG(( "Cann't create progressBar gadget, instance data not progressBar type\n" ));
assert( 0 );
return NULL;
} // end if
// create the button window
progressBar = TheWindowManager->winCreate( parent, status,
x, y, width, height,
GadgetProgressBarSystem,
instData );
if( progressBar == NULL )
{
DEBUG_LOG(( "Unable to create progress bar control\n" ));
assert( 0 );
return NULL;
} // end if
//
// assign draw function, the draw functions must actually be implemented
// on the device level of the engine
//
if( BitTest( progressBar->winGetStatus(), WIN_STATUS_IMAGE ) )
progressBar->winSetDrawFunc( getProgressBarImageDrawFunc() );
else
progressBar->winSetDrawFunc( getProgressBarDrawFunc() );
// set the owner to the parent, or if no parent it will be itself
progressBar->winSetOwner( parent );
// assign the default images/colors
assignDefaultGadgetLook( progressBar, defaultFont, defaultVisual );
return progressBar;
} // end gogoGadgetProgressBar
//-------------------------------------------------------------------------------------------------
/** Does all generic window creation, calls appropriate text field create
* function to set up specific data */
//-------------------------------------------------------------------------------------------------
GameWindow *GameWindowManager::gogoGadgetStaticText( GameWindow *parent,
UnsignedInt status,
Int x, Int y,
Int width, Int height,
WinInstanceData *instData,
TextData *textData,
GameFont *defaultFont,
Bool defaultVisual )
{
GameWindow *textWin;
TextData *data;
// Static Text can not be a Tab Stop
BitClear( instData->m_style, GWS_TAB_STOP );
if( BitTest( instData->getStyle(), GWS_STATIC_TEXT ) )
{
textWin = winCreate( parent, status, x, y, width, height,
GadgetStaticTextSystem, instData );
}
else
{
DEBUG_LOG(( "gogoGadgetText warning: unrecognized text style.\n" ));
return NULL;
}
if( textWin != NULL )
{
// set the owner to the parent, or if no parent it will be itself
textWin->winSetOwner( parent );
// assign callbacks
textWin->winSetInputFunc( GadgetStaticTextInput );
if( BitTest( textWin->winGetStatus(), WIN_STATUS_IMAGE ) )
textWin->winSetDrawFunc( getStaticTextImageDrawFunc() );
else
textWin->winSetDrawFunc( getStaticTextDrawFunc() );
data = NEW TextData;
assert( textData != NULL );
memcpy( data, textData, sizeof(TextData) );
// allocate a display string for the tet
data->text = TheDisplayStringManager->newDisplayString();
// set whether or not we center the wrapped text
data->text->setWordWrapCentered( BitTest( instData->getStatus(), WIN_STATUS_WRAP_CENTERED ));
// Add the entry field data struct to the window's class data
textWin->winSetUserData( data );
// assign the default images/colors
assignDefaultGadgetLook( textWin, defaultFont, defaultVisual );
// assign text from label
UnicodeString text = winTextLabelToText( instData->m_textLabelString );
if( text.getLength() )
GadgetStaticTextSetText( textWin, text );
} // end if
return textWin;
} // end gogoGadetStaticText
//-------------------------------------------------------------------------------------------------
/** Does all generic window creation, calls appropriate entry field create
* function to set up specific data */
//-------------------------------------------------------------------------------------------------
GameWindow *GameWindowManager::gogoGadgetTextEntry( GameWindow *parent,
UnsignedInt status,
Int x, Int y,
Int width, Int height,
WinInstanceData *instData,
EntryData *entryData,
GameFont *defaultFont,
Bool defaultVisual )
{
GameWindow *entry;
EntryData *data;
if( BitTest( instData->getStyle(), GWS_ENTRY_FIELD ) == FALSE )
{
DEBUG_LOG(( "Unable to create text entry, style not entry type\n" ));
assert( 0 );
return NULL;
} // end if
// create the window
entry = winCreate( parent, status, x, y, width, height,
GadgetTextEntrySystem, instData );
if( entry == NULL )
{
DEBUG_LOG(( "Unable to create text entry window\n" ));
assert( 0 );
return NULL;
} // end if
// set owner of this control
entry->winSetOwner( parent );
// assign callbacks
entry->winSetInputFunc( GadgetTextEntryInput );
if( BitTest( entry->winGetStatus(), WIN_STATUS_IMAGE ) )
entry->winSetDrawFunc( getTextEntryImageDrawFunc() );
else
entry->winSetDrawFunc( getTextEntryDrawFunc() );
// zero entry data
// memset( entryData->text, 0, ENTRY_TEXT_LEN );
// memset( entryData->constructText, 0, ENTRY_TEXT_LEN );
// initialize character positions, legths etc
if( entryData->text )
entryData->charPos = entryData->text->getTextLength();
else
entryData->charPos = 0;
entryData->conCharPos = 0;
entryData->receivedUnichar = FALSE;
if( entryData->maxTextLen >= ENTRY_TEXT_LEN )
entryData->maxTextLen = ENTRY_TEXT_LEN;
// allocate entry data
data = NEW EntryData;
// copy over data control
memcpy( data, entryData, sizeof(EntryData) );
// allocate new text display string
data->text = TheDisplayStringManager->newDisplayString();
data->sText = TheDisplayStringManager->newDisplayString();
data->constructText = TheDisplayStringManager->newDisplayString();
// set the max for the text lengths
// data->text->allocateFixed( ENTRY_TEXT_LEN );
// data->sText->allocateFixed( ENTRY_TEXT_LEN );
// do any real display string copies
if( entryData->text )
data->text->setText( entryData->text->getText() );
if( entryData->sText )
data->sText->setText( entryData->sText->getText() );
// set data into window
entry->winSetUserData( data );
// asian languages get to have list box kanji character completion
data->constructList = NULL;
if( OurLanguage == LANGUAGE_ID_KOREAN ||
OurLanguage == LANGUAGE_ID_JAPANESE )
{
// we need to create the construct listbox
WinInstanceData boxInstData;
ListboxData lData;
// intialize instData
boxInstData.init();
// define display region
memset( &lData, 0, sizeof(ListboxData) );
lData.listLength = 128;
lData.autoScroll = FALSE;
lData.scrollIfAtEnd = FALSE;
lData.autoPurge = TRUE;
lData.scrollBar = TRUE;
lData.multiSelect = FALSE;
lData.columns = 1;
lData.columnWidth = NULL;
boxInstData.m_style = GWS_SCROLL_LISTBOX | GWS_MOUSE_TRACK;
data->constructList = gogoGadgetListBox( NULL,
WIN_STATUS_ABOVE |
WIN_STATUS_HIDDEN |
WIN_STATUS_NO_FOCUS |
WIN_STATUS_ONE_LINE,
0, height,
110, 119,
&boxInstData,
&lData,
NULL,
TRUE );
if( data->constructList == NULL )
{
DEBUG_LOG(( "gogoGadgetEntry warning: Failed to create listbox.\n" ));
assert( 0 );
winDestroy( entry );
return NULL;
} // end if
} // end, korean or japanese
// assign the default images/colors
assignDefaultGadgetLook( entry, defaultFont, defaultVisual );
// assign text from label
UnicodeString text = winTextLabelToText( instData->m_textLabelString );
if( text.getLength() )
GadgetTextEntrySetText( entry, text );
return entry;
} // end gogoGadgetTextEntry
//-------------------------------------------------------------------------------------------------
/** Use this method to assign the default images/colors to gadgets as
* they area created */
//-------------------------------------------------------------------------------------------------
void GameWindowManager::assignDefaultGadgetLook( GameWindow *gadget,
GameFont *defaultFont,
Bool assignVisual )
{
UnsignedByte alpha = 255;
static Color red = TheWindowManager->winMakeColor( 255, 0, 0, alpha );
static Color darkRed = TheWindowManager->winMakeColor( 128, 0, 0, alpha );
static Color lightRed = TheWindowManager->winMakeColor( 255, 128, 128, alpha );
static Color green = TheWindowManager->winMakeColor( 0, 255, 0, alpha );
static Color darkGreen = TheWindowManager->winMakeColor( 0, 128, 0, alpha );
static Color lightGreen = TheWindowManager->winMakeColor( 128, 255, 128, alpha );
static Color blue = TheWindowManager->winMakeColor( 0, 0, 255, alpha );
static Color darkBlue = TheWindowManager->winMakeColor( 0, 0, 128, alpha );
static Color lightBlue = TheWindowManager->winMakeColor( 128, 128, 255, alpha );
static Color purple = TheWindowManager->winMakeColor( 255, 0, 255, alpha );
static Color darkPurple = TheWindowManager->winMakeColor( 128, 0, 128, alpha );
static Color lightPurple= TheWindowManager->winMakeColor( 255, 128, 255, alpha );
static Color yellow = TheWindowManager->winMakeColor( 255, 255, 0, alpha );
static Color darkYellow = TheWindowManager->winMakeColor( 128, 128, 0, alpha );
static Color lightYellow= TheWindowManager->winMakeColor( 255, 255, 128, alpha );
static Color cyan = TheWindowManager->winMakeColor( 0, 255, 255, alpha );
static Color darkCyan = TheWindowManager->winMakeColor( 64, 128, 128, alpha );
static Color lightCyan = TheWindowManager->winMakeColor( 128, 255, 255, alpha );
static Color gray = TheWindowManager->winMakeColor( 128, 128, 128, alpha );
static Color darkGray = TheWindowManager->winMakeColor( 64, 64, 64, alpha );
static Color lightGray = TheWindowManager->winMakeColor( 192, 192, 192, alpha );
static Color black = TheWindowManager->winMakeColor( 0, 0, 0, alpha );
static Color white = TheWindowManager->winMakeColor( 254, 254, 254, alpha );
// a cool off-white: a progress bar filled in pure white swallows its own white frame
static Color offWhite = TheWindowManager->winMakeColor( 228, 236, 240, alpha );
static Color enabledText = white;
static Color enabledTextBorder = darkGray;
static Color disabledText = darkGray;
static Color disabledTextBorder = black;
static Color hiliteText = lightBlue;
static Color hiliteTextBorder = blue;
static Color imeCompositeText = green;
static Color imeCompositeTextBorder = blue;
WinInstanceData *instData;
// sanity
if( gadget == NULL )
return;
// get instance data
instData = gadget->winGetInstanceData();
// set default font
if( defaultFont )
gadget->winSetFont( defaultFont );
else
{
if (TheGlobalLanguageData && TheGlobalLanguageData->m_defaultWindowFont.name.isNotEmpty())
{ gadget->winSetFont( TheWindowManager->winFindFont(
TheGlobalLanguageData->m_defaultWindowFont.name,
TheGlobalLanguageData->m_defaultWindowFont.size,
TheGlobalLanguageData->m_defaultWindowFont.bold) );
}
else
gadget->winSetFont( TheWindowManager->winFindFont( AsciiString("Times New Roman"), 14, FALSE ) );
}
// if we don't want to assign default colors/images get out of here
if( assignVisual == FALSE )
return;
// create images for the correct gadget type
if( BitTest( instData->getStyle(), GWS_PUSH_BUTTON ) )
{
// enabled background
GadgetButtonSetEnabledImage( gadget, winFindImage( "PushButtonEnabled" ) );
GadgetButtonSetEnabledColor( gadget, red );
GadgetButtonSetEnabledBorderColor( gadget, lightRed );
// enabled selected button
GadgetButtonSetEnabledSelectedImage( gadget, winFindImage( "PushButtonEnabledSelected" ) );
GadgetButtonSetEnabledSelectedColor( gadget, yellow );
GadgetButtonSetEnabledSelectedBorderColor( gadget, white );
// Disabled background
GadgetButtonSetDisabledImage( gadget, winFindImage( "PushButtonDisabled" ) );
GadgetButtonSetDisabledColor( gadget, gray );
GadgetButtonSetDisabledBorderColor( gadget, lightGray );
// Disabled selected button
GadgetButtonSetDisabledSelectedImage( gadget, winFindImage( "PushButtonDisabledSelected" ) );
GadgetButtonSetDisabledSelectedColor( gadget, lightGray );
GadgetButtonSetDisabledSelectedBorderColor( gadget, gray );
// Hilite background
GadgetButtonSetHiliteImage( gadget, winFindImage( "PushButtonHilite" ) );
GadgetButtonSetHiliteColor( gadget, green );
GadgetButtonSetHiliteBorderColor( gadget, darkGreen );
// Hilite selected button
GadgetButtonSetHiliteSelectedImage( gadget, winFindImage( "PushButtonHiliteSelected" ) );
GadgetButtonSetHiliteSelectedColor( gadget, yellow );
GadgetButtonSetHiliteSelectedBorderColor( gadget, white );
// set default text colors for the gadget
gadget->winSetEnabledTextColors( enabledText, enabledTextBorder );
gadget->winSetDisabledTextColors( disabledText, disabledTextBorder );
gadget->winSetHiliteTextColors( hiliteText, hiliteTextBorder );
gadget->winSetIMECompositeTextColors( imeCompositeText, imeCompositeTextBorder );
} // end if
else if( BitTest( instData->getStyle(), GWS_CHECK_BOX ) )
{
// enabled background
GadgetCheckBoxSetEnabledImage( gadget, winFindImage( "CheckBoxEnabled" ) );
GadgetCheckBoxSetEnabledColor( gadget, red );
GadgetCheckBoxSetEnabledBorderColor( gadget, lightRed );
// enabled CheckBox unselected
GadgetCheckBoxSetEnabledUncheckedBoxImage( gadget, winFindImage( "CheckBoxEnabledBoxUnselected" ) );
GadgetCheckBoxSetEnabledUncheckedBoxColor( gadget, WIN_COLOR_UNDEFINED );
GadgetCheckBoxSetEnabledUncheckedBoxBorderColor( gadget, lightBlue );
// enabled CheckBox selected
GadgetCheckBoxSetEnabledCheckedBoxImage( gadget, winFindImage( "CheckBoxEnabledBoxSelected" ) );
GadgetCheckBoxSetEnabledCheckedBoxColor( gadget, blue );
GadgetCheckBoxSetEnabledCheckedBoxBorderColor( gadget, lightBlue );
// disabled background
GadgetCheckBoxSetDisabledImage( gadget, winFindImage( "CheckBoxDisabled" ) );
GadgetCheckBoxSetDisabledColor( gadget, gray );
GadgetCheckBoxSetDisabledBorderColor( gadget, lightGray );
// Disabled CheckBox unselected
GadgetCheckBoxSetDisabledUncheckedBoxImage( gadget, winFindImage( "CheckBoxDisabledBoxUnselected" ) );
GadgetCheckBoxSetDisabledUncheckedBoxColor( gadget, WIN_COLOR_UNDEFINED );
GadgetCheckBoxSetDisabledUncheckedBoxBorderColor( gadget, lightGray );
// Disabled CheckBox selected
GadgetCheckBoxSetDisabledCheckedBoxImage( gadget, winFindImage( "CheckBoxDisabledBoxSelected" ) );
GadgetCheckBoxSetDisabledCheckedBoxColor( gadget, darkGray );
GadgetCheckBoxSetDisabledCheckedBoxBorderColor( gadget, white );
// Hilite background
GadgetCheckBoxSetHiliteImage( gadget, winFindImage( "CheckBoxHilite" ) );
GadgetCheckBoxSetHiliteColor( gadget, green );
GadgetCheckBoxSetHiliteBorderColor( gadget, lightGreen );
// Hilite CheckBox unselected
GadgetCheckBoxSetHiliteUncheckedBoxImage( gadget, winFindImage( "CheckBoxHiliteBoxUnselected" ) );
GadgetCheckBoxSetHiliteUncheckedBoxColor( gadget, WIN_COLOR_UNDEFINED );
GadgetCheckBoxSetHiliteUncheckedBoxBorderColor( gadget, lightBlue );
// Hilite CheckBox selected
GadgetCheckBoxSetHiliteCheckedBoxImage( gadget, winFindImage( "CheckBoxHiliteBoxSelected" ) );
GadgetCheckBoxSetHiliteCheckedBoxColor( gadget, yellow );
GadgetCheckBoxSetHiliteCheckedBoxBorderColor( gadget, white );
// set default text colors for the gadget
gadget->winSetEnabledTextColors( enabledText, enabledTextBorder );
gadget->winSetDisabledTextColors( disabledText, disabledTextBorder );
gadget->winSetHiliteTextColors( hiliteText, hiliteTextBorder );
gadget->winSetIMECompositeTextColors( imeCompositeText, imeCompositeTextBorder );
} // end else if
else if( BitTest( instData->getStyle(), GWS_RADIO_BUTTON ) )
{
// enabled background
GadgetRadioSetEnabledImage( gadget, winFindImage( "RadioButtonEnabled" ) );
GadgetRadioSetEnabledColor( gadget, red );
GadgetRadioSetEnabledBorderColor( gadget, lightRed );
// enabled radio unselected
GadgetRadioSetEnabledUncheckedBoxImage( gadget, winFindImage( "RadioButtonEnabledBoxUnselected" ) );
GadgetRadioSetEnabledUncheckedBoxColor( gadget, darkRed );
GadgetRadioSetEnabledUncheckedBoxBorderColor( gadget, black );
// enabled radio selected
GadgetRadioSetEnabledCheckedBoxImage( gadget, winFindImage( "RadioButtonEnabledBoxSelected" ) );
GadgetRadioSetEnabledCheckedBoxColor( gadget, blue );
GadgetRadioSetEnabledCheckedBoxBorderColor( gadget, lightBlue );
// disabled background
GadgetRadioSetDisabledImage( gadget, winFindImage( "RadioButtonDisabled" ) );
GadgetRadioSetDisabledColor( gadget, gray );
GadgetRadioSetDisabledBorderColor( gadget, lightGray );
// Disabled radio unselected
GadgetRadioSetDisabledUncheckedBoxImage( gadget, winFindImage( "RadioButtonDisabledBoxUnselected" ) );
GadgetRadioSetDisabledUncheckedBoxColor( gadget, gray );
GadgetRadioSetDisabledUncheckedBoxBorderColor( gadget, lightGray );
// Disabled radio selected
GadgetRadioSetDisabledCheckedBoxImage( gadget, winFindImage( "RadioButtonDisabledBoxSelected" ) );
GadgetRadioSetDisabledCheckedBoxColor( gadget, darkGray );
GadgetRadioSetDisabledCheckedBoxBorderColor( gadget, white );
// Hilite background
GadgetRadioSetHiliteImage( gadget, winFindImage( "RadioButtonHilite" ) );
GadgetRadioSetHiliteColor( gadget, green );
GadgetRadioSetHiliteBorderColor( gadget, lightGreen );
// Hilite radio unselected
GadgetRadioSetHiliteUncheckedBoxImage( gadget, winFindImage( "RadioButtonHiliteBoxUnselected" ) );
GadgetRadioSetHiliteUncheckedBoxColor( gadget, darkGreen );
GadgetRadioSetHiliteUncheckedBoxBorderColor( gadget, lightGreen );
// Hilite radio selected
GadgetRadioSetHiliteCheckedBoxImage( gadget, winFindImage( "RadioButtonHiliteBoxSelected" ) );
GadgetRadioSetHiliteCheckedBoxColor( gadget, yellow );
GadgetRadioSetHiliteCheckedBoxBorderColor( gadget, white );
// set default text colors for the gadget
gadget->winSetEnabledTextColors( enabledText, enabledTextBorder );
gadget->winSetDisabledTextColors( disabledText, disabledTextBorder );
gadget->winSetHiliteTextColors( hiliteText, hiliteTextBorder );
gadget->winSetIMECompositeTextColors( imeCompositeText, imeCompositeTextBorder );
} // end else if
else if( BitTest( instData->getStyle(), GWS_HORZ_SLIDER ) )
{
// enabled
GadgetSliderSetEnabledImageLeft( gadget, winFindImage( "HSliderEnabledLeftEnd" ) );
GadgetSliderSetEnabledImageRight( gadget, winFindImage( "HSliderEnabledRightEnd" ) );
GadgetSliderSetEnabledImageCenter( gadget, winFindImage( "HSliderEnabledRepeatingCenter" ) );
GadgetSliderSetEnabledImageSmallCenter( gadget, winFindImage( "HSliderEnabledSmallRepeatingCenter" ) );
GadgetSliderSetEnabledColor( gadget, red );
GadgetSliderSetEnabledBorderColor( gadget, lightRed );
// disabled
GadgetSliderSetDisabledImageLeft( gadget, winFindImage( "HSliderDisabledLeftEnd" ) );
GadgetSliderSetDisabledImageRight( gadget, winFindImage( "HSliderDisabledRightEnd" ) );
GadgetSliderSetDisabledImageCenter( gadget, winFindImage( "HSliderDisabledRepeatingCenter" ) );
GadgetSliderSetDisabledImageSmallCenter( gadget, winFindImage( "HSliderDisabledSmallRepeatingCenter" ) );
GadgetSliderSetDisabledColor( gadget, red );
GadgetSliderSetDisabledBorderColor( gadget, lightRed );
// hilite
GadgetSliderSetHiliteImageLeft( gadget, winFindImage( "HSliderHiliteLeftEnd" ) );
GadgetSliderSetHiliteImageRight( gadget, winFindImage( "HSliderHiliteRightEnd" ) );
GadgetSliderSetHiliteImageCenter( gadget, winFindImage( "HSliderHiliteRepeatingCenter" ) );
GadgetSliderSetHiliteImageSmallCenter( gadget, winFindImage( "HSliderHiliteSmallRepeatingCenter" ) );
GadgetSliderSetHiliteColor( gadget, red );
GadgetSliderSetHiliteBorderColor( gadget, lightRed );
// set default text colors for the gadget
gadget->winSetEnabledTextColors( enabledText, enabledTextBorder );
gadget->winSetDisabledTextColors( disabledText, disabledTextBorder );
gadget->winSetHiliteTextColors( hiliteText, hiliteTextBorder );
gadget->winSetIMECompositeTextColors( imeCompositeText, imeCompositeTextBorder );
//
// set the default colors and images for the slider thumb
//
// enabled
GadgetSliderSetEnabledThumbImage( gadget, winFindImage( "HSliderThumbEnabled" ) );
GadgetSliderSetEnabledThumbColor( gadget, GadgetSliderGetEnabledColor( gadget ) );
GadgetSliderSetEnabledThumbBorderColor( gadget, GadgetSliderGetEnabledBorderColor( gadget ) );
GadgetSliderSetEnabledSelectedThumbImage( gadget, winFindImage( "HSliderThumbEnabled" ) );
GadgetSliderSetEnabledSelectedThumbColor( gadget, GadgetSliderGetEnabledBorderColor( gadget ) );
GadgetSliderSetEnabledSelectedThumbBorderColor( gadget, GadgetSliderGetEnabledColor( gadget ) );
// disabled
GadgetSliderSetDisabledThumbImage( gadget, winFindImage( "HSliderThumbDisabled" ) );
GadgetSliderSetDisabledThumbColor( gadget, GadgetSliderGetDisabledColor( gadget ) );
GadgetSliderSetDisabledThumbBorderColor( gadget, GadgetSliderGetDisabledBorderColor( gadget ) );
GadgetSliderSetDisabledSelectedThumbImage( gadget, winFindImage( "HSliderThumbDisabled" ) );
GadgetSliderSetDisabledSelectedThumbColor( gadget, GadgetSliderGetDisabledBorderColor( gadget ) );
GadgetSliderSetDisabledSelectedThumbBorderColor( gadget, GadgetSliderGetDisabledColor( gadget ) );
// hilite
GadgetSliderSetHiliteThumbImage( gadget, winFindImage( "HSliderThumbHilite" ) );
GadgetSliderSetHiliteThumbColor( gadget, GadgetSliderGetHiliteColor( gadget ) );
GadgetSliderSetHiliteThumbBorderColor( gadget, GadgetSliderGetHiliteBorderColor( gadget ) );
GadgetSliderSetHiliteSelectedThumbImage( gadget, winFindImage( "HSliderThumbHiliteSelected" ) );
GadgetSliderSetHiliteSelectedThumbColor( gadget, GadgetSliderGetHiliteBorderColor( gadget ) );
GadgetSliderSetHiliteSelectedThumbBorderColor( gadget, GadgetSliderGetHiliteColor( gadget ) );
} // end if
else if( BitTest( instData->getStyle(), GWS_VERT_SLIDER ) )
{
// enabled
GadgetSliderSetEnabledImageTop( gadget, winFindImage( "VSliderEnabledTopEnd" ) );
GadgetSliderSetEnabledImageBottom( gadget, winFindImage( "VSliderEnabledBottomEnd" ) );
GadgetSliderSetEnabledImageCenter( gadget, winFindImage( "VSliderEnabledRepeatingCenter" ) );
GadgetSliderSetEnabledImageSmallCenter( gadget, winFindImage( "VSliderEnabledSmallRepeatingCenter" ) );
GadgetSliderSetEnabledColor( gadget, red );
GadgetSliderSetEnabledBorderColor( gadget, lightRed );
// disabled
GadgetSliderSetDisabledImageTop( gadget, winFindImage( "VSliderDisabledTopEnd" ) );
GadgetSliderSetDisabledImageBottom( gadget, winFindImage( "VSliderDisabledBottomEnd" ) );
GadgetSliderSetDisabledImageCenter( gadget, winFindImage( "VSliderDisabledRepeatingCenter" ) );
GadgetSliderSetDisabledImageSmallCenter( gadget, winFindImage( "VSliderDisabledSmallRepeatingCenter" ) );
GadgetSliderSetDisabledColor( gadget, red );
GadgetSliderSetDisabledBorderColor( gadget, lightRed );
// hilite
GadgetSliderSetHiliteImageTop( gadget, winFindImage( "VSliderHiliteTopEnd" ) );
GadgetSliderSetHiliteImageBottom( gadget, winFindImage( "VSliderHiliteBottomEnd" ) );
GadgetSliderSetHiliteImageCenter( gadget, winFindImage( "VSliderHiliteRepeatingCenter" ) );
GadgetSliderSetHiliteImageSmallCenter( gadget, winFindImage( "VSliderHiliteSmallRepeatingCenter" ) );
GadgetSliderSetHiliteColor( gadget, red );
GadgetSliderSetHiliteBorderColor( gadget, lightRed );
// set default text colors for the gadget
gadget->winSetEnabledTextColors( enabledText, enabledTextBorder );
gadget->winSetDisabledTextColors( disabledText, disabledTextBorder );
gadget->winSetHiliteTextColors( hiliteText, hiliteTextBorder );
gadget->winSetIMECompositeTextColors( imeCompositeText, imeCompositeTextBorder );
//
// set the default colors and images for the slider thumb
//
// enabled
GadgetSliderSetEnabledThumbImage( gadget, winFindImage( "VSliderThumbEnabled" ) );
GadgetSliderSetEnabledThumbColor( gadget, GadgetSliderGetEnabledColor( gadget ) );
GadgetSliderSetEnabledThumbBorderColor( gadget, GadgetSliderGetEnabledBorderColor( gadget ) );
GadgetSliderSetEnabledSelectedThumbImage( gadget, winFindImage( "VSliderThumbEnabled" ) );
GadgetSliderSetEnabledSelectedThumbColor( gadget, GadgetSliderGetEnabledBorderColor( gadget ) );
GadgetSliderSetEnabledSelectedThumbBorderColor( gadget, GadgetSliderGetEnabledColor( gadget ) );
// disabled
GadgetSliderSetDisabledThumbImage( gadget, winFindImage( "VSliderThumbDisabled" ) );
GadgetSliderSetDisabledThumbColor( gadget, GadgetSliderGetDisabledColor( gadget ) );
GadgetSliderSetDisabledThumbBorderColor( gadget, GadgetSliderGetDisabledBorderColor( gadget ) );
GadgetSliderSetDisabledSelectedThumbImage( gadget, winFindImage( "VSliderThumbDisabled" ) );
GadgetSliderSetDisabledSelectedThumbColor( gadget, GadgetSliderGetDisabledBorderColor( gadget ) );
GadgetSliderSetDisabledSelectedThumbBorderColor( gadget, GadgetSliderGetDisabledColor( gadget ) );
// hilite
GadgetSliderSetHiliteThumbImage( gadget, winFindImage( "VSliderThumbHilite" ) );
GadgetSliderSetHiliteThumbColor( gadget, GadgetSliderGetHiliteColor( gadget ) );
GadgetSliderSetHiliteThumbBorderColor( gadget, GadgetSliderGetHiliteBorderColor( gadget ) );
GadgetSliderSetHiliteSelectedThumbImage( gadget, winFindImage( "VSliderThumbHiliteSelected" ) );
GadgetSliderSetHiliteSelectedThumbColor( gadget, GadgetSliderGetHiliteBorderColor( gadget ) );
GadgetSliderSetHiliteSelectedThumbBorderColor( gadget, GadgetSliderGetHiliteColor( gadget ) );
} // end else if
else if( BitTest( instData->getStyle(), GWS_SCROLL_LISTBOX ) )
{
ListboxData *listboxData = (ListboxData *)gadget->winGetUserData();
// set the colors
GadgetListBoxSetColors( gadget,
red, // enabled
lightRed, // enabled border
yellow, // enabled selected item
white, // enabled selected item border
gray, // disabled
lightGray, // disabled border
lightGray, // disabled selected item
white, // disabled selected item border
green, // hilite
darkGreen, // hilite border
white, // hilite selected item
darkGreen ); // hilite selected item border
// now set the images
// enabled
GadgetListBoxSetEnabledImage( gadget, winFindImage( "ListBoxEnabled" ) );
GadgetListBoxSetEnabledSelectedItemImageLeft( gadget, winFindImage( "ListBoxEnabledSelectedItemLeftEnd" ) );
GadgetListBoxSetEnabledSelectedItemImageRight( gadget, winFindImage( "ListBoxEnabledSelectedItemRightEnd" ) );
GadgetListBoxSetEnabledSelectedItemImageCenter( gadget, winFindImage( "ListBoxEnabledSelectedItemRepeatingCenter" ) );
GadgetListBoxSetEnabledSelectedItemImageSmallCenter( gadget, winFindImage( "ListBoxEnabledSelectedItemSmallRepeatingCenter" ) );
// disabled
GadgetListBoxSetDisabledImage( gadget, winFindImage( "ListBoxDisabled" ) );
GadgetListBoxSetDisabledSelectedItemImageLeft( gadget, winFindImage( "ListBoxDisabledSelectedItemLeftEnd" ) );
GadgetListBoxSetDisabledSelectedItemImageRight( gadget, winFindImage( "ListBoxDisabledSelectedItemRightEnd" ) );
GadgetListBoxSetDisabledSelectedItemImageCenter( gadget, winFindImage( "ListBoxDisabledSelectedItemRepeatingCenter" ) );
GadgetListBoxSetDisabledSelectedItemImageSmallCenter( gadget, winFindImage( "ListBoxDisabledSelectedItemSmallRepeatingCenter" ) );
// hilited
GadgetListBoxSetHiliteImage( gadget, winFindImage( "ListBoxHilite" ) );
GadgetListBoxSetHiliteSelectedItemImageLeft( gadget, winFindImage( "ListBoxHiliteSelectedItemLeftEnd" ) );
GadgetListBoxSetHiliteSelectedItemImageRight( gadget, winFindImage( "ListBoxHiliteSelectedItemRightEnd" ) );
GadgetListBoxSetHiliteSelectedItemImageCenter( gadget, winFindImage( "ListBoxHiliteSelectedItemRepeatingCenter" ) );
GadgetListBoxSetHiliteSelectedItemImageSmallCenter( gadget, winFindImage( "ListBoxHiliteSelectedItemSmallRepeatingCenter" ) );
// assign default slider colors and images as part of the list box
GameWindow *slider = listboxData->slider;
if( slider )
{
GameWindow *upButton = listboxData->upButton;
GameWindow *downButton = listboxData->downButton;
// slider and slider thumb ----------------------------------------------
// enabled
GadgetSliderSetEnabledImageTop( slider, winFindImage( "VSliderLargeEnabledTopEnd" ) );
GadgetSliderSetEnabledImageBottom( slider, winFindImage( "VSliderLargeEnabledBottomEnd" ) );
GadgetSliderSetEnabledImageCenter( slider, winFindImage( "VSliderLargeEnabledRepeatingCenter" ) );
GadgetSliderSetEnabledImageSmallCenter( slider, winFindImage( "VSliderLargeEnabledSmallRepeatingCenter" ) );
GadgetSliderSetEnabledThumbImage( slider, winFindImage( "VSliderLargeThumbEnabled" ) );
GadgetSliderSetEnabledSelectedThumbImage( slider, winFindImage( "VSliderLargeThumbEnabled" ) );
// disabled
GadgetSliderSetDisabledImageTop( slider, winFindImage( "VSliderLargeDisabledTopEnd" ) );
GadgetSliderSetDisabledImageBottom( slider, winFindImage( "VSliderLargeDisabledBottomEnd" ) );
GadgetSliderSetDisabledImageCenter( slider, winFindImage( "VSliderLargeDisabledRepeatingCenter" ) );
GadgetSliderSetDisabledImageSmallCenter( slider, winFindImage( "VSliderLargeDisabledSmallRepeatingCenter" ) );
GadgetSliderSetDisabledThumbImage( slider, winFindImage( "VSliderLargeThumbDisabled" ) );
GadgetSliderSetDisabledSelectedThumbImage( slider, winFindImage( "VSliderLargeThumbDisabled" ) );
// hilite
GadgetSliderSetHiliteImageTop( slider, winFindImage( "VSliderLargeHiliteTopEnd" ) );
GadgetSliderSetHiliteImageBottom( slider, winFindImage( "VSliderLargeHiliteBottomEnd" ) );
GadgetSliderSetHiliteImageCenter( slider, winFindImage( "VSliderLargeHiliteRepeatingCenter" ) );
GadgetSliderSetHiliteImageSmallCenter( slider, winFindImage( "VSliderLargeHiliteSmallRepeatingCenter" ) );
GadgetSliderSetHiliteThumbImage( slider, winFindImage( "VSliderLargeThumbHilite" ) );
GadgetSliderSetHiliteSelectedThumbImage( slider, winFindImage( "VSliderLargeThumbHilite" ) );
// up button ------------------------------------------------------------
// enabled
GadgetButtonSetEnabledImage( upButton, winFindImage( "VSliderLargeUpButtonEnabled" ) );
GadgetButtonSetEnabledSelectedImage( upButton, winFindImage( "VSliderLargeUpButtonEnabled" ) );
// disabled
GadgetButtonSetDisabledImage( upButton, winFindImage( "VSliderLargeUpButtonDisabled" ) );
GadgetButtonSetDisabledSelectedImage( upButton, winFindImage( "VSliderLargeUpButtonDisabled" ) );
// hilite
GadgetButtonSetHiliteImage( upButton, winFindImage( "VSliderLargeUpButtonHilite" ) );
GadgetButtonSetHiliteSelectedImage( upButton, winFindImage( "VSliderLargeUpButtonHiliteSelected" ) );
// down button ----------------------------------------------------------
// enabled
GadgetButtonSetEnabledImage( downButton, winFindImage( "VSliderLargeDownButtonEnabled" ) );
GadgetButtonSetEnabledSelectedImage( downButton, winFindImage( "VSliderLargeDownButtonEnabled" ) );
// disabled
GadgetButtonSetDisabledImage( downButton, winFindImage( "VSliderLargeDownButtonDisabled" ) );
GadgetButtonSetDisabledSelectedImage( downButton, winFindImage( "VSliderLargeDownButtonDisabled" ) );
// hilite
GadgetButtonSetHiliteImage( downButton, winFindImage( "VSliderLargeDownButtonHilite" ) );
GadgetButtonSetHiliteSelectedImage( downButton, winFindImage( "VSliderLargeDownButtonHiliteSelected" ) );
} // end if
} // end else if
else if( BitTest( instData->getStyle(), GWS_COMBO_BOX ) )
{
// ComboBoxData *comboBoxData = (ComboBoxData *)gadget->winGetUserData();
GadgetComboBoxSetColors( gadget,
red, // enabled
lightRed, // enabled border
yellow, // enabled selected item
white, // enabled selected item border
gray, // disabled
lightGray, // disabled border
lightGray, // disabled selected item
white, // disabled selected item border
green, // hilite
darkGreen, // hilite border
white, // hilite selected item
darkGreen ); // hilite selected item border
// enabled
GadgetComboBoxSetEnabledImage( gadget, winFindImage( "ListBoxEnabled" ) );
GadgetComboBoxSetEnabledSelectedItemImageLeft( gadget, winFindImage( "ListBoxEnabledSelectedItemLeftEnd" ) );
GadgetComboBoxSetEnabledSelectedItemImageRight( gadget, winFindImage( "ListBoxEnabledSelectedItemRightEnd" ) );
GadgetComboBoxSetEnabledSelectedItemImageCenter( gadget, winFindImage( "ListBoxEnabledSelectedItemRepeatingCenter" ) );
GadgetComboBoxSetEnabledSelectedItemImageSmallCenter( gadget, winFindImage( "ListBoxEnabledSelectedItemSmallRepeatingCenter" ) );
// disabled
GadgetComboBoxSetDisabledImage( gadget, winFindImage( "ListBoxDisabled" ) );
GadgetComboBoxSetDisabledSelectedItemImageLeft( gadget, winFindImage( "ListBoxDisabledSelectedItemLeftEnd" ) );
GadgetComboBoxSetDisabledSelectedItemImageRight( gadget, winFindImage( "ListBoxDisabledSelectedItemRightEnd" ) );
GadgetComboBoxSetDisabledSelectedItemImageCenter( gadget, winFindImage( "ListBoxDisabledSelectedItemRepeatingCenter" ) );
GadgetComboBoxSetDisabledSelectedItemImageSmallCenter( gadget, winFindImage( "ListBoxDisabledSelectedItemSmallRepeatingCenter" ) );
// hilited
GadgetComboBoxSetHiliteImage( gadget, winFindImage( "ListBoxHilite" ) );
GadgetComboBoxSetHiliteSelectedItemImageLeft( gadget, winFindImage( "ListBoxHiliteSelectedItemLeftEnd" ) );
GadgetComboBoxSetHiliteSelectedItemImageRight( gadget, winFindImage( "ListBoxHiliteSelectedItemRightEnd" ) );
GadgetComboBoxSetHiliteSelectedItemImageCenter( gadget, winFindImage( "ListBoxHiliteSelectedItemRepeatingCenter" ) );
GadgetComboBoxSetHiliteSelectedItemImageSmallCenter( gadget, winFindImage( "ListBoxHiliteSelectedItemSmallRepeatingCenter" ) );
gadget->winSetEnabledTextColors( enabledText, enabledTextBorder );
gadget->winSetDisabledTextColors( disabledText, disabledTextBorder );
gadget->winSetHiliteTextColors( hiliteText, hiliteTextBorder );
gadget->winSetIMECompositeTextColors( imeCompositeText, imeCompositeTextBorder );
GameWindow *dropDownButton = GadgetComboBoxGetDropDownButton( gadget );
if ( dropDownButton )
{
// enabled background
GadgetButtonSetEnabledImage( dropDownButton, winFindImage( "PushButtonEnabled" ) );
// enabled selected button
GadgetButtonSetEnabledSelectedImage( dropDownButton, winFindImage( "PushButtonEnabledSelected" ) );
// Disabled background
GadgetButtonSetDisabledImage( dropDownButton, winFindImage( "PushButtonDisabled" ) );
// Disabled selected button
GadgetButtonSetDisabledSelectedImage( dropDownButton, winFindImage( "PushButtonDisabledSelected" ) );
// Hilite background
GadgetButtonSetHiliteImage( dropDownButton, winFindImage( "PushButtonHilite" ) );
// Hilite selected button
GadgetButtonSetHiliteSelectedImage( dropDownButton, winFindImage( "PushButtonHiliteSelected" ) );
}
GameWindow *editBox = GadgetComboBoxGetEditBox( gadget );
if ( editBox )
{
// enabled
GadgetTextEntrySetEnabledImageLeft( editBox, winFindImage( "TextEntryEnabledLeftEnd" ) );
GadgetTextEntrySetEnabledImageRight( editBox, winFindImage( "TextEntryEnabledRightEnd" ) );
GadgetTextEntrySetEnabledImageCenter( editBox, winFindImage( "TextEntryEnabledRepeatingCenter" ) );
GadgetTextEntrySetEnabledImageSmallCenter( editBox, winFindImage( "TextEntryEnabledSmallRepeatingCenter" ) );
// disabled
GadgetTextEntrySetDisabledImageLeft( editBox, winFindImage( "TextEntryDisabledLeftEnd" ) );
GadgetTextEntrySetDisabledImageRight( editBox, winFindImage( "TextEntryDisabledRightEnd" ) );
GadgetTextEntrySetDisabledImageCenter( editBox, winFindImage( "TextEntryDisabledRepeatingCenter" ) );
GadgetTextEntrySetDisabledImageSmallCenter( editBox, winFindImage( "TextEntryDisabledSmallRepeatingCenter" ) );
// hilited
GadgetTextEntrySetHiliteImageLeft( editBox, winFindImage( "TextEntryHiliteLeftEnd" ) );
GadgetTextEntrySetHiliteImageRight( editBox, winFindImage( "TextEntryHiliteRightEnd" ) );
GadgetTextEntrySetHiliteImageCenter( editBox, winFindImage( "TextEntryHiliteRepeatingCenter" ) );
GadgetTextEntrySetHiliteImageSmallCenter( editBox, winFindImage( "TextEntryHiliteSmallRepeatingCenter" ) );
}
GameWindow * listBox = GadgetComboBoxGetListBox( gadget );
if ( listBox )
{
// now set the images
// enabled
GadgetListBoxSetEnabledImage( listBox, winFindImage( "ListBoxEnabled" ) );
GadgetListBoxSetEnabledSelectedItemImageLeft( listBox, winFindImage( "ListBoxEnabledSelectedItemLeftEnd" ) );
GadgetListBoxSetEnabledSelectedItemImageRight( listBox, winFindImage( "ListBoxEnabledSelectedItemRightEnd" ) );
GadgetListBoxSetEnabledSelectedItemImageCenter( listBox, winFindImage( "ListBoxEnabledSelectedItemRepeatingCenter" ) );
GadgetListBoxSetEnabledSelectedItemImageSmallCenter( listBox, winFindImage( "ListBoxEnabledSelectedItemSmallRepeatingCenter" ) );
// disabled
GadgetListBoxSetDisabledImage( listBox, winFindImage( "ListBoxDisabled" ) );
GadgetListBoxSetDisabledSelectedItemImageLeft( listBox, winFindImage( "ListBoxDisabledSelectedItemLeftEnd" ) );
GadgetListBoxSetDisabledSelectedItemImageRight( listBox, winFindImage( "ListBoxDisabledSelectedItemRightEnd" ) );
GadgetListBoxSetDisabledSelectedItemImageCenter( listBox, winFindImage( "ListBoxDisabledSelectedItemRepeatingCenter" ) );
GadgetListBoxSetDisabledSelectedItemImageSmallCenter( listBox, winFindImage( "ListBoxDisabledSelectedItemSmallRepeatingCenter" ) );
// hilited
GadgetListBoxSetHiliteImage( listBox, winFindImage( "ListBoxHilite" ) );
GadgetListBoxSetHiliteSelectedItemImageLeft( listBox, winFindImage( "ListBoxHiliteSelectedItemLeftEnd" ) );
GadgetListBoxSetHiliteSelectedItemImageRight( listBox, winFindImage( "ListBoxHiliteSelectedItemRightEnd" ) );
GadgetListBoxSetHiliteSelectedItemImageCenter( listBox, winFindImage( "ListBoxHiliteSelectedItemRepeatingCenter" ) );
GadgetListBoxSetHiliteSelectedItemImageSmallCenter( listBox, winFindImage( "ListBoxHiliteSelectedItemSmallRepeatingCenter" ) );
// assign default slider colors and images as part of the list box
GameWindow *slider = GadgetListBoxGetSlider( listBox );
if( slider )
{
GameWindow *upButton = GadgetListBoxGetUpButton( listBox );
GameWindow *downButton = GadgetListBoxGetDownButton( listBox );
// slider and slider thumb ----------------------------------------------
// enabled
GadgetSliderSetEnabledImageTop( slider, winFindImage( "VSliderLargeEnabledTopEnd" ) );
GadgetSliderSetEnabledImageBottom( slider, winFindImage( "VSliderLargeEnabledBottomEnd" ) );
GadgetSliderSetEnabledImageCenter( slider, winFindImage( "VSliderLargeEnabledRepeatingCenter" ) );
GadgetSliderSetEnabledImageSmallCenter( slider, winFindImage( "VSliderLargeEnabledSmallRepeatingCenter" ) );
GadgetSliderSetEnabledThumbImage( slider, winFindImage( "VSliderLargeThumbEnabled" ) );
GadgetSliderSetEnabledSelectedThumbImage( slider, winFindImage( "VSliderLargeThumbEnabled" ) );
// disabled
GadgetSliderSetDisabledImageTop( slider, winFindImage( "VSliderLargeDisabledTopEnd" ) );
GadgetSliderSetDisabledImageBottom( slider, winFindImage( "VSliderLargeDisabledBottomEnd" ) );
GadgetSliderSetDisabledImageCenter( slider, winFindImage( "VSliderLargeDisabledRepeatingCenter" ) );
GadgetSliderSetDisabledImageSmallCenter( slider, winFindImage( "VSliderLargeDisabledSmallRepeatingCenter" ) );
GadgetSliderSetDisabledThumbImage( slider, winFindImage( "VSliderLargeThumbDisabled" ) );
GadgetSliderSetDisabledSelectedThumbImage( slider, winFindImage( "VSliderLargeThumbDisabled" ) );
// hilite
GadgetSliderSetHiliteImageTop( slider, winFindImage( "VSliderLargeHiliteTopEnd" ) );
GadgetSliderSetHiliteImageBottom( slider, winFindImage( "VSliderLargeHiliteBottomEnd" ) );
GadgetSliderSetHiliteImageCenter( slider, winFindImage( "VSliderLargeHiliteRepeatingCenter" ) );
GadgetSliderSetHiliteImageSmallCenter( slider, winFindImage( "VSliderLargeHiliteSmallRepeatingCenter" ) );
GadgetSliderSetHiliteThumbImage( slider, winFindImage( "VSliderLargeThumbHilite" ) );
GadgetSliderSetHiliteSelectedThumbImage( slider, winFindImage( "VSliderLargeThumbHilite" ) );
// up button ------------------------------------------------------------
// enabled
GadgetButtonSetEnabledImage( upButton, winFindImage( "VSliderLargeUpButtonEnabled" ) );
GadgetButtonSetEnabledSelectedImage( upButton, winFindImage( "VSliderLargeUpButtonEnabled" ) );
// disabled
GadgetButtonSetDisabledImage( upButton, winFindImage( "VSliderLargeUpButtonDisabled" ) );
GadgetButtonSetDisabledSelectedImage( upButton, winFindImage( "VSliderLargeUpButtonDisabled" ) );
// hilite
GadgetButtonSetHiliteImage( upButton, winFindImage( "VSliderLargeUpButtonHilite" ) );
GadgetButtonSetHiliteSelectedImage( upButton, winFindImage( "VSliderLargeUpButtonHiliteSelected" ) );
// down button ----------------------------------------------------------
// enabled
GadgetButtonSetEnabledImage( downButton, winFindImage( "VSliderLargeDownButtonEnabled" ) );
GadgetButtonSetEnabledSelectedImage( downButton, winFindImage( "VSliderLargeDownButtonEnabled" ) );
// disabled
GadgetButtonSetDisabledImage( downButton, winFindImage( "VSliderLargeDownButtonDisabled" ) );
GadgetButtonSetDisabledSelectedImage( downButton, winFindImage( "VSliderLargeDownButtonDisabled" ) );
// hilite
GadgetButtonSetHiliteImage( downButton, winFindImage( "VSliderLargeDownButtonHilite" ) );
GadgetButtonSetHiliteSelectedImage( downButton, winFindImage( "VSliderLargeDownButtonHiliteSelected" ) );
} // end if
}
} // end else if
else if( BitTest( instData->getStyle(), GWS_PROGRESS_BAR ) )
{
// enabled
GadgetProgressBarSetEnabledColor( gadget, red );
GadgetProgressBarSetEnabledBorderColor( gadget, lightRed );
GadgetProgressBarSetEnabledImageLeft( gadget, winFindImage( "ProgressBarEnabledLeftEnd" ) );
GadgetProgressBarSetEnabledImageRight( gadget, winFindImage( "ProgressBarEnabledRightEnd" ) );
GadgetProgressBarSetEnabledImageCenter( gadget, winFindImage( "ProgressBarEnabledRepeatingCenter" ) );
GadgetProgressBarSetEnabledImageSmallCenter( gadget, winFindImage( "ProgressBarEnabledSmallRepeatingCenter" ) );
GadgetProgressBarSetEnabledBarColor( gadget, offWhite );
GadgetProgressBarSetEnabledBarBorderColor( gadget, white );
GadgetProgressBarSetEnabledBarImageLeft( gadget, winFindImage( "ProgressBarEnabledBarLeftEnd" ) );
GadgetProgressBarSetEnabledBarImageRight( gadget, winFindImage( "ProgressBarEnabledBarRightEnd" ) );
GadgetProgressBarSetEnabledBarImageCenter( gadget, winFindImage( "ProgressBarEnabledBarRepeatingCenter" ) );
GadgetProgressBarSetEnabledBarImageSmallCenter( gadget, winFindImage( "ProgressBarEnabledBarSmallRepeatingCenter" ) );
// disabled
GadgetProgressBarSetDisabledColor( gadget, darkGray );
GadgetProgressBarSetDisabledBorderColor( gadget, lightGray );
GadgetProgressBarSetDisabledImageLeft( gadget, winFindImage( "ProgressBarDisabledLeftEnd" ) );
GadgetProgressBarSetDisabledImageRight( gadget, winFindImage( "ProgressBarDisabledRightEnd" ) );
GadgetProgressBarSetDisabledImageCenter( gadget, winFindImage( "ProgressBarDisabledRepeatingCenter" ) );
GadgetProgressBarSetDisabledImageSmallCenter( gadget, winFindImage( "ProgressBarDisabledSmallRepeatingCenter" ) );
GadgetProgressBarSetDisabledBarColor( gadget, lightGray );
GadgetProgressBarSetDisabledBarBorderColor( gadget, white );
GadgetProgressBarSetDisabledBarImageLeft( gadget, winFindImage( "ProgressBarDisabledBarLeftEnd" ) );
GadgetProgressBarSetDisabledBarImageRight( gadget, winFindImage( "ProgressBarDisabledBarRightEnd" ) );
GadgetProgressBarSetDisabledBarImageCenter( gadget, winFindImage( "ProgressBarDisabledBarRepeatingCenter" ) );
GadgetProgressBarSetDisabledBarImageSmallCenter( gadget, winFindImage( "ProgressBarDisabledBarSmallRepeatingCenter" ) );
// Hilite
GadgetProgressBarSetHiliteColor( gadget, green );
GadgetProgressBarSetHiliteBorderColor( gadget, darkGreen );
GadgetProgressBarSetHiliteImageLeft( gadget, winFindImage( "ProgressBarHiliteLeftEnd" ) );
GadgetProgressBarSetHiliteImageRight( gadget, winFindImage( "ProgressBarHiliteRightEnd" ) );
GadgetProgressBarSetHiliteImageCenter( gadget, winFindImage( "ProgressBarHiliteRepeatingCenter" ) );
GadgetProgressBarSetHiliteImageSmallCenter( gadget, winFindImage( "ProgressBarHiliteSmallRepeatingCenter" ) );
GadgetProgressBarSetHiliteBarColor( gadget, yellow );
GadgetProgressBarSetHiliteBarBorderColor( gadget, white );
GadgetProgressBarSetHiliteBarImageLeft( gadget, winFindImage( "ProgressBarHiliteBarLeftEnd" ) );
GadgetProgressBarSetHiliteBarImageRight( gadget, winFindImage( "ProgressBarHiliteBarRightEnd" ) );
GadgetProgressBarSetHiliteBarImageCenter( gadget, winFindImage( "ProgressBarHiliteBarRepeatingCenter" ) );
GadgetProgressBarSetHiliteBarImageSmallCenter( gadget, winFindImage( "ProgressBarHiliteBarSmallRepeatingCenter" ) );
} // end else if
else if( BitTest( instData->getStyle(), GWS_STATIC_TEXT ) )
{
// enabled
GadgetStaticTextSetEnabledImage( gadget, winFindImage( "StaticTextEnabled" ) );
GadgetStaticTextSetEnabledColor( gadget, red );
GadgetStaticTextSetEnabledBorderColor( gadget, lightRed );
// disabled
GadgetStaticTextSetDisabledImage( gadget, winFindImage( "StaticTextDisabled" ) );
GadgetStaticTextSetDisabledColor( gadget, darkGray );
GadgetStaticTextSetDisabledBorderColor( gadget, lightGray );
// hilite
GadgetStaticTextSetHiliteImage( gadget, winFindImage( "StaticTextHilite" ) );
GadgetStaticTextSetHiliteColor( gadget, darkGreen );
GadgetStaticTextSetHiliteBorderColor( gadget, lightGreen );
// set default text colors for the gadget
gadget->winSetEnabledTextColors( enabledText, enabledTextBorder );
gadget->winSetDisabledTextColors( disabledText, disabledTextBorder );
gadget->winSetHiliteTextColors( hiliteText, hiliteTextBorder );
gadget->winSetIMECompositeTextColors( imeCompositeText, imeCompositeTextBorder );
} // end else if
else if( BitTest( instData->getStyle(), GWS_ENTRY_FIELD ) )
{
// enabled
GadgetTextEntrySetEnabledImageLeft( gadget, winFindImage( "TextEntryEnabledLeftEnd" ) );
GadgetTextEntrySetEnabledImageRight( gadget, winFindImage( "TextEntryEnabledRightEnd" ) );
GadgetTextEntrySetEnabledImageCenter( gadget, winFindImage( "TextEntryEnabledRepeatingCenter" ) );
GadgetTextEntrySetEnabledImageSmallCenter( gadget, winFindImage( "TextEntryEnabledSmallRepeatingCenter" ) );
GadgetTextEntrySetEnabledColor( gadget, red );
GadgetTextEntrySetEnabledBorderColor( gadget, lightRed );
// disabled
GadgetTextEntrySetDisabledImageLeft( gadget, winFindImage( "TextEntryDisabledLeftEnd" ) );
GadgetTextEntrySetDisabledImageRight( gadget, winFindImage( "TextEntryDisabledRightEnd" ) );
GadgetTextEntrySetDisabledImageCenter( gadget, winFindImage( "TextEntryDisabledRepeatingCenter" ) );
GadgetTextEntrySetDisabledImageSmallCenter( gadget, winFindImage( "TextEntryDisabledSmallRepeatingCenter" ) );
GadgetTextEntrySetDisabledColor( gadget, gray );
GadgetTextEntrySetDisabledBorderColor( gadget, black );
// hilited
GadgetTextEntrySetHiliteImageLeft( gadget, winFindImage( "TextEntryHiliteLeftEnd" ) );
GadgetTextEntrySetHiliteImageRight( gadget, winFindImage( "TextEntryHiliteRightEnd" ) );
GadgetTextEntrySetHiliteImageCenter( gadget, winFindImage( "TextEntryHiliteRepeatingCenter" ) );
GadgetTextEntrySetHiliteImageSmallCenter( gadget, winFindImage( "TextEntryHiliteSmallRepeatingCenter" ) );
GadgetTextEntrySetHiliteColor( gadget, green );
GadgetTextEntrySetHiliteBorderColor( gadget, darkGreen );
// set default text colors for the gadget
gadget->winSetEnabledTextColors( enabledText, enabledTextBorder );
gadget->winSetDisabledTextColors( disabledText, disabledTextBorder );
gadget->winSetHiliteTextColors( hiliteText, hiliteTextBorder );
gadget->winSetIMECompositeTextColors( imeCompositeText, imeCompositeTextBorder );
} // end else if
} // end assignDefaultGadgetLook
//-------------------------------------------------------------------------------------------------
/** Given a text label, retreive the real localized text associated
* with that label */
//-------------------------------------------------------------------------------------------------
UnicodeString GameWindowManager::winTextLabelToText( AsciiString label )
{
// sanity
if( label.isEmpty() )
return UnicodeString::TheEmptyString;
/// @todo we need to write the string manager here, this is TEMPORARY!!!
UnicodeString tmp;
tmp.translate(label);
return tmp;
} // end winTextLabelToText
/* An open combo box grows to cover the list it dropped, and that list is drawn over whatever is
under it - including out past the edge of the panel the box sits on. Hit testing walks the
parents first, so a row hanging past that edge belongs to nobody: it draws, it highlights
nothing, and the pick never happens. The open box is the one window allowed to be bigger than
its parent, so it is asked before the panel is. Extracted from getWindowUnderCursor so the
rule can be checked without standing a window manager up. */
Bool OpenWindowOwnsPoint( Bool isOpen, Int originX, Int originY, Int width, Int height, Int x, Int y )
{
if( !isOpen )
return FALSE;
return x >= originX && x <= originX + width &&
y >= originY && y <= originY + height;
}
//-------------------------------------------------------------------------------------------------
/** find the top window at the given coordinates */
//-------------------------------------------------------------------------------------------------
GameWindow *GameWindowManager::getWindowUnderCursor( Int x, Int y, Bool ignoreEnabled )
{
if( m_mouseCaptor )
{
// in what what window within the captured window are we?
return m_mouseCaptor->winPointInChild( x, y, ignoreEnabled );
}
if( m_grabWindow )
{
// in what what window within the grabbed window are we?
return m_grabWindow->winPointInChild( x, y, ignoreEnabled );
}
if( m_loneWindow )
{
ICoord2D origin, size;
m_loneWindow->winGetScreenPosition( &origin.x, &origin.y );
m_loneWindow->winGetSize( &size.x, &size.y );
if( OpenWindowOwnsPoint( !m_loneWindow->winIsHidden(), origin.x, origin.y,
size.x, size.y, x, y ) )
return m_loneWindow->winPointInChild( x, y, ignoreEnabled );
}
GameWindow *window = NULL;
if( m_modalHead && m_modalHead->window )
{
return m_modalHead->window->winPointInChild( x, y, ignoreEnabled );
}
else
{
// search for top-level window which contains pointer
for( window = m_windowList; window; window = window->m_next )
{
if( BitTest( window->m_status, WIN_STATUS_ABOVE ) &&
!BitTest( window->m_status, WIN_STATUS_HIDDEN ) &&
x >= window->m_region.lo.x &&
x <= window->m_region.hi.x &&
y >= window->m_region.lo.y &&
y <= window->m_region.hi.y)
{
if( BitTest( window->m_status, WIN_STATUS_ENABLED ) || ignoreEnabled )
{
// determine which child window the mouse is in
window = window->winPointInChild( x, y, ignoreEnabled );
break; // exit for
}
} // end if
} // end for window
// check !above, below and hidden
if( window == NULL )
{
for( window = m_windowList; window; window = window->m_next )
{
if( !BitTest( window->m_status, WIN_STATUS_ABOVE |
WIN_STATUS_BELOW |
WIN_STATUS_HIDDEN ) &&
x >= window->m_region.lo.x &&
x <= window->m_region.hi.x &&
y >= window->m_region.lo.y &&
y <= window->m_region.hi.y)
{
if( BitTest( window->m_status, WIN_STATUS_ENABLED )|| ignoreEnabled)
{
// determine which child window the mouse is in
window = window->winPointInChild( x, y, ignoreEnabled );
break; // exit for
}
}
}
} // end if, window == NULL
// check below and !hidden
if( window == NULL )
{
for( window = m_windowList; window; window = window->m_next )
{
if( BitTest( window->m_status, WIN_STATUS_BELOW ) &&
!BitTest( window->m_status, WIN_STATUS_HIDDEN ) &&
x >= window->m_region.lo.x &&
x <= window->m_region.hi.x &&
y >= window->m_region.lo.y &&
y <= window->m_region.hi.y)
{
if( BitTest( window->m_status, WIN_STATUS_ENABLED )|| ignoreEnabled)
{
// determine which child window the mouse is in
window = window->winPointInChild( x, y, ignoreEnabled );
break; // exit for
}
}
}
} // end if
} // end else, no modal head
if( window )
{
if( BitTest( window->m_status, WIN_STATUS_NO_INPUT ))
{
// this window does not accept input, discard
window = NULL;
}
else if( ignoreEnabled && !( BitTest( window->m_status, WIN_STATUS_ENABLED ) ))
{
window = NULL;
}
}
return window;
}
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
static WindowMsgHandledType testGrab( GameWindow *window, UnsignedInt msg,
WindowMsgData mData1, WindowMsgData mData2 )
{
switch( msg )
{
case GWM_LEFT_DOWN: return MSG_HANDLED; // use it
}
return MSG_IGNORED;
}
//-------------------------------------------------------------------------------------------------
/** Just for testing */
//-------------------------------------------------------------------------------------------------
Bool GameWindowManager::initTestGUI( void )
{
// winCreateFromScript( "_ATest.wnd" );
return TRUE;
// UnsignedByte alpha = 200;
GameWindow *window;
UnsignedInt statusFlags = WIN_STATUS_ENABLED | WIN_STATUS_DRAGABLE | WIN_STATUS_IMAGE;
WinInstanceData instData;
// make some windows inside each other in the upper left
window = TheWindowManager->winCreate( NULL, statusFlags, 0, 0, 100, 100, NULL, NULL );
window->winSetInputFunc( testGrab );
window->winSetEnabledColor( 0, TheWindowManager->winMakeColor( 255, 254, 255, 255 ) );
window->winSetEnabledBorderColor( 0 , TheWindowManager->winMakeColor( 0, 0, 0, 255 ) );
window = TheWindowManager->winCreate( window, statusFlags, 10, 10, 50, 50, NULL, NULL );
window->winSetInputFunc( testGrab );
window->winSetEnabledColor( 0, TheWindowManager->winMakeColor( 128, 128, 128, 255 ) );
window->winSetEnabledBorderColor( 0 , TheWindowManager->winMakeColor( 0, 0, 0, 255 ) );
// make a push button
instData.init();
BitSet( instData.m_style, GWS_PUSH_BUTTON | GWS_MOUSE_TRACK );
instData.m_textLabelString = "What Up?";
window = TheWindowManager->gogoGadgetPushButton( NULL,
WIN_STATUS_ENABLED | WIN_STATUS_IMAGE,
200, 100,
100, 30,
&instData, NULL, TRUE );
// make a push button
instData.init();
BitSet( instData.m_style, GWS_PUSH_BUTTON | GWS_MOUSE_TRACK );
instData.m_textLabelString = "Enabled";
window = TheWindowManager->gogoGadgetPushButton( NULL,
WIN_STATUS_ENABLED,
330, 100,
100, 30,
&instData, NULL, TRUE );
// make a push button
instData.init();
BitSet( instData.m_style, GWS_PUSH_BUTTON | GWS_MOUSE_TRACK );
instData.m_textLabelString = "Disabled";
window = TheWindowManager->gogoGadgetPushButton( NULL,
0,
450, 100,
100, 30,
&instData, NULL, TRUE );
// make a check box
instData.init();
instData.m_style = GWS_CHECK_BOX | GWS_MOUSE_TRACK;
instData.m_textLabelString = "Check";
window = TheWindowManager->gogoGadgetCheckbox( NULL,
WIN_STATUS_ENABLED |
WIN_STATUS_IMAGE,
200, 150,
100, 30,
&instData, NULL, TRUE );
// make a check box
instData.init();
instData.m_style = GWS_CHECK_BOX | GWS_MOUSE_TRACK;
instData.m_textLabelString = "Check";
window = TheWindowManager->gogoGadgetCheckbox( NULL,
WIN_STATUS_ENABLED,
330, 150,
100, 30,
&instData, NULL, TRUE );
// make window to hold radio buttons
window = TheWindowManager->winCreate( NULL, WIN_STATUS_ENABLED | WIN_STATUS_DRAGABLE,
200, 200, 250, 45, NULL );
window->winSetInputFunc( testGrab );
window->winSetEnabledColor( 0, TheWindowManager->winMakeColor( 50, 50, 50, 200 ) );
window->winSetEnabledBorderColor( 0, TheWindowManager->winMakeColor( 254, 254, 254, 255 ) );
// make a radio button
GameWindow *radio;
RadioButtonData rData;
instData.init();
instData.m_style = GWS_RADIO_BUTTON | GWS_MOUSE_TRACK;
instData.m_textLabelString = "Mama Said!";
rData.group = 1;
radio = TheWindowManager->gogoGadgetRadioButton( window,
WIN_STATUS_ENABLED | WIN_STATUS_IMAGE,
10, 10,
100, 30,
&instData,
&rData, NULL, TRUE );
// make a radio button
instData.init();
instData.m_style = GWS_RADIO_BUTTON | GWS_MOUSE_TRACK;
instData.m_textLabelString = "On the Run";
radio = TheWindowManager->gogoGadgetRadioButton( window,
WIN_STATUS_ENABLED,
130, 10,
100, 30,
&instData,
&rData, NULL, TRUE );
GadgetRadioSetEnabledColor( radio, GameMakeColor( 0, 0, 255, 255 ) );
GadgetRadioSetEnabledBorderColor( radio, GameMakeColor( 0, 0, 255, 255 ) );
// make a listbox
ListboxData listData;
memset( &listData, 0, sizeof( ListboxData ) );
listData.listLength = 8;
listData.autoScroll = 1;
listData.scrollIfAtEnd = FALSE;
listData.autoPurge = 1;
listData.scrollBar = 1;
listData.multiSelect = 1;
listData.forceSelect = 0;
listData.columns = 1;
listData.columnWidth = NULL;
instData.init();
instData.m_style = GWS_SCROLL_LISTBOX | GWS_MOUSE_TRACK;
window = TheWindowManager->gogoGadgetListBox( NULL,
WIN_STATUS_ENABLED,
200, 250,
100, 100,
&instData,
&listData, NULL, TRUE );
GadgetListBoxAddEntryText( window, UnicodeString(u"Listbox text"),
TheWindowManager->winMakeColor( 255, 255, 255, 255 ), -1, 0 );
GadgetListBoxAddEntryText( window, UnicodeString(u"More text"),
TheWindowManager->winMakeColor( 105, 105, 255, 255 ), -1, 0 );
GadgetListBoxAddEntryText( window, UnicodeString(u"Nothing"),
TheWindowManager->winMakeColor( 105, 105, 255, 255 ), -1, 0 );
GadgetListBoxAddEntryText( window, UnicodeString(u"Seasons"),
TheWindowManager->winMakeColor( 105, 205, 255, 255 ), -1, 0 );
GadgetListBoxAddEntryText( window, UnicodeString(u"Misery"),
TheWindowManager->winMakeColor( 235, 105, 255, 255 ), -1, 0 );
GadgetListBoxAddEntryText( window, UnicodeString(u"Natural"),
TheWindowManager->winMakeColor( 105, 205, 45, 255 ), -1, 0 );
window->winSetFont( TheFontLibrary->getFont( AsciiString("Times New Roman"), 12, FALSE ) );
// make a listbox
memset( &listData, 0, sizeof( ListboxData ) );
listData.listLength = 8;
listData.autoScroll = 1;
listData.scrollIfAtEnd = FALSE;
listData.autoPurge = 1;
listData.scrollBar = 1;
listData.multiSelect = 0;
listData.forceSelect = 0;
listData.columns = 1;
listData.columnWidth = NULL;
instData.init();
instData.m_style = GWS_SCROLL_LISTBOX | GWS_MOUSE_TRACK;
window = TheWindowManager->gogoGadgetListBox( NULL,
WIN_STATUS_ENABLED | WIN_STATUS_IMAGE,
75, 250,
100, 100,
&instData,
&listData, NULL, TRUE );
GadgetListBoxAddEntryText( window, UnicodeString(u"Listbox text"),
TheWindowManager->winMakeColor( 255, 255, 255, 255 ), -1, -1 );
GadgetListBoxAddEntryText( window, UnicodeString(u"More text"),
TheWindowManager->winMakeColor( 105, 105, 255, 255 ), -1, -1 );
GadgetListBoxAddEntryText( window, UnicodeString(u"Nothing"),
TheWindowManager->winMakeColor( 105, 105, 255, 255 ), -1, -1 );
GadgetListBoxAddEntryText( window, UnicodeString(u"Seasons"),
TheWindowManager->winMakeColor( 105, 205, 255, 255 ), -1, -1 );
GadgetListBoxAddEntryText( window, UnicodeString(u"Misery"),
TheWindowManager->winMakeColor( 235, 105, 255, 255 ), -1, -1 );
GadgetListBoxAddEntryText( window, UnicodeString(u"Natural"),
TheWindowManager->winMakeColor( 105, 205, 45, 255 ), -1, -1 );
// make a vert slider
SliderData sliderData;
memset( &sliderData, 0, sizeof( sliderData ) );
sliderData.maxVal = 100;
sliderData.minVal = 0;
sliderData.numTicks = 100;
sliderData.position = 0;
instData.init();
instData.m_style = GWS_VERT_SLIDER | GWS_MOUSE_TRACK;
window = TheWindowManager->gogoGadgetSlider( NULL,
WIN_STATUS_ENABLED,
360, 250,
11, 100,
&instData,
&sliderData, NULL, TRUE );
// make a vert slider
memset( &sliderData, 0, sizeof( sliderData ) );
sliderData.maxVal = 100;
sliderData.minVal = 0;
sliderData.numTicks = 100;
sliderData.position = 0;
instData.init();
instData.m_style = GWS_VERT_SLIDER | GWS_MOUSE_TRACK;
window = TheWindowManager->gogoGadgetSlider( NULL,
WIN_STATUS_ENABLED | WIN_STATUS_IMAGE,
400, 250,
11, 100,
&instData,
&sliderData, NULL, TRUE );
// make a horizontal slider
memset( &sliderData, 0, sizeof( sliderData ) );
sliderData.maxVal = 100;
sliderData.minVal = 0;
sliderData.numTicks = 100;
sliderData.position = 0;
instData.init();
instData.m_style = GWS_HORZ_SLIDER | GWS_MOUSE_TRACK;
window = TheWindowManager->gogoGadgetSlider( NULL,
WIN_STATUS_ENABLED,
200, 400,
200, 11,
&instData,
&sliderData, NULL, TRUE );
// make a horizontal slider
memset( &sliderData, 0, sizeof( sliderData ) );
sliderData.maxVal = 100;
sliderData.minVal = 0;
sliderData.numTicks = 100;
sliderData.position = 0;
instData.init();
instData.m_style = GWS_HORZ_SLIDER | GWS_MOUSE_TRACK;
window = TheWindowManager->gogoGadgetSlider( NULL,
WIN_STATUS_ENABLED | WIN_STATUS_IMAGE,
200, 420,
200, 11,
&instData,
&sliderData, NULL, TRUE );
// make a progress bar
instData.init();
instData.m_style = GWS_PROGRESS_BAR | GWS_MOUSE_TRACK;
window = TheWindowManager->gogoGadgetProgressBar( NULL,
WIN_STATUS_ENABLED,
200, 450,
250, 15,
&instData, NULL, TRUE );
// make a progress bar
instData.init();
instData.m_style = GWS_PROGRESS_BAR | GWS_MOUSE_TRACK;
window = TheWindowManager->gogoGadgetProgressBar( NULL,
WIN_STATUS_ENABLED | WIN_STATUS_IMAGE,
200, 470,
250, 15,
&instData, NULL, TRUE );
// make some static text
TextData textData;
textData.centered = 1;
instData.init();
instData.m_style = GWS_STATIC_TEXT | GWS_MOUSE_TRACK;
instData.m_textLabelString = "Centered Static Text";
window = TheWindowManager->gogoGadgetStaticText( NULL,
WIN_STATUS_ENABLED,
200, 490,
300, 25,
&instData,
&textData, NULL, TRUE );
// make some static text
textData.centered = 0;
instData.init();
instData.m_style = GWS_STATIC_TEXT | GWS_MOUSE_TRACK;
instData.m_textLabelString = "Not Centered Static Text";
window = TheWindowManager->gogoGadgetStaticText( NULL,
WIN_STATUS_ENABLED | WIN_STATUS_IMAGE,
200, 520,
300, 25,
&instData,
&textData, NULL, TRUE );
window->winSetEnabledTextColors( TheWindowManager->winMakeColor( 128, 128, 255, 255 ),
TheWindowManager->winMakeColor( 255, 255, 255, 255 ) );
// make some entry text
EntryData entryData;
memset( &entryData, 0, sizeof( entryData ) );
entryData.maxTextLen = 30;
instData.init();
instData.m_style = GWS_ENTRY_FIELD | GWS_MOUSE_TRACK;
instData.m_textLabelString = "Entry";
window = TheWindowManager->gogoGadgetTextEntry( NULL,
WIN_STATUS_ENABLED,
450, 270,
400, 30,
&instData,
&entryData, NULL, TRUE );
// make some entry text
memset( &entryData, 0, sizeof( entryData ) );
entryData.maxTextLen = 30;
instData.init();
instData.m_style = GWS_ENTRY_FIELD | GWS_MOUSE_TRACK;
instData.m_textLabelString = "Entry";
window = TheWindowManager->gogoGadgetTextEntry( NULL,
WIN_STATUS_ENABLED | WIN_STATUS_IMAGE,
450, 310,
400, 30,
&instData,
&entryData, NULL, TRUE );
return TRUE;
} // end initTestGUI
void GameWindowManager::winNextTab( GameWindow *window )
{
if(m_tabList.size() == 0|| m_modalHead)
return;
GameWindowList::iterator it = m_tabList.begin();
while( it != m_tabList.end())
{
if(*it == window)
{
it++;
break;
}
it++;
}
if(it != m_tabList.end())
winSetFocus(*it);
else
{
winSetFocus(*m_tabList.begin());
}
winSetLoneWindow(NULL);
}
void GameWindowManager::winPrevTab( GameWindow *window )
{
if(m_tabList.size() == 0 || m_modalHead)
return;
GameWindowList::reverse_iterator it = m_tabList.rbegin();
while( it != m_tabList.rend())
{
if(*it == window)
{
it++;
break;
}
it++;
}
if(it != m_tabList.rend())
winSetFocus(*it);
else
{
winSetFocus(*m_tabList.rbegin());
}
winSetLoneWindow(NULL);
}
void GameWindowManager::registerTabList( GameWindowList tabList )
{
m_tabList.clear();
m_tabList = tabList;
}
void GameWindowManager::clearTabList( void )
{
m_tabList.clear();
}