nigger/CnC_Generals_Zero_Hour
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
CnC_Generals_Zero_Hour/GeneralsMD/Code/Tools/GUIEdit/Source/EditWindow.cpp

1782 lines
50 KiB
C++
Raw Normal View History

Initial commit of Command & Conquer Generals and Command & Conquer Generals Zero Hour source code.
2025-02-27 17:34:39 +00:00
/*
** 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/>.
*/
////////////////////////////////////////////////////////////////////////////////
// //
// (c) 2001-2003 Electronic Arts Inc. //
// //
////////////////////////////////////////////////////////////////////////////////
// FILE: EditWindow.cpp ///////////////////////////////////////////////////////
//-----------------------------------------------------------------------------
//
// Westwood Studios Pacific.
//
// Confidential Information
// Copyright (C) 2001 - All Rights Reserved
//
//-----------------------------------------------------------------------------
//
// Project: RTS3
//
// File name: EditWindow.cpp
//
// Created: Colin Day, July 2001
//
// Desc: Main edit window for the GUI editing tool
//
//-----------------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////////////
// SYSTEM INCLUDES ////////////////////////////////////////////////////////////
#include <stdlib.h>
#include <stdio.h>
// USER INCLUDES //////////////////////////////////////////////////////////////
#include "Common/Debug.h"
#include "GameClient/Display.h"
#include "GameClient/GameWindowManager.h"
#include "W3DDevice/GameClient/W3DFileSystem.h"
#include "Resource.h"
#include "EditWindow.h"
#include "GUIEdit.h"
#include "WinMain.h"
#include "HierarchyView.h"
#include "Properties.h"
#include "WW3D2/WW3D.h"
#include "WW3D2/Render2D.h"
// DEFINES ////////////////////////////////////////////////////////////////////
// PRIVATE TYPES //////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// PRIVATE DATA ///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
Bool EditWindow::m_classRegistered = FALSE; ///< class registered flag
char *EditWindow::m_className = "EditWindowClass"; ///< edit window class name
///////////////////////////////////////////////////////////////////////////////
// PUBLIC DATA ////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
EditWindow *TheEditWindow = NULL; ///< edit window singleton
///////////////////////////////////////////////////////////////////////////////
// PRIVATE PROTOTYPES /////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// PRIVATE FUNCTIONS //////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// editProc ===================================================================
/** Window procedure for the edit window */
//=============================================================================
LRESULT CALLBACK EditWindow::editProc( HWND hWnd, UINT message,
WPARAM wParam, LPARAM lParam )
{
switch( message )
{
// ------------------------------------------------------------------------
case WM_TIMER:
{
Int timerID = wParam;
if( TheEditWindow )
{
if( timerID == TIMER_EDIT_WINDOW_PULSE )
TheEditWindow->updatePulse();
} // end if
return 0;
} // end timer
//-------------------------------------------------------------------------
case WM_MOUSEMOVE:
case WM_LBUTTONDOWN:
case WM_LBUTTONUP:
case WM_MBUTTONDOWN:
case WM_MBUTTONUP:
case WM_RBUTTONDOWN:
case WM_RBUTTONUP:
{
TheEditWindow->mouseEvent( message, wParam, lParam );
return 0;
} // end mouse events
// ------------------------------------------------------------------------
case WM_COMMAND:
{
Int controlID = LOWORD( wParam );
// Int nofifyCode = HIWORD( wParam );
// HWND hWndControl = (HWND)lParam;
switch( controlID )
{
// --------------------------------------------------------------------
case POPUP_MENU_NEW_WINDOW:
case POPUP_MENU_NEW_PUSH_BUTTON:
case POPUP_MENU_NEW_RADIO_BUTTON:
case POPUP_MENU_NEW_TAB_CONTROL:
case POPUP_MENU_NEW_CHECK_BOX:
case POPUP_MENU_NEW_LISTBOX:
case POPUP_MENU_NEW_COMBO_BOX:
case POPUP_MENU_NEW_HORIZONTAL_SLIDER:
case POPUP_MENU_NEW_VERTICAL_SLIDER:
case POPUP_MENU_NEW_PROGRESS_BAR:
case POPUP_MENU_NEW_TEXT_ENTRY:
case POPUP_MENU_NEW_STATIC_TEXT:
case POPUP_MENU_PROPERTIES:
case POPUP_MENU_DELETE:
case POPUP_MENU_BRING_TO_TOP:
{
ICoord2D pos;
GameWindow *window;
// get position the menu was initiated at
TheEditWindow->getPopupMenuClickPos( &pos );
//
// if the position the user clicked at was on another window,
// that window will become the parent of the new one
//
window = TheEditor->getWindowAtPos( pos.x, pos.y );
// create new window at that location
switch( controlID )
{
// ----------------------------------------------------------------
case POPUP_MENU_NEW_WINDOW:
TheEditor->newWindow( GWS_USER_WINDOW,
window, pos.x, pos.y,
15 * TheEditor->getGridResolution(),
15 * TheEditor->getGridResolution() );
break;
// ----------------------------------------------------------------
case POPUP_MENU_NEW_PUSH_BUTTON:
TheEditor->newWindow( GWS_PUSH_BUTTON,
window, pos.x, pos.y,
15 * TheEditor->getGridResolution(),
3 * TheEditor->getGridResolution() );
break;
// ----------------------------------------------------------------
case POPUP_MENU_NEW_CHECK_BOX:
TheEditor->newWindow( GWS_CHECK_BOX,
window, pos.x, pos.y,
15 * TheEditor->getGridResolution(),
3 * TheEditor->getGridResolution() );
break;
// ----------------------------------------------------------------
case POPUP_MENU_NEW_RADIO_BUTTON:
TheEditor->newWindow( GWS_RADIO_BUTTON,
window, pos.x, pos.y,
15 * TheEditor->getGridResolution(),
3 * TheEditor->getGridResolution() );
break;
// ----------------------------------------------------------------
case POPUP_MENU_NEW_TAB_CONTROL:
TheEditor->newWindow( GWS_TAB_CONTROL,
window, pos.x, pos.y,
45 * TheEditor->getGridResolution(),
30 * TheEditor->getGridResolution() );
break;
// ----------------------------------------------------------------
case POPUP_MENU_NEW_LISTBOX:
TheEditor->newWindow( GWS_SCROLL_LISTBOX,
window, pos.x, pos.y,
20 * TheEditor->getGridResolution(),
20 * TheEditor->getGridResolution() );
break;
// ----------------------------------------------------------------
case POPUP_MENU_NEW_COMBO_BOX:
TheEditor->newWindow( GWS_COMBO_BOX,
window, pos.x, pos.y,
15 * TheEditor->getGridResolution(),
3 * TheEditor->getGridResolution() );
break;
// ----------------------------------------------------------------
case POPUP_MENU_NEW_HORIZONTAL_SLIDER:
TheEditor->newWindow( GWS_HORZ_SLIDER,
window, pos.x, pos.y,
20 * TheEditor->getGridResolution(),
GADGET_SIZE );
break;
// ----------------------------------------------------------------
case POPUP_MENU_NEW_VERTICAL_SLIDER:
TheEditor->newWindow( GWS_VERT_SLIDER,
window, pos.x, pos.y,
GADGET_SIZE,
20 * TheEditor->getGridResolution() );
break;
// ----------------------------------------------------------------
case POPUP_MENU_NEW_PROGRESS_BAR:
TheEditor->newWindow( GWS_PROGRESS_BAR,
window, pos.x, pos.y,
40 * TheEditor->getGridResolution(),
GADGET_SIZE );
break;
// ----------------------------------------------------------------
case POPUP_MENU_NEW_TEXT_ENTRY:
TheEditor->newWindow( GWS_ENTRY_FIELD,
window, pos.x, pos.y,
20 * TheEditor->getGridResolution(),
25 );
break;
// ----------------------------------------------------------------
case POPUP_MENU_NEW_STATIC_TEXT:
TheEditor->newWindow( GWS_STATIC_TEXT,
window, pos.x, pos.y,
15 * TheEditor->getGridResolution(),
15 * TheEditor->getGridResolution() );
break;
// ----------------------------------------------------------------
case POPUP_MENU_DELETE:
TheEditor->deleteSelected();
break;
// ----------------------------------------------------------------
case POPUP_MENU_BRING_TO_TOP:
TheEditor->bringSelectedToTop();
break;
// ----------------------------------------------------------------
case POPUP_MENU_PROPERTIES:
if( window )
InitPropertiesDialog( window, pos.x, pos.y );
break;
} // end switch
break;
} // end new window
} // end switch on control id
return 0;
} // end command
// ------------------------------------------------------------------------
default:
{
break;
} // end default
} // end switch( message )
return DefWindowProc( hWnd, message, wParam, lParam );
} // end editProc
// EditWindow::registerEditWindowClass ========================================
/** Register a class with the windows OS for an edit window */
//=============================================================================
void EditWindow::registerEditWindowClass( void )
{
WNDCLASSEX wcex;
ATOM atom;
HINSTANCE hInst = TheEditor->getInstance();
wcex.cbSize = sizeof( WNDCLASSEX );
wcex.style = CS_HREDRAW | CS_VREDRAW;
wcex.lpfnWndProc = (WNDPROC)editProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
wcex.hInstance = hInst;
wcex.hIcon = LoadIcon( hInst, (LPCTSTR)IDI_GUIEDIT );
wcex.hCursor = NULL; //LoadCursor(NULL, IDC_ARROW);
wcex.hbrBackground = (HBRUSH)GetStockObject( BLACK_BRUSH );
wcex.lpszMenuName = NULL;
wcex.lpszClassName = m_className;
wcex.hIconSm = LoadIcon(wcex.hInstance, (LPCTSTR)IDI_SMALL);
atom = RegisterClassEx( &wcex );
// if successfully registered we don't ever need to do this again
if( atom != 0 )
m_classRegistered = TRUE;
} // end registerEditWindowClass
///////////////////////////////////////////////////////////////////////////////
// PUBLIC FUNCTIONS ///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// EditWindow::EditWindow =====================================================
/** */
//=============================================================================
EditWindow::EditWindow( void )
{
m_pulse = 0;
m_size.x = 0;
m_size.y = 0;
m_bitDepth = 32;
m_editWindowHWnd = NULL;
m_assetManager = NULL;
m_2DRender = NULL;
m_w3dInitialized = FALSE;
m_popupMenuClickPos.x = 0;
m_popupMenuClickPos.y = 0;
m_pickedWindow = NULL;
m_dragMoveOrigin.x = 0;
m_dragMoveOrigin.y = 0;
m_dragMoveDest.x = 0;
m_dragMoveDest.y = 0;
m_dragSelecting = FALSE;
m_selectRegion.lo.x = 0;
m_selectRegion.lo.y = 0;
m_selectRegion.hi.x = 0;
m_selectRegion.hi.y = 0;
m_resizingWindow = FALSE;
m_windowToResize = NULL;
m_resizeOrigin.x = 0;
m_resizeOrigin.y = 0;
m_resizeDest.x = 0;
m_resizeDest.y = 0;
m_backgroundColor.red = 0.0f;
m_backgroundColor.green = 0.3f;
m_backgroundColor.blue = 0.3f;
m_backgroundColor.alpha = 1.0f;
m_clipRegion.lo.x = 0;
m_clipRegion.lo.y = 0;
m_clipRegion.hi.x = 0;
m_clipRegion.hi.y = 0;
m_isClippedEnabled = FALSE;
} // end EditWindow
// EditWindow::~EditWindow ====================================================
/** */
//=============================================================================
EditWindow::~EditWindow( void )
{
// call the shutdown
shutdown();
} // end ~EditWindow
// EditWindow::init ===========================================================
/** Initialize the edit window */
//=============================================================================
void EditWindow::init( UnsignedInt clientWidth, UnsignedInt clientHeight )
{
UnsignedInt windowStyle = WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_BORDER | WS_CAPTION;
UnsignedInt extendedWindowStyle = 0;
ICoord2D size;
// register an edit window class with windows if not already done
if( m_classRegistered == FALSE )
registerEditWindowClass();
// create 2D renderer
m_2DRender = new Render2DClass;
// save width and height
size.x = clientWidth;
size.y = clientHeight;
setSize( &size );
//
// we want a client area the specified width and height, figure out how
// big our window rectangle needs to be in order to have a client are
// of that size
//
RECT clientRect;
clientRect.left = 0;
clientRect.top = 0;
clientRect.right = m_size.x;
clientRect.bottom = m_size.y;
AdjustWindowRect( &clientRect, windowStyle, FALSE );
// create the window
m_editWindowHWnd = CreateWindowEx( extendedWindowStyle, // extended window style
m_className, // class name
"Edit Window", // window name
windowStyle, // style bits
0, // x location
0, // y location
clientRect.right - clientRect.left, // width
clientRect.bottom - clientRect.top, // height,
TheEditor->getWindowHandle(), // parent
NULL, // menu
TheEditor->getInstance(), // instance
NULL ); // creation parameters
// display the window
ShowWindow( m_editWindowHWnd, SW_SHOW );
// create the file system for our asset file locations
TheW3DFileSystem = new W3DFileSystem; // our own file system for asset locations
// initialize W3D
WWMath::Init();
WW3D::Init( m_editWindowHWnd );
WW3D::Set_Screen_UV_Bias( TRUE ); ///< this makes text look good :)
if( WW3D::Set_Render_Device( 0,
m_size.x,
m_size.y,
m_bitDepth,
TRUE ) != WW3D_ERROR_OK )
{
assert( 0 );
shutdown();
return;
} // end if
// create asset manager
m_assetManager = new WW3DAssetManager;
assert( m_assetManager );
m_assetManager->Set_WW3D_Load_On_Demand( true );
// W3D is now initialized
m_w3dInitialized = TRUE;
// set a timer for updating visual pulse drawing
SetTimer( m_editWindowHWnd, TIMER_EDIT_WINDOW_PULSE, 5, NULL );
} // end init
// EditWindow::shutdown =======================================================
/** Shutdown edit window */
//=============================================================================
void EditWindow::shutdown( void )
{
// delete 2d renderer
delete m_2DRender;
m_2DRender = NULL;
// delete asset manager
m_assetManager->Free_Assets();
delete m_assetManager;
// shutdown WW3D
WW3D::Shutdown();
WWMath::Shutdown();
// delete the w3d file system
delete TheW3DFileSystem;
TheW3DFileSystem = NULL;
// destroy the edit window
if( m_editWindowHWnd )
DestroyWindow( m_editWindowHWnd );
m_editWindowHWnd = NULL;
// unregister our edit window class
UnregisterClass( m_className, TheEditor->getInstance() );
m_classRegistered = FALSE;
} // EditWindowShutdown
// EditWindow::updatePulse ====================================================
/** Update pulse from timer message */
//=============================================================================
void EditWindow::updatePulse( void )
{
static Bool dir = 1;
static Int stepSize = 4;
static Int pulseMax = 175,
pulseMin = 75;
// this is used for drawing pusling lines for moving stuff
if( dir == 1 )
{
m_pulse += stepSize;
if( m_pulse >= pulseMax )
dir = 0;
} // end if
else
{
m_pulse -= stepSize;
if( m_pulse <= pulseMin )
dir = 1;
} // end else
} // end updatePulse
// EditWindow::mouseEvent =====================================================
/** A mouse event has occurred from our window procedure */
//=============================================================================
void EditWindow::mouseEvent( UnsignedInt windowsMessage,
WPARAM wParam, LPARAM lParam )
{
Int x = LOWORD( lParam );
Int y = HIWORD( lParam );
Bool controlDown = BitTest( GetKeyState( VK_CONTROL ), 0x1000 );
ICoord2D mouse;
// setup mouse in nice struct
mouse.x = x;
mouse.y = y;
// for mouse move messges always update the status bar
if( windowsMessage == WM_MOUSEMOVE )
{
char buffer[ 64 ];
ICoord2D mousePrint;
// only print mouse positions in the edit window
mousePrint.x = x;
mousePrint.y = y;
if( mousePrint.x < 0 )
mousePrint.x = 0;
if( mousePrint.x > m_size.x )
mousePrint.x = m_size.x;
if( mousePrint.y < 0 )
mousePrint.y = 0;
if( mousePrint.y > m_size.y )
mousePrint.y = m_size.y;
sprintf( buffer, "Mouse Location (X = %d, Y = %d)",
mousePrint.x, mousePrint.y );
TheEditor->statusMessage( STATUS_MOUSE_COORDS, buffer );
// keep focus in our app
if( GetFocus() != TheEditor->getWindowHandle() )
SetFocus( TheEditor->getWindowHandle() );
} // end if
//
// if we're in test mode just pump all input through to the
// window system so we can see how everything acts
//
if( TheEditor->getMode() == MODE_TEST_RUN )
{
if( TheWin32Mouse )
TheWin32Mouse->addWin32Event( windowsMessage, wParam, lParam, NO_TIME_FROM_WINDOWS);
return;
} // end if
//
// If we're in the keyboard move, ignore the mouse
//
if (TheEditor->getMode() == MODE_KEYBOARD_MOVE)
return;
// do logic for each of the mouse messages
switch( windowsMessage )
{
// ------------------------------------------------------------------------
case WM_MOUSEMOVE:
{
//
// this is really stupid, but the tree controls just don't
// give enough hooks into all the events we need ... it's possible
// to be in drag and drop mode due to menus opening up and the
// user clicking on blank area etc. So if the mouse is in the
// the edit window just make sure all our drag and drop stuff is
// clear in the hierarchy
//
TheHierarchyView->setDragWindow( NULL );
TheHierarchyView->setDragTarget( NULL );
TheHierarchyView->setPopupTarget( NULL );
if( TheEditor->getMode() == MODE_DRAG_MOVE )
{
// update destination for drag move
m_dragMoveDest = mouse;
} // end if
else if( m_dragSelecting )
{
// update drag selection region
m_selectRegion.hi.x = x;
m_selectRegion.hi.y = y;
} // end else if
else if( m_resizingWindow )
{
// save the position of our mouse for resizing
m_resizeDest = mouse;
} // end else if
else
{
//
// if we have ONE window selected and are close to an anchor corner
// to resize it change the cursor to resize cursor
//
TheEditWindow->handleResizeAvailable( x, y );
} // end else
break;
} // end mouse move
// ------------------------------------------------------------------------
case WM_LBUTTONDOWN:
{
//
// if we're in drag move mode ignore this command ... usually this
// doesn't happen cause you usually get into drag move mode by pressing
// down, holding down, and dragging ... but it's possible to move
// windows via the hierarchy view for those hard to reach windows
//
if( TheEditor->getMode() == MODE_DRAG_MOVE &&
TheEditor->selectionCount() == 1 &&
TheHierarchyView->getPopupTarget() != NULL )
break;
//
// if we are in one of the resize modes then this click will
// resize the window selected
//
if( TheEditor->getMode() == MODE_RESIZE_TOP_LEFT ||
TheEditor->getMode() == MODE_RESIZE_BOTTOM_RIGHT ||
TheEditor->getMode() == MODE_RESIZE_TOP_RIGHT ||
TheEditor->getMode() == MODE_RESIZE_BOTTOM_LEFT ||
TheEditor->getMode() == MODE_RESIZE_TOP ||
TheEditor->getMode() == MODE_RESIZE_BOTTOM ||
TheEditor->getMode() == MODE_RESIZE_RIGHT ||
TheEditor->getMode() == MODE_RESIZE_LEFT )
{
// mouse movements will now resize the window in the selection list
m_windowToResize = TheEditor->getFirstSelected();
if( m_windowToResize )
m_resizingWindow = TRUE;
// save our mouse position for the resizing process
m_resizeOrigin = mouse;
m_resizeDest = mouse;
} // end if
else
{
GameWindow *window = TheEditor->getWindowAtPos( x, y );
if( window )
{
//
// if this window is not selected, then this window will become
// the selected window instead of anything else that is selected.
//
if( TheEditor->isWindowSelected( window ) == FALSE )
{
//
// if control key is not down we clear selections, otherwise
// we will add this one to the select list
//
if( controlDown == FALSE )
TheEditor->clearSelections();
// select this window
TheEditor->selectWindow( window );
} // end if
else
{
//
// this window is selected, if control is down we will
// unselect this window
//
if( controlDown == TRUE )
{
TheEditor->unSelectWindow( window );
}
// only proceed into drag mode if we have something selected
else if( TheEditor->isWindowSelected( window ) )
{
// set move locations
m_dragMoveOrigin = mouse;
m_dragMoveDest = mouse;
// capture the mouse
SetCapture( m_editWindowHWnd );
// change to drag move mode and switch cursor
TheEditor->setMode( MODE_DRAG_MOVE );
} // end if
} // end else
} // end if
else
{
// start a drag selection box
m_dragSelecting = TRUE;
m_selectRegion.lo.x = x;
m_selectRegion.lo.y = y;
m_selectRegion.hi.x = x;
m_selectRegion.hi.y = y;
} // end else
} // end if
break;
} // end left button down
// ------------------------------------------------------------------------
case WM_LBUTTONUP:
{
// exit drag move mode
if( TheEditor->getMode() == MODE_DRAG_MOVE )
{
// move the windows
if ((m_dragMoveOrigin.x != m_dragMoveDest.x) || (m_dragMoveOrigin.y != m_dragMoveDest.y)) {
TheEditor->dragMoveSelectedWindows( &m_dragMoveOrigin, &m_dragMoveDest );
}
// release capture
SetCapture( NULL );
// go back to normal mode
TheEditor->setMode( MODE_EDIT );
} // end if
else if( m_dragSelecting )
{
// select the windows in the region
TheEditor->selectWindowsInRegion( &m_selectRegion );
// stop a drag selection if in progress
m_dragSelecting = FALSE;
} // end else
else if( m_resizingWindow )
{
GameWindow *window = TheEditor->getFirstSelected();
DEBUG_ASSERTCRASH(window, ("No window selected for resize!"));
if (window)
{
ICoord2D resultLoc, resultSize;
ICoord2D dest = m_resizeDest;
// adjust resize dest by the grid if it's on
if( TheEditor->isGridSnapOn() )
TheEditor->gridSnapLocation( &dest, &dest );
// compute the location to resize it at
TheEditor->computeResizeLocation( TheEditor->getMode(),
window,
&m_resizeOrigin, &dest,
&resultLoc, &resultSize );
// move the window
TheEditor->moveWindowTo( window, resultLoc.x, resultLoc.y );
// resize the window
window->winSetSize( resultSize.x, resultSize.y );
}
// go back to normal
m_resizingWindow = FALSE;
TheEditor->setMode( MODE_EDIT );
} // end resizing window
break;
} // end left button up
// ------------------------------------------------------------------------
case WM_MBUTTONDOWN:
{
break;
} // end middle button down
// ------------------------------------------------------------------------
case WM_MBUTTONUP:
{
break;
} // end middle button up
// ------------------------------------------------------------------------
case WM_RBUTTONDOWN:
{
ICoord2D clickPos = mouse;
GameWindow *window;
// adjust the mouse pos if we're on a grid
if( TheEditor->isGridSnapOn() )
TheEditor->gridSnapLocation( &mouse, &clickPos );
// get the window at the click pos
window = TheEditor->getWindowAtPos( clickPos.x, clickPos.y );
//
// if there is a window here and it is not part of the selection
// list, everything else is unselected
//
if( window )
{
if( TheEditor->isWindowSelected( window ) == FALSE )
TheEditor->clearSelections();
// select this window
TheEditor->selectWindow( window );
} // end if
else
{
// no window here, clear selections anyway
TheEditor->clearSelections();
} // end else
// open right click menu
TheEditWindow->openPopupMenu( clickPos.x, clickPos.y );
break;
} // end right button down
// ------------------------------------------------------------------------
case WM_RBUTTONUP:
{
break;
} // end right button up
// ------------------------------------------------------------------------
default:
{
break;
} // end default
} // end switch on widnows message
} // end mouseEvent
// EditWindow::inCornerTolerance ==============================================
/** If the 'dest' point is within 'tolerance' distance to the 'source'
* point this returns TRUE */
//=============================================================================
Bool EditWindow::inCornerTolerance( ICoord2D *dest, ICoord2D *source,
Int tolerance )
{
IRegion2D region;
// sanity
if( dest == NULL || source == NULL )
return FALSE;
/// @todo we should write PointInRegion() stuff again like it was in Nox
// build the region around the source point
region.lo.x = source->x - tolerance;
region.lo.y = source->y - tolerance;
region.hi.x = source->x + tolerance;
region.hi.y = source->y + tolerance;
// check if in region
if( dest->x >= region.lo.x &&
dest->x <= region.hi.x &&
dest->y >= region.lo.y &&
dest->y <= region.hi.y )
return TRUE;
return FALSE;
} // end inCornerTolerance
// EditWindow::inLineTolerance ================================================
/** If the 'dest' point is within the region defined around the
* line with th specified tolerance return TRUE */
//=============================================================================
Bool EditWindow::inLineTolerance( ICoord2D *dest,
ICoord2D *lineStart, ICoord2D *lineEnd,
Int tolerance )
{
IRegion2D region;
// sanity
if( dest == NULL || lineStart == NULL || lineEnd == NULL )
return FALSE;
// setup region
region.lo.x = lineStart->x - tolerance;
region.lo.y = lineStart->y - tolerance;
region.hi.x = lineEnd->x + tolerance;
region.hi.y = lineEnd->y + tolerance;
// check if in region
if( dest->x >= region.lo.x &&
dest->x <= region.hi.x &&
dest->y >= region.lo.y &&
dest->y <= region.hi.y )
return TRUE;
return FALSE;
} // end inLineTolerance
// EditWindow::handleResizeAvailable ==========================================
/** Given the mouse position, if it is close enough to a corner of a
* SINGLE selected window then we change the icon to the appropriate
* resize icon. If the mouse is not moved from this position then
* the next left click will allow for a resize of the window */
//=============================================================================
void EditWindow::handleResizeAvailable( Int mouseX, Int mouseY )
{
GameWindow *window;
ICoord2D origin, size, mouse, point;
const Int tol = 5;
// if there is zero or more than 1 window selected we can't resize
if( TheEditor->selectionCount() != 1 )
return;
// get mouse data in a nice coord 2d
mouse.x = mouseX;
mouse.y = mouseY;
// get the selected window data
window = TheEditor->getFirstSelected();
window->winGetScreenPosition( &origin.x, &origin.y );
window->winGetSize( &size.x, &size.y );
// check for around top left corner
point = origin;
if( inCornerTolerance( &mouse, &point, tol ) == TRUE )
{
TheEditor->setMode( MODE_RESIZE_TOP_LEFT );
return;
} // end if
// check for around bottom right corner
point.x = origin.x + size.x;
point.y = origin.y + size.y;
if( inCornerTolerance( &mouse, &point, tol ) == TRUE )
{
TheEditor->setMode( MODE_RESIZE_BOTTOM_RIGHT );
return;
} // end if
// check for around top right corner
point.x = origin.x + size.x;
point.y = origin.y;
if( inCornerTolerance( &mouse, &point, tol ) == TRUE )
{
TheEditor->setMode( MODE_RESIZE_TOP_RIGHT );
return;
} // end if
// check for around bottom left corner
point.x = origin.x;
point.y = origin.y + size.y;
if( inCornerTolerance( &mouse, &point, tol ) == TRUE )
{
TheEditor->setMode( MODE_RESIZE_BOTTOM_LEFT );
return;
} // end if
ICoord2D lineStart, lineEnd;
// check for along top edge
lineStart = origin;
lineEnd.x = origin.x + size.x;
lineEnd.y = origin.y;
if( inLineTolerance( &mouse, &lineStart, &lineEnd, tol ) == TRUE )
{
TheEditor->setMode( MODE_RESIZE_TOP );
return;
} // end if
// check for along bottom edge
lineStart.x = origin.x;
lineStart.y = origin.y + size.y;
lineEnd.x = origin.x + size.x;
lineEnd.y = origin.y + size.y;
if( inLineTolerance( &mouse, &lineStart, &lineEnd, tol ) == TRUE )
{
TheEditor->setMode( MODE_RESIZE_BOTTOM );
return;
} // end if
// check for along left edge
lineStart = origin;
lineEnd.x = origin.x;
lineEnd.y = origin.y + size.y;
if( inLineTolerance( &mouse, &lineStart, &lineEnd, tol ) == TRUE )
{
TheEditor->setMode( MODE_RESIZE_LEFT );
return;
} // end if
// check for along right edge
lineStart.x = origin.x + size.x;
lineStart.y = origin.y;
lineEnd.x = origin.x + size.x;
lineEnd.y = origin.y + size.y;
if( inLineTolerance( &mouse, &lineStart, &lineEnd, tol ) == TRUE )
{
TheEditor->setMode( MODE_RESIZE_RIGHT );
return;
} // end if
// we are not resizing anything at all, set us to normal mode
TheEditor->setMode( MODE_EDIT );
} // end handleResizeAvailable
// EditWindow::drawSeeThruOutlines ============================================
/** Draw an outline for a window that is see thru so we can still work
* with it in the editor */
//=============================================================================
void EditWindow::drawSeeThruOutlines( GameWindow *windowList, Color c )
{
// end recursion
if( windowList == NULL )
return;
// draw outline for this window
if( BitTest( windowList->winGetStatus(), WIN_STATUS_SEE_THRU ) )
{
ICoord2D pos;
ICoord2D size;
// get position and size
windowList->winGetScreenPosition( &pos.x, &pos.y );
windowList->winGetSize( &size.x, &size.y );
// draw a box on the window
drawOpenRect( pos.x, pos.y, size.x, size.y, 1, c );
} // end if
// check window children
GameWindow *child;
for( child = windowList->winGetChild(); child; child = child->winGetNext() )
drawSeeThruOutlines( child, c );
// go to siblings
drawSeeThruOutlines( windowList->winGetNext(), c );
} // end drawSeeThruOutlines
// EditWindow::drawHiddenOutlines =============================================
/** Draw an outline for a window that is hidden so we can still work
* with it in the editor */
//=============================================================================
void EditWindow::drawHiddenOutlines( GameWindow *windowList, Color c )
{
// end recursion
if( windowList == NULL )
return;
//
// draw outline for this window, we are hidden if we have the hidden
// status or any of our parents are hidden
//
Bool hidden = FALSE;
GameWindow *parent= windowList->winGetParent();
while( parent )
{
if( BitTest( parent->winGetStatus(), WIN_STATUS_HIDDEN ) )
hidden = TRUE;
parent = parent->winGetParent();
} // end while
if( BitTest( windowList->winGetStatus(), WIN_STATUS_HIDDEN ) )
hidden = TRUE;
if( hidden )
{
ICoord2D pos;
ICoord2D size;
// get position and size
windowList->winGetScreenPosition( &pos.x, &pos.y );
windowList->winGetSize( &size.x, &size.y );
// draw a box on the window
drawOpenRect( pos.x, pos.y, size.x, size.y, 2, c );
} // end if
// check window children
GameWindow *child;
for( child = windowList->winGetChild(); child; child = child->winGetNext() )
drawHiddenOutlines( child, c );
// go to siblings
drawHiddenOutlines( windowList->winGetNext(), c );
} // end drawHiddenOutlines
// EditWindow::drawUIback =====================================================
/** Draw any visual feedback to the user about selection boxes or windows
* that are selected, draggin windows etc */
//=============================================================================
void EditWindow::drawUIFeedback( void )
{
WindowSelectionEntry *select;
Int color = m_pulse * 2;
if( color > 255 )
color = 255;
// draw hidden window outlines if requested
if( TheEditor->getShowHiddenOutlines() )
drawHiddenOutlines( TheWindowManager->winGetWindowList(),
GameMakeColor( color, 64, 64, 255 ) );
// draw see-thru window outlines if requested
if( TheEditor->getShowSeeThruOutlines() )
drawSeeThruOutlines( TheWindowManager->winGetWindowList(),
GameMakeColor( 64, 64, color, 255 ) );
// if the grid is visible draw it on top of everything
if( TheEditor->isGridVisible() == TRUE )
drawGrid();
// draw drag selection box
if( m_dragSelecting )
{
Int width, height;
Real selectBoxWidth = 2.0f;
Color selectBoxColor = GameMakeColor( 0, 255, 0, 255 );
width = m_selectRegion.hi.x - m_selectRegion.lo.x;
height = m_selectRegion.hi.y - m_selectRegion.lo.y;
drawOpenRect( m_selectRegion.lo.x, m_selectRegion.lo.y,
width, height, selectBoxWidth, selectBoxColor );
} // end if
// draw select lines on selected windows
select = TheEditor->getSelectList();
while( select )
{
ICoord2D origin, size;
GameWindow *window;
Real windowSelectWidth = 2.0f;
Color windowSelectColor;
windowSelectColor = GameMakeColor( 0, color, 0, 255 );
// get window properties
window = select->window;
window->winGetScreenPosition( &origin.x, &origin.y );
window->winGetSize( &size.x, &size.y );
// draw a box on the window
drawOpenRect( origin.x, origin.y, size.x, size.y,
windowSelectWidth, windowSelectColor );
// go to next selection
select = select->next;
} // end while
//
// if we're drag moving, draw outlines of all the windows in the
// select list offset by the start to end of the drag move
//
if( TheEditor->getMode() == MODE_DRAG_MOVE || TheEditor->getMode() == MODE_KEYBOARD_MOVE )
{
ICoord2D origin, size;
ICoord2D moveLoc, safeLoc;
GameWindow *window, *parent;
Real outlineWidth = 1.0f;
Color outlineColor;
// determine outline using pulse counter
outlineColor = GameMakeColor( m_pulse, m_pulse, m_pulse + 25, 255 );
// traverse selection list
select = TheEditor->getSelectList();
while( select )
{
// get window data
window = select->window;
window->winGetScreenPosition( &origin.x, &origin.y );
window->winGetSize( &size.x, &size.y );
// figure out the destination of the window from this move
ICoord2D change;
change.x = (m_dragMoveDest.x - m_dragMoveOrigin.x);
change.y = (m_dragMoveDest.y - m_dragMoveOrigin.y);
// [SKB: Jun 02 2003 @ 2:7pm] :
// Don't move the object unless we have moved the mouse,
// this is to avoid the irritating movement of a window when just
// clicking on a window.
if (change.x || change.y)
{
moveLoc.x = origin.x + change.x;
moveLoc.y = origin.y + change.y;
// snap move location to grid if on
if( (TheEditor->getMode() == MODE_DRAG_MOVE) && TheEditor->isGridSnapOn() )
TheEditor->gridSnapLocation( &moveLoc, &moveLoc );
// keep location legal
TheEditor->computeSafeLocation( window, moveLoc.x, moveLoc.y,
&safeLoc.x, &safeLoc.y );
// adjust location by parent location if present
parent = window->winGetParent();
if( parent )
{
ICoord2D parentOrigin;
parent->winGetScreenPosition( &parentOrigin.x, &parentOrigin.y );
safeLoc.x += parentOrigin.x;
safeLoc.y += parentOrigin.y;
} // end if
// draw outline of window at what would be the drag move destination
drawOpenRect( safeLoc.x, safeLoc.y, size.x, size.y,
outlineWidth, outlineColor );
}
// go to next selection
select = select->next;
} // end while
} // end if
// if resizing a window draw that resize representation
if( m_resizingWindow )
{
GameWindow *window = m_windowToResize;
ICoord2D loc, size;
Color outlineColor;
Real outlineWidth = 1.0f;
GameWindow *parent;
ICoord2D dest = m_resizeDest;
// adjust resize dest by the grid if it's on
if( TheEditor->isGridSnapOn() )
TheEditor->gridSnapLocation( &dest, &dest );
//
// given the location that we started dragging at and the destination
// drag location along with the mode of resizing compute what the
// new location and the new size of the selected window to resize
//
TheEditor->computeResizeLocation( TheEditor->getMode(),
window,
&m_resizeOrigin, &dest,
&loc, &size );
// adjust location by parent location if present
parent = window->winGetParent();
if( parent )
{
ICoord2D parentOrigin;
parent->winGetScreenPosition( &parentOrigin.x, &parentOrigin.y );
loc.x += parentOrigin.x;
loc.y += parentOrigin.y;
} // end if
// draw a box for the window at its new location
outlineColor = GameMakeColor( m_pulse, m_pulse, m_pulse, 255 );
drawOpenRect( loc.x, loc.y, size.x, size.y, outlineWidth, outlineColor );
} // end if
// draw lines around any drag source and drag targets in the hierarchy view
GameWindow *dragSource = TheHierarchyView->getDragWindow();
Color dragColor = GameMakeColor( color, 0, color, 255 );
if( dragSource )
{
ICoord2D origin, size;
// get size and position
dragSource->winGetScreenPosition( &origin.x, &origin.y );
dragSource->winGetSize( &size.x, &size.y );
// draw box
drawOpenRect( origin.x, origin.y, size.x, size.y, 2, dragColor );
} // end if
// drag target
GameWindow *dragTarget = TheHierarchyView->getDragTarget();
if( dragTarget )
{
ICoord2D origin, size;
// get size and position
dragTarget->winGetScreenPosition( &origin.x, &origin.y );
dragTarget->winGetSize( &size.x, &size.y );
// draw box
drawOpenRect( origin.x, origin.y, size.x, size.y, 2, dragColor );
} // end if
} // end drawUIFeedback
// EditWindow::drawGrid =======================================================
/** Draw the grid */
//=============================================================================
void EditWindow::drawGrid( void )
{
// HDC hdc = GetDC( getWindowHandle() );
Int res = TheEditor->getGridResolution();
Int x, y;
RGBColorInt *gridColor = TheEditor->getGridColor();
Color color = GameMakeColor( gridColor->red, gridColor->green,
gridColor->blue, gridColor->alpha );
// set us to invert where we draw
// SetROP2( hdc, R2_NOT );
// SelectObject( hdc, (HPEN)GetStockObject( WHITE_PEN ) );
for( y = 0; y < m_size.y; y += res )
{
TheDisplay->drawLine( 0, y, m_size.x, y, 1, color );
// MoveToEx( hdc, 0, y, NULL );
// LineTo( hdc, m_size.x, y );
}
for( x = 0; x < m_size.x; x += res )
{
TheDisplay->drawLine( x, 0, x, m_size.y, 1, color );
// MoveToEx( hdc, x, 0, NULL );
// LineTo( hdc, x, m_size.y );
}
/*
for( y = 0; y < m_size.y; y += res )
{
for( x = 0; x < m_size.x; x += res )
{
MoveToEx( hdc, x, y, NULL );
LineTo( hdc, x + 1, y + 1 );
// TheDisplay->drawLine( x, y, x + 1, y + 1, 1, 0xFFFFFFFF );
} // end for x
} // end for y
*/
// release the dc
// ReleaseDC( getWindowHandle(), hdc );
} // end drawGrid
// EditWindow::draw ===========================================================
/** Draw the edit window */
//=============================================================================
void EditWindow::draw( void )
{
static UnsignedInt syncTime = 0;
// allow W3D to update its internals
WW3D::Sync( syncTime );
// for now, use constant time steps to avoid animations running independent of framerate
syncTime += 50;
// start render block
WW3D::Begin_Render( true, true, Vector3( m_backgroundColor.red,
m_backgroundColor.green,
m_backgroundColor.blue ) );
// draw the windows
TheWindowManager->winRepaint();
// draw selected drag box and any window selection boxes
if( TheEditor->getMode() != MODE_TEST_RUN )
drawUIFeedback();
// render is all done!
WW3D::End_Render();
} // end draw
// EditWindow::setSize ========================================================
/** The edit window should now be logically consider this size */
//=============================================================================
void EditWindow::setSize( ICoord2D *size )
{
// save the size
m_size = *size;
// the display should reflect the new size as well
if( TheDisplay )
{
TheDisplay->setWidth( m_size.x );
TheDisplay->setHeight( m_size.y );
} // end if
// set the extents for our 2D renderer
if( m_2DRender )
m_2DRender->Set_Coordinate_Range( RectClass( 0,
0,
m_size.x,
m_size.y ) );
} // end setSize
// EditWindow::openPopupMenu ==================================================
/** Open the new control menu that comes up when the user right clicks
* in the workspace to create new controls */
//=============================================================================
void EditWindow::openPopupMenu( Int x, Int y )
{
HMENU menu, subMenu;
POINT screen;
Int selectCount = TheEditor->selectionCount();
// get the menu with the new control items
menu = LoadMenu( TheEditor->getInstance(), (LPCTSTR)POPUP_MENU );
subMenu = GetSubMenu( menu, 0 );
// enable/disable menu items
if( selectCount == 0 )
{
EnableMenuItem( subMenu, POPUP_MENU_DELETE, MF_GRAYED );
EnableMenuItem( subMenu, POPUP_MENU_PROPERTIES, MF_GRAYED );
EnableMenuItem( subMenu, POPUP_MENU_BRING_TO_TOP, MF_GRAYED );
} // end if
else
{
EnableMenuItem( subMenu, POPUP_MENU_DELETE, MF_ENABLED );
EnableMenuItem( subMenu, POPUP_MENU_PROPERTIES, MF_ENABLED );
EnableMenuItem( subMenu, POPUP_MENU_BRING_TO_TOP, MF_ENABLED );
} // end else
//
// open up right mouse track menu, note that we have to translate the
// x,y of this mouse click which is local to this window into
// screen coordinates
//
screen.x = x;
screen.y = y;
ClientToScreen( m_editWindowHWnd, &screen );
TrackPopupMenuEx( subMenu, 0, screen.x, screen.y, m_editWindowHWnd, NULL );
// save the location click for the creation of the popup menu
m_popupMenuClickPos.x = x;
m_popupMenuClickPos.y = y;
} // end openPopupMenu
// EditWindow::drawLine =======================================================
/** draw a line on the display in pixel coordinates with the specified color */
//=============================================================================
void EditWindow::drawLine( Int startX, Int startY,
Int endX, Int endY,
Real lineWidth, UnsignedInt lineColor )
{
m_2DRender->Reset();
m_2DRender->Enable_Texturing( FALSE );
m_2DRender->Add_Line( Vector2( startX, startY ), Vector2( endX, endY ),
lineWidth, lineColor );
m_2DRender->Render();
} // end drawLIne
// EditWindow::drawOpenRect ===================================================
/** draw a rect border on the display in pixel coordinates with the
* specified color */
//=============================================================================
void EditWindow::drawOpenRect( Int startX, Int startY,
Int width, Int height,
Real lineWidth, UnsignedInt lineColor )
{
m_2DRender->Reset();
m_2DRender->Enable_Texturing( FALSE );
m_2DRender->Add_Outline( RectClass( startX, startY,
startX + width, startY + height ),
lineWidth, lineColor );
// render it now!
m_2DRender->Render();
} // end drawOpenRect
// EditWindow::drawFillRect ===================================================
/** draw a filled rect on the display in pixel coords with the
* specified color */
//=============================================================================
void EditWindow::drawFillRect( Int startX, Int startY,
Int width, Int height,
UnsignedInt color )
{
m_2DRender->Reset();
m_2DRender->Enable_Texturing( FALSE );
m_2DRender->Add_Rect( RectClass( startX, startY,
startX + width, startY + height ),
0, 0, color );
// render it now!
m_2DRender->Render();
} // end drawFillRect
// EditWindow::drawImage ======================================================
/** draw an image fit within the screen coordinates */
//=============================================================================
void EditWindow::drawImage( const Image *image,
Int startX, Int startY,
Int endX, Int endY,
Color color )
{
// sanity
if( image == NULL )
return;
const Region2D *uv = image->getUV();
m_2DRender->Reset();
m_2DRender->Enable_Texturing( TRUE );
m_2DRender->Set_Texture( image->getFilename().str() );
RectClass screen_rect(startX,startY,endX,endY);
RectClass uv_rect(uv->lo.x,uv->lo.y,uv->hi.x,uv->hi.y);
if (m_isClippedEnabled)
{ //need to clip this quad to clip rectangle
//
// Check for completely clipped
//
if ( endX <= m_clipRegion.lo.x ||
endY <= m_clipRegion.lo.y)
{
return; //nothing to render
} else {
//
// Clip the polygons to the specified area
//
RectClass clipped_rect;
clipped_rect.Left = __max (screen_rect.Left, m_clipRegion.lo.x);
clipped_rect.Right = __min (screen_rect.Right, m_clipRegion.hi.x);
clipped_rect.Top = __max (screen_rect.Top, m_clipRegion.lo.y);
clipped_rect.Bottom = __min (screen_rect.Bottom, m_clipRegion.hi.y);
//
// Clip the texture to the specified area
//
RectClass clipped_uv_rect;
float percent = ((clipped_rect.Left - screen_rect.Left) / screen_rect.Width ());
clipped_uv_rect.Left = uv_rect.Left + (uv_rect.Width () * percent);
percent = ((clipped_rect.Right - screen_rect.Left) / screen_rect.Width ());
clipped_uv_rect.Right = uv_rect.Left + (uv_rect.Width () * percent);
percent = ((clipped_rect.Top - screen_rect.Top) / screen_rect.Height ());
clipped_uv_rect.Top = uv_rect.Top + (uv_rect.Height () * percent);
percent = ((clipped_rect.Bottom - screen_rect.Top) / screen_rect.Height ());
clipped_uv_rect.Bottom = uv_rect.Top + (uv_rect.Height () * percent);
//
// Use the clipped rectangles to render
//
screen_rect = clipped_rect;
uv_rect = clipped_uv_rect;
}
}
// if rotated 90 degrees clockwise we have to adjust the uv coords
if( BitTest( image->getStatus(), IMAGE_STATUS_ROTATED_90_CLOCKWISE ) )
{
m_2DRender->Add_Tri( Vector2( screen_rect.Left, screen_rect.Top ),
Vector2( screen_rect.Left, screen_rect.Bottom ),
Vector2( screen_rect.Right, screen_rect.Top ),
Vector2( uv_rect.Right, uv_rect.Top),
Vector2( uv_rect.Left, uv_rect.Top),
Vector2( uv_rect.Right, uv_rect.Bottom ),
color );
m_2DRender->Add_Tri( Vector2( screen_rect.Right, screen_rect.Bottom ),
Vector2( screen_rect.Right, screen_rect.Top ),
Vector2( screen_rect.Left, screen_rect.Bottom ),
Vector2( uv_rect.Left, uv_rect.Bottom ),
Vector2( uv_rect.Right, uv_rect.Bottom ),
Vector2( uv_rect.Left, uv_rect.Top ),
color );
} // end if
else
{
// just draw as normal
m_2DRender->Add_Quad( screen_rect, uv_rect, color );
} // end else
m_2DRender->Render();
} // end drawImage
// EditWindow::getBackgroundColor =============================================
/** Get the background color for the edit window */
//=============================================================================
RGBColorReal EditWindow::getBackgroundColor( void )
{
return m_backgroundColor;
} // end getBackgroundColor
// EditWindow::setBackgroundColor =============================================
/** Set the background color for the edit window */
//=============================================================================
void EditWindow::setBackgroundColor( RGBColorReal color )
{
m_backgroundColor = color;
} // end setBackgroundColor
// EditWindow::notifyWindowDeleted ============================================
/** A window has been deleted from the editor and the editor is now
* notifying the edit window about it in case anything must be
* cleaned up */
//=============================================================================
void EditWindow::notifyWindowDeleted( GameWindow *window )
{
// sanity
if( window == NULL )
return;
// check to see if the resizing window was deleted
if( m_windowToResize == window )
{
// get back to normal mode and clean up
m_windowToResize = NULL;
m_resizingWindow = FALSE;
TheEditor->setMode( MODE_EDIT );
} // end if
// null out picked window if needed
if( m_pickedWindow == window )
m_pickedWindow = NULL;
//
// go back to edit mode, this keeps us from staying in a resize mode
// after deleting the window under the cursor
//
TheEditor->setMode( MODE_EDIT );
} // end notifyWindowDeleted
Reference in New Issue Copy Permalink