2065 lines
47 KiB
C++
2065 lines
47 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 GPL Source Code
|
|
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).
|
|
|
|
Doom 3 Source Code is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Doom 3 Source Code is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Doom 3 Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code. If not, please request a copy in writing from id Software at the address below.
|
|
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
#include "../../idlib/precompiled.h"
|
|
#pragma hdrstop
|
|
|
|
#include "../../sys/win32/rc/guied_resource.h"
|
|
#include "../../renderer/tr_local.h"
|
|
#include "../../sys/win32/win_local.h"
|
|
#include "../../ui/DeviceContext.h"
|
|
#include "../../ui/EditWindow.h"
|
|
#include "../../ui/ListWindow.h"
|
|
#include "../../ui/BindWindow.h"
|
|
#include "../../ui/RenderWindow.h"
|
|
#include "../../ui/ChoiceWindow.h"
|
|
|
|
#include "GEApp.h"
|
|
#include "GEItemPropsDlg.h"
|
|
#include "GEItemScriptsDlg.h"
|
|
|
|
// Modifiers
|
|
#include "GEModifierGroup.h"
|
|
#include "GEMoveModifier.h"
|
|
#include "GESizeModifier.h"
|
|
#include "GEStateModifier.h"
|
|
#include "GEZOrderModifier.h"
|
|
#include "GEInsertModifier.h"
|
|
#include "GEHideModifier.h"
|
|
#include "GEDeleteModifier.h"
|
|
|
|
static float g_ZoomScales[rvGEWorkspace::ZOOM_MAX] = { 0, 0.25f, 0.33f, 0.50f, 0.66f, 1.0f, 1.5f, 2.0f, 3.0f };
|
|
|
|
static const int ID_GUIED_SELECT_FIRST = 9800;
|
|
static const int ID_GUIED_SELECT_LAST = 9900;
|
|
|
|
idList<rvGEClipboardItem*> rvGEWorkspace::mClipboard;
|
|
|
|
rvGEWorkspace::rvGEWorkspace ( rvGEApp* app ) : mApplication ( app )
|
|
{
|
|
mWnd = 0;
|
|
mInterface = 0;
|
|
mZoom = ZOOM_100;
|
|
mScrollHorz = false;
|
|
mScrollVert = false;
|
|
mModified = false;
|
|
mNew = false;
|
|
mDragScroll = false;
|
|
mSourceControlState = SCS_CHECKEDOUT;
|
|
mFilename = "guis/Untitled.gui";
|
|
mDragType = rvGESelectionMgr::HT_NONE;
|
|
mHandCursor = LoadCursor ( app->GetInstance(), MAKEINTRESOURCE(IDC_GUIED_HAND) );
|
|
mDontAdd = false;
|
|
|
|
mSelections.SetWorkspace ( this );
|
|
}
|
|
|
|
rvGEWorkspace::~rvGEWorkspace ( )
|
|
{
|
|
// Make sure all the wrappers get cleaned up
|
|
rvGEWindowWrapper::GetWrapper ( mInterface->GetDesktop ( ) )->EnumChildren ( CleanupEnumProc, NULL );
|
|
|
|
DestroyCursor ( mHandCursor );
|
|
|
|
delete mInterface;
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvGEWorkspace::CleanupEnumProc
|
|
|
|
Window enumeration procedure that deletes all the wrapper classes
|
|
================
|
|
*/
|
|
bool rvGEWorkspace::CleanupEnumProc ( rvGEWindowWrapper* wrapper, void* data )
|
|
{
|
|
bool result;
|
|
|
|
if ( !wrapper )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
result = wrapper->EnumChildren ( CleanupEnumProc, data );
|
|
|
|
// Cleanup the window wrapper
|
|
delete wrapper;
|
|
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvGEWorkspace::GetZoomScale
|
|
|
|
Returns the scale of the current zoom level
|
|
================
|
|
*/
|
|
float rvGEWorkspace::GetZoomScale ( void )
|
|
{
|
|
return g_ZoomScales [ mZoom ];
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvGEWorkspace::Attach
|
|
|
|
Attaches the workspace to the given window. This is usually done after the
|
|
window is created and the file has been loaded.
|
|
================
|
|
*/
|
|
bool rvGEWorkspace::Attach ( HWND wnd )
|
|
{
|
|
assert ( wnd );
|
|
|
|
mWnd = wnd;
|
|
|
|
// Initialize the pixel format for this window
|
|
SetupPixelFormat ( );
|
|
|
|
// Jam the workspace pointer into the userdata window long so
|
|
// we can retrieve the workspace from the window later
|
|
SetWindowLong ( mWnd, GWL_USERDATA, (LONG) this );
|
|
|
|
UpdateTitle ( );
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvGEWorkspace::Detach
|
|
|
|
Detaches the workspace from the window it is currently attached to
|
|
================
|
|
*/
|
|
void rvGEWorkspace::Detach ( void )
|
|
{
|
|
assert ( mWnd );
|
|
|
|
SetWindowLong ( mWnd, GWL_USERDATA, 0 );
|
|
mWnd = NULL;
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvGEWorkspace::SetupPixelFormat
|
|
|
|
Setup the pixel format for the opengl context
|
|
================
|
|
*/
|
|
bool rvGEWorkspace::SetupPixelFormat ( void )
|
|
{
|
|
HDC hDC = GetDC ( mWnd );
|
|
bool result = true;
|
|
|
|
int pixelFormat = ChoosePixelFormat(hDC, &win32.pfd);
|
|
if (pixelFormat > 0)
|
|
{
|
|
if (SetPixelFormat(hDC, pixelFormat, &win32.pfd) == NULL)
|
|
{
|
|
result = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
result = false;
|
|
}
|
|
|
|
ReleaseDC ( mWnd, hDC );
|
|
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvGEWorkspace::RenderGrid
|
|
|
|
Renders the grid on top of the user interface
|
|
================
|
|
*/
|
|
void rvGEWorkspace::RenderGrid ( void )
|
|
{
|
|
float x;
|
|
float y;
|
|
float step;
|
|
idVec4& color = mApplication->GetOptions().GetGridColor ( );
|
|
|
|
// See if the grid is off before rendering it
|
|
if ( !mApplication->GetOptions().GetGridVisible ( ))
|
|
{
|
|
return;
|
|
}
|
|
|
|
qglEnable(GL_BLEND);
|
|
qglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
|
|
qglColor4f ( color[0], color[1], color[2], 0.5f );
|
|
|
|
qglBegin ( GL_LINES );
|
|
step = mApplication->GetOptions().GetGridWidth ( ) * g_ZoomScales[mZoom];
|
|
for ( x = mRect.x + mRect.w; x >= mRect.x ; x -= step )
|
|
{
|
|
qglVertex2f ( x, mRect.y );
|
|
qglVertex2f ( x, mRect.y + mRect.h );
|
|
}
|
|
step = mApplication->GetOptions().GetGridHeight ( ) * g_ZoomScales[mZoom];
|
|
for ( y = mRect.y + mRect.h; y >= mRect.y ; y -= step )
|
|
{
|
|
qglVertex2f ( mRect.x, y );
|
|
qglVertex2f ( mRect.x + mRect.w, y );
|
|
}
|
|
qglEnd ( );
|
|
|
|
qglDisable(GL_BLEND);
|
|
qglColor3f ( color[0], color[1], color[2] );
|
|
|
|
qglBegin ( GL_LINES );
|
|
step = mApplication->GetOptions().GetGridWidth ( ) * g_ZoomScales[mZoom];
|
|
for ( x = mRect.x + mRect.w; x >= mRect.x ; x -= step * 4 )
|
|
{
|
|
qglVertex2f ( x, mRect.y );
|
|
qglVertex2f ( x, mRect.y + mRect.h );
|
|
}
|
|
step = mApplication->GetOptions().GetGridHeight ( ) * g_ZoomScales[mZoom];
|
|
for ( y = mRect.y + mRect.h; y >= mRect.y ; y -= step * 4 )
|
|
{
|
|
qglVertex2f ( mRect.x, y );
|
|
qglVertex2f ( mRect.x + mRect.w, y );
|
|
}
|
|
qglEnd ( );
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvGEWorkspace::Render
|
|
|
|
Renders the workspace to the given DC
|
|
================
|
|
*/
|
|
void rvGEWorkspace::Render ( HDC hdc )
|
|
{
|
|
int front;
|
|
int back;
|
|
float scale;
|
|
|
|
scale = g_ZoomScales[mZoom];
|
|
|
|
// Switch GL contexts to our dc
|
|
if (!qwglMakeCurrent( hdc, win32.hGLRC ))
|
|
{
|
|
common->Printf("ERROR: wglMakeCurrent failed.. Error:%i\n", qglGetError());
|
|
common->Printf("Please restart Q3Radiant if the Map view is not working\n");
|
|
return;
|
|
}
|
|
|
|
// Prepare the view and clear it
|
|
GL_State( GLS_DEFAULT );
|
|
qglViewport(0, 0, mWindowWidth, mWindowHeight );
|
|
qglScissor(0, 0, mWindowWidth, mWindowHeight );
|
|
qglClearColor ( 0.75f, 0.75f, 0.75f, 0 );
|
|
|
|
qglDisable(GL_DEPTH_TEST);
|
|
qglDisable(GL_CULL_FACE);
|
|
qglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
|
// Render the workspace below
|
|
glMatrixMode(GL_PROJECTION);
|
|
glLoadIdentity();
|
|
qglOrtho(0,mWindowWidth, mWindowHeight, 0, -1, 1);
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glLoadIdentity();
|
|
|
|
qglColor3f ( mApplication->GetOptions().GetWorkspaceColor()[0], mApplication->GetOptions().GetWorkspaceColor()[1], mApplication->GetOptions().GetWorkspaceColor()[2] );
|
|
qglBegin ( GL_QUADS );
|
|
qglVertex2f ( mRect.x, mRect.y );
|
|
qglVertex2f ( mRect.x + mRect.w, mRect.y );
|
|
qglVertex2f ( mRect.x + mRect.w, mRect.y + mRect.h );
|
|
qglVertex2f ( mRect.x, mRect.y + mRect.h );
|
|
qglEnd ( );
|
|
|
|
// Prepare the renderSystem view to draw the GUI in
|
|
viewDef_t viewDef;
|
|
memset ( &viewDef, 0, sizeof(viewDef) );
|
|
tr.viewDef = &viewDef;
|
|
tr.viewDef->renderView.x = mRect.x;
|
|
tr.viewDef->renderView.y = mWindowHeight - mRect.y - mRect.h;
|
|
tr.viewDef->renderView.width = mRect.w;
|
|
tr.viewDef->renderView.height = mRect.h;
|
|
tr.viewDef->scissor.x1 = 0;
|
|
tr.viewDef->scissor.y1 = 0;
|
|
tr.viewDef->scissor.x2 = mRect.w;
|
|
tr.viewDef->scissor.y2 = mRect.h;
|
|
tr.viewDef->isEditor = true;
|
|
renderSystem->BeginFrame(mWindowWidth, mWindowHeight );
|
|
|
|
// Draw the gui
|
|
mInterface->Redraw ( 0 ); // eventLoop->Milliseconds() );
|
|
|
|
// We are done using the renderSystem now
|
|
renderSystem->EndFrame( &front, &back );
|
|
|
|
if ( mApplication->GetActiveWorkspace ( ) == this )
|
|
{
|
|
mApplication->GetStatusBar().SetTriangles ( backEnd.pc.c_drawIndexes/3 );
|
|
}
|
|
|
|
// Prepare the viewport for drawing selections, etc.
|
|
GL_State( GLS_DEFAULT );
|
|
qglDisable( GL_TEXTURE_CUBE_MAP_EXT );
|
|
// qglDisable(GL_BLEND);
|
|
qglDisable(GL_CULL_FACE);
|
|
|
|
qglViewport(0, 0, mWindowWidth, mWindowHeight );
|
|
qglScissor(0, 0, mWindowWidth, mWindowHeight );
|
|
glMatrixMode(GL_PROJECTION);
|
|
glLoadIdentity();
|
|
qglOrtho(0,mWindowWidth, mWindowHeight, 0, -1, 1);
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glLoadIdentity();
|
|
|
|
RenderGrid ( );
|
|
|
|
mSelections.Render ( );
|
|
|
|
qglFinish ( );
|
|
qwglSwapBuffers(hdc);
|
|
|
|
qglEnable( GL_TEXTURE_CUBE_MAP_EXT );
|
|
qglEnable( GL_CULL_FACE);
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvGEWorkspace::UpdateTitle
|
|
|
|
Updates the window title with the name of the file and the zoom level and weither its open or not
|
|
================
|
|
*/
|
|
void rvGEWorkspace::UpdateTitle ( void )
|
|
{
|
|
// Set the window title based on the current filename
|
|
SetWindowText ( mWnd, va("%s%s (%d%%)", idStr(mFilename).StripPath ( ).c_str( ), mModified?"*":"", (int) (g_ZoomScales[mZoom] * 100)) );
|
|
|
|
gApp.GetStatusBar().SetZoom ( (int)(g_ZoomScales[mZoom] * 100.0f) );
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvGEWorkspace::UpdateRectangle
|
|
|
|
Updates the rectangle (not counting scrolling)
|
|
================
|
|
*/
|
|
void rvGEWorkspace::UpdateRectangle ( bool useScroll )
|
|
{
|
|
RECT rcClient;
|
|
float x;
|
|
float y;
|
|
float scale;
|
|
|
|
scale = g_ZoomScales[mZoom];
|
|
|
|
// Grab the current client rectangle of the window and cache off the width and height
|
|
GetClientRect ( mWnd, &rcClient );
|
|
mWindowWidth = rcClient.right - rcClient.left;
|
|
mWindowHeight = rcClient.bottom - rcClient.top;
|
|
|
|
// The workspace is always centered in the window
|
|
x = mRect.x = mWindowWidth / 2 - (SCREEN_WIDTH * scale) / 2;
|
|
y = mRect.y = mWindowHeight / 2 - (SCREEN_HEIGHT * scale) / 2;
|
|
mRect.w = (SCREEN_WIDTH * scale);
|
|
mRect.h = (SCREEN_HEIGHT * scale);
|
|
|
|
// When using the scroll position offset the rectangle based on the scrollbar positions
|
|
if ( useScroll )
|
|
{
|
|
// Adjust the start of the rectangle for the scroll positiond
|
|
mRect.y -= (float)GetScrollPos ( mWnd, SB_VERT ) / 1000.0f;
|
|
mRect.x -= (float)GetScrollPos ( mWnd, SB_HORZ ) / 1000.0f;
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvGEWorkspace::Scroll
|
|
|
|
Adjusts the given scrollbar by the given offset
|
|
================
|
|
*/
|
|
void rvGEWorkspace::Scroll ( int scrollbar, int offset )
|
|
{
|
|
SCROLLINFO si;
|
|
|
|
if ( scrollbar == SB_HORZ && !mScrollHorz )
|
|
{
|
|
return;
|
|
}
|
|
else if ( scrollbar == SB_VERT && !mScrollVert )
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Get all the vertial scroll bar information
|
|
si.cbSize = sizeof (si);
|
|
si.fMask = SIF_ALL;
|
|
|
|
// Save the position for comparison later on
|
|
GetScrollInfo ( mWnd, scrollbar, &si);
|
|
|
|
si.nPos += (1000 * offset);
|
|
if ( si.nPos < si.nMin ) si.nPos = si.nMin;
|
|
if ( si.nPos > si.nMax ) si.nPos = si.nMax;
|
|
|
|
si.fMask = SIF_POS;
|
|
SetScrollInfo (mWnd, scrollbar, &si, TRUE);
|
|
GetScrollInfo (mWnd, scrollbar, &si);
|
|
|
|
UpdateRectangle ( );
|
|
}
|
|
|
|
int rvGEWorkspace::HandleScroll ( int scrollbar, WPARAM wParam, LPARAM lParam )
|
|
{
|
|
SCROLLINFO si;
|
|
|
|
// Get all the vertial scroll bar information
|
|
si.cbSize = sizeof (si);
|
|
si.fMask = SIF_ALL;
|
|
|
|
// Save the position for comparison later on
|
|
GetScrollInfo ( mWnd, scrollbar, &si);
|
|
|
|
switch (LOWORD (wParam))
|
|
{
|
|
// user clicked left or up arrow
|
|
case SB_LINELEFT:
|
|
si.nPos -= 1000;
|
|
break;
|
|
|
|
// user clicked right or down arrow
|
|
case SB_LINERIGHT:
|
|
si.nPos += 1000;
|
|
break;
|
|
|
|
// user clicked shaft left of the scroll box
|
|
case SB_PAGELEFT:
|
|
si.nPos -= si.nPage;
|
|
break;
|
|
|
|
// user clicked shaft right of the scroll box
|
|
case SB_PAGERIGHT:
|
|
si.nPos += si.nPage;
|
|
break;
|
|
|
|
// user dragged the scroll box
|
|
case SB_THUMBTRACK:
|
|
si.nPos = si.nTrackPos;
|
|
break;
|
|
|
|
default :
|
|
break;
|
|
}
|
|
|
|
// Set the position and then retrieve it. Due to adjustments
|
|
// by Windows it may not be the same as the value set.
|
|
si.fMask = SIF_POS;
|
|
SetScrollInfo (mWnd, scrollbar, &si, TRUE);
|
|
GetScrollInfo (mWnd, scrollbar, &si);
|
|
|
|
UpdateRectangle ( );
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvGEWorkspace::UpdateScrollbars
|
|
|
|
Updates the states and the ranges of the scrollbars as well as the rectangle
|
|
================
|
|
*/
|
|
void rvGEWorkspace::UpdateScrollbars ( void )
|
|
{
|
|
SCROLLINFO info;
|
|
|
|
// First update the rectangle without applying scroll positions so
|
|
// we know the real sizes and coordinates
|
|
UpdateRectangle ( false );
|
|
|
|
// Setup the veritcal scrollbar
|
|
info.cbSize = sizeof(info);
|
|
info.fMask = SIF_RANGE|SIF_PAGE;
|
|
info.nMax = (mRect.h - mWindowHeight + 10) * 1000 / 2;
|
|
info.nMin = -info.nMax;
|
|
info.nPage = (int)((float)info.nMax * (float)((float)mWindowHeight / mRect.h));
|
|
info.nMax += info.nPage;
|
|
|
|
// If there is something to scroll then turn on the vertical scroll bar
|
|
// if its not on and update the scroll info.
|
|
if ( info.nMax > 0 )
|
|
{
|
|
if ( !mScrollVert )
|
|
{
|
|
mScrollVert = true;
|
|
ShowScrollBar ( mWnd, SB_VERT, mScrollVert );
|
|
}
|
|
SetScrollInfo ( mWnd, SB_VERT, &info, TRUE );
|
|
}
|
|
// Nothing to scroll, turn off the scrollbar if its on.
|
|
else if ( mScrollVert )
|
|
{
|
|
mScrollVert = false;
|
|
SetScrollPos ( mWnd, SB_VERT, 0, FALSE );
|
|
ShowScrollBar ( mWnd, SB_VERT, mScrollVert );
|
|
}
|
|
|
|
// Setup the horizontal scrollbar
|
|
info.nMax = (mRect.w - mWindowWidth + 10) * 1000 / 2;
|
|
info.nMin = -info.nMax;
|
|
info.nPage = (int)((float)info.nMax * (float)((float)mWindowWidth / mRect.w));
|
|
info.nMax += info.nPage;
|
|
|
|
// If there is something to scroll then turn on the vertical scroll bar
|
|
// if its not on and update the scroll info.
|
|
if ( info.nMax > 0 )
|
|
{
|
|
if ( !mScrollHorz )
|
|
{
|
|
mScrollHorz = true;
|
|
ShowScrollBar ( mWnd, SB_HORZ, mScrollHorz );
|
|
}
|
|
|
|
SetScrollInfo ( mWnd, SB_HORZ, &info, TRUE );
|
|
}
|
|
// Nothing to scroll, turn off the scrollbar if its on.
|
|
else if ( mScrollHorz )
|
|
{
|
|
mScrollHorz = false;
|
|
SetScrollPos ( mWnd, SB_HORZ, 0, FALSE );
|
|
ShowScrollBar ( mWnd, SB_HORZ, mScrollHorz );
|
|
}
|
|
|
|
// Need to update the rectangle again to take the scrollbar changes into account
|
|
UpdateRectangle ( true );
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvGEWorkspace::UpdateCursor
|
|
|
|
Called to update the cursor when the mouse is within the workspace window
|
|
================
|
|
*/
|
|
void rvGEWorkspace::UpdateCursor ( rvGESelectionMgr::EHitTest type )
|
|
{
|
|
switch ( type )
|
|
{
|
|
case rvGESelectionMgr::HT_SELECT:
|
|
SetCursor ( LoadCursor ( NULL, MAKEINTRESOURCE(IDC_ARROW) ) );
|
|
break;
|
|
|
|
case rvGESelectionMgr::HT_MOVE:
|
|
SetCursor ( LoadCursor ( NULL, MAKEINTRESOURCE(IDC_SIZEALL) ) );
|
|
break;
|
|
|
|
case rvGESelectionMgr::HT_SIZE_LEFT:
|
|
case rvGESelectionMgr::HT_SIZE_RIGHT:
|
|
SetCursor ( LoadCursor ( NULL, MAKEINTRESOURCE(IDC_SIZEWE ) ) );
|
|
break;
|
|
|
|
case rvGESelectionMgr::HT_SIZE_TOP:
|
|
case rvGESelectionMgr::HT_SIZE_BOTTOM:
|
|
SetCursor ( LoadCursor ( NULL, MAKEINTRESOURCE(IDC_SIZENS ) ) );
|
|
break;
|
|
|
|
case rvGESelectionMgr::HT_SIZE_TOPRIGHT:
|
|
case rvGESelectionMgr::HT_SIZE_BOTTOMLEFT:
|
|
SetCursor ( LoadCursor ( NULL, MAKEINTRESOURCE(IDC_SIZENESW ) ) );
|
|
break;
|
|
|
|
case rvGESelectionMgr::HT_SIZE_BOTTOMRIGHT:
|
|
case rvGESelectionMgr::HT_SIZE_TOPLEFT:
|
|
SetCursor ( LoadCursor ( NULL, MAKEINTRESOURCE(IDC_SIZENWSE ) ) );
|
|
break;
|
|
}
|
|
}
|
|
|
|
void rvGEWorkspace::UpdateCursor ( float x, float y )
|
|
{
|
|
idVec2 point;
|
|
rvGESelectionMgr::EHitTest type;
|
|
|
|
// First convert the worspace coord to a window coord
|
|
point = WorkspaceToWindow ( idVec2( x, y ) );
|
|
|
|
// See if it hits anything
|
|
type = mSelections.HitTest ( point.x, point.y );
|
|
|
|
// If it hits something then use it to update the cursor
|
|
if ( rvGESelectionMgr::HT_NONE != type )
|
|
{
|
|
UpdateCursor ( type );
|
|
}
|
|
else
|
|
{
|
|
SetCursor ( LoadCursor ( NULL, MAKEINTRESOURCE(IDC_ARROW ) ) );
|
|
}
|
|
}
|
|
|
|
void rvGEWorkspace::UpdateCursor ( void )
|
|
{
|
|
if ( mDragType == rvGESelectionMgr::HT_NONE )
|
|
{
|
|
POINT point;
|
|
idVec2 cursor;
|
|
|
|
GetCursorPos ( &point );
|
|
cursor.Set ( point.x, point.y );
|
|
WindowToWorkspace ( cursor );
|
|
|
|
UpdateCursor ( cursor.x, cursor.y );
|
|
}
|
|
else
|
|
{
|
|
UpdateCursor ( mDragType );
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvGEWorkspace::HandleMessage
|
|
|
|
Handles window messages to the workspace
|
|
================
|
|
*/
|
|
void rvGEWorkspace::HandleMessage ( UINT msg, WPARAM wParam, LPARAM lParam )
|
|
{
|
|
switch ( msg )
|
|
{
|
|
case WM_CLOSE:
|
|
{
|
|
|
|
if ( IsModified ( ) )
|
|
{
|
|
if ( IDYES == gApp.MessageBox ( va("Save changes to the document \"%s\" before closing?", GetFilename() ), MB_YESNO|MB_ICONQUESTION ) )
|
|
{
|
|
SendMessage ( mApplication->GetMDIFrame(), WM_COMMAND, MAKELONG(ID_GUIED_FILE_SAVE,0), 0 );
|
|
}
|
|
}
|
|
|
|
|
|
GetApplication ( )->GetNavigator().SetWorkspace(NULL);
|
|
GetApplication ( )->GetTransformer().SetWorkspace(NULL);
|
|
GetApplication ( )->GetProperties().SetWorkspace(NULL);
|
|
break;
|
|
}
|
|
|
|
case WM_CAPTURECHANGED:
|
|
if ( (HWND)lParam != mWnd )
|
|
{
|
|
mDragScroll = false;
|
|
mDragType = rvGESelectionMgr::HT_NONE;
|
|
}
|
|
break;
|
|
|
|
case WM_SETCURSOR:
|
|
{
|
|
POINT point;
|
|
idVec2 cursor;
|
|
GetCursorPos ( &point );
|
|
cursor.Set ( point.x, point.y );
|
|
WindowToWorkspace ( cursor );
|
|
if ( mDragType == rvGESelectionMgr::HT_NONE )
|
|
{
|
|
UpdateCursor ( cursor.x, cursor.y );
|
|
}
|
|
else
|
|
{
|
|
UpdateCursor ( mDragType );
|
|
}
|
|
break;
|
|
}
|
|
|
|
case WM_MOUSEWHEEL:
|
|
if ( (short)HIWORD(wParam) > 0 )
|
|
{
|
|
ZoomIn ( );
|
|
}
|
|
else if ( (short)HIWORD(wParam) < 0 )
|
|
{
|
|
ZoomOut ( );
|
|
}
|
|
break;
|
|
|
|
case WM_MOUSEMOVE:
|
|
HandleMouseMove ( wParam, lParam );
|
|
break;
|
|
|
|
case WM_MBUTTONDOWN:
|
|
HandleMButtonDown ( wParam, lParam );
|
|
break;
|
|
|
|
case WM_MBUTTONUP:
|
|
HandleMButtonUp ( wParam, lParam );
|
|
break;
|
|
|
|
case WM_LBUTTONDOWN:
|
|
HandleLButtonDown ( wParam, lParam );
|
|
break;
|
|
|
|
case WM_LBUTTONUP:
|
|
HandleLButtonUp ( wParam, lParam );
|
|
break;
|
|
|
|
case WM_LBUTTONDBLCLK:
|
|
HandleLButtonDblClk ( wParam, lParam );
|
|
break;
|
|
|
|
case WM_INITMENUPOPUP:
|
|
SendMessage ( mApplication->GetMDIFrame(), msg, wParam, lParam );
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
HandleCommand ( wParam, lParam );
|
|
break;
|
|
|
|
case WM_RBUTTONDOWN:
|
|
HandleRButtonDown ( wParam, lParam );
|
|
break;
|
|
|
|
case WM_SIZE:
|
|
UpdateScrollbars();
|
|
break;
|
|
|
|
case WM_VSCROLL:
|
|
HandleScroll ( SB_VERT, wParam, lParam );
|
|
break;
|
|
|
|
case WM_HSCROLL:
|
|
HandleScroll ( SB_HORZ, wParam, lParam );
|
|
break;
|
|
|
|
case WM_KEYDOWN:
|
|
HandleKeyDown ( wParam, lParam );
|
|
break;
|
|
}
|
|
}
|
|
/*
|
|
================
|
|
rvGEWorkspace::HandleCommand
|
|
|
|
Handles command messages destined for the workspace window. This is for
|
|
special workspace commands, any unhandled commands are forwarded to the main window
|
|
================
|
|
*/
|
|
int rvGEWorkspace::HandleCommand ( WPARAM wParam, LPARAM lParam )
|
|
{
|
|
// Select command
|
|
if ( LOWORD(wParam) >= ID_GUIED_SELECT_FIRST && LOWORD(wParam) <= ID_GUIED_SELECT_LAST )
|
|
{
|
|
idWindow* window = mSelectMenu[LOWORD(wParam)-ID_GUIED_SELECT_FIRST];
|
|
rvGEWindowWrapper* wrapper = rvGEWindowWrapper::GetWrapper ( window );
|
|
|
|
// Handle multi select as well
|
|
if ( GetAsyncKeyState ( VK_SHIFT ) & 0x8000 )
|
|
{
|
|
if ( wrapper->IsSelected ( ) )
|
|
{
|
|
mSelections.Remove ( window );
|
|
}
|
|
else
|
|
{
|
|
mSelections.Add ( window );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
mSelections.Set ( window );
|
|
}
|
|
}
|
|
|
|
return SendMessage ( mApplication->GetMDIFrame(), WM_COMMAND, wParam, lParam );
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvGEWorkspace::HandleMButtonDown
|
|
|
|
Handles the middle mouse down message in the workspace
|
|
================
|
|
*/
|
|
int rvGEWorkspace::HandleMButtonDown ( WPARAM wParam, LPARAM lParam )
|
|
{
|
|
if ( mDragType != rvGESelectionMgr::HT_NONE )
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
mDragPoint.Set ( LOWORD(lParam), HIWORD(lParam) );
|
|
mDragScroll = true;
|
|
SetCursor ( mHandCursor );
|
|
SetCapture ( mWnd );
|
|
|
|
WindowToWorkspace ( mDragPoint );
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvGEWorkspace::HandleMButtonUp
|
|
|
|
Handles the middle mouse up message in the workspace
|
|
================
|
|
*/
|
|
int rvGEWorkspace::HandleMButtonUp ( WPARAM wParam, LPARAM lParam )
|
|
{
|
|
if ( mDragScroll )
|
|
{
|
|
mDragScroll = false;
|
|
ReleaseCapture ( );
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvGEWorkspace::HandleRButtonDown
|
|
|
|
Handles the left mouse down message in the workspace
|
|
================
|
|
*/
|
|
int rvGEWorkspace::HandleRButtonDown ( WPARAM wParam, LPARAM lParam )
|
|
{
|
|
POINT point = { LOWORD(lParam), HIWORD(lParam) };
|
|
HMENU menu;
|
|
|
|
// Add the select menu
|
|
mSelectMenu.Clear ( );
|
|
|
|
// Cache where the menu is being brought up so we can
|
|
// figure out which windows are under the point
|
|
mSelectMenuPos[0] = point.x;
|
|
mSelectMenuPos[1] = point.y;
|
|
WindowToWorkspace ( mSelectMenuPos );
|
|
|
|
// Build a list of all the windows under the menu point
|
|
rvGEWindowWrapper::GetWrapper ( mInterface->GetDesktop() )->EnumChildren ( BuildSelectMenuEnumProc, this );
|
|
|
|
// Add the desktop window always
|
|
mSelectMenu.Append ( mInterface->GetDesktop() );
|
|
|
|
//
|
|
menu = GetSubMenu ( LoadMenu ( mApplication->GetInstance(), MAKEINTRESOURCE(IDR_GUIED_ITEM_POPUP) ), 0 );
|
|
|
|
HMENU popup = CreatePopupMenu ( );
|
|
|
|
int i;
|
|
for ( i = 0; i < mSelectMenu.Num(); i ++ )
|
|
{
|
|
rvGEWindowWrapper* wrapper = rvGEWindowWrapper::GetWrapper ( mSelectMenu[i] );
|
|
AppendMenu ( popup, MF_STRING|MF_ENABLED|(wrapper->IsSelected()?MF_CHECKED:0), ID_GUIED_SELECT_FIRST + i, mSelectMenu[i]->GetName() );
|
|
}
|
|
|
|
InsertMenu ( menu, 1, MF_POPUP|MF_BYPOSITION, (LONG) popup, "Select" );
|
|
|
|
// Bring up the popup menu
|
|
ClientToScreen ( mWnd, &point );
|
|
TrackPopupMenu ( menu, TPM_RIGHTBUTTON|TPM_LEFTALIGN, point.x, point.y, 0, mWnd, NULL );
|
|
|
|
DestroyMenu ( popup );
|
|
DestroyMenu ( menu );
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvGEWorkspace::HandleLButtonDown
|
|
|
|
Handles the left mouse down message in the workspace
|
|
================
|
|
*/
|
|
int rvGEWorkspace::HandleLButtonDown ( WPARAM wParam, LPARAM lParam )
|
|
{
|
|
if ( mDragScroll )
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
idVec2 point ( LOWORD(lParam), HIWORD(lParam) );
|
|
WindowToWorkspace ( point );
|
|
|
|
// Make sure whatever modifications get generated cant be merged into whats already there
|
|
mModifiers.BlockNextMerge ( );
|
|
|
|
mDragPoint.Set ( LOWORD(lParam), HIWORD(lParam) );
|
|
mDragTime = Sys_Milliseconds ( );
|
|
mDragX = true;
|
|
mDragY = true;
|
|
|
|
// If we have selections then start a drag
|
|
if ( mSelections.Num ( ) )
|
|
{
|
|
mDragType = mSelections.HitTest ( mDragPoint.x, mDragPoint.y );
|
|
}
|
|
|
|
rvGEWindowWrapper* wrapper;
|
|
wrapper = rvGEWindowWrapper::GetWrapper ( mInterface->GetDesktop ( ) );
|
|
|
|
idWindow* window = wrapper->WindowFromPoint ( point.x, point.y );
|
|
|
|
// dissallow selection of the desktop.
|
|
if ( gApp.GetOptions().GetIgnoreDesktopSelect() && window == mInterface->GetDesktop ( ) )
|
|
{
|
|
window = NULL;
|
|
}
|
|
|
|
if ( mDragType == rvGESelectionMgr::HT_MOVE || mDragType == rvGESelectionMgr::HT_NONE )
|
|
{
|
|
if ( window )
|
|
{
|
|
bool selected;
|
|
|
|
selected = mSelections.IsSelected ( window );
|
|
|
|
if ( GetAsyncKeyState ( VK_SHIFT ) & 0x8000 )
|
|
{
|
|
if ( !selected )
|
|
{
|
|
mSelections.Add ( window );
|
|
mDragType = rvGESelectionMgr::HT_MOVE;
|
|
}
|
|
else
|
|
{
|
|
mSelections.Remove ( window );
|
|
}
|
|
}
|
|
else if ( !selected && mDragType == rvGESelectionMgr::HT_NONE )
|
|
{
|
|
mSelections.Set ( window );
|
|
mDragType = rvGESelectionMgr::HT_MOVE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
mSelections.Clear ( );
|
|
}
|
|
}
|
|
|
|
if ( mSelections.IsExpression ( ) )
|
|
{
|
|
mDragType = rvGESelectionMgr::HT_SELECT;
|
|
}
|
|
// Windows capture
|
|
else if ( mDragType != rvGESelectionMgr::HT_NONE )
|
|
{
|
|
SetCapture ( mWnd );
|
|
}
|
|
|
|
WindowToWorkspace ( mDragPoint );
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvGEWorkspace::HandleLButtonUp
|
|
|
|
Handles the left mouse up message in the workspace
|
|
================
|
|
*/
|
|
int rvGEWorkspace::HandleLButtonUp ( WPARAM wParam, LPARAM lParam )
|
|
{
|
|
if ( mDragType != rvGESelectionMgr::HT_NONE )
|
|
{
|
|
ReleaseCapture ( );
|
|
mModifiers.BlockNextMerge ( );
|
|
|
|
// Update the transformer
|
|
mApplication->GetTransformer().Update ( );
|
|
}
|
|
|
|
// No more dragging
|
|
mDragType = rvGESelectionMgr::HT_NONE;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvGEWorkspace::HandleLButtonDblClk
|
|
|
|
Handle a double click by opening properties
|
|
================
|
|
*/
|
|
int rvGEWorkspace::HandleLButtonDblClk ( WPARAM wParam, LPARAM lParam )
|
|
{
|
|
EditSelectedProperties ( );
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvGEWorkspace::HandleMouseMove
|
|
|
|
Handles the moving of the mouse for dragging and cursor updating
|
|
================
|
|
*/
|
|
int rvGEWorkspace::HandleMouseMove ( WPARAM wParam, LPARAM lParam )
|
|
{
|
|
idVec2 cursor;
|
|
|
|
cursor.Set ( (short)LOWORD(lParam), (short)HIWORD(lParam) );
|
|
|
|
// Convert the window point to the workspace before updating the
|
|
// cursor with the position
|
|
WindowToWorkspace ( cursor );
|
|
|
|
// Scrolling the window around
|
|
if ( mDragScroll )
|
|
{
|
|
Scroll ( SB_HORZ, mDragPoint.x - cursor.x );
|
|
Scroll ( SB_VERT, mDragPoint.y - cursor.y );
|
|
|
|
SetCursor ( mHandCursor );
|
|
|
|
mDragPoint = cursor;
|
|
|
|
return 0;
|
|
}
|
|
|
|
// If not dragging then just update the cursor and return
|
|
if ( mDragType == rvGESelectionMgr::HT_NONE )
|
|
{
|
|
UpdateCursor ( cursor.x, cursor.y );
|
|
return 0;
|
|
}
|
|
|
|
// Dont allow a drag move start until the button has been down for 100 ms or so
|
|
if ( mDragType == rvGESelectionMgr::HT_MOVE && Sys_Milliseconds() - mDragTime <= 50 )
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
// Handle grid snapping
|
|
if ( gApp.GetOptions().GetGridSnap ( ) )
|
|
{
|
|
cursor.x = (float)(((int)cursor.x + gApp.GetOptions().GetGridWidth()/2) / gApp.GetOptions().GetGridWidth() * gApp.GetOptions().GetGridWidth());
|
|
cursor.y = (float)(((int)cursor.y + gApp.GetOptions().GetGridWidth()/2) / gApp.GetOptions().GetGridWidth() * gApp.GetOptions().GetGridWidth());
|
|
}
|
|
|
|
// If the cursor hasnt moved then there is nothing to update with the drag
|
|
if ( (int) cursor.x == (int) mDragPoint.x && (int) cursor.y == (int) mDragPoint.y )
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
switch ( mDragType )
|
|
{
|
|
case rvGESelectionMgr::HT_MOVE:
|
|
AddModifierMove ( "Move", cursor.x - mDragPoint.x, cursor.y - mDragPoint.y, mApplication->GetOptions().GetGridSnap ( ) );
|
|
break;
|
|
|
|
case rvGESelectionMgr::HT_SIZE_BOTTOM:
|
|
AddModifierSize ( "Size", 0, 0, 0, cursor.y - mDragPoint.y, mApplication->GetOptions().GetGridSnap ( ) );
|
|
break;
|
|
|
|
case rvGESelectionMgr::HT_SIZE_TOP:
|
|
AddModifierSize ( "Size", 0, cursor.y - mDragPoint.y, 0, 0, mApplication->GetOptions().GetGridSnap ( ) );
|
|
break;
|
|
|
|
case rvGESelectionMgr::HT_SIZE_RIGHT:
|
|
AddModifierSize ( "Size", 0, 0, cursor.x - mDragPoint.x, 0, mApplication->GetOptions().GetGridSnap ( ) );
|
|
break;
|
|
|
|
case rvGESelectionMgr::HT_SIZE_LEFT:
|
|
AddModifierSize ( "Size", cursor.x - mDragPoint.x, 0, 0, 0, mApplication->GetOptions().GetGridSnap ( ) );
|
|
break;
|
|
|
|
case rvGESelectionMgr::HT_SIZE_TOPLEFT:
|
|
AddModifierSize ( "Size", cursor.x - mDragPoint.x, cursor.y - mDragPoint.y, 0, 0, mApplication->GetOptions().GetGridSnap ( ) );
|
|
break;
|
|
|
|
case rvGESelectionMgr::HT_SIZE_TOPRIGHT:
|
|
AddModifierSize ( "Size", 0, cursor.y - mDragPoint.y, cursor.x - mDragPoint.x, 0, mApplication->GetOptions().GetGridSnap ( ) );
|
|
break;
|
|
|
|
case rvGESelectionMgr::HT_SIZE_BOTTOMLEFT:
|
|
AddModifierSize ( "Size", cursor.x - mDragPoint.x, 0, 0, cursor.y - mDragPoint.y, mApplication->GetOptions().GetGridSnap ( ) );
|
|
break;
|
|
|
|
case rvGESelectionMgr::HT_SIZE_BOTTOMRIGHT:
|
|
AddModifierSize ( "Size", 0, 0, cursor.x - mDragPoint.x, cursor.y - mDragPoint.y, mApplication->GetOptions().GetGridSnap ( ) );
|
|
break;
|
|
}
|
|
|
|
UpdateCursor ( mDragType );
|
|
|
|
// If the x coordinate has changed then update it
|
|
if ( (int)cursor.x != (int)mDragPoint.x && mDragX )
|
|
{
|
|
mDragPoint.x = cursor.x;
|
|
}
|
|
|
|
// If the y coordinate has changed then update it
|
|
if ( (int)cursor.y != (int)mDragPoint.y && mDragY )
|
|
{
|
|
mDragPoint.y = cursor.y;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvGEWorkspace::HandleKeyDown
|
|
|
|
Handles the the pressing of a key
|
|
================
|
|
*/
|
|
int rvGEWorkspace::HandleKeyDown ( WPARAM wParam, LPARAM lParam )
|
|
{
|
|
bool shift = (GetAsyncKeyState ( VK_SHIFT ) & 0x8000) ? true : false;
|
|
|
|
switch ( wParam )
|
|
{
|
|
case VK_LEFT:
|
|
if ( shift )
|
|
{
|
|
AddModifierSizeNudge ( -1, 0, false );
|
|
}
|
|
else
|
|
{
|
|
AddModifierMoveNudge ( -1, 0, false );
|
|
}
|
|
break;
|
|
|
|
case VK_RIGHT:
|
|
if ( shift )
|
|
{
|
|
AddModifierSizeNudge ( 1, 0, false );
|
|
}
|
|
else
|
|
{
|
|
AddModifierMoveNudge ( 1, 0, false );
|
|
}
|
|
break;
|
|
|
|
case VK_DOWN:
|
|
if ( shift )
|
|
{
|
|
AddModifierSizeNudge ( 0, 1, false );
|
|
}
|
|
else
|
|
{
|
|
AddModifierMoveNudge ( 0, 1, false );
|
|
}
|
|
break;
|
|
|
|
case VK_UP:
|
|
if ( shift )
|
|
{
|
|
AddModifierSizeNudge ( 0, -1, false );
|
|
}
|
|
else
|
|
{
|
|
AddModifierMoveNudge ( 0, -1, false );
|
|
}
|
|
break;
|
|
|
|
case VK_ESCAPE:
|
|
mSelections.Clear ( );
|
|
mApplication->GetNavigator().Update ( );
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvGEWorkspace::WindowToWorkspace
|
|
|
|
Converts the given coordinates in windows space to the workspace's coordinates.
|
|
================
|
|
*/
|
|
idVec2& rvGEWorkspace::WindowToWorkspace ( idVec2& point )
|
|
{
|
|
point.x = (point.x - mRect.x) / mRect.w * SCREEN_WIDTH;
|
|
point.y = (point.y - mRect.y) / mRect.h * SCREEN_HEIGHT;
|
|
|
|
return point;
|
|
}
|
|
|
|
idRectangle& rvGEWorkspace::WindowToWorkspace ( idRectangle& rect )
|
|
{
|
|
rect.x = (rect.x - mRect.x) / mRect.w * SCREEN_WIDTH;
|
|
rect.y = (rect.y - mRect.y) / mRect.h * SCREEN_HEIGHT;
|
|
rect.w = rect.w / mRect.w * SCREEN_WIDTH;
|
|
rect.h = rect.h / mRect.h * SCREEN_HEIGHT;
|
|
|
|
return rect;
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvGEWorkspace::WindowToWorkspace
|
|
|
|
Converts the given workspace coordinates to the windows coordinates.
|
|
================
|
|
*/
|
|
idVec2& rvGEWorkspace::WorkspaceToWindow ( idVec2& point )
|
|
{
|
|
point.x = mRect.x + (point.x / SCREEN_WIDTH * mRect.w);
|
|
point.y = mRect.y + (point.y / SCREEN_HEIGHT * mRect.h);
|
|
|
|
return point;
|
|
}
|
|
|
|
idRectangle& rvGEWorkspace::WorkspaceToWindow ( idRectangle& rect )
|
|
{
|
|
rect.x = mRect.x + (rect.x / SCREEN_WIDTH * mRect.w);
|
|
rect.y = mRect.y + (rect.y / SCREEN_HEIGHT * mRect.h);
|
|
rect.w = rect.w / SCREEN_WIDTH * mRect.w;
|
|
rect.h = rect.h / SCREEN_HEIGHT * mRect.h;
|
|
|
|
return rect;
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvGEWorkspace::ZoomIn
|
|
|
|
Zooms the workspace in by one zoom level
|
|
================
|
|
*/
|
|
rvGEWorkspace::EZoomLevel rvGEWorkspace::ZoomIn ( void )
|
|
{
|
|
mZoom = mZoom + 1;
|
|
if ( mZoom >= ZOOM_MAX )
|
|
{
|
|
mZoom = ZOOM_MAX - 1;
|
|
}
|
|
|
|
UpdateScrollbars ( );
|
|
UpdateTitle ( );
|
|
|
|
InvalidateRect ( mWnd, NULL, FALSE );
|
|
|
|
return (EZoomLevel)mZoom;
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvGEWorkspace::ZoomOut
|
|
|
|
Zooms the workspace out by one level
|
|
================
|
|
*/
|
|
rvGEWorkspace::EZoomLevel rvGEWorkspace::ZoomOut ( void )
|
|
{
|
|
mZoom--;
|
|
if ( mZoom <= ZOOM_MIN )
|
|
{
|
|
mZoom = ZOOM_MIN + 1;
|
|
}
|
|
|
|
UpdateScrollbars ( );
|
|
UpdateTitle ( );
|
|
|
|
InvalidateRect ( mWnd, NULL, FALSE );
|
|
|
|
return (EZoomLevel)mZoom;
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvGEWorkspace::CreateModifier
|
|
|
|
Creates a new modifier of the given type for the given window. This function is called
|
|
specifically from the add modifiers function with the variable args list forwarded.
|
|
================
|
|
*/
|
|
rvGEModifier* rvGEWorkspace::CreateModifier ( EModifierType type, idWindow* window, va_list args )
|
|
{
|
|
rvGEModifier* mod;
|
|
|
|
switch ( type )
|
|
{
|
|
case MOD_DELETE:
|
|
mod = new rvGEDeleteModifier ( "Delete", window );
|
|
break;
|
|
|
|
case MOD_HIDE:
|
|
mod = new rvGEHideModifier ( "Hide", window, true );
|
|
break;
|
|
|
|
case MOD_UNHIDE:
|
|
mod = new rvGEHideModifier ( "Hide", window, false );
|
|
break;
|
|
|
|
case MOD_SEND_BACKWARD:
|
|
mod = new rvGEZOrderModifier ( "Send Backward", window, rvGEZOrderModifier::ZO_BACKWARD );
|
|
break;
|
|
|
|
case MOD_SEND_BACK:
|
|
mod = new rvGEZOrderModifier ( "Send to Back", window, rvGEZOrderModifier::ZO_BACK );
|
|
break;
|
|
|
|
case MOD_BRING_FORWARD:
|
|
mod = new rvGEZOrderModifier ( "Bring Forward", window, rvGEZOrderModifier::ZO_FORWARD );
|
|
break;
|
|
|
|
case MOD_BRING_FRONT:
|
|
mod = new rvGEZOrderModifier ( "Bring to Front", window, rvGEZOrderModifier::ZO_FRONT );
|
|
break;
|
|
|
|
default:
|
|
mod = NULL;
|
|
break;
|
|
}
|
|
|
|
return mod;
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvGEWorkspace::AddModifiers
|
|
|
|
Add the specific modifier for the given window
|
|
================
|
|
*/
|
|
void rvGEWorkspace::AddModifiers ( idWindow* window, EModifierType type, ... )
|
|
{
|
|
va_list args;
|
|
|
|
va_start(args,type) ;
|
|
mModifiers.Append ( CreateModifier ( type, window, args ) );
|
|
va_end (args) ;
|
|
|
|
SetModified ( true );
|
|
}
|
|
|
|
void rvGEWorkspace::AddModifiers ( EModifierType type, ... )
|
|
{
|
|
va_list args;
|
|
|
|
// Nothing to move if there is no selection
|
|
if ( !mSelections.Num ( ) )
|
|
{
|
|
return;
|
|
}
|
|
// More than one selection requires a modifier group
|
|
else if ( mSelections.Num ( ) > 1 )
|
|
{
|
|
rvGEModifierGroup* group = new rvGEModifierGroup;
|
|
int i;
|
|
|
|
for ( i = 0; i < mSelections.Num(); i ++ )
|
|
{
|
|
va_start(args,type);
|
|
group->Append ( CreateModifier ( type, mSelections[i], args ) );
|
|
va_end (args);
|
|
}
|
|
|
|
mModifiers.Append ( group );
|
|
}
|
|
// Single modifier
|
|
else
|
|
{
|
|
va_start(args,type) ;
|
|
mModifiers.Append ( CreateModifier ( type, mSelections[0], args ) );
|
|
va_end (args) ;
|
|
}
|
|
|
|
SetModified ( true );
|
|
}
|
|
|
|
bool rvGEWorkspace::BuildSelectMenuEnumProc ( rvGEWindowWrapper* wrapper, void* data )
|
|
{
|
|
rvGEWorkspace* workspace;
|
|
|
|
workspace = (rvGEWorkspace*) data;
|
|
assert ( workspace );
|
|
|
|
if ( !wrapper )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
wrapper->EnumChildren ( BuildSelectMenuEnumProc, data );
|
|
|
|
if ( wrapper->IsDeleted ( ) || wrapper->IsHidden ( ) )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if ( wrapper->GetScreenRect ( ).Contains ( workspace->mSelectMenuPos[0], workspace->mSelectMenuPos[1] ) )
|
|
{
|
|
workspace->mSelectMenu.Append ( wrapper->GetWindow ( ));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool rvGEWorkspace::ShowAllEnumProc ( rvGEWindowWrapper* wrapper, void* data )
|
|
{
|
|
rvGEModifierGroup* group = (rvGEModifierGroup*) data;
|
|
|
|
wrapper->EnumChildren ( ShowAllEnumProc, data );
|
|
|
|
if ( wrapper->IsHidden ( ) )
|
|
{
|
|
group->Append ( new rvGEHideModifier ( "Show Hidden", wrapper->GetWindow ( ), false ) );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void rvGEWorkspace::AddModifierShowAll ( void )
|
|
{
|
|
rvGEModifierGroup* group = new rvGEModifierGroup;
|
|
|
|
rvGEWindowWrapper::GetWrapper( mInterface->GetDesktop ( ) )->EnumChildren ( ShowAllEnumProc, group );
|
|
|
|
if ( !group->GetCount ( ) )
|
|
{
|
|
delete group;
|
|
}
|
|
else
|
|
{
|
|
mModifiers.Append ( group );
|
|
}
|
|
|
|
mApplication->GetNavigator().Refresh ( );
|
|
}
|
|
|
|
void rvGEWorkspace::DeleteSelected ( void )
|
|
{
|
|
AddModifiers ( MOD_DELETE );
|
|
mSelections.Clear ( );
|
|
mApplication->GetNavigator().Update ( );
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvGEWorkspace::NewWindow
|
|
|
|
Create a new window
|
|
================
|
|
*/
|
|
idWindow* rvGEWorkspace::NewWindow ( idDict* state, rvGEWindowWrapper::EWindowType type )
|
|
{
|
|
idWindow* window = new idWindow ( mInterface->GetDesktop()->GetDC(), mInterface );
|
|
rvGEWindowWrapper* wrapper;
|
|
int count;
|
|
idStr baseName;
|
|
|
|
switch ( type )
|
|
{
|
|
case rvGEWindowWrapper::WT_NORMAL:
|
|
window = new idWindow ( mInterface->GetDesktop()->GetDC(), mInterface );
|
|
break;
|
|
|
|
case rvGEWindowWrapper::WT_BIND:
|
|
window = new idBindWindow ( mInterface->GetDesktop()->GetDC(), mInterface );
|
|
break;
|
|
|
|
case rvGEWindowWrapper::WT_RENDER:
|
|
window = new idRenderWindow ( mInterface->GetDesktop()->GetDC(), mInterface );
|
|
break;
|
|
|
|
case rvGEWindowWrapper::WT_CHOICE:
|
|
window = new idChoiceWindow ( mInterface->GetDesktop()->GetDC(), mInterface );
|
|
break;
|
|
|
|
case rvGEWindowWrapper::WT_EDIT:
|
|
window = new idEditWindow ( mInterface->GetDesktop()->GetDC(), mInterface );
|
|
break;
|
|
|
|
default:
|
|
assert ( false );
|
|
return NULL;
|
|
}
|
|
|
|
baseName = state ? state->GetString("name","unnamed") : "unnamed";
|
|
baseName.StripQuotes ( );
|
|
|
|
count = 0;
|
|
if ( mInterface->GetDesktop()->FindChildByName ( baseName ) )
|
|
{
|
|
count = 1;
|
|
while ( 1 )
|
|
{
|
|
drawWin_t* dw = mInterface->GetDesktop()->FindChildByName ( va("%s%d",baseName.c_str(),count) );
|
|
if ( !dw )
|
|
{
|
|
break;
|
|
}
|
|
assert ( dw->win );
|
|
wrapper = rvGEWindowWrapper::GetWrapper ( dw->win );
|
|
if ( wrapper && wrapper->IsDeleted ( ) )
|
|
{
|
|
break;
|
|
}
|
|
count++;
|
|
}
|
|
}
|
|
|
|
idStr winName;
|
|
idStr winTemplate;
|
|
|
|
if ( count )
|
|
{
|
|
winName = va("%s%d", baseName.c_str(), count );
|
|
}
|
|
else
|
|
{
|
|
winName = baseName;
|
|
}
|
|
winTemplate = winName + " { }";
|
|
|
|
idParser src( winTemplate, winTemplate.Length(), "", LEXFL_ALLOWMULTICHARLITERALS | LEXFL_NOSTRINGCONCAT | LEXFL_ALLOWBACKSLASHSTRINGCONCAT );
|
|
window->Parse ( &src );
|
|
|
|
wrapper = rvGEWindowWrapper::GetWrapper ( window );
|
|
|
|
if ( state )
|
|
{
|
|
wrapper->SetState ( *state );
|
|
}
|
|
|
|
wrapper->SetStateKey ( "name", winName );
|
|
wrapper->Finish ( );
|
|
|
|
SetModified ( true );
|
|
|
|
|
|
return window;
|
|
}
|
|
|
|
idWindow* rvGEWorkspace::AddWindow ( rvGEWindowWrapper::EWindowType type )
|
|
{
|
|
idWindow* window;
|
|
idDict state;
|
|
|
|
state.Set ( "rect", "0,0,100,100" );
|
|
state.Set ( "visible", "1" );
|
|
|
|
window = NewWindow ( &state, type );
|
|
assert ( window );
|
|
|
|
mModifiers.Append ( new rvGEInsertModifier ( "New", window, mInterface->GetDesktop(), NULL ) );
|
|
|
|
mSelections.Set ( window );
|
|
mApplication->GetNavigator().Update ( );
|
|
mApplication->GetTransformer().Update ( );
|
|
mApplication->GetProperties().Update ( );
|
|
|
|
return window;
|
|
}
|
|
|
|
bool rvGEWorkspace::EditSelectedProperties ( void )
|
|
{
|
|
if ( !mSelections.Num ( ) || mSelections.Num() > 1 )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
idDict dict;
|
|
if ( GEItemPropsDlg_DoModal ( mWnd, mSelections[0], dict ) )
|
|
{
|
|
mModifiers.Append ( new rvGEStateModifier ( "Item Properties", mSelections[0], dict ) );
|
|
SetModified ( true );
|
|
}
|
|
|
|
mApplication->GetNavigator().Update ( );
|
|
mApplication->GetTransformer().Update ( );
|
|
mApplication->GetProperties().Update ( );
|
|
|
|
return true;
|
|
}
|
|
|
|
bool rvGEWorkspace::EditSelectedScripts ( void )
|
|
{
|
|
if ( GEItemScriptsDlg_DoModal ( mWnd, mSelections[0] ) )
|
|
{
|
|
gApp.GetNavigator().Refresh ( );
|
|
SetModified ( true );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void rvGEWorkspace::BringSelectedForward ( void )
|
|
{
|
|
AddModifiers ( MOD_BRING_FORWARD );
|
|
mApplication->GetNavigator().Update ( );
|
|
}
|
|
|
|
void rvGEWorkspace::BringSelectedToFront ( void )
|
|
{
|
|
AddModifiers ( MOD_BRING_FRONT );
|
|
mApplication->GetNavigator().Update ( );
|
|
}
|
|
|
|
void rvGEWorkspace::SendSelectedToBack ( void )
|
|
{
|
|
AddModifiers ( MOD_SEND_BACK );
|
|
mApplication->GetNavigator().Update ( );
|
|
}
|
|
|
|
void rvGEWorkspace::SendSelectedBackward ( void )
|
|
{
|
|
AddModifiers ( MOD_SEND_BACKWARD );
|
|
mApplication->GetNavigator().Update ( );
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvGEWorkspace::MakeSelectedSameSize
|
|
|
|
Align the selected items to the first one using the given align type
|
|
================
|
|
*/
|
|
void rvGEWorkspace::MakeSelectedSameSize ( bool changeWidth, bool changeHeight )
|
|
{
|
|
rvGEModifierGroup* group;
|
|
idRectangle rectTo;
|
|
int i;
|
|
|
|
group = new rvGEModifierGroup ( );
|
|
|
|
rectTo = rvGEWindowWrapper::GetWrapper ( mSelections[0] )->GetClientRect ( );
|
|
|
|
for ( i = 1; i < mSelections.Num(); i ++ )
|
|
{
|
|
idRectangle rectFrom;
|
|
float width = 0;
|
|
float height = 0;
|
|
|
|
rectFrom = rvGEWindowWrapper::GetWrapper(mSelections[i])->GetClientRect ();
|
|
|
|
if ( changeWidth )
|
|
{
|
|
width = rectTo.w - rectFrom.w;
|
|
}
|
|
|
|
if ( changeHeight )
|
|
{
|
|
height = rectTo.h - rectFrom.h;
|
|
}
|
|
|
|
group->Append ( new rvGESizeModifier ( "Make Same Size", mSelections[i], 0, 0, width, height ) );
|
|
}
|
|
|
|
mModifiers.Append ( group );
|
|
|
|
// Cant merge alignments
|
|
mModifiers.BlockNextMerge ( );
|
|
|
|
SetModified ( true );
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvGEWorkspace::AlignSelected
|
|
|
|
Align the selected items to the first one using the given align type
|
|
================
|
|
*/
|
|
void rvGEWorkspace::AlignSelected ( EItemAlign align )
|
|
{
|
|
static const char* alignNames[]={"Lefts","Centers","Rights","Tops","Middles","Bottoms" };
|
|
int i;
|
|
idStr modName;
|
|
rvGEModifierGroup* group;
|
|
|
|
assert ( mSelections.Num() > 1 );
|
|
|
|
modName = "Align " + idStr(alignNames[align]);
|
|
|
|
group = new rvGEModifierGroup ( );
|
|
|
|
idRectangle rectTo;
|
|
rectTo = rvGEWindowWrapper::GetWrapper ( mSelections[0] )->GetScreenRect ( );
|
|
|
|
// Everything gets aligned to the first selection so run
|
|
// through all other selections and move them.
|
|
for ( i = 1; i < mSelections.Num(); i ++ )
|
|
{
|
|
float x;
|
|
float y;
|
|
idRectangle rectFrom;
|
|
|
|
rectFrom = rvGEWindowWrapper::GetWrapper ( mSelections[i] )->GetScreenRect ( );
|
|
|
|
switch ( align )
|
|
{
|
|
case ALIGN_LEFTS:
|
|
x = rectTo[0] - rectFrom[0];
|
|
y = 0;
|
|
break;
|
|
|
|
case ALIGN_RIGHTS:
|
|
x = (rectTo[0]+rectTo[2]) - (rectFrom[0]+rectFrom[2]);
|
|
y = 0;
|
|
break;
|
|
|
|
case ALIGN_CENTERS:
|
|
x = (rectTo[0]+rectTo[2]/2) - (rectFrom[0]+rectFrom[2]/2);
|
|
y = 0;
|
|
break;
|
|
|
|
case ALIGN_TOPS:
|
|
y = rectTo[1] - rectFrom[1];
|
|
x = 0;
|
|
break;
|
|
|
|
case ALIGN_BOTTOMS:
|
|
x = 0;
|
|
y = (rectTo[1]+rectTo[3]) - (rectFrom[1]+rectFrom[3]);
|
|
break;
|
|
|
|
case ALIGN_MIDDLES:
|
|
x = 0;
|
|
y = (rectTo[1]+rectTo[3]/2) - (rectFrom[1]+rectFrom[3]/2);
|
|
break;
|
|
|
|
default:
|
|
assert ( false );
|
|
break;
|
|
}
|
|
|
|
group->Append ( new rvGEMoveModifier ( modName, mSelections[i], x, y ) );
|
|
}
|
|
|
|
mModifiers.Append ( group );
|
|
|
|
// Cant merge alignments
|
|
mModifiers.BlockNextMerge ( );
|
|
|
|
SetModified ( true );
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvGEWorkspace::AddModifierMove
|
|
|
|
Adds a move modifier with the given offsets
|
|
================
|
|
*/
|
|
void rvGEWorkspace::AddModifierMove ( const char* modName, float x, float y, bool snap )
|
|
{
|
|
idRectangle scaleRect;
|
|
idRectangle newRect;
|
|
|
|
scaleRect = mSelections.GetRect ( );
|
|
WindowToWorkspace ( scaleRect );
|
|
newRect = scaleRect;
|
|
newRect.x += x;
|
|
newRect.y += y;
|
|
|
|
if ( snap )
|
|
{
|
|
gApp.GetOptions ().SnapRectToGrid ( newRect, true, true, false, false );
|
|
}
|
|
|
|
rvGEModifierGroup* group = new rvGEModifierGroup;
|
|
for ( int i = 0; i < mSelections.Num(); i ++ )
|
|
{
|
|
if ( !mSelections[i]->GetParent ( ) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// IF the parent window is being moved around as well then dont move this one.
|
|
if ( rvGEWindowWrapper::GetWrapper ( mSelections[i]->GetParent ( ) )->IsSelected ( ) )
|
|
{
|
|
// We still need the modifier there so the selection can be restored and
|
|
// so the rectangle gets updated
|
|
group->Append ( new rvGEMoveModifier ( modName, mSelections[i], 0, 0 ) );
|
|
continue;
|
|
}
|
|
|
|
group->Append ( new rvGEMoveModifier ( modName, mSelections[i], newRect.x-scaleRect.x, newRect.y-scaleRect.y ) );
|
|
}
|
|
|
|
mModifiers.Append ( group );
|
|
|
|
SetModified ( true );
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvGEWorkspace::AddModifierSize
|
|
|
|
Adds a size modifier with the given offsets
|
|
================
|
|
*/
|
|
void rvGEWorkspace::AddModifierSize ( const char* modName, float l, float t, float r, float b, bool snap )
|
|
{
|
|
idRectangle scaleRect;
|
|
idRectangle sizeRect;
|
|
idRectangle newRect;
|
|
|
|
scaleRect = mSelections.GetRect ( );
|
|
WindowToWorkspace ( scaleRect );
|
|
newRect = scaleRect;
|
|
newRect.x += l;
|
|
newRect.y += t;
|
|
newRect.w += (r - l);
|
|
newRect.h += (b - t);
|
|
|
|
// Restrict sizing below 1 width
|
|
if ( newRect.w <= 1 )
|
|
{
|
|
newRect.x = newRect.x - (l ? (1 - newRect.w) : 0);
|
|
mDragPoint.x = newRect.x;
|
|
newRect.w = 1;
|
|
mDragX = false;
|
|
}
|
|
else
|
|
{
|
|
mDragX = true;
|
|
}
|
|
|
|
// Restrict sizing below 1 height
|
|
if ( newRect.h <= 1 )
|
|
{
|
|
newRect.y = newRect.y - (t ? (1 - newRect.h) : 0);
|
|
mDragPoint.y = newRect.y;
|
|
newRect.h = 1;
|
|
mDragY = false;
|
|
}
|
|
else
|
|
{
|
|
mDragY = true;
|
|
}
|
|
|
|
if ( snap )
|
|
{
|
|
gApp.GetOptions ().SnapRectToGrid ( newRect, l != 0.0f, t != 0.0f, r != 0.0f, b != 0.0f );
|
|
}
|
|
|
|
rvGEModifierGroup* group = new rvGEModifierGroup;
|
|
for ( int i = 0; i < mSelections.Num(); i ++ )
|
|
{
|
|
sizeRect = rvGEWindowWrapper::GetWrapper ( mSelections[i] )->GetScreenRect ( );
|
|
|
|
l = (newRect.x + ((sizeRect.x - scaleRect.x) / scaleRect.w) * newRect.w) - sizeRect.x;
|
|
t = (newRect.y + ((sizeRect.y - scaleRect.y) / scaleRect.h) * newRect.h) - sizeRect.y;
|
|
r = (sizeRect.w / scaleRect.w * newRect.w) - sizeRect.w + l;
|
|
b = (sizeRect.h / scaleRect.h * newRect.h) - sizeRect.h + t;
|
|
|
|
// This is sorta crufty but needs to be done. When a parent is being sized at the same
|
|
// time as a child you will get double movement because the child is relative to the parent. Therefore
|
|
// we need to subtract out the closest parents sizing.
|
|
idWindow* parent = mSelections[i];
|
|
while ( NULL != (parent = parent->GetParent ( ) ) )
|
|
{
|
|
rvGEWindowWrapper* pwrapper = rvGEWindowWrapper::GetWrapper ( parent );
|
|
float offset;
|
|
|
|
if ( !pwrapper->IsSelected ( ) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
sizeRect = pwrapper->GetScreenRect ( );
|
|
|
|
// Subtract out the left and right modifications
|
|
offset = ((newRect.x + ((sizeRect.x - scaleRect.x) / scaleRect.w) * newRect.w) - sizeRect.x);
|
|
l -= offset;
|
|
r -= offset;
|
|
|
|
// Subtract out the top and bottom modifications
|
|
offset = ((newRect.y + ((sizeRect.y - scaleRect.y) / scaleRect.h) * newRect.h) - sizeRect.y);
|
|
t -= offset;
|
|
b -= offset;
|
|
|
|
break;
|
|
}
|
|
|
|
group->Append ( new rvGESizeModifier ( modName, mSelections[i], l, t, r, b ) );
|
|
}
|
|
|
|
mModifiers.Append ( group );
|
|
|
|
SetModified ( true );
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvGEWorkspace::MakeSelectedAChild
|
|
|
|
Makes the selected windows a child of the first selected window
|
|
================
|
|
*/
|
|
void rvGEWorkspace::MakeSelectedAChild ( void )
|
|
{
|
|
rvGEModifierGroup* group;
|
|
int i;
|
|
|
|
if ( !rvGEWindowWrapper::GetWrapper ( mSelections[0] )->CanHaveChildren ( ) )
|
|
{
|
|
gApp.MessageBox ( "Cannot add children to an htmlDef item", MB_OK|MB_ICONERROR );
|
|
return;
|
|
}
|
|
|
|
group = new rvGEModifierGroup;
|
|
|
|
for ( i = 1; i < mSelections.Num(); i ++ )
|
|
{
|
|
if ( mSelections[i]->GetParent ( ) == mSelections[0] )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if ( !mSelections[i]->GetParent ( ) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
group->Append ( new rvGEInsertModifier ( "Make Child", mSelections[i], mSelections[0], NULL ) );
|
|
}
|
|
|
|
mModifiers.Append ( group );
|
|
|
|
// Navigator needs an update since the ordering has changed
|
|
gApp.GetNavigator().Update ( );
|
|
|
|
SetModified ( true );
|
|
}
|
|
|
|
void rvGEWorkspace::Copy ( void )
|
|
{
|
|
int i;
|
|
|
|
// Clear the current clipboard
|
|
for ( i = 0; i < mClipboard.Num(); i ++ )
|
|
{
|
|
delete mClipboard[i];
|
|
}
|
|
|
|
mClipboard.Clear ( );
|
|
|
|
for ( i = 0; i < mSelections.Num(); i ++ )
|
|
{
|
|
rvGEWindowWrapper* wrapper = rvGEWindowWrapper::GetWrapper ( mSelections[i] );
|
|
assert ( wrapper );
|
|
|
|
rvGEClipboardItem* item = new rvGEClipboardItem;
|
|
item->mStateDict = wrapper->GetStateDict ( );
|
|
item->mScriptDict = wrapper->GetScriptDict ( );
|
|
item->mVarDict = wrapper->GetVariableDict ( );
|
|
|
|
item->mStateDict.Set ( "windowType", rvGEWindowWrapper::WindowTypeToString ( wrapper->GetWindowType ( ) ) );
|
|
|
|
mClipboard.Append ( item );
|
|
}
|
|
}
|
|
|
|
void rvGEWorkspace::Paste ( void )
|
|
{
|
|
int i;
|
|
|
|
rvGEModifierGroup* group = new rvGEModifierGroup;
|
|
|
|
mSelections.Clear ( );
|
|
|
|
for ( i = 0; i < mClipboard.Num(); i ++ )
|
|
{
|
|
idDict state;
|
|
rvGEWindowWrapper::EWindowType type;
|
|
|
|
state.Copy ( mClipboard[i]->mStateDict );
|
|
type = rvGEWindowWrapper::StringToWindowType ( state.GetString ( "windowType", "windowDef" ) );
|
|
state.Delete ( "windowType" );
|
|
|
|
idWindow* window = NewWindow ( &state, type );
|
|
group->Append ( new rvGEInsertModifier ( "Paste", window, mInterface->GetDesktop(), NULL ) );
|
|
mSelections.Add ( window );
|
|
|
|
rvGEWindowWrapper::GetWrapper ( window )->GetScriptDict ( ) = mClipboard[i]->mScriptDict;
|
|
rvGEWindowWrapper::GetWrapper ( window )->GetVariableDict ( ) = mClipboard[i]->mVarDict;
|
|
}
|
|
|
|
mModifiers.Append ( group );
|
|
|
|
mApplication->GetNavigator().Update ( );
|
|
|
|
SetModified ( true );
|
|
}
|
|
|
|
void rvGEWorkspace::HideSelected ( void )
|
|
{
|
|
AddModifiers ( MOD_HIDE );
|
|
mSelections.Clear ( );
|
|
mApplication->GetNavigator().Refresh ( );
|
|
}
|
|
|
|
void rvGEWorkspace::UnhideSelected ( void )
|
|
{
|
|
AddModifiers ( MOD_UNHIDE );
|
|
mApplication->GetNavigator().Refresh ( );
|
|
}
|
|
|
|
void rvGEWorkspace::HideWindow ( idWindow* window )
|
|
{
|
|
AddModifiers ( window, MOD_HIDE );
|
|
mApplication->GetNavigator().Refresh ( );
|
|
}
|
|
|
|
void rvGEWorkspace::UnhideWindow ( idWindow* window )
|
|
{
|
|
AddModifiers ( window, MOD_UNHIDE );
|
|
mApplication->GetNavigator().Refresh ( );
|
|
}
|
|
|
|
/*
|
|
================
|
|
rvGEWorkspace::SetModified
|
|
|
|
Sets the modified state of the window and if source control is enabled it
|
|
will attempt to check out the file
|
|
================
|
|
*/
|
|
void rvGEWorkspace::SetModified ( bool mod )
|
|
{
|
|
if ( mModified != mod )
|
|
{
|
|
|
|
mModified = mod;
|
|
UpdateTitle ( );
|
|
|
|
}
|
|
}
|