Quake-III-Arena

XYWnd.cpp (89114B)

---

 /*
 ===========================================================================
 Copyright (C) 1999-2005 Id Software, Inc.
 
 This file is part of Quake III Arena source code.
 
 Quake III Arena 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 2 of the License,
 or (at your option) any later version.
 
 Quake III Arena 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 Foobar; if not, write to the Free Software
 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 ===========================================================================
 */
 // XYWnd.cpp : implementation file
 //
 // QERadiant
 //
 // 
 
 #include "stdafx.h"
 #include "Radiant.h"
 #include "XYWnd.h"
 #include "qe3.h"
 #include "PrefsDlg.h"
 #include "DialogInfo.h"
 #include "splines/splines.h"
 
 #ifdef _DEBUG
 #define new DEBUG_NEW
 #undef THIS_FILE
 static char THIS_FILE[] = __FILE__;
 #endif
 
 #define	PAGEFLIPS	2
 
 
 const char* g_pDimStrings[] = {"x:%.f", "y:%.f", "z:%.f"};
 const char* g_pOrgStrings[] = {"(x:%.f  y:%.f)", "(x:%.f  z:%.f)", "(y:%.f  z:%.f)"};
 CString g_strDim;
 CString g_strStatus;
 
 bool g_bCrossHairs = false;
 bool g_bScaleMode;
 int g_nScaleHow;
 bool g_bRotateMode;
 bool g_bClipMode;
 bool g_bRogueClipMode;
 bool g_bSwitch;
 CClipPoint g_Clip1;
 CClipPoint g_Clip2;
 CClipPoint g_Clip3;
 CClipPoint* g_pMovingClip;
 brush_t g_brFrontSplits;
 brush_t g_brBackSplits;
 
 brush_t g_brClipboard;
 brush_t g_brUndo;
 entity_t	g_enClipboard;
 
 vec3_t g_vRotateOrigin;
 vec3_t g_vRotation;
 
 bool g_bPathMode;
 CClipPoint g_PathPoints[256];
 CClipPoint* g_pMovingPath;
 int g_nPathCount;
 int g_nPathLimit;
 
 bool g_bSmartGo;
 
 bool g_bPointMode;
 CClipPoint g_PointPoints[512];
 CClipPoint* g_pMovingPoint;
 int g_nPointCount;
 int g_nPointLimit;
 
 
 const int XY_LEFT = 0x01;
 const int XY_RIGHT = 0x02;
 const int XY_UP = 0x04;
 const int XY_DOWN = 0x08;
 
 PFNPathCallback* g_pPathFunc = NULL;
 
 void AcquirePath(int nCount, PFNPathCallback* pFunc)
 {
   g_nPathCount = 0;
   g_nPathLimit = nCount;
   g_pPathFunc = pFunc;
   g_bPathMode = true;
 }
 
 
 CPtrArray g_ptrMenus;
 
 CMemFile g_Clipboard(4096);
 CMemFile g_PatchClipboard(4096);
 
 extern int pressx;
 extern int pressy;
 
 
 /////////////////////////////////////////////////////////////////////////////
 // CXYWnd
 
 IMPLEMENT_DYNCREATE(CXYWnd, CWnd);
 
 CXYWnd::CXYWnd()
 {
   g_brClipboard.next = &g_brClipboard;
   g_brUndo.next = &g_brUndo;
   g_nScaleHow = 0;
   g_bRotateMode = false;
   g_bClipMode = false;
   g_bRogueClipMode = false;
   g_bSwitch = true;
   g_pMovingClip = NULL;
   g_pMovingPath = NULL;
   g_brFrontSplits.next = &g_brFrontSplits;
   g_brBackSplits.next = &g_brBackSplits;
   m_bActive = false;
   //m_bTiming = true;
   m_bTiming = false;
   m_bRButtonDown = false;
   m_nUpdateBits = W_XY;
   g_bPathMode = false;
   g_nPathCount = 0;
   g_nPathLimit = 0;
   m_nTimerID = -1;
   XY_Init();
 }
 
 CXYWnd::~CXYWnd()
 {
   int nSize = g_ptrMenus.GetSize();
   while (nSize > 0)
   {
     CMenu* pMenu = reinterpret_cast<CMenu*>(g_ptrMenus.GetAt(nSize-1));
     ASSERT(pMenu);
     pMenu->DestroyMenu();
     delete pMenu;
     nSize--;
   }
   g_ptrMenus.RemoveAll();
   m_mnuDrop.DestroyMenu();
 }
 
 
 BEGIN_MESSAGE_MAP(CXYWnd, CWnd)
 	//{{AFX_MSG_MAP(CXYWnd)
 	ON_WM_CREATE()
 	ON_WM_LBUTTONDOWN()
 	ON_WM_MBUTTONDOWN()
 	ON_WM_RBUTTONDOWN()
 	ON_WM_LBUTTONUP()
 	ON_WM_MBUTTONUP()
 	ON_WM_RBUTTONUP()
 	ON_WM_MOUSEMOVE()
 	ON_WM_PAINT()
 	ON_WM_KEYDOWN()
 	ON_WM_SIZE()
 	ON_WM_DESTROY()
 	ON_COMMAND(ID_SELECT_MOUSEROTATE, OnSelectMouserotate)
 	ON_WM_TIMER()
 	ON_WM_KEYUP()
 	ON_WM_NCCALCSIZE()
 	ON_WM_KILLFOCUS()
 	ON_WM_SETFOCUS()
 	ON_WM_CLOSE()
 	ON_COMMAND(ID_SELECTION_MAKE_DETAIL, CMainFrame::OnSelectionMakeDetail)
 	ON_COMMAND(ID_SELECTION_MAKE_STRUCTURAL, CMainFrame::OnSelectionMakeStructural)
 	ON_COMMAND(ID_SELECTION_SELECTCOMPLETETALL, CMainFrame::OnSelectionSelectcompletetall)
 	ON_COMMAND(ID_SELECTION_SELECTINSIDE, CMainFrame::OnSelectionSelectinside)
 	ON_COMMAND(ID_SELECTION_SELECTPARTIALTALL, CMainFrame::OnSelectionSelectpartialtall)
 	ON_COMMAND(ID_SELECTION_SELECTTOUCHING, CMainFrame::OnSelectionSelecttouching)
 	ON_COMMAND(ID_SELECTION_UNGROUPENTITY, CMainFrame::OnSelectionUngroupentity)
 	//}}AFX_MSG_MAP
   ON_COMMAND_RANGE(ID_ENTITY_START, ID_ENTITY_END, OnEntityCreate)
 END_MESSAGE_MAP()
 
 
 /////////////////////////////////////////////////////////////////////////////
 // CXYWnd message handlers
 LONG WINAPI XYWndProc(HWND, UINT, WPARAM, LPARAM);
 BOOL CXYWnd::PreCreateWindow(CREATESTRUCT& cs) 
 {
   WNDCLASS wc;
   HINSTANCE hInstance = AfxGetInstanceHandle();
   if (::GetClassInfo(hInstance, XY_WINDOW_CLASS, &wc) == FALSE)
   {
     // Register a new class
   	memset (&wc, 0, sizeof(wc));
     wc.style         = CS_NOCLOSE | CS_OWNDC;
     wc.lpszClassName = XY_WINDOW_CLASS;
     wc.hCursor       = NULL; //LoadCursor (NULL,IDC_ARROW);
     wc.lpfnWndProc   = ::DefWindowProc;
     if (AfxRegisterClass(&wc) == FALSE)
       Error ("CCamWnd RegisterClass: failed");
   }
 
   cs.lpszClass = XY_WINDOW_CLASS;
   cs.lpszName = "VIEW";
   if (cs.style != QE3_CHILDSTYLE)
     cs.style = QE3_SPLITTER_STYLE;
 
 	return CWnd::PreCreateWindow(cs);
 }
 
 HDC   s_hdcXY;
 HGLRC s_hglrcXY;
 
 static unsigned s_stipple[32] =
 {
 	0xaaaaaaaa, 0x55555555,0xaaaaaaaa, 0x55555555,
 	0xaaaaaaaa, 0x55555555,0xaaaaaaaa, 0x55555555,
 	0xaaaaaaaa, 0x55555555,0xaaaaaaaa, 0x55555555,
 	0xaaaaaaaa, 0x55555555,0xaaaaaaaa, 0x55555555,
 	0xaaaaaaaa, 0x55555555,0xaaaaaaaa, 0x55555555,
 	0xaaaaaaaa, 0x55555555,0xaaaaaaaa, 0x55555555,
 	0xaaaaaaaa, 0x55555555,0xaaaaaaaa, 0x55555555,
 	0xaaaaaaaa, 0x55555555,0xaaaaaaaa, 0x55555555,
 };
 
 /*
 ============
 WXY_WndProc
 ============
 */
 LONG WINAPI XYWndProc (
     HWND    hWnd,
     UINT    uMsg,
     WPARAM  wParam,
     LPARAM  lParam)
 {
     switch (uMsg)
     {
 	case WM_DESTROY:
 		QEW_StopGL( hWnd, s_hglrcXY, s_hdcXY );
 		return 0;
 
 	case WM_NCCALCSIZE:// don't let windows copy pixels
 		DefWindowProc (hWnd, uMsg, wParam, lParam);
 		return WVR_REDRAW;
 
 	case WM_KILLFOCUS:
 	case WM_SETFOCUS:
 		SendMessage( hWnd, WM_NCACTIVATE, uMsg == WM_SETFOCUS, 0 );
 		return 0;
 
    	case WM_CLOSE:
         DestroyWindow (hWnd);
 		return 0;
     }
 
 	return DefWindowProc (hWnd, uMsg, wParam, lParam);
 }
 
 
 static void WXY_InitPixelFormat( PIXELFORMATDESCRIPTOR *pPFD )
 {
 	memset( pPFD, 0, sizeof( *pPFD ) );
 
 	pPFD->nSize    = sizeof( PIXELFORMATDESCRIPTOR );
 	pPFD->nVersion = 1;
 	pPFD->dwFlags  = PFD_DOUBLEBUFFER | PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW;
 	pPFD->iPixelType = PFD_TYPE_RGBA;
 	pPFD->cColorBits = 24;
 	pPFD->cDepthBits = 32;
 	pPFD->iLayerType = PFD_MAIN_PLANE;
 
 }
 
 void WXY_Print( void )
 {
 	DOCINFO di;
 
 	PRINTDLG pd;
 
 	/*
 	** initialize the PRINTDLG struct and execute it
 	*/
 	memset( &pd, 0, sizeof( pd ) );
 	pd.lStructSize = sizeof( pd );
 	pd.hwndOwner = g_qeglobals.d_hwndXY;
 	pd.Flags = PD_RETURNDC;
 	pd.hInstance = 0;
 	if ( !PrintDlg( &pd ) || !pd.hDC )
 	{
 		MessageBox( g_qeglobals.d_hwndMain, "Could not PrintDlg()", "QE4 Print Error", MB_OK | MB_ICONERROR );
 		return;
 	}
 
 	/*
 	** StartDoc
 	*/
 	memset( &di, 0, sizeof( di ) );
 	di.cbSize = sizeof( di );
 	di.lpszDocName = "QE4";
 	if ( StartDoc( pd.hDC, &di ) <= 0 )
 	{
 		MessageBox( g_qeglobals.d_hwndMain, "Could not StartDoc()", "QE4 Print Error", MB_OK | MB_ICONERROR );
 		return;
 	}
 
 	/*
 	** StartPage
 	*/
 	if ( StartPage( pd.hDC ) <= 0 )
 	{
 		MessageBox( g_qeglobals.d_hwndMain, "Could not StartPage()", "QE4 Print Error", MB_OK | MB_ICONERROR );
 		return;
 	}
 
 	/*
 	** read pixels from the XY window
 	*/
 	{
 		int bmwidth = 320, bmheight = 320;
 		int pwidth, pheight;
 
 		RECT r;
 
 		GetWindowRect( g_qeglobals.d_hwndXY, &r );
 
 		bmwidth  = r.right - r.left;
 		bmheight = r.bottom - r.top;
 
 		pwidth  = GetDeviceCaps( pd.hDC, PHYSICALWIDTH ) - GetDeviceCaps( pd.hDC, PHYSICALOFFSETX );
 		pheight = GetDeviceCaps( pd.hDC, PHYSICALHEIGHT ) - GetDeviceCaps( pd.hDC, PHYSICALOFFSETY );
 
 		StretchBlt( pd.hDC,
 			0, 0,
 			pwidth, pheight,
 			s_hdcXY,
 			0, 0,
 			bmwidth, bmheight,
 			SRCCOPY );
 	}
 
 	/*
 	** EndPage and EndDoc
 	*/
 	if ( EndPage( pd.hDC ) <= 0 )
 	{
 		MessageBox( g_qeglobals.d_hwndMain, "QE4 Print Error", "Could not EndPage()", MB_OK | MB_ICONERROR );
 		return;
 	}
 
 	if ( EndDoc( pd.hDC ) <= 0 )
 	{
 		MessageBox( g_qeglobals.d_hwndMain, "QE4 Print Error", "Could not EndDoc()", MB_OK | MB_ICONERROR );
 		return;
 	}
 }
 
 int CXYWnd::OnCreate(LPCREATESTRUCT lpCreateStruct) 
 {
 	if (CWnd::OnCreate(lpCreateStruct) == -1)
 		return -1;
 
   s_hdcXY = ::GetDC(GetSafeHwnd());
 	QEW_SetupPixelFormat(s_hdcXY, false);
 	if ( ( s_hglrcXY = qwglCreateContext( s_hdcXY ) ) == 0 )
 	  Error( "wglCreateContext in WXY_WndProc failed" );
 
 	if (!qwglShareLists( g_qeglobals.d_hglrcBase, s_hglrcXY ) )
 	  Error( "wglShareLists in WXY_WndProc failed" );
 
   if (!qwglMakeCurrent( s_hdcXY, s_hglrcXY ))
 	  Error ("wglMakeCurrent failed");
 
 	qglPolygonStipple ((unsigned char *)s_stipple);
 	qglLineStipple (3, 0xaaaa);
   g_qeglobals.d_hwndXY = GetSafeHwnd();
 	return 0;
 }
 
 float ptSum(vec3_t pt)
 {
   return pt[0] + pt[1] + pt[2];
 }
 
 void CXYWnd::DropClipPoint(UINT nFlags, CPoint point)
 {
   CRect rctZ;
   GetClientRect(rctZ);
   if (g_pMovingClip)
   {
     SetCapture();
     SnapToPoint (point.x, rctZ.Height() - 1 - point.y , *g_pMovingClip);
   }
   else
   {
     vec3_t* pPt = NULL;
     if (g_Clip1.Set() == false)
     {
       pPt = g_Clip1;
       g_Clip1.Set(true);
       g_Clip1.m_ptScreen = point;
     }
     else 
     if (g_Clip2.Set() == false)
     {
       pPt = g_Clip2;
       g_Clip2.Set(true);
       g_Clip2.m_ptScreen = point;
     }
     else 
     if (g_Clip3.Set() == false)
     {
       pPt = g_Clip3;
       g_Clip3.Set(true);
       g_Clip3.m_ptScreen = point;
     }
     else 
     {
       RetainClipMode(true);
       pPt = g_Clip1;
       g_Clip1.Set(true);
       g_Clip1.m_ptScreen = point;
     }
     SnapToPoint (point.x, rctZ.Height() - 1 - point.y , *pPt);
   }
   Sys_UpdateWindows(XY | W_CAMERA_IFON);
 }
 
 
 void CXYWnd::DropPathPoint(UINT nFlags, CPoint point)
 {
   CRect rctZ;
   GetClientRect(rctZ);
   if (g_pMovingPath)
   {
     SetCapture();
     SnapToPoint (point.x, rctZ.Height() - 1 - point.y , *g_pMovingPath);
   }
   else
   {
     g_PathPoints[g_nPathCount].Set(true);
     g_PathPoints[g_nPathCount].m_ptScreen = point;
     SnapToPoint(point.x, rctZ.Height() - 1 - point.y, g_PathPoints[g_nPathCount]);
     g_nPathCount++;
     if (g_nPathCount == g_nPathLimit)
     {
       if (g_pPathFunc)
         g_pPathFunc(true, g_nPathCount);
       g_nPathCount = 0;
       g_bPathMode = false;
       g_pPathFunc = NULL;
     }
   }
   Sys_UpdateWindows(XY | W_CAMERA_IFON);
 }
 
 void CXYWnd::AddPointPoint(UINT nFlags, vec3_t* pVec)
 {
   g_PointPoints[g_nPointCount].Set(true);
   //g_PointPoints[g_nPointCount].m_ptScreen = point;
   _VectorCopy(*pVec, g_PointPoints[g_nPointCount]);
   g_PointPoints[g_nPointCount].SetPointPtr(pVec);
   g_nPointCount++;
   Sys_UpdateWindows(XY | W_CAMERA_IFON);
 }
 
 
 void CXYWnd::OnLButtonDown(UINT nFlags, CPoint point) 
 {
   g_pParentWnd->SetActiveXY(this);
   UndoCopy();
 
 	// plugin entities
 	if (DispatchOnLButtonDown(nFlags, point.x, point.y ))
 		return;
 
   if (ClipMode() && !RogueClipMode())
   {
     DropClipPoint(nFlags, point);
   }
   else if (PathMode())
   {
     DropPathPoint(nFlags, point);
   }
   else OriginalButtonDown(nFlags, point);
 }
 
 void CXYWnd::OnMButtonDown(UINT nFlags, CPoint point) 
 {
   OriginalButtonDown(nFlags, point);
 }
 
 
 float Betwixt(float f1, float f2)
 {
   if (f1 > f2)
     return f2 + ((f1 - f2) / 2);
   else
     return f1 + ((f2 - f1) / 2);
 }
 
 void CXYWnd::ProduceSplits(brush_t** pFront, brush_t** pBack)
 {
   *pFront = NULL;
   *pBack = NULL;
   if (ClipMode())
   {
     if (g_Clip1.Set() && g_Clip2.Set())
     {
       face_t face;
       VectorCopy(g_Clip1.m_ptClip,face.planepts[0]);
       VectorCopy(g_Clip2.m_ptClip,face.planepts[1]);
       VectorCopy(g_Clip3.m_ptClip,face.planepts[2]);
       if (selected_brushes.next && (selected_brushes.next->next == &selected_brushes))
       {
         if (g_Clip3.Set() == false)
         {
           if (m_nViewType == XY)
           {
             face.planepts[0][2] = selected_brushes.next->mins[2];
             face.planepts[1][2] = selected_brushes.next->mins[2];
             face.planepts[2][0] = Betwixt(g_Clip1.m_ptClip[0], g_Clip2.m_ptClip[0]);
             face.planepts[2][1] = Betwixt(g_Clip1.m_ptClip[1], g_Clip2.m_ptClip[1]);
             face.planepts[2][2] = selected_brushes.next->maxs[2];
           }
           else if (m_nViewType == YZ)
           {
             face.planepts[0][0] = selected_brushes.next->mins[0];
             face.planepts[1][0] = selected_brushes.next->mins[0];
             face.planepts[2][1] = Betwixt(g_Clip1.m_ptClip[1], g_Clip2.m_ptClip[1]);
             face.planepts[2][2] = Betwixt(g_Clip1.m_ptClip[2], g_Clip2.m_ptClip[2]);
             face.planepts[2][0] = selected_brushes.next->maxs[0];
           }
           else
           {
             face.planepts[0][1] = selected_brushes.next->mins[1];
             face.planepts[1][1] = selected_brushes.next->mins[1];
             face.planepts[2][0] = Betwixt(g_Clip1.m_ptClip[0], g_Clip2.m_ptClip[0]);
             face.planepts[2][2] = Betwixt(g_Clip1.m_ptClip[2], g_Clip2.m_ptClip[2]);
             face.planepts[2][1] = selected_brushes.next->maxs[1];
           }
         }
 
         Brush_SplitBrushByFace (selected_brushes.next, &face, pFront, pBack);
       }
 
     }
   }
 }
 
 void CleanList(brush_t* pList)
 {
   brush_t* pBrush = pList->next; 
   while (pBrush != NULL && pBrush != pList)
   {
     brush_t* pNext = pBrush->next;
     Brush_Free(pBrush);
     pBrush = pNext;
   }
 }
 
 void CXYWnd::ProduceSplitLists()
 {
 	if (AnyPatchesSelected())
 	{
 		Sys_Printf("Deslecting patches for clip operation.\n");
 		brush_t *next;
 		for (brush_t *pb = selected_brushes.next ; pb != &selected_brushes ; pb = next)
 		{
 			next = pb->next;
 			if (pb->patchBrush)
 			{
 				Brush_RemoveFromList (pb);
 				Brush_AddToList (pb, &active_brushes);
 				UpdatePatchInspector();
 			}
 			if (pb->terrainBrush)
 			{
 				Brush_RemoveFromList (pb);
 				Brush_AddToList (pb, &active_brushes);
 				UpdateTerrainInspector();
 			}
 		}
 	}
 
 	CleanList(&g_brFrontSplits);
 	CleanList(&g_brBackSplits);
 	g_brFrontSplits.next = &g_brFrontSplits;
 	g_brBackSplits.next = &g_brBackSplits;
 	brush_t* pBrush;
 	for (pBrush = selected_brushes.next ; pBrush != NULL && pBrush != &selected_brushes ; pBrush=pBrush->next)
 	{
 		brush_t* pFront = NULL;
 		brush_t* pBack = NULL;
 		if (ClipMode())
 		{
 			if (g_Clip1.Set() && g_Clip2.Set())
 			{
 				face_t face;
 				VectorCopy(g_Clip1.m_ptClip,face.planepts[0]);
 				VectorCopy(g_Clip2.m_ptClip,face.planepts[1]);
 				VectorCopy(g_Clip3.m_ptClip,face.planepts[2]);
 				if (g_Clip3.Set() == false)
 				{
 					if (g_pParentWnd->ActiveXY()->GetViewType() == XY)
 					{
 						face.planepts[0][2] = pBrush->mins[2];
 						face.planepts[1][2] = pBrush->mins[2];
 						face.planepts[2][0] = Betwixt(g_Clip1.m_ptClip[0], g_Clip2.m_ptClip[0]);
 						face.planepts[2][1] = Betwixt(g_Clip1.m_ptClip[1], g_Clip2.m_ptClip[1]);
 						face.planepts[2][2] = pBrush->maxs[2];
 					}
 					else if (g_pParentWnd->ActiveXY()->GetViewType() == YZ)
 					{
 						face.planepts[0][0] = pBrush->mins[0];
 						face.planepts[1][0] = pBrush->mins[0];
 						face.planepts[2][1] = Betwixt(g_Clip1.m_ptClip[1], g_Clip2.m_ptClip[1]);
 						face.planepts[2][2] = Betwixt(g_Clip1.m_ptClip[2], g_Clip2.m_ptClip[2]);
 						face.planepts[2][0] = pBrush->maxs[0];
 					}
 					else
 					{
 						face.planepts[0][1] = pBrush->mins[1];
 						face.planepts[1][1] = pBrush->mins[1];
 						face.planepts[2][0] = Betwixt(g_Clip1.m_ptClip[0], g_Clip2.m_ptClip[0]);
 						face.planepts[2][2] = Betwixt(g_Clip1.m_ptClip[2], g_Clip2.m_ptClip[2]);
 						face.planepts[2][1] = pBrush->maxs[1];
 					}
 				}
 				Brush_SplitBrushByFace (pBrush, &face, &pFront, &pBack);
 				if (pBack)
 					Brush_AddToList(pBack, &g_brBackSplits);
 				if (pFront)
 					Brush_AddToList(pFront, &g_brFrontSplits);
 			}
 		}
 	}
 }
 
 void Brush_CopyList (brush_t* pFrom, brush_t* pTo)
 {
 	brush_t* pBrush = pFrom->next; 
 	while (pBrush != NULL && pBrush != pFrom)
 	{
 		brush_t* pNext = pBrush->next;
 		Brush_RemoveFromList(pBrush);
 		Brush_AddToList(pBrush, pTo);
 		pBrush = pNext;
 	}
 }
 
 void CXYWnd::OnRButtonDown(UINT nFlags, CPoint point) 
 {
   g_pParentWnd->SetActiveXY(this);
   m_ptDown = point;
   m_bRButtonDown = true;
 
   if (g_PrefsDlg.m_nMouseButtons == 3) // 3 button mouse 
   {
     if ((GetKeyState(VK_CONTROL) & 0x8000))
     {
       if (ClipMode()) // already there?
         DropClipPoint(nFlags, point);
       else
       {
         SetClipMode(true);
         g_bRogueClipMode = true;
         DropClipPoint(nFlags, point);
       }
       return;
     }
   }
   OriginalButtonDown(nFlags, point);
 }
 
 void CXYWnd::OnLButtonUp(UINT nFlags, CPoint point) 
 {
 	// plugin entities
 	if (DispatchOnLButtonUp(nFlags, point.x, point.y ))
 		return;
 
 	if (ClipMode())
   {
     if (g_pMovingClip)
     {
       ReleaseCapture();
       g_pMovingClip = NULL;
     }
   }
   OriginalButtonUp(nFlags, point);
 }
 
 void CXYWnd::OnMButtonUp(UINT nFlags, CPoint point) 
 {
   OriginalButtonUp(nFlags, point);
 }
 
 void CXYWnd::OnRButtonUp(UINT nFlags, CPoint point) 
 {
   m_bRButtonDown = false;
   if (point == m_ptDown)    // mouse didn't move
   {
     bool bGo = true;
     if ((GetKeyState(VK_MENU) & 0x8000))
       bGo = false;
     if ((GetKeyState(VK_CONTROL) & 0x8000))
       bGo = false;
     if ((GetKeyState(VK_SHIFT) & 0x8000))
       bGo = false;
     if (bGo)
       HandleDrop();
   }
   OriginalButtonUp(nFlags, point);
 }
 
 void CXYWnd::OriginalButtonDown(UINT nFlags, CPoint point)
 {
   CRect rctZ;
   GetClientRect(rctZ);
   SetWindowPos(&wndTop, 0,0,0,0, SWP_NOMOVE | SWP_NOSIZE);
   if (::GetTopWindow( g_qeglobals.d_hwndMain ) != GetSafeHwnd())
     ::BringWindowToTop(GetSafeHwnd());
 	SetFocus();
 	SetCapture();
 	XY_MouseDown (point.x, rctZ.Height() - 1 - point.y , nFlags);
   m_nScrollFlags = nFlags;
 }          
 
 void CXYWnd::OriginalButtonUp(UINT nFlags, CPoint point)
 {
   CRect rctZ;
   GetClientRect(rctZ);
   XY_MouseUp (point.x, rctZ.Height() - 1 - point.y , nFlags);
 	if (! (nFlags & (MK_LBUTTON|MK_RBUTTON|MK_MBUTTON)))
 		ReleaseCapture ();
 }
 
 
 float fDiff(float f1, float f2)
 {
   if (f1 > f2)
     return f1 - f2;
   else
     return f2 - f1;
 }
 
 
 vec3_t tdp;
 void CXYWnd::OnMouseMove(UINT nFlags, CPoint point) 
 {
 	// plugin entities
 	//++timo TODO: handle return code
 	DispatchOnMouseMove( nFlags, point.x, point.y );
 
   m_ptDown.x = 0;
   m_ptDown.y = 0;
 
   if ( g_PrefsDlg.m_bChaseMouse == TRUE &&
        (point.x < 0 || point.y < 0 || 
        point.x > m_nWidth || point.y > m_nHeight) &&
        GetCapture() == this)
   {
     float fAdjustment = (g_qeglobals.d_gridsize / 8 * 64) / m_fScale;
     //m_ptDrag = point;
     m_ptDragAdj.x = 0;
     m_ptDragAdj.y = 0;
     if (point.x < 0)
     {
       m_ptDragAdj.x = -fAdjustment;
     }
     else 
     if (point.x > m_nWidth)
     {
       m_ptDragAdj.x = fAdjustment;
     }
     if (point.y < 0)
     {
       m_ptDragAdj.y = -fAdjustment;
     }
     else
     if (point.y > m_nHeight)
     {
       m_ptDragAdj.y = fAdjustment;
     }
     if (m_nTimerID == -1)
     {
       m_nTimerID = SetTimer(100, 50, NULL);
       m_ptDrag = point;
       m_ptDragTotal = 0;
     }
     return;
   }
   //else if (m_nTimerID != -1)
   if (m_nTimerID != -1)
   {
     KillTimer(m_nTimerID);
     pressx -= m_ptDragTotal.x;
     pressy += m_ptDragTotal.y;
     m_nTimerID = -1;
     //return;
   }
 
   bool bCrossHair = false;
   if (!m_bRButtonDown)
   {
     tdp[0] = tdp[1] = tdp[2] = 0.0;
     SnapToPoint (point.x, m_nHeight - 1 - point.y , tdp);
 
     g_strStatus.Format("x:: %.1f  y:: %.1f  z:: %.1f", tdp[0], tdp[1], tdp[2]);
     g_pParentWnd->SetStatusText(1, g_strStatus);
 
     // i need to generalize the point code.. having 3 flavors pretty much sucks.. 
     // once the new curve stuff looks like it is going to stick i will 
     // rationalize this down to a single interface.. 
     if (PointMode())
     {
       if (g_pMovingPoint && GetCapture() == this)
       {
         bCrossHair = true;
         SnapToPoint (point.x, m_nHeight - 1 - point.y , g_pMovingPoint->m_ptClip);
         g_pMovingPoint->UpdatePointPtr();
         Sys_UpdateWindows(XY | W_CAMERA_IFON);
       }
       else
       {
         g_pMovingPoint = NULL;
         int nDim1 = (m_nViewType == YZ) ? 1 : 0;
         int nDim2 = (m_nViewType == XY) ? 1 : 2;
         for (int n = 0; n < g_nPointCount; n++)
         {
           if ( fDiff(g_PointPoints[n].m_ptClip[nDim1], tdp[nDim1]) < 3 &&
                fDiff(g_PointPoints[n].m_ptClip[nDim2], tdp[nDim2]) < 3 )
           {
             bCrossHair = true;
             g_pMovingPoint = &g_PointPoints[n];
           }
         }
       }
     }
     else if (ClipMode())
     {
       if (g_pMovingClip && GetCapture() == this)
       {
         bCrossHair = true;
         SnapToPoint (point.x, m_nHeight - 1 - point.y , g_pMovingClip->m_ptClip);
         Sys_UpdateWindows(XY | W_CAMERA_IFON);
       }
       else
       {
         g_pMovingClip = NULL;
         int nDim1 = (m_nViewType == YZ) ? 1 : 0;
         int nDim2 = (m_nViewType == XY) ? 1 : 2;
         if (g_Clip1.Set())
         {
           if ( fDiff(g_Clip1.m_ptClip[nDim1], tdp[nDim1]) < 3 &&
                fDiff(g_Clip1.m_ptClip[nDim2], tdp[nDim2]) < 3 )
           {
             bCrossHair = true;
             g_pMovingClip = &g_Clip1;
           }
         }
         if (g_Clip2.Set())
         {
           if ( fDiff(g_Clip2.m_ptClip[nDim1], tdp[nDim1]) < 3 &&
                fDiff(g_Clip2.m_ptClip[nDim2], tdp[nDim2]) < 3 )
           {
             bCrossHair = true;
             g_pMovingClip = &g_Clip2;
           }
         }
         if (g_Clip3.Set())
         {
           if ( fDiff(g_Clip3.m_ptClip[nDim1], tdp[nDim1]) < 3 &&
                fDiff(g_Clip3.m_ptClip[nDim2], tdp[nDim2]) < 3 )
           {
             bCrossHair = true;
             g_pMovingClip = &g_Clip3;
           }
         }
       }
       if (bCrossHair == false)
         XY_MouseMoved (point.x, m_nHeight - 1 - point.y , nFlags);
     }
     else if (PathMode())
     {
       if (g_pMovingPath && GetCapture() == this)
       {
         bCrossHair = true;
         SnapToPoint (point.x, m_nHeight - 1 - point.y , g_pMovingPath->m_ptClip);
         Sys_UpdateWindows(XY | W_CAMERA_IFON);
       }
       else
       {
         g_pMovingPath = NULL;
         int nDim1 = (m_nViewType == YZ) ? 1 : 0;
         int nDim2 = (m_nViewType == XY) ? 1 : 2;
         for (int n = 0; n < g_nPathCount; n++)
         {
           if ( fDiff(g_PathPoints[n].m_ptClip[nDim1], tdp[nDim1]) < 3 &&
                fDiff(g_PathPoints[n].m_ptClip[nDim2], tdp[nDim2]) < 3 )
           {
             bCrossHair = true;
             g_pMovingPath = &g_PathPoints[n];
           }
         }
       }
     }
     else
     {
       XY_MouseMoved (point.x, m_nHeight - 1 - point.y , nFlags);
     }
   }
   else 
   {
     XY_MouseMoved (point.x, m_nHeight - 1 - point.y , nFlags);
   }
   if (bCrossHair)
     SetCursor(::LoadCursor(NULL, IDC_CROSS));
   else
     SetCursor(::LoadCursor(NULL, IDC_ARROW));
 }
 
 void CXYWnd::RetainClipMode(bool bMode)
 {
   bool bSave = g_bRogueClipMode;
   SetClipMode(bMode);
   if (bMode == true)
     g_bRogueClipMode = bSave;
   else
     g_bRogueClipMode = false;
 }
 
 void CXYWnd::SetClipMode(bool bMode)
 {
   g_bClipMode = bMode;
   g_bRogueClipMode = false;
   if (bMode)
   {
     g_Clip1.Reset();
     g_Clip2.Reset();
     g_Clip3.Reset();
     CleanList(&g_brFrontSplits);
     CleanList(&g_brBackSplits);
     g_brFrontSplits.next = &g_brFrontSplits;
     g_brBackSplits.next = &g_brBackSplits;
   }
   else
   {
     if (g_pMovingClip)
     {
       ReleaseCapture();
       g_pMovingClip = NULL;
     }
     CleanList(&g_brFrontSplits);
     CleanList(&g_brBackSplits);
     g_brFrontSplits.next = &g_brFrontSplits;
     g_brBackSplits.next = &g_brBackSplits;
     Sys_UpdateWindows(XY | W_CAMERA_IFON);
   }
 }
 
 bool CXYWnd::ClipMode()
 {
   return g_bClipMode;
 }
 
 bool CXYWnd::RogueClipMode()
 {
   return g_bRogueClipMode;
 }
 
 bool CXYWnd::PathMode()
 {
   return g_bPathMode;
 }
 
 
 bool CXYWnd::PointMode()
 {
   return g_bPointMode;
 }
 
 void CXYWnd::SetPointMode(bool b)
 {
   g_bPointMode = b;
   if (!b)
     g_nPointCount = 0;
 }
 
 
 void CXYWnd::OnPaint() 
 {
 	CPaintDC dc(this); // device context for painting
   bool bPaint = true;
   if (!qwglMakeCurrent(dc.m_hDC, s_hglrcXY))
   {
     Sys_Printf("ERROR: wglMakeCurrent failed.. Error:%i\n",qglGetError());
     Sys_Printf("Please restart Q3Radiant if the Map view is not working\n");
     bPaint = false;
   }
   if (bPaint)
   {
     QE_CheckOpenGLForErrors();
 		XY_Draw ();
     QE_CheckOpenGLForErrors();
 
     if (m_nViewType != XY)
     {
       qglPushMatrix();
       if (m_nViewType == YZ)
         qglRotatef (-90,  0, 1, 0);	    // put Z going up
       qglRotatef (-90,  1, 0, 0);	    // put Z going up
     }
  
     if (g_bCrossHairs)
     {
 	    qglColor4f(0.2, 0.9, 0.2, 0.8);
 		  qglBegin (GL_LINES);
       if (m_nViewType == XY)
       {
         qglVertex2f(-16384, tdp[1]);
         qglVertex2f(16384, tdp[1]);
         qglVertex2f(tdp[0], -16384);
         qglVertex2f(tdp[0], 16384);
       }
       else if (m_nViewType == YZ)
       {
         qglVertex3f(tdp[0], -16384, tdp[2]);
         qglVertex3f(tdp[0], 16384, tdp[2]);
         qglVertex3f(tdp[0], tdp[1], -16384);
         qglVertex3f(tdp[0], tdp[1], 16384);
       }
       else
       {
         qglVertex3f(-16384, tdp[1], tdp[2]);
         qglVertex3f( 16384, tdp[1], tdp[2]);
         qglVertex3f(tdp[0], tdp[1], -16384);
         qglVertex3f(tdp[0], tdp[1], 16384);
       }
 		  qglEnd();
     }
 
     if (ClipMode())
     {
       qglPointSize (4);
 		  qglColor3fv(g_qeglobals.d_savedinfo.colors[COLOR_CLIPPER]);
 		  qglBegin (GL_POINTS);
       if (g_Clip1.Set())
 			  qglVertex3fv (g_Clip1);
       if (g_Clip2.Set())
 			  qglVertex3fv (g_Clip2);
       if (g_Clip3.Set())
 			  qglVertex3fv (g_Clip3);
 		  qglEnd ();
 		  qglPointSize (1);
 
       CString strMsg;
       if (g_Clip1.Set())
       {
         qglRasterPos3f (g_Clip1.m_ptClip[0]+2, g_Clip1.m_ptClip[1]+2, g_Clip1.m_ptClip[2]+2);
         strMsg = "1";
         //strMsg.Format("1 (%f, %f, %f)", g_Clip1[0], g_Clip1[1], g_Clip1[2]);
 	      qglCallLists (strMsg.GetLength(), GL_UNSIGNED_BYTE, strMsg);
       }
       if (g_Clip2.Set())
       {
         qglRasterPos3f (g_Clip2.m_ptClip[0]+2, g_Clip2.m_ptClip[1]+2, g_Clip2.m_ptClip[2]+2);
         strMsg = "2";
         //strMsg.Format("2 (%f, %f, %f)", g_Clip2[0], g_Clip2[1], g_Clip2[2]);
 	      qglCallLists (strMsg.GetLength(), GL_UNSIGNED_BYTE, strMsg);
       }
       if (g_Clip3.Set())
       {
         qglRasterPos3f (g_Clip3.m_ptClip[0]+2, g_Clip3.m_ptClip[1]+2, g_Clip3.m_ptClip[2]+2);
         strMsg = "3";
         //strMsg.Format("3 (%f, %f, %f)", g_Clip3[0], g_Clip3[1], g_Clip3[2]);
 	      qglCallLists (strMsg.GetLength(), GL_UNSIGNED_BYTE, strMsg);
       }
       if (g_Clip1.Set() && g_Clip2.Set())
       {
         ProduceSplitLists();
         brush_t* pBrush;
         brush_t* pList = ( (m_nViewType == XZ) ? !g_bSwitch : g_bSwitch) ? &g_brBackSplits : &g_brFrontSplits;
 	      for (pBrush = pList->next ; pBrush != NULL && pBrush != pList ; pBrush=pBrush->next)
         {
 		      qglColor3f (1,1,0);
 	        face_t *face;
 	        int order;
 	        for (face = pBrush->brush_faces,order = 0 ; face ; face=face->next, order++)
 	        {
 		        winding_t* w = face->face_winding;
 		        if (!w)
 			        continue;
 		        // draw the polygon
 		        qglBegin(GL_LINE_LOOP);
             for (int i=0 ; i<w->numpoints ; i++)
 		          qglVertex3fv(w->points[i]);
 		        qglEnd();
 	        }
         }
       }
 
     }
 
 
 
     if (PathMode())
     {
       qglPointSize (4);
 		  qglColor3fv(g_qeglobals.d_savedinfo.colors[COLOR_CLIPPER]);
 		  qglBegin (GL_POINTS);
 
       for (int n = 0; n < g_nPathCount; n++)
         qglVertex3fv(g_PathPoints[n]);
 		  qglEnd ();
 		  qglPointSize (1);
 
       CString strMsg;
       for (n = 0; n < g_nPathCount; n++)
       {
         qglRasterPos3f (g_PathPoints[n].m_ptClip[0]+2, g_PathPoints[n].m_ptClip[1]+2, g_PathPoints[n].m_ptClip[2]+2);
         strMsg.Format("%i", n+1);
 	      qglCallLists (strMsg.GetLength(), GL_UNSIGNED_BYTE, strMsg);
       }
 
     }
     if (m_nViewType != XY)
       qglPopMatrix();
 
 		qwglSwapBuffers(dc.m_hDC);
     TRACE("XY Paint\n");
   }
  }
 
 void CXYWnd::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
 {
   g_pParentWnd->HandleKey(nChar, nRepCnt, nFlags);
 }
 
 
 
 // FIXME: the brush_t *pBrush is never used. ( Entity_Create uses selected_brushes )
 void CreateEntityFromName(char* pName, brush_t* pBrush)
 {
 	eclass_t *pecNew;
 	entity_t *petNew;
 	if (stricmp(pName, "worldspawn") == 0)
 	{
 		MessageBox(g_qeglobals.d_hwndMain, "Can't create an entity with worldspawn.", "info", 0);
 		return;
 	}
 	
 	pecNew = Eclass_ForName(pName, false);
 	
 	// create it
 	petNew = Entity_Create(pecNew);
 	if (petNew == NULL)
 	{
 		if (!((selected_brushes.next == &selected_brushes)||(selected_brushes.next->next != &selected_brushes)))
 		{
 			brush_t* b = selected_brushes.next;
 			if (b->owner != world_entity && b->owner->eclass->fixedsize && pecNew->fixedsize)
 			{
 				vec3_t mins, maxs;
 				vec3_t origin;
 				for (int i=0 ; i<3 ; i++)
 					origin[i] = b->mins[i] - pecNew->mins[i];
 				
 				VectorAdd (pecNew->mins, origin, mins);
 				VectorAdd (pecNew->maxs, origin, maxs);
 				brush_t* nb = Brush_Create (mins, maxs, &pecNew->texdef);
 				Entity_LinkBrush (b->owner, nb);
 				nb->owner->eclass = pecNew;
 				SetKeyValue (nb->owner, "classname", pName);
 				Brush_Free(b);
 				Brush_Build(nb);
 				Brush_AddToList (nb, &active_brushes);
 				Select_Brush(nb);
 				return;
 			}
 		}
 		MessageBox(g_qeglobals.d_hwndMain, "Failed to create entity.", "info", 0);
 		return;
 	}
 	
 	Select_Deselect ();
 	//entity_t* pEntity = world_entity;
 	//if (selected_brushes.next != &selected_brushes)
 	//	pEntity = selected_brushes.next->owner;
 	Select_Brush (petNew->brushes.onext);
 	
 	if (stricmp(pName, "misc_model") == 0)
 	{
 		SetInspectorMode(W_ENTITY);
 		PostMessage(g_qeglobals.d_hwndEntity, WM_COMMAND, IDC_BTN_ASSIGNMODEL, 0);
 	}
 	
 }
 
 
 brush_t* CreateEntityBrush(int x, int y, CXYWnd* pWnd)
 {
 	vec3_t	mins, maxs;
 	int		i;
 	float	temp;
 	brush_t	*n;
 
 	pWnd->SnapToPoint (x, y, mins);
   x += 32;
   y += 32;
 	pWnd->SnapToPoint (x, y, maxs);
 
   int nDim = (pWnd->GetViewType() == XY) ? 2 : (pWnd->GetViewType() == YZ) ? 0 : 1;
 	mins[nDim] = g_qeglobals.d_gridsize * ((int)(g_qeglobals.d_new_brush_bottom_z/g_qeglobals.d_gridsize));
 	maxs[nDim] = g_qeglobals.d_gridsize * ((int)(g_qeglobals.d_new_brush_top_z/g_qeglobals.d_gridsize));
 
   if (maxs[nDim] <= mins[nDim])
 		maxs[nDim] = mins[nDim] + g_qeglobals.d_gridsize;
 
 	for (i=0 ; i<3 ; i++)
 	{
 		if (mins[i] == maxs[i])
 			maxs[i] += 16;	// don't create a degenerate brush
 		if (mins[i] > maxs[i])
 		{
 			temp = mins[i];
 			mins[i] = maxs[i];
 			maxs[i] = temp;
 		}
 	}
 
 	n = Brush_Create (mins, maxs, &g_qeglobals.d_texturewin.texdef);
 	if (!n)
 		return NULL;
 
 	Brush_AddToList (n, &selected_brushes);
 	Entity_LinkBrush (world_entity, n);
 	Brush_Build( n );
   return n;
 }
 
 void CreateRightClickEntity(CXYWnd* pWnd, int x, int y, char* pName)
 {
   CRect rctZ;
   pWnd->GetClientRect(rctZ);
   brush_t* pBrush = (selected_brushes.next == &selected_brushes) ? CreateEntityBrush(x, rctZ.Height() - 1 - y, pWnd) : selected_brushes.next;
   CreateEntityFromName(pName, pBrush);
   //Select_Brush(pBrush);
 }
 
 brush_t* CreateSmartBrush(vec3_t v)
 {
 	vec3_t	mins, maxs;
 	int		i;
 	brush_t	*n;
 
 	for (i=0 ; i<3 ; i++)
 	{
     mins[i] = v[i] - 16;
     maxs[i] = v[i] + 16;
   }
 
 	n = Brush_Create (mins, maxs, &g_qeglobals.d_texturewin.texdef);
 	if (!n)
 		return NULL;
 
 	Brush_AddToList(n, &selected_brushes);
 	//Entity_LinkBrush(world_entity, n);
 	Brush_Build(n);
   return n;
 }
 
 
 
 
 CString g_strSmartEntity;
 int g_nSmartX;
 int g_nSmartY;
 bool g_bSmartWaiting;
 void _SmartPointDone(bool b, int n)
 {
   g_bSmartWaiting = false;
 }
 
 void CreateSmartEntity(CXYWnd* pWnd, int x, int y, const char* pName)
 {
   g_nSmartX = x;
   g_nSmartY = y;
   g_strSmartEntity = pName;
   if (g_strSmartEntity.Find("Smart_Train") >= 0)
   {
     ShowInfoDialog("Select the path of the train by left clicking in XY, YZ and/or XZ views. You can move an already dropped point by grabbing and moving it. When you are finished, press ENTER to accept and create the entity and path(s), press ESC to abandon the creation");
     g_bPathMode = true;
     g_nPathLimit = 0;
     g_nPathCount = 0;
     g_bSmartGo = true;
   }
   else
   if (g_strSmartEntity.Find("Smart_Monster...") >= 0)
   {
     g_bPathMode = true;
     g_nPathLimit = 0;
     g_nPathCount = 0;
   }
   else
   if (g_strSmartEntity.Find("Smart_Rotating") >= 0)
   {
     g_bSmartWaiting = true;
     ShowInfoDialog("Left click to specify the rotation origin");
     AcquirePath(1, &_SmartPointDone);
     while (g_bSmartWaiting)
     {
       MSG msg;
       if (::PeekMessage( &msg, NULL, 0, 0, PM_REMOVE )) 
       { 
         TranslateMessage(&msg);
         DispatchMessage(&msg);
       }
     }
     HideInfoDialog();
     CPtrArray array;
     g_bScreenUpdates = false;
     CreateRightClickEntity(g_pParentWnd->ActiveXY(), g_nSmartX, g_nSmartY, "func_rotating");
     array.Add(reinterpret_cast<void*>(selected_brushes.next));
     Select_Deselect();
     brush_t* pBrush = CreateSmartBrush(g_PathPoints[0]);
     array.Add(pBrush);
     Select_Deselect();
     Select_Brush(reinterpret_cast<brush_t*>(array.GetAt(0)));
     Select_Brush(reinterpret_cast<brush_t*>(array.GetAt(1)));
     ConnectEntities();
     g_bScreenUpdates = true;
   }
 }
 
 
 void FinishSmartCreation()
 {
   CPtrArray array;
   HideInfoDialog();
   brush_t* pEntities = NULL;
   if (g_strSmartEntity.Find("Smart_Train") >= 0)
   {
     g_bScreenUpdates = false;
     CreateRightClickEntity(g_pParentWnd->ActiveXY(), g_nSmartX, g_nSmartY, "func_train");
     array.Add(reinterpret_cast<void*>(selected_brushes.next));
     for (int n = 0; n < g_nPathCount; n++)
     {
       Select_Deselect();
       CreateRightClickEntity(g_pParentWnd->ActiveXY(), g_PathPoints[n].m_ptScreen.x,g_PathPoints[n].m_ptScreen.y, "path_corner");
       array.Add(reinterpret_cast<void*>(selected_brushes.next));
     }
 
     for (n = 0; n < g_nPathCount; n++)
     {
       Select_Deselect();
       Select_Brush(reinterpret_cast<brush_t*>(array.GetAt(n)));
       Select_Brush(reinterpret_cast<brush_t*>(array.GetAt(n+1)));
       ConnectEntities();
     }
     g_bScreenUpdates = true;
 
   }
   g_nPathCount = 0;
   g_bPathMode = false;
   Sys_UpdateWindows(W_ALL);
 }
 
 void CXYWnd::KillPathMode()
 {
   g_bSmartGo = false;
   g_bPathMode = false;
   if (g_pPathFunc)
     g_pPathFunc(false, g_nPathCount);
   g_nPathCount = 0;
   g_pPathFunc = NULL;
   Sys_UpdateWindows(W_ALL);
 }
 
 // gets called for drop down menu messages
 // TIP: it's not always about EntityCreate
 void CXYWnd::OnEntityCreate(unsigned int nID) 
 {
   if (m_mnuDrop.GetSafeHmenu())
   {
     CString strItem;
     m_mnuDrop.GetMenuString(nID, strItem, MF_BYCOMMAND);
 
 		if (strItem.CompareNoCase("Add to...") == 0)
 		{
 			//++timo TODO: fill the menu with current groups?
 			// this one is for adding to existing groups only
 			Sys_Printf("TODO: Add to... in CXYWnd::OnEntityCreate\n");
 		}
 		else if (strItem.CompareNoCase("Remove") == 0)
 		{
 			// remove selected brushes from their current group
 			brush_t *b;
 			for( b = selected_brushes.next; b != &selected_brushes; b = b->next )
 			{
 				
 			}
 		}
 
 		//++timo FIXME: remove when all hooks are in
 		if (strItem.CompareNoCase("Add to...") == 0
 			|| strItem.CompareNoCase("Remove") == 0
 			|| strItem.CompareNoCase("Name...") == 0
 			|| strItem.CompareNoCase("New group...") == 0)
 		{
 			Sys_Printf("TODO: hook drop down group menu\n");
 			return;
 		}
 		
     if (strItem.Find("Smart_") >= 0)
     {
       CreateSmartEntity(this, m_ptDown.x, m_ptDown.y, strItem);
     }
     else
     {
       CreateRightClickEntity(this, m_ptDown.x, m_ptDown.y, strItem.GetBuffer(0));
     }
 		
     Sys_UpdateWindows(W_ALL);
     //OnLButtonDown((MK_LBUTTON | MK_SHIFT), CPoint(m_ptDown.x+2, m_ptDown.y+2));
   }
 }
 
 
 void CXYWnd::HandleDrop()
 {
   if (g_PrefsDlg.m_bRightClick == false)
     return;
   if (!m_mnuDrop.GetSafeHmenu()) // first time, load it up
   {
     m_mnuDrop.CreatePopupMenu();
     int nID = ID_ENTITY_START;
 
     CMenu* pChild2 = new CMenu;
     pChild2->CreateMenu();
     pChild2->AppendMenu(MF_STRING, ID_SELECTION_SELECTCOMPLETETALL, "Select Complete Tall");
     pChild2->AppendMenu(MF_STRING, ID_SELECTION_SELECTTOUCHING, "Select Touching");
     pChild2->AppendMenu(MF_STRING, ID_SELECTION_SELECTPARTIALTALL, "Select Partial Tall");
     pChild2->AppendMenu(MF_STRING, ID_SELECTION_SELECTINSIDE, "Select Inside");
     m_mnuDrop.AppendMenu(MF_POPUP, reinterpret_cast<unsigned int>(pChild2->GetSafeHmenu()), "Select");
     m_mnuDrop.AppendMenu(MF_SEPARATOR, nID++, "");
 
     CMenu* pChild3 = new CMenu;
     pChild3->CreateMenu();
     pChild3->AppendMenu(MF_STRING, ID_DROP_GROUP_ADDTO, "Add to...");
     pChild3->AppendMenu(MF_STRING, ID_DROP_GROUP_REMOVE, "Remove");
     pChild3->AppendMenu(MF_STRING, ID_DROP_GROUP_NAME, "Name...");
     pChild3->AppendMenu(MF_SEPARATOR, nID++, "");
     pChild3->AppendMenu(MF_STRING, ID_DROP_GROUP_NEWGROUP, "New Group...");
     m_mnuDrop.AppendMenu(MF_POPUP, reinterpret_cast<unsigned int>(pChild3->GetSafeHmenu()), "Group");
     m_mnuDrop.AppendMenu(MF_SEPARATOR, nID++, "");
 
     m_mnuDrop.AppendMenu(MF_STRING, ID_SELECTION_UNGROUPENTITY, "Ungroup Entity");
     m_mnuDrop.AppendMenu(MF_STRING, ID_SELECTION_MAKE_DETAIL, "Make Detail");
     m_mnuDrop.AppendMenu(MF_STRING, ID_SELECTION_MAKE_STRUCTURAL, "Make Structural");
     m_mnuDrop.AppendMenu(MF_SEPARATOR, nID++, "");
 
     CMenu* pChild = new CMenu;
     pChild->CreateMenu();
     pChild->AppendMenu(MF_STRING, nID++, "Smart_Train");
     //pChild->AppendMenu(MF_STRING, nID++, "Smart_Rotating");
     m_mnuDrop.AppendMenu(MF_POPUP, reinterpret_cast<unsigned int>(pChild->GetSafeHmenu()), "Smart Entities");
     m_mnuDrop.AppendMenu(MF_SEPARATOR, nID++, "");
 
     pChild = NULL;
 	  eclass_t	*e;
     CString strActive;
     CString strLast;
     CString strName;
 	  for (e=eclass ; e ; e=e->next)
     {
       strLast = strName;
       strName = e->name;
       int n_ = strName.Find("_");
       if (n_ > 0)
       {
         CString strLeft = strName.Left(n_);
         CString strRight = strName.Right(strName.GetLength() - n_ - 1);
         if (strLeft == strActive) // this is a child
         {
           ASSERT(pChild);
           pChild->AppendMenu(MF_STRING, nID++, strName);
         }
         else
         {
           if (pChild)
           {
             m_mnuDrop.AppendMenu(MF_POPUP, reinterpret_cast<unsigned int>(pChild->GetSafeHmenu()), strActive);
             g_ptrMenus.Add(pChild);
             //pChild->DestroyMenu();
             //delete pChild;
             pChild = NULL;
           }
           strActive = strLeft;
           pChild = new CMenu;
           pChild->CreateMenu();
           pChild->AppendMenu(MF_STRING, nID++, strName);
         }
       }
       else
       {
         if (pChild)
         {
           m_mnuDrop.AppendMenu(MF_POPUP, reinterpret_cast<unsigned int>(pChild->GetSafeHmenu()), strActive);
           g_ptrMenus.Add(pChild);
           //pChild->DestroyMenu();
           //delete pChild;
           pChild = NULL;
         }
         strActive = "";
         m_mnuDrop.AppendMenu(MF_STRING, nID++, strName);
       }
     }
   }
 
   CPoint ptMouse;
   GetCursorPos(&ptMouse);
   m_mnuDrop.TrackPopupMenu(TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_RIGHTBUTTON, ptMouse.x, ptMouse.y, this);
 }
 
 void CXYWnd::XY_Init()
 {
 	m_vOrigin[0] = 0;
 	m_vOrigin[1] = 20;
   m_vOrigin[2] = 46;
   m_fScale = 1;
 }
 
 void CXYWnd::SnapToPoint (int x, int y, vec3_t point)
 {
   if (g_PrefsDlg.m_bNoClamp)
   {
     XY_ToPoint(x, y, point);
   }
   else
   {
     XY_ToGridPoint(x, y, point);
   }
 //--  else
 //--    XY_ToPoint(x, y, point);
 //--    //XY_ToPoint(x, y, point);
 }
 
 
 void CXYWnd::XY_ToPoint (int x, int y, vec3_t point)
 {
   float fx = x;
   float fy = y;
   float fw = m_nWidth;
   float fh = m_nHeight;
   if (m_nViewType == XY)
   {
 	  point[0] = m_vOrigin[0] + (fx - fw / 2) / m_fScale;
 	  point[1] = m_vOrigin[1] + (fy - fh / 2) / m_fScale;
 	  //point[2] = 0;
   }
   else if (m_nViewType == YZ)
   {
     ////point[0] = 0;
 	  //point[1] = m_vOrigin[0] + (fx - fw / 2) / m_fScale;
 	  //point[2] = m_vOrigin[1] + (fy - fh / 2 ) / m_fScale;
 	  point[1] = m_vOrigin[1] + (fx - fw / 2) / m_fScale;
 	  point[2] = m_vOrigin[2] + (fy - fh / 2 ) / m_fScale;
   }
   else
   {
 	  //point[0] = m_vOrigin[0] + (fx - fw / 2) / m_fScale;
 	  ////point[1] = 0;
 	  //point[2] = m_vOrigin[1] + (fy - fh / 2) / m_fScale;
 	  point[0] = m_vOrigin[0] + (fx - fw / 2) / m_fScale;
 	  //point[1] = 0;
 	  point[2] = m_vOrigin[2] + (fy - fh / 2) / m_fScale;
   }
 }
 
 
 void CXYWnd::XY_ToGridPoint (int x, int y, vec3_t point)
 {
   if (m_nViewType == XY)
   {
 	  point[0] = m_vOrigin[0] + (x - m_nWidth / 2) / m_fScale;
 	  point[1] = m_vOrigin[1] + (y - m_nHeight / 2) / m_fScale;
 	  //point[2] = 0;
 	  point[0] = floor(point[0] / g_qeglobals.d_gridsize + 0.5) * g_qeglobals.d_gridsize;
 	  point[1] = floor(point[1] / g_qeglobals.d_gridsize + 0.5) * g_qeglobals.d_gridsize;
   }
   else if (m_nViewType == YZ)
   {
 	  //point[0] = 0;
 	  //point[1] = m_vOrigin[0] + (x - m_nWidth / 2) / m_fScale;
 	  //point[2] = m_vOrigin[1] + (y - m_nHeight / 2) / m_fScale;
 	  point[1] = m_vOrigin[1] + (x - m_nWidth / 2) / m_fScale;
 	  point[2] = m_vOrigin[2] + (y - m_nHeight / 2) / m_fScale;
 	  point[1] = floor(point[1] / g_qeglobals.d_gridsize + 0.5) * g_qeglobals.d_gridsize;
 	  point[2] = floor(point[2] / g_qeglobals.d_gridsize + 0.5) * g_qeglobals.d_gridsize;
   }
   else
   {
 	  //point[1] = 0;
 	  //point[0] = m_vOrigin[0] + (x - m_nWidth / 2) / m_fScale;
 	  //point[2] = m_vOrigin[1] + (y - m_nHeight / 2) / m_fScale;
 	  point[0] = m_vOrigin[0] + (x - m_nWidth / 2) / m_fScale;
 	  point[2] = m_vOrigin[2] + (y - m_nHeight / 2) / m_fScale;
 	  point[0] = floor(point[0] / g_qeglobals.d_gridsize + 0.5) * g_qeglobals.d_gridsize;
 	  point[2] = floor(point[2] / g_qeglobals.d_gridsize + 0.5) * g_qeglobals.d_gridsize;
   }
 }
 
 
 void CXYWnd::XY_MouseDown (int x, int y, int buttons)
 {
 
 	vec3_t	point;
 	vec3_t	origin, dir, right, up;
 
 	m_nButtonstate = buttons;
   m_nPressx = x;
 	m_nPressy = y;
 	VectorCopy (vec3_origin, m_vPressdelta);
 
 	XY_ToPoint (x, y, point);
 	
   VectorCopy (point, origin);
 
 	dir[0] = 0; dir[1] = 0; dir[2] = 0;
   if (m_nViewType == XY)
   {
 	  origin[2] = 8192;
     dir[2] = -1;
   	right[0] = 1 / m_fScale; 
     right[1] = 0; 
     right[2] = 0;
 	  up[0] = 0; 
     up[1] = 1 / m_fScale;
     up[2] = 0;
   }
   else if (m_nViewType == YZ)
   {
     origin[0] = 8192;
     dir[0] = -1;
   	right[1] = 1 / m_fScale; 
     right[2] = 0; 
     right[0] = 0;
    	up[0] = 0; 
     up[2] = 1 / m_fScale;
     up[1] = 0;
   }
   else
   {
     origin[1] = 8192;
     dir[1] = -1;
   	right[0] = 1 / m_fScale;
     right[2] = 0; 
     right[1] = 0;
 	  up[0] = 0; 
     up[2] = 1 / m_fScale;
     up[1] = 0;
   }
 
 
 	m_bPress_selection = (selected_brushes.next != &selected_brushes);
 
   GetCursorPos(&m_ptCursor);
 	//Sys_GetCursorPos (&m_ptCursor.x, &m_ptCursor.y);
 
 	// lbutton = manipulate selection
 	// shift-LBUTTON = select
 	if ( (buttons == MK_LBUTTON)
 		|| (buttons == (MK_LBUTTON | MK_SHIFT))
 		|| (buttons == (MK_LBUTTON | MK_CONTROL))
 		|| (buttons == (MK_LBUTTON | MK_CONTROL | MK_SHIFT)) )
 	{	
 		if (g_qeglobals.d_select_mode == sel_addpoint) {
 			XY_ToGridPoint(x, y, point);
 			if (g_qeglobals.selectObject) {
 				g_qeglobals.selectObject->addPoint(point[0], point[1], point[2]);
 			}
 			return;
 		}
     Patch_SetView( (m_nViewType == XY) ? W_XY : (m_nViewType == YZ) ? W_YZ : W_XZ);
 		Drag_Begin (x, y, buttons, right, up,	origin, dir);
 		return;
 	}
 
   int nMouseButton = g_PrefsDlg.m_nMouseButtons == 2 ? MK_RBUTTON : MK_MBUTTON;
 
 	// control mbutton = move camera
 	if (m_nButtonstate == (MK_CONTROL|nMouseButton) )
 	{	
 	  VectorCopyXY(point, g_pParentWnd->GetCamera()->Camera().origin);
 		Sys_UpdateWindows (W_CAMERA|W_XY_OVERLAY);
 	}
 
 	// mbutton = angle camera
 	if ((g_PrefsDlg.m_nMouseButtons == 3 && m_nButtonstate == MK_MBUTTON) ||
       (g_PrefsDlg.m_nMouseButtons == 2 && m_nButtonstate == (MK_SHIFT|MK_CONTROL|MK_RBUTTON)))
 	{	
 		VectorSubtract (point, g_pParentWnd->GetCamera()->Camera().origin, point);
 
     int n1 = (m_nViewType == XY) ? 1 : 2;
     int n2 = (m_nViewType == YZ) ? 1 : 0;
     int nAngle = (m_nViewType == XY) ? YAW : PITCH;
     if (point[n1] || point[n2])
     {
 		  g_pParentWnd->GetCamera()->Camera().angles[nAngle] = 180/Q_PI*atan2 (point[n1], point[n2]);
 		  Sys_UpdateWindows (W_CAMERA_IFON|W_XY_OVERLAY);
     }
 	}
 
 	// shift mbutton = move z checker
 	if (m_nButtonstate == (MK_SHIFT | nMouseButton))
 	{
     if (RotateMode() || g_bPatchBendMode)
     {
 		  SnapToPoint (x, y, point);
 	    VectorCopyXY(point, g_vRotateOrigin);
       if (g_bPatchBendMode)
       {
         VectorCopy(point, g_vBendOrigin);
       }
 		  Sys_UpdateWindows (W_XY);
       return;
     }
     else
     {
 		  SnapToPoint (x, y, point);
       if (m_nViewType == XY)
       {
 		    z.origin[0] = point[0];
 		    z.origin[1] = point[1];
       }
       else if (m_nViewType == YZ)
       {
 		    z.origin[0] = point[1];
 		    z.origin[1] = point[2];
       }
       else
       {
 		    z.origin[0] = point[0];
 		    z.origin[1] = point[2];
       }
 		  Sys_UpdateWindows (W_XY_OVERLAY|W_Z);
 		  return;
     }
 	}
 }
 
 
 void CXYWnd::XY_MouseUp(int x, int y, int buttons)
 {
 	Drag_MouseUp (buttons);
 	if (!m_bPress_selection)
 		Sys_UpdateWindows (W_ALL);
 	m_nButtonstate = 0;
   while (::ShowCursor(TRUE) < 0)
     ;
 }
 
 qboolean CXYWnd::DragDelta (int x, int y, vec3_t move)
 {
 	vec3_t	xvec, yvec, delta;
 	int		i;
 
 	xvec[0] = 1 / m_fScale;
 	xvec[1] = xvec[2] = 0;
 	yvec[1] = 1 / m_fScale;
 	yvec[0] = yvec[2] = 0;
 
 	for (i=0 ; i<3 ; i++)
 	{
 		delta[i] = xvec[i] * (x - m_nPressx) + yvec[i] * (y - m_nPressy);
     if (!g_PrefsDlg.m_bNoClamp)
     {
 		  delta[i] = floor(delta[i] / g_qeglobals.d_gridsize + 0.5) * g_qeglobals.d_gridsize;
     }
 	}
 	VectorSubtract (delta, m_vPressdelta, move);
 	VectorCopy (delta, m_vPressdelta);
 
 	if (move[0] || move[1] || move[2])
 		return true;
 	return false;
 }
 
 
 /*
 ==============
 NewBrushDrag
 ==============
 */
 void CXYWnd::NewBrushDrag (int x, int y)
 {
 	vec3_t	mins, maxs, junk;
 	int		i;
 	float	temp;
 	brush_t	*n;
 
 	if (!DragDelta (x,y, junk))
 		return;
 
   // delete the current selection
 	if (selected_brushes.next != &selected_brushes)
 		Brush_Free (selected_brushes.next);
 	
   SnapToPoint (m_nPressx, m_nPressy, mins);
 
   int nDim = (m_nViewType == XY) ? 2 : (m_nViewType == YZ) ? 0 : 1;
 
 	mins[nDim] = g_qeglobals.d_gridsize * ((int)(g_qeglobals.d_new_brush_bottom_z / g_qeglobals.d_gridsize));
 	SnapToPoint (x, y, maxs);
 	maxs[nDim] = g_qeglobals.d_gridsize * ((int)(g_qeglobals.d_new_brush_top_z / g_qeglobals.d_gridsize));
 	if (maxs[nDim] <= mins[nDim])
 		maxs[nDim] = mins[nDim] + g_qeglobals.d_gridsize;
 
 	for (i=0 ; i<3 ; i++)
 	{
 		if (mins[i] == maxs[i])
 			return;	// don't create a degenerate brush
 		if (mins[i] > maxs[i])
 		{
 			temp = mins[i];
 			mins[i] = maxs[i];
 			maxs[i] = temp;
 		}
 	}
 
 	n = Brush_Create (mins, maxs, &g_qeglobals.d_texturewin.texdef);
 	if (!n)
 		return;
 
   vec3_t vSize;
   VectorSubtract(maxs, mins, vSize);
   g_strStatus.Format("Size X:: %.1f  Y:: %.1f  Z:: %.1f", vSize[0], vSize[1], vSize[2]);
   g_pParentWnd->SetStatusText(2, g_strStatus);
 
 	Brush_AddToList (n, &selected_brushes);
 
 	Entity_LinkBrush (world_entity, n);
 
 	Brush_Build( n );
 
   //	Sys_UpdateWindows (W_ALL);
 	Sys_UpdateWindows (W_XY| W_CAMERA);
 
 }
 
 /*
 ==============
 XY_MouseMoved
 ==============
 */
 void CXYWnd::XY_MouseMoved (int x, int y, int buttons)
 {
 	vec3_t	point;
 
 
 	if (!m_nButtonstate)
   {
     if (g_bCrossHairs)
     {
       ::ShowCursor(FALSE);
   		Sys_UpdateWindows (W_XY | W_XY_OVERLAY);
       ::ShowCursor(TRUE);
     }
 		return;
   }
 
 	// lbutton without selection = drag new brush
 	//if (m_nButtonstate == MK_LBUTTON && !m_bPress_selection && g_qeglobals.d_select_mode != sel_curvepoint && g_qeglobals.d_select_mode != sel_splineedit)
 	if (m_nButtonstate == MK_LBUTTON && !m_bPress_selection && g_qeglobals.d_select_mode == sel_brush)
 	{
 		NewBrushDrag (x, y);
 		return;
 	}
 
 	// lbutton (possibly with control and or shift)
 	// with selection = drag selection
 	if (m_nButtonstate & MK_LBUTTON)
 	{
 		Drag_MouseMoved (x, y, buttons);
 		Sys_UpdateWindows (W_XY_OVERLAY | W_CAMERA_IFON | W_Z);
 		return;
 	}
 
   int nMouseButton = g_PrefsDlg.m_nMouseButtons == 2 ? MK_RBUTTON : MK_MBUTTON;
 	// control mbutton = move camera
 	if (m_nButtonstate == (MK_CONTROL|nMouseButton) )
 	{
 		SnapToPoint (x, y, point);
 	  VectorCopyXY(point, g_pParentWnd->GetCamera()->Camera().origin);
 		Sys_UpdateWindows (W_XY_OVERLAY | W_CAMERA);
 		return;
 	}
 
 	// shift mbutton = move z checker
 	if (m_nButtonstate == (MK_SHIFT|nMouseButton) )
 	{
     if (RotateMode() || g_bPatchBendMode)
     {
 		  SnapToPoint (x, y, point);
 	    VectorCopyXY(point, g_vRotateOrigin);
       if (g_bPatchBendMode)
       {
         VectorCopy(point, g_vBendOrigin);
       }
 		  Sys_UpdateWindows (W_XY);
       return;
     }
     else
     {
 		  SnapToPoint (x, y, point);
       if (m_nViewType == XY)
       {
 		    z.origin[0] = point[0];
 		    z.origin[1] = point[1];
       }
       else if (m_nViewType == YZ)
       {
 		    z.origin[0] = point[1];
 		    z.origin[1] = point[2];
       }
       else
       {
 		    z.origin[0] = point[0];
 		    z.origin[1] = point[2];
       }
     }
 		Sys_UpdateWindows (W_XY_OVERLAY|W_Z);
 		return;
 	}
 
 	// mbutton = angle camera
 	if ((g_PrefsDlg.m_nMouseButtons == 3 && m_nButtonstate == MK_MBUTTON) ||
       (g_PrefsDlg.m_nMouseButtons == 2 && m_nButtonstate == (MK_SHIFT|MK_CONTROL|MK_RBUTTON)))
 	{	
 		SnapToPoint (x, y, point);
 		VectorSubtract (point, g_pParentWnd->GetCamera()->Camera().origin, point);
 
     int n1 = (m_nViewType == XY) ? 1 : 2;
     int n2 = (m_nViewType == YZ) ? 1 : 0;
     int nAngle = (m_nViewType == XY) ? YAW : PITCH;
     if (point[n1] || point[n2])
     {
 		  g_pParentWnd->GetCamera()->Camera().angles[nAngle] = 180/Q_PI*atan2 (point[n1], point[n2]);
 		  Sys_UpdateWindows (W_CAMERA_IFON|W_XY_OVERLAY);
     }
 		return;
 	}
 
 
 	// rbutton = drag xy origin
 	if (m_nButtonstate == MK_RBUTTON)
 	{
 		Sys_GetCursorPos (&x, &y);
 		if (x != m_ptCursor.x || y != m_ptCursor.y)
 		{
       int nDim1 = (m_nViewType == YZ) ? 1 : 0;
       int nDim2 = (m_nViewType == XY) ? 1 : 2;
 			m_vOrigin[nDim1] -= (x - m_ptCursor.x) / m_fScale;
 			m_vOrigin[nDim2] += (y - m_ptCursor.y) / m_fScale;
 	    SetCursorPos (m_ptCursor.x, m_ptCursor.y);
       ::ShowCursor(FALSE);
       //XY_Draw();
       //RedrawWindow(NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW);
 			Sys_UpdateWindows (W_XY | W_XY_OVERLAY);
       //::ShowCursor(TRUE);
 		}
 		return;
 	}
 
 }
 
 
 /*
 ============================================================================
 
 DRAWING
 
 ============================================================================
 */
 
 
 /*
 ==============
 XY_DrawGrid
 ==============
 */
 void CXYWnd::XY_DrawGrid()
 {
 	float	x, y, xb, xe, yb, ye;
 	int		w, h;
 	char	text[32];
 
 	qglDisable(GL_TEXTURE_2D);
 	qglDisable(GL_TEXTURE_1D);
 	qglDisable(GL_DEPTH_TEST);
 	qglDisable(GL_BLEND);
 
 	w = m_nWidth / 2 / m_fScale;
 	h = m_nHeight / 2 / m_fScale;
 
 
   int nDim1 = (m_nViewType == YZ) ? 1 : 0;
   int nDim2 = (m_nViewType == XY) ? 1 : 2;
   //int nDim1 = 0;
   //int nDim2 = 1;
 
 
 	xb = m_vOrigin[nDim1] - w;
 	if (xb < region_mins[nDim1])
 		xb = region_mins[nDim1];
 	xb = 64 * floor (xb/64);
 
 	xe = m_vOrigin[nDim1] + w;
 	if (xe > region_maxs[nDim1])
 		xe = region_maxs[nDim1];
 	xe = 64 * ceil (xe/64);
 
 	yb = m_vOrigin[nDim2] - h;
 	if (yb < region_mins[nDim2])
 		yb = region_mins[nDim2];
 	yb = 64 * floor (yb/64);
 
 	ye = m_vOrigin[nDim2] + h;
 	if (ye > region_maxs[nDim2])
 		ye = region_maxs[nDim2];
 	ye = 64 * ceil (ye/64);
 
 	// draw major blocks
 
 	qglColor3fv(g_qeglobals.d_savedinfo.colors[COLOR_GRIDMAJOR]);
 
 	int stepSize = 64 * 0.1 / m_fScale;
 	if (stepSize < 64) {
 		stepSize = 64;
 	} else {
 		int i;
 		for (i = 1; i < stepSize; i <<= 1) {
 		}
 		stepSize = i;
 	}
 
 	if ( g_qeglobals.d_showgrid )
 	{
 		
 		qglBegin (GL_LINES);
 		
 		for (x=xb ; x<=xe ; x+=stepSize)
 		{
 			qglVertex2f (x, yb);
 			qglVertex2f (x, ye);
 		}
 		for (y=yb ; y<=ye ; y+=stepSize)
 		{
 			qglVertex2f (xb, y);
 			qglVertex2f (xe, y);
 		}
 		
 		qglEnd ();
 		
 	}
 
 	// draw minor blocks
 	if ( m_fScale > .1 && g_qeglobals.d_showgrid && g_qeglobals.d_gridsize * m_fScale >= 4 && 
        g_qeglobals.d_savedinfo.colors[COLOR_GRIDMINOR] != g_qeglobals.d_savedinfo.colors[COLOR_GRIDBACK])
 	{
 		qglColor3fv(g_qeglobals.d_savedinfo.colors[COLOR_GRIDMINOR]);
 
 		qglBegin (GL_LINES);
 		for (x=xb ; x<xe ; x += g_qeglobals.d_gridsize)
 		{
 			if ( ! ((int)x & 63) )
 				continue;
 			qglVertex2f (x, yb);
 			qglVertex2f (x, ye);
 		}
 		for (y=yb ; y<ye ; y+=g_qeglobals.d_gridsize)
 		{
 			if ( ! ((int)y & 63) )
 				continue;
 			qglVertex2f (xb, y);
 			qglVertex2f (xe, y);
 		}
 		qglEnd ();
 	}
 
 	// draw coordinate text if needed
 
 	if ( g_qeglobals.d_savedinfo.show_coordinates)
 	{
 		//glColor4f(0, 0, 0, 0);
 		qglColor3fv(g_qeglobals.d_savedinfo.colors[COLOR_GRIDTEXT]);
 
 		for (x=xb ; x<xe ; x+=stepSize)
 		{
 			qglRasterPos2f (x, m_vOrigin[nDim2] + h - 6 / m_fScale);
 			sprintf (text, "%i",(int)x);
 			qglCallLists (strlen(text), GL_UNSIGNED_BYTE, text);
 		}
 		for (y=yb ; y<ye ; y+=stepSize)
 		{
 			qglRasterPos2f (m_vOrigin[nDim1] - w + 1, y);
 			sprintf (text, "%i",(int)y);
 			qglCallLists (strlen(text), GL_UNSIGNED_BYTE, text);
 		}
 
 
     if (Active())
 		  qglColor3fv(g_qeglobals.d_savedinfo.colors[COLOR_VIEWNAME]);
 
     qglRasterPos2f ( m_vOrigin[nDim1] - w + 35 / m_fScale, m_vOrigin[nDim2] + h - 20 / m_fScale );
 
     char cView[20];
     if (m_nViewType == XY)
       strcpy(cView, "XY Top");
     else 
     if (m_nViewType == XZ)
       strcpy(cView, "XZ Front");
     else
       strcpy(cView, "YZ Side");
 
 		qglCallLists (strlen(cView), GL_UNSIGNED_BYTE, cView);
     
 
   }
 
 
 /*
   if (true)
   {
 		qglColor3f(g_qeglobals.d_savedinfo.colors[COLOR_GRIDMINOR]);
 		qglBegin (GL_LINES);
   	qglVertex2f (x, yb);
 		qglVertex2f (x, ye);
     qglEnd();
   }
   */
 
 }
 
 /*
 ==============
 XY_DrawBlockGrid
 ==============
 */
 void CXYWnd::XY_DrawBlockGrid()
 {
 	float	x, y, xb, xe, yb, ye;
 	int		w, h;
 	char	text[32];
 
 	qglDisable(GL_TEXTURE_2D);
 	qglDisable(GL_TEXTURE_1D);
 	qglDisable(GL_DEPTH_TEST);
 	qglDisable(GL_BLEND);
 
 	w = m_nWidth / 2 / m_fScale;
 	h = m_nHeight / 2 / m_fScale;
 
   int nDim1 = (m_nViewType == YZ) ? 1 : 0;
   int nDim2 = (m_nViewType == XY) ? 1 : 2;
 
   xb = m_vOrigin[nDim1] - w;
 	if (xb < region_mins[nDim1])
 		xb = region_mins[nDim1];
 	xb = 1024 * floor (xb/1024);
 
 	xe = m_vOrigin[nDim1] + w;
 	if (xe > region_maxs[nDim1])
 		xe = region_maxs[nDim1];
 	xe = 1024 * ceil (xe/1024);
 
 	yb = m_vOrigin[nDim2] - h;
 	if (yb < region_mins[nDim2])
 		yb = region_mins[nDim2];
 	yb = 1024 * floor (yb/1024);
 
 	ye = m_vOrigin[nDim2] + h;
 	if (ye > region_maxs[nDim2])
 		ye = region_maxs[nDim2];
 	ye = 1024 * ceil (ye/1024);
 
 	// draw major blocks
 
   qglColor3fv(g_qeglobals.d_savedinfo.colors[COLOR_GRIDBLOCK]);
 	qglLineWidth (2);
 
 	qglBegin (GL_LINES);
 	
 	for (x=xb ; x<=xe ; x+=1024)
 	{
 		qglVertex2f (x, yb);
 		qglVertex2f (x, ye);
 	}
 	for (y=yb ; y<=ye ; y+=1024)
 	{
 		qglVertex2f (xb, y);
 		qglVertex2f (xe, y);
 	}
 	
 	qglEnd ();
 	qglLineWidth (1);
 
 	// draw coordinate text if needed
 
 	for (x=xb ; x<xe ; x+=1024)
 		for (y=yb ; y<ye ; y+=1024)
 		{
 			qglRasterPos2f (x+512, y+512);
 			sprintf (text, "%i,%i",(int)floor(x/1024), (int)floor(y/1024) );
 			qglCallLists (strlen(text), GL_UNSIGNED_BYTE, text);
 		}
 
 	qglColor4f(0, 0, 0, 0);
 }
 
 void CXYWnd::DrawRotateIcon()
 {
 	float	x, y;
 
   if (m_nViewType == XY)
   {
     x = g_vRotateOrigin[0];
     y = g_vRotateOrigin[1];
   }
   else if (m_nViewType == YZ)
   {
     x = g_vRotateOrigin[1];
     y = g_vRotateOrigin[2];
   }
   else
   {
     x = g_vRotateOrigin[0];
     y = g_vRotateOrigin[2];
   }
 
 	qglEnable (GL_BLEND);
 	qglDisable (GL_TEXTURE_2D);
 	qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
 	qglDisable (GL_CULL_FACE);
 	qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 	qglColor4f (0.8, 0.1, 0.9, 0.25);
 
   qglBegin(GL_QUADS);
 	qglVertex3f (x-4,y-4,0);
 	qglVertex3f (x+4,y-4,0);
 	qglVertex3f (x+4,y+4,0);
 	qglVertex3f (x-4,y+4,0);
 	qglEnd ();
 	qglDisable (GL_BLEND);
 
 	qglColor4f (1.0, 0.2, 1.0, 1);
 	qglBegin(GL_POINTS);
 	qglVertex3f (x,y,0);
 	qglEnd ();
 
 #if 0
 	qglBegin(GL_LINES);
 	qglVertex3f (x-6,y+6,0);
 	qglVertex3f (x+6,y+6,0);
 	qglVertex3f (x-6,y-6,0);
 	qglVertex3f (x+6,y-6,0);
 	qglEnd ();
 #endif
 
 }
 
 void CXYWnd::DrawCameraIcon()
 {
 	float	x, y, a;
 
   if (m_nViewType == XY)
   {
     x = g_pParentWnd->GetCamera()->Camera().origin[0];
 		y = g_pParentWnd->GetCamera()->Camera().origin[1];
 	  a = g_pParentWnd->GetCamera()->Camera().angles[YAW]/180*Q_PI;
   }
   else if (m_nViewType == YZ)
   {
 	  x = g_pParentWnd->GetCamera()->Camera().origin[1];
 		y = g_pParentWnd->GetCamera()->Camera().origin[2];
 	  a = g_pParentWnd->GetCamera()->Camera().angles[PITCH]/180*Q_PI;
   }
   else
   {
 	  x = g_pParentWnd->GetCamera()->Camera().origin[0];
 		y = g_pParentWnd->GetCamera()->Camera().origin[2];
 	  a = g_pParentWnd->GetCamera()->Camera().angles[PITCH]/180*Q_PI;
   }
 
 	qglColor3f (0.0, 0.0, 1.0);
 	qglBegin(GL_LINE_STRIP);
 	qglVertex3f (x-16,y,0);
 	qglVertex3f (x,y+8,0);
 	qglVertex3f (x+16,y,0);
 	qglVertex3f (x,y-8,0);
 	qglVertex3f (x-16,y,0);
 	qglVertex3f (x+16,y,0);
 	qglEnd ();
 	
 	qglBegin(GL_LINE_STRIP);
 	qglVertex3f (x+48*cos(a+Q_PI/4), y+48*sin(a+Q_PI/4), 0);
 	qglVertex3f (x, y, 0);
 	qglVertex3f (x+48*cos(a-Q_PI/4), y+48*sin(a-Q_PI/4), 0);
 	qglEnd ();
 
 #if 0
   char text[128];
 	qglRasterPos2f (x+64, y+64);
 	sprintf (text, "%f",g_pParentWnd->GetCamera()->Camera().angles[YAW]);
 	qglCallLists (strlen(text), GL_UNSIGNED_BYTE, text);
 #endif
 
 }
 
 void CXYWnd::DrawZIcon (void)
 {
   if (m_nViewType == XY)
   {
 	  float x = z.origin[0];
 	  float y = z.origin[1];
 	  qglEnable (GL_BLEND);
 	  qglDisable (GL_TEXTURE_2D);
 	  qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
 	  qglDisable (GL_CULL_FACE);
 	  qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 	  qglColor4f (0.0, 0.0, 1.0, 0.25);
 	  qglBegin(GL_QUADS);
 	  qglVertex3f (x-8,y-8,0);
 	  qglVertex3f (x+8,y-8,0);
 	  qglVertex3f (x+8,y+8,0);
 	  qglVertex3f (x-8,y+8,0);
 	  qglEnd ();
 	  qglDisable (GL_BLEND);
 
 	  qglColor4f (0.0, 0.0, 1.0, 1);
 
 	  qglBegin(GL_LINE_LOOP);
 	  qglVertex3f (x-8,y-8,0);
 	  qglVertex3f (x+8,y-8,0);
 	  qglVertex3f (x+8,y+8,0);
 	  qglVertex3f (x-8,y+8,0);
 	  qglEnd ();
 
     qglBegin(GL_LINE_STRIP);
 	  qglVertex3f (x-4,y+4,0);
 	  qglVertex3f (x+4,y+4,0);
 	  qglVertex3f (x-4,y-4,0);
 	  qglVertex3f (x+4,y-4,0);
 	  qglEnd ();
   }
 }
 
 
 /*
 ==================
 FilterBrush
 ==================
 */
 BOOL FilterBrush(brush_t *pb)
 {
 	if (!pb->owner)
 		return FALSE;		// during construction
 
   if (pb->hiddenBrush)
   {
     return TRUE;
   }
 
 	if (g_qeglobals.d_savedinfo.exclude & EXCLUDE_CAULK)
   {
     // filter out the brush only if all faces are caulk
     // if not don't hide the whole brush, proceed on a per-face basis (Cam_Draw)
     //++timo TODO: set this as a preference .. show caulk: hide any brush with caulk // don't draw caulk faces
     face_t *f;
     f=pb->brush_faces;
     while (f)
     {
       if (!strstr(f->texdef.name, "caulk"))
         break;
       f = f->next;
     }
     if (!f)
       return TRUE;
 
 #if 0
     if (strstr(pb->brush_faces->texdef.name, "caulk"))
       return TRUE;
 #endif
 
     //++timo FIXME: .. same deal here?
     if (strstr(pb->brush_faces->texdef.name, "donotenter"))
       return TRUE;
   }
 
 	if (g_qeglobals.d_savedinfo.exclude & EXCLUDE_HINT)
   {
     if (strstr(pb->brush_faces->texdef.name, "hint"))
       return TRUE;
   }
 
 	if (g_qeglobals.d_savedinfo.exclude & EXCLUDE_CLIP)
 	{
     if (strstr(pb->brush_faces->texdef.name, "clip"))
       return TRUE;
 
     if (strstr(pb->brush_faces->texdef.name, "skip"))
       return TRUE;
 
 		//if (!strncmp(pb->brush_faces->texdef.name, "clip", 4))
 		//	return TRUE;
 	}
 
 	if (g_qeglobals.d_savedinfo.exclude & EXCLUDE_WATER)
 	{
 		for (face_t* f = pb->brush_faces ; f ; f=f->next)
     {
       if (f->texdef.contents & (CONTENTS_WATER | CONTENTS_SLIME | CONTENTS_LAVA))
         return TRUE;
     }
 	}
 
 	if (g_qeglobals.d_savedinfo.exclude & EXCLUDE_DETAIL)
 	{
 		if (pb->brush_faces->texdef.contents & CONTENTS_DETAIL)
 			return TRUE;
 	}
 
 	if (g_qeglobals.d_savedinfo.exclude & EXCLUDE_CURVES)
 	{
 		if (pb->patchBrush)
 			return TRUE;
 	}
 
 	if( g_qeglobals.d_savedinfo.exclude & EXCLUDE_TERRAIN )
 	{
 		if( pb->terrainBrush )
 		{
 			return TRUE;
 		}
 	}
 
 	if (pb->owner == world_entity)
 	{
 		if (g_qeglobals.d_savedinfo.exclude & EXCLUDE_WORLD)
 			return TRUE;
 		return FALSE;
 	}
 	else 
   {
     if (g_qeglobals.d_savedinfo.exclude & EXCLUDE_ENT)
     {
 		  return (strncmp(pb->owner->eclass->name, "func_group", 10));
     }
   }
 
 	if (g_qeglobals.d_savedinfo.exclude & EXCLUDE_LIGHTS)
 	{
     return (pb->owner->eclass->nShowFlags & ECLASS_LIGHT);
 		//if (!strncmp(pb->owner->eclass->name, "light", 5))
 		//	return TRUE;
 	}
 
 	if (g_qeglobals.d_savedinfo.exclude & EXCLUDE_PATHS)
 	{
     return (pb->owner->eclass->nShowFlags & ECLASS_PATH);
 		//if (!strncmp(pb->owner->eclass->name, "path", 4))
 		//	return TRUE;
 	}
 
 	return FALSE;
 }
 
 /*
 =============================================================
 
   PATH LINES
 
 =============================================================
 */
 
 /*
 ==================
 DrawPathLines
 
 Draws connections between entities.
 Needs to consider all entities, not just ones on screen,
 because the lines can be visible when neither end is.
 Called for both camera view and xy view.
 ==================
 */
 void DrawPathLines (void)
 {
 	int		i, j, k;
 	vec3_t	mid, mid1;
 	entity_t *se, *te;
 	brush_t	*sb, *tb;
 	char	*psz;
 	vec3_t	dir, s1, s2;
 	vec_t	len, f;
 	int		arrows;
 	int			num_entities;
 	char		*ent_target[MAX_MAP_ENTITIES];
 	entity_t	*ent_entity[MAX_MAP_ENTITIES];
 
 	if (g_qeglobals.d_savedinfo.exclude & EXCLUDE_PATHS)
     return;
 
 	num_entities = 0;
 	for (te = entities.next ; te != &entities && num_entities != MAX_MAP_ENTITIES ; te = te->next)
 	{
 		ent_target[num_entities] = ValueForKey (te, "target");
 		if (ent_target[num_entities][0])
 		{
 			ent_entity[num_entities] = te;
 			num_entities++;
 		}
 	}
 
 	for (se = entities.next ; se != &entities ; se = se->next)
 	{
 		psz = ValueForKey(se, "targetname");
 	
 		if (psz == NULL || psz[0] == '\0')
 			continue;
 		
 		sb = se->brushes.onext;
 		if (sb == &se->brushes)
 			continue;
 
 		for (k=0 ; k<num_entities ; k++)
 		{
 		if (strcmp (ent_target[k], psz))
 				continue;
 
 			te = ent_entity[k];
 			tb = te->brushes.onext;
 			if (tb == &te->brushes)
 				continue;
 
 			for (i=0 ; i<3 ; i++)
 				mid[i] = (sb->mins[i] + sb->maxs[i])*0.5; 
 
 			for (i=0 ; i<3 ; i++)
 				mid1[i] = (tb->mins[i] + tb->maxs[i])*0.5; 
 
 			VectorSubtract (mid1, mid, dir);
 			len = VectorNormalize (dir);
 			s1[0] = -dir[1]*8 + dir[0]*8;
 			s2[0] = dir[1]*8 + dir[0]*8;
 			s1[1] = dir[0]*8 + dir[1]*8;
 			s2[1] = -dir[0]*8 + dir[1]*8;
 
 			qglColor3f (se->eclass->color[0], se->eclass->color[1], se->eclass->color[2]);
 
 			qglBegin(GL_LINES);
 			qglVertex3fv(mid);
 			qglVertex3fv(mid1);
 
 			arrows = (int)(len / 256) + 1;
 
 			for (i=0 ; i<arrows ; i++)
 			{
 				f = len * (i + 0.5) / arrows;
 
 				for (j=0 ; j<3 ; j++)
 					mid1[j] = mid[j] + f*dir[j];
 				qglVertex3fv (mid1);
 				qglVertex3f (mid1[0] + s1[0], mid1[1] + s1[1], mid1[2]);
 				qglVertex3fv (mid1);
 				qglVertex3f (mid1[0] + s2[0], mid1[1] + s2[1], mid1[2]);
 			}
 
 			qglEnd();
 		}
 	}
 
 	return;
 }
 
 //=============================================================
 
 // can be greatly simplified but per usual i am in a hurry 
 // which is not an excuse, just a fact
 void CXYWnd::PaintSizeInfo(int nDim1, int nDim2, vec3_t vMinBounds, vec3_t vMaxBounds)
 {
 
   vec3_t vSize;
   VectorSubtract(vMaxBounds, vMinBounds, vSize);
 
   qglColor3f(g_qeglobals.d_savedinfo.colors[COLOR_SELBRUSHES][0] * .65, 
             g_qeglobals.d_savedinfo.colors[COLOR_SELBRUSHES][1] * .65,
             g_qeglobals.d_savedinfo.colors[COLOR_SELBRUSHES][2] * .65);
 
   if (m_nViewType == XY)
   {
 		qglBegin (GL_LINES);
 
     qglVertex3f(vMinBounds[nDim1], vMinBounds[nDim2] - 6.0f  / m_fScale, 0.0f);
     qglVertex3f(vMinBounds[nDim1], vMinBounds[nDim2] - 10.0f / m_fScale, 0.0f);
 
     qglVertex3f(vMinBounds[nDim1], vMinBounds[nDim2] - 10.0f  / m_fScale, 0.0f);
     qglVertex3f(vMaxBounds[nDim1], vMinBounds[nDim2] - 10.0f  / m_fScale, 0.0f);
 
     qglVertex3f(vMaxBounds[nDim1], vMinBounds[nDim2] - 6.0f  / m_fScale, 0.0f);
     qglVertex3f(vMaxBounds[nDim1], vMinBounds[nDim2] - 10.0f / m_fScale, 0.0f);
   
 
     qglVertex3f(vMaxBounds[nDim1] + 6.0f  / m_fScale, vMinBounds[nDim2], 0.0f);
     qglVertex3f(vMaxBounds[nDim1] + 10.0f  / m_fScale, vMinBounds[nDim2], 0.0f);
 
     qglVertex3f(vMaxBounds[nDim1] + 10.0f  / m_fScale, vMinBounds[nDim2], 0.0f);
     qglVertex3f(vMaxBounds[nDim1] + 10.0f  / m_fScale, vMaxBounds[nDim2], 0.0f);
   
     qglVertex3f(vMaxBounds[nDim1] + 6.0f  / m_fScale, vMaxBounds[nDim2], 0.0f);
     qglVertex3f(vMaxBounds[nDim1] + 10.0f  / m_fScale, vMaxBounds[nDim2], 0.0f);
 
     qglEnd();
 
     qglRasterPos3f (Betwixt(vMinBounds[nDim1], vMaxBounds[nDim1]),  vMinBounds[nDim2] - 20.0  / m_fScale, 0.0f);
     g_strDim.Format(g_pDimStrings[nDim1], vSize[nDim1]);
 	  qglCallLists (g_strDim.GetLength(), GL_UNSIGNED_BYTE, g_strDim);
     
     qglRasterPos3f (vMaxBounds[nDim1] + 16.0  / m_fScale, Betwixt(vMinBounds[nDim2], vMaxBounds[nDim2]), 0.0f);
     g_strDim.Format(g_pDimStrings[nDim2], vSize[nDim2]);
 	  qglCallLists (g_strDim.GetLength(), GL_UNSIGNED_BYTE, g_strDim);
 
     qglRasterPos3f (vMinBounds[nDim1] + 4, vMaxBounds[nDim2] + 8 / m_fScale, 0.0f);
     g_strDim.Format(g_pOrgStrings[0], vMinBounds[nDim1], vMaxBounds[nDim2]);
 	  qglCallLists (g_strDim.GetLength(), GL_UNSIGNED_BYTE, g_strDim);
 
   }
   else
   if (m_nViewType == XZ)
   {
 		qglBegin (GL_LINES);
 
     qglVertex3f(vMinBounds[nDim1], 0, vMinBounds[nDim2] - 6.0f  / m_fScale);
     qglVertex3f(vMinBounds[nDim1], 0, vMinBounds[nDim2] - 10.0f / m_fScale);
 
     qglVertex3f(vMinBounds[nDim1], 0,vMinBounds[nDim2] - 10.0f  / m_fScale);
     qglVertex3f(vMaxBounds[nDim1], 0,vMinBounds[nDim2] - 10.0f  / m_fScale);
 
     qglVertex3f(vMaxBounds[nDim1], 0,vMinBounds[nDim2] - 6.0f  / m_fScale);
     qglVertex3f(vMaxBounds[nDim1], 0,vMinBounds[nDim2] - 10.0f / m_fScale);
   
 
     qglVertex3f(vMaxBounds[nDim1] + 6.0f  / m_fScale, 0,vMinBounds[nDim2]);
     qglVertex3f(vMaxBounds[nDim1] + 10.0f  / m_fScale, 0,vMinBounds[nDim2]);
 
     qglVertex3f(vMaxBounds[nDim1] + 10.0f  / m_fScale, 0,vMinBounds[nDim2]);
     qglVertex3f(vMaxBounds[nDim1] + 10.0f  / m_fScale, 0,vMaxBounds[nDim2]);
   
     qglVertex3f(vMaxBounds[nDim1] + 6.0f  / m_fScale, 0,vMaxBounds[nDim2]);
     qglVertex3f(vMaxBounds[nDim1] + 10.0f  / m_fScale, 0,vMaxBounds[nDim2]);
 
     qglEnd();
 
     qglRasterPos3f (Betwixt(vMinBounds[nDim1], vMaxBounds[nDim1]), 0, vMinBounds[nDim2] - 20.0  / m_fScale);
     g_strDim.Format(g_pDimStrings[nDim1], vSize[nDim1]);
 	  qglCallLists (g_strDim.GetLength(), GL_UNSIGNED_BYTE, g_strDim);
     
     qglRasterPos3f (vMaxBounds[nDim1] + 16.0  / m_fScale, 0, Betwixt(vMinBounds[nDim2], vMaxBounds[nDim2]));
     g_strDim.Format(g_pDimStrings[nDim2], vSize[nDim2]);
 	  qglCallLists (g_strDim.GetLength(), GL_UNSIGNED_BYTE, g_strDim);
 
     qglRasterPos3f (vMinBounds[nDim1] + 4, 0, vMaxBounds[nDim2] + 8 / m_fScale);
     g_strDim.Format(g_pOrgStrings[1], vMinBounds[nDim1], vMaxBounds[nDim2]);
 	  qglCallLists (g_strDim.GetLength(), GL_UNSIGNED_BYTE, g_strDim);
 
   }
   else
   {
 		qglBegin (GL_LINES);
 
     qglVertex3f(0, vMinBounds[nDim1], vMinBounds[nDim2] - 6.0f  / m_fScale);
     qglVertex3f(0, vMinBounds[nDim1], vMinBounds[nDim2] - 10.0f / m_fScale);
 
     qglVertex3f(0, vMinBounds[nDim1], vMinBounds[nDim2] - 10.0f  / m_fScale);
     qglVertex3f(0, vMaxBounds[nDim1], vMinBounds[nDim2] - 10.0f  / m_fScale);
 
     qglVertex3f(0, vMaxBounds[nDim1], vMinBounds[nDim2] - 6.0f  / m_fScale);
     qglVertex3f(0, vMaxBounds[nDim1], vMinBounds[nDim2] - 10.0f / m_fScale);
   
 
     qglVertex3f(0, vMaxBounds[nDim1] + 6.0f  / m_fScale, vMinBounds[nDim2]);
     qglVertex3f(0, vMaxBounds[nDim1] + 10.0f  / m_fScale, vMinBounds[nDim2]);
 
     qglVertex3f(0, vMaxBounds[nDim1] + 10.0f  / m_fScale, vMinBounds[nDim2]);
     qglVertex3f(0, vMaxBounds[nDim1] + 10.0f  / m_fScale, vMaxBounds[nDim2]);
   
     qglVertex3f(0, vMaxBounds[nDim1] + 6.0f  / m_fScale, vMaxBounds[nDim2]);
     qglVertex3f(0, vMaxBounds[nDim1] + 10.0f  / m_fScale, vMaxBounds[nDim2]);
 
     qglEnd();
 
     qglRasterPos3f (0, Betwixt(vMinBounds[nDim1], vMaxBounds[nDim1]),  vMinBounds[nDim2] - 20.0  / m_fScale);
     g_strDim.Format(g_pDimStrings[nDim1], vSize[nDim1]);
 	  qglCallLists (g_strDim.GetLength(), GL_UNSIGNED_BYTE, g_strDim);
     
     qglRasterPos3f (0, vMaxBounds[nDim1] + 16.0  / m_fScale, Betwixt(vMinBounds[nDim2], vMaxBounds[nDim2]));
     g_strDim.Format(g_pDimStrings[nDim2], vSize[nDim2]);
 	  qglCallLists (g_strDim.GetLength(), GL_UNSIGNED_BYTE, g_strDim);
 
     qglRasterPos3f (0, vMinBounds[nDim1] + 4.0, vMaxBounds[nDim2] + 8 / m_fScale);
     g_strDim.Format(g_pOrgStrings[2], vMinBounds[nDim1], vMaxBounds[nDim2]);
 	  qglCallLists (g_strDim.GetLength(), GL_UNSIGNED_BYTE, g_strDim);
 
   }
 }
 
 
 
 /*
 ==============
 XY_Draw
 ==============
 */
 long g_lCount = 0;
 long g_lTotal = 0;
 extern void DrawBrushEntityName (brush_t *b);
 
 void CXYWnd::XY_Draw()
 {
   brush_t	*brush;
 	float	w, h;
 	entity_t	*e;
 	double	start, end;
 	double	start2, end2;
 	vec3_t	mins, maxs;
 	int		drawn, culled;
 	int		i;
 
 	if (!active_brushes.next)
 		return;	// not valid yet
 
 	if (m_bTiming)
 		start = Sys_DoubleTime();
 	//
 	// clear
 	//
 	m_bDirty = false;
 
 	qglViewport(0, 0, m_nWidth, m_nHeight);
 	qglClearColor (g_qeglobals.d_savedinfo.colors[COLOR_GRIDBACK][0],
 		            g_qeglobals.d_savedinfo.colors[COLOR_GRIDBACK][1],
 		            g_qeglobals.d_savedinfo.colors[COLOR_GRIDBACK][2],0);
 
   qglClear(GL_COLOR_BUFFER_BIT);
 
 	//
 	// set up viewpoint
 	//
 	qglMatrixMode(GL_PROJECTION);
   qglLoadIdentity ();
 
 	w = m_nWidth / 2 / m_fScale;
 	h = m_nHeight / 2/ m_fScale;
   int nDim1 = (m_nViewType == YZ) ? 1 : 0;
   int nDim2 = (m_nViewType == XY) ? 1 : 2;
 	mins[0] = m_vOrigin[nDim1] - w;
 	maxs[0] = m_vOrigin[nDim1] + w;
 	mins[1] = m_vOrigin[nDim2] - h;
 	maxs[1] = m_vOrigin[nDim2] + h;
 
 
 	qglOrtho (mins[0], maxs[0], mins[1], maxs[1], -8192, 8192);
   //glRotatef
 	//
 	// now draw the grid
 	//
 	XY_DrawGrid ();
 
 	//
 	// draw stuff
 	//
   qglShadeModel (GL_FLAT);
 	qglDisable(GL_TEXTURE_2D);
 	qglDisable(GL_TEXTURE_1D);
 	qglDisable(GL_DEPTH_TEST);
 	qglDisable(GL_BLEND);
 	qglColor3f(0, 0, 0);
 
   //glEnable (GL_LINE_SMOOTH);
 
 	drawn = culled = 0;
 
   if (m_nViewType != XY)
   {
     qglPushMatrix();
     if (m_nViewType == YZ)
       qglRotatef (-90,  0, 1, 0);	    // put Z going up
     //else
       qglRotatef (-90,  1, 0, 0);	    // put Z going up
   }
 
 	e = world_entity;
 	
   if (m_bTiming)
 		start2 = Sys_DoubleTime();
 
 	for (brush = active_brushes.next ; brush != &active_brushes ; brush=brush->next)
 	{
 		if (brush->mins[nDim1] > maxs[0] || 
         brush->mins[nDim2] > maxs[1] || 
         brush->maxs[nDim1] < mins[0] || 
         brush->maxs[nDim2] < mins[1])
 		{
 		  culled++;
 		  continue;		// off screen
 		}
 
 	 	if (FilterBrush (brush))
 	 		continue;
 
     drawn++;
 
     if (brush->owner != e && brush->owner)
 		{
 
 			qglColor3fv(brush->owner->eclass->color);
 		}
     else
     {
 		  qglColor3fv(g_qeglobals.d_savedinfo.colors[COLOR_BRUSHES]);
     }
 
     Brush_DrawXY(brush, m_nViewType);
 	}
   
   
   if (m_bTiming)
 		end2 = Sys_DoubleTime();
 
 
   DrawPathLines ();
 
 	//
 	// draw pointfile
 	//
 	if ( g_qeglobals.d_pointfile_display_list)
 		qglCallList (g_qeglobals.d_pointfile_display_list);
 
 
   if (!(m_nViewType == XY))
     qglPopMatrix();
 
   //
 	// draw block grid
 	//
 	if ( g_qeglobals.show_blocks)
 		XY_DrawBlockGrid ();
 
 	//
 	// now draw selected brushes
 	//
   if (m_nViewType != XY)
   {
     qglPushMatrix();
     if (m_nViewType == YZ)
       qglRotatef (-90,  0, 1, 0);	    // put Z going up
     //else
       qglRotatef (-90,  1, 0, 0);	    // put Z going up
   }
 
 
   qglPushMatrix();
 	qglTranslatef( g_qeglobals.d_select_translate[0], g_qeglobals.d_select_translate[1], g_qeglobals.d_select_translate[2]);
 
   if (RotateMode())
     qglColor3f(0.8, 0.1, 0.9);
   else
   if (ScaleMode())
     qglColor3f(0.1, 0.8, 0.1);
   else
     qglColor3fv(g_qeglobals.d_savedinfo.colors[COLOR_SELBRUSHES]);
 
 
   if (g_PrefsDlg.m_bNoStipple == FALSE)
   {
     qglEnable (GL_LINE_STIPPLE);
 	  qglLineStipple (3, 0xaaaa);
   }
 	qglLineWidth (2);
 
   vec3_t vMinBounds;
   vec3_t vMaxBounds;
   vMinBounds[0] = vMinBounds[1] = vMinBounds[2] = 9999.9f;
   vMaxBounds[0] = vMaxBounds[1] = vMaxBounds[2] = -9999.9f;
 
   int nSaveDrawn = drawn;
   bool bFixedSize = false;
 	for (brush = selected_brushes.next ; brush != &selected_brushes ; brush=brush->next)
 	{
 		drawn++;
 		Brush_DrawXY(brush, m_nViewType);
 
     if (!bFixedSize)
     {
       if (brush->owner->eclass->fixedsize)
         bFixedSize = true;
       if (g_PrefsDlg.m_bSizePaint)
       {
         for (i = 0; i < 3; i ++)
         {
           if (brush->mins[i] < vMinBounds[i])
             vMinBounds[i] = brush->mins[i];
           if (brush->maxs[i] > vMaxBounds[i])
             vMaxBounds[i] = brush->maxs[i];
         }
       }
     }
 	}
 
   if (g_PrefsDlg.m_bNoStipple == FALSE)
   {
 	  qglDisable (GL_LINE_STIPPLE);
   }
 	qglLineWidth (1);
 
   if (!bFixedSize && !RotateMode() && !ScaleMode() && drawn - nSaveDrawn > 0 && g_PrefsDlg.m_bSizePaint)
     PaintSizeInfo(nDim1, nDim2, vMinBounds, vMaxBounds);
 
 
 	// edge / vertex flags
 
 	if (g_qeglobals.d_select_mode == sel_vertex)
 	{
 		qglPointSize (4);
 		qglColor3f (0,1,0);
 		qglBegin (GL_POINTS);
 		for (i=0 ; i<g_qeglobals.d_numpoints ; i++)
 			qglVertex3fv (g_qeglobals.d_points[i]);
 		qglEnd ();
 		qglPointSize (1);
 	}
 	else if (g_qeglobals.d_select_mode == sel_edge)
 	{
 		float	*v1, *v2;
 
 		qglPointSize (4);
 		qglColor3f (0,0,1);
 		qglBegin (GL_POINTS);
 		for (i=0 ; i<g_qeglobals.d_numedges ; i++)
 		{
 			v1 = g_qeglobals.d_points[g_qeglobals.d_edges[i].p1];
 			v2 = g_qeglobals.d_points[g_qeglobals.d_edges[i].p2];
 			qglVertex3f ( (v1[0]+v2[0])*0.5,(v1[1]+v2[1])*0.5,(v1[2]+v2[2])*0.5);
 		}
 		qglEnd ();
 		qglPointSize (1);
 	}
 
 
 	g_splineList->draw(static_cast<qboolean>(g_qeglobals.d_select_mode == sel_editpoint || g_qeglobals.d_select_mode == sel_addpoint));
 
   qglPopMatrix();
 
 	qglTranslatef (-g_qeglobals.d_select_translate[0], -g_qeglobals.d_select_translate[1], -g_qeglobals.d_select_translate[2]);
 
 
   if (!(m_nViewType == XY))
     qglPopMatrix();
 
   // area selection hack
   if (g_qeglobals.d_select_mode == sel_area)
   {
 	  qglEnable (GL_BLEND);
 	  qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 	  qglColor4f(0.0, 0.0, 1.0, 0.25);
     qglRectf(g_qeglobals.d_vAreaTL[nDim1], g_qeglobals.d_vAreaTL[nDim2], g_qeglobals.d_vAreaBR[nDim1], g_qeglobals.d_vAreaBR[nDim2]);
 	  qglDisable (GL_BLEND);
   }
 
 
   //
 	// now draw camera point
 	//
 	DrawCameraIcon ();
 	DrawZIcon ();
 
   if (RotateMode())
   {
     DrawRotateIcon();
   }
 
   // plugin entities
   //++timo TODO: use an object for the 2D view
   DrawPluginEntities( (VIEWTYPE)m_nViewType );
 
   qglFinish();
 	//QE_CheckOpenGLForErrors();
 
   if (m_bTiming)
 	{
 		end = Sys_DoubleTime ();
     i = (int)(1000*(end-start));
     int i3 = (int)(1000*(end2-start2));
     g_lCount++;
     g_lTotal += i;
     int i2 = g_lTotal / g_lCount;
 		Sys_Printf ("xy: %i ab: %i  avg: %i\n", i, i3, i2);
 	}
 }
 
 /*
 ==============
 XY_Overlay
 ==============
 */
 void CXYWnd::XY_Overlay()
 {
 	int	w, h;
 	int	r[4];
 	static	vec3_t	lastz;
 	static	vec3_t	lastcamera;
 
 
 	qglViewport(0, 0, m_nWidth, m_nHeight);
 
 	//
 	// set up viewpoint
 	//
 	qglMatrixMode(GL_PROJECTION);
   qglLoadIdentity ();
 
 	w = m_nWidth / 2 / m_fScale;
 	h = m_nHeight / 2 / m_fScale;
 
   qglOrtho (m_vOrigin[0] - w, m_vOrigin[0] + w	, m_vOrigin[1] - h, m_vOrigin[1] + h, -8000, 8000);
 	//
 	// erase the old camera and z checker positions
 	// if the entire xy hasn't been redrawn
 	//
 	if (m_bDirty)
 	{
 		qglReadBuffer (GL_BACK);
 		qglDrawBuffer (GL_FRONT);
 
 		qglRasterPos2f (lastz[0]-9, lastz[1]-9);
 		qglGetIntegerv (GL_CURRENT_RASTER_POSITION,r);
 		qglCopyPixels(r[0], r[1], 18,18, GL_COLOR);
 
 		qglRasterPos2f (lastcamera[0]-50, lastcamera[1]-50);
 		qglGetIntegerv (GL_CURRENT_RASTER_POSITION,r);
 		qglCopyPixels(r[0], r[1], 100,100, GL_COLOR);
 	}
 	m_bDirty = true;
 
 	//
 	// save off underneath where we are about to draw
 	//
 	VectorCopy (z.origin, lastz);
 	VectorCopy (g_pParentWnd->GetCamera()->Camera().origin, lastcamera);
 
 	qglReadBuffer (GL_FRONT);
 	qglDrawBuffer (GL_BACK);
 
 	qglRasterPos2f (lastz[0]-9, lastz[1]-9);
 	qglGetIntegerv (GL_CURRENT_RASTER_POSITION,r);
 	qglCopyPixels(r[0], r[1], 18,18, GL_COLOR);
 
 	qglRasterPos2f (lastcamera[0]-50, lastcamera[1]-50);
 	qglGetIntegerv (GL_CURRENT_RASTER_POSITION,r);
 	qglCopyPixels(r[0], r[1], 100,100, GL_COLOR);
 
 	//
 	// draw the new icons
 	//
 	qglDrawBuffer (GL_FRONT);
 
   qglShadeModel (GL_FLAT);
 	qglDisable(GL_TEXTURE_2D);
 	qglDisable(GL_TEXTURE_1D);
 	qglDisable(GL_DEPTH_TEST);
 	qglDisable(GL_BLEND);
 	qglColor3f(0, 0, 0);
 
 	DrawCameraIcon ();
 	DrawZIcon ();
 
 	qglDrawBuffer (GL_BACK);
   qglFinish();
 }
 
 
 vec3_t& CXYWnd::GetOrigin()
 {
   return m_vOrigin;
 }
 
 void CXYWnd::SetOrigin(vec3_t org)
 {
 	m_vOrigin[0] = org[0];
 	m_vOrigin[1] = org[1];
 	m_vOrigin[2] = org[2];
 }
 
 void CXYWnd::OnSize(UINT nType, int cx, int cy) 
 {
 	CWnd::OnSize(nType, cx, cy);
   CRect rect;
   GetClientRect(rect);
   m_nWidth = rect.Width();
   m_nHeight = rect.Height();
 }
 
 brush_t hold_brushes;
 void CXYWnd::Clip()
 {
   if (ClipMode())
   {
     hold_brushes.next = &hold_brushes;
     ProduceSplitLists();
     //brush_t* pList = (g_bSwitch) ? &g_brFrontSplits : &g_brBackSplits;
     brush_t* pList;
 	if (g_PrefsDlg.m_bSwitchClip)
 		pList = ( (m_nViewType == XZ) ? g_bSwitch: !g_bSwitch) ? &g_brFrontSplits : &g_brBackSplits;
 	else
 		pList = ( (m_nViewType == XZ) ? !g_bSwitch: g_bSwitch) ? &g_brFrontSplits : &g_brBackSplits;
 
     
 	if (pList->next != pList)
     {
       Brush_CopyList(pList, &hold_brushes);
       CleanList(&g_brFrontSplits);
       CleanList(&g_brBackSplits);
       Select_Delete();
       Brush_CopyList(&hold_brushes, &selected_brushes);
       if (RogueClipMode())
         RetainClipMode(false);
       else
         RetainClipMode(true);
       Sys_UpdateWindows(W_ALL);
     }
   }
   else if (PathMode())
   {
     FinishSmartCreation();
     if (g_pPathFunc)
       g_pPathFunc(true, g_nPathCount);
     g_pPathFunc = NULL;
     g_nPathCount = 0;
     g_bPathMode = false;
   }
 }
 
 void CXYWnd::SplitClip()
 {
 	ProduceSplitLists();
 	if ((g_brFrontSplits.next != &g_brFrontSplits) &&
 		(g_brBackSplits.next != &g_brBackSplits))
 	{
 		Select_Delete();
 		Brush_CopyList(&g_brFrontSplits, &selected_brushes);
 		Brush_CopyList(&g_brBackSplits, &selected_brushes);
 		CleanList(&g_brFrontSplits);
 		CleanList(&g_brBackSplits);
 		if (RogueClipMode())
 			RetainClipMode(false);
 		else
 			RetainClipMode(true);
 	}
 }
 
 void CXYWnd::FlipClip()
 {
   g_bSwitch = !g_bSwitch;
   Sys_UpdateWindows(XY | W_CAMERA_IFON);
 }
 
 
 // makes sure the selected brush or camera is in view
 void CXYWnd::PositionView()
 {
   int nDim1 = (m_nViewType == YZ) ? 1 : 0;
   int nDim2 = (m_nViewType == XY) ? 1 : 2;
   brush_t* b = selected_brushes.next;
   if (b && b->next != b)
   {
 	  m_vOrigin[nDim1] = b->mins[nDim1];
 	  m_vOrigin[nDim2] = b->mins[nDim2];
   }
   else
   {
 	  m_vOrigin[nDim1] = g_pParentWnd->GetCamera()->Camera().origin[nDim1];
 	  m_vOrigin[nDim2] = g_pParentWnd->GetCamera()->Camera().origin[nDim2];
   }
 }
 
 void CXYWnd::VectorCopyXY(vec3_t in, vec3_t out)
 {
   if (m_nViewType == XY)
   {
 	  out[0] = in[0];
 	  out[1] = in[1];
   }
   else
   if (m_nViewType == XZ)
   {
 	  out[0] = in[0];
 	  out[2] = in[2];
   }
   else
   {
 	  out[1] = in[1];
 	  out[2] = in[2];
   }
 }
 
 
 void CXYWnd::OnDestroy() 
 {
 	QEW_StopGL( GetSafeHwnd(), s_hglrcXY, s_hdcXY );
 	CWnd::OnDestroy();
   // delete this;
 }
 
 void CXYWnd::SetViewType(int n) 
 { 
   m_nViewType = n; 
   if (g_pParentWnd->CurrentStyle() == QR_QE4)
   {
     CString str = "YZ Side";
     if (m_nViewType == XY)
       str = "XY Top";
     else if (m_nViewType == XZ)
       str = "XZ Front";
     SetWindowText(str);
   }
 };
 
 void CXYWnd::Redraw(unsigned int nBits)
 {
   m_nUpdateBits = nBits;
   RedrawWindow(NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW);
   m_nUpdateBits = W_XY;
 }
 
 bool CXYWnd::RotateMode()
 {
   return g_bRotateMode;
 }
 
 bool CXYWnd::ScaleMode()
 {
   return g_bScaleMode;
 }
 
 bool CXYWnd::SetRotateMode(bool bMode)
 {
   if (bMode && selected_brushes.next != &selected_brushes)
   {
     g_bRotateMode = true;
     Select_GetTrueMid(g_vRotateOrigin);
     g_vRotation[0] = g_vRotation[1] = g_vRotation[2] = 0.0;
   }
   else 
   {
     if (bMode)
       Sys_Printf("Need a brush selected to turn on Mouse Rotation mode\n");
     g_bRotateMode = false;
   }
   RedrawWindow();
   return g_bRotateMode;
 }
 
 void CXYWnd::SetScaleMode(bool bMode)
 {
   g_bScaleMode = bMode;
   RedrawWindow();
 }
 
 
 
 
 // xy - z
 // xz - y
 // yz - x
 
 void CXYWnd::OnSelectMouserotate() 
 {
 	// TODO: Add your command handler code here
 	
 }
 
 void CleanCopyEntities()
 {
 	entity_t* pe = g_enClipboard.next;
   while (pe != NULL && pe != &g_enClipboard)
   {
     entity_t* next = pe->next;
     epair_t* enext = NULL;
 	  for (epair_t* ep = pe->epairs ; ep ; ep=enext)
     {
 		  enext = ep->next;
       free (ep->key);
       free (ep->value);
 		  free (ep);
     }
 	  free (pe);
     pe = next;
   }
   g_enClipboard.next = g_enClipboard.prev = &g_enClipboard;
 }
 
 entity_t	*Entity_CopyClone (entity_t *e)
 {
 	entity_t	*n;
 	epair_t		*ep, *np;
 
 	n = (entity_t*)qmalloc(sizeof(*n));
 	n->brushes.onext = n->brushes.oprev = &n->brushes;
 	n->eclass = e->eclass;
 
 	// add the entity to the entity list
 	n->next = g_enClipboard.next;
 	g_enClipboard.next = n;
 	n->next->prev = n;
 	n->prev = &g_enClipboard;
 
 	for (ep = e->epairs ; ep ; ep=ep->next)
 	{
 		np = (epair_t*)qmalloc(sizeof(*np));
 		np->key = copystring(ep->key);
 		np->value = copystring(ep->value);
 		np->next = n->epairs;
 		n->epairs = np;
 	}
 	return n;
 }
 
 bool OnList(entity_t* pFind, CPtrArray* pList)
 {
   int nSize = pList->GetSize();
   while (nSize-- > 0)
   {
     entity_t* pEntity = reinterpret_cast<entity_t*>(pList->GetAt(nSize));
     if (pEntity == pFind)
       return true;
   }
   return false;
 }
 
 void CXYWnd::Copy()
 {
 #if 1
   CWaitCursor WaitCursor; 
   g_Clipboard.SetLength(0);
   g_PatchClipboard.SetLength(0);
   
   Map_SaveSelected(&g_Clipboard, &g_PatchClipboard);
   bool bClipped = false;
   UINT nClipboard = ::RegisterClipboardFormat("RadiantClippings");
   if (nClipboard > 0)
   {
     if (OpenClipboard())
     {
       ::EmptyClipboard();
   		long lSize = g_Clipboard.GetLength();
       HANDLE h = ::GlobalAlloc(GMEM_ZEROINIT | GMEM_MOVEABLE | GMEM_DDESHARE, lSize + sizeof(long));
       if (h != NULL)
       {
         unsigned char *cp = reinterpret_cast<unsigned char*>(::GlobalLock(h));
 				memcpy(cp, &lSize, sizeof(long));
 				cp += sizeof(long);
         g_Clipboard.SeekToBegin();
         g_Clipboard.Read(cp, lSize);
         ::GlobalUnlock(h);
         ::SetClipboardData(nClipboard, h);
         ::CloseClipboard();
         bClipped = true;
       }
     }
   }
 
   if (!bClipped)
   {
     Sys_Printf("Unable to register Windows clipboard formats, copy/paste between editors will not be possible");
   }
 
 /*
   CString strOut;
   ::GetTempPath(1024, strOut.GetBuffer(1024));
   strOut.ReleaseBuffer();
   AddSlash(strOut);
   strOut += "RadiantClipboard.$$$";
   Map_SaveSelected(strOut.GetBuffer(0));
 */
 
 #else
   CPtrArray holdArray;
   CleanList(&g_brClipboard);
   CleanCopyEntities();
 	for (brush_t* pBrush = selected_brushes.next ; pBrush != NULL && pBrush != &selected_brushes ; pBrush=pBrush->next)
   {
 		if (pBrush->owner == world_entity)
     {
       brush_t* pClone = Brush_Clone(pBrush);
       pClone->owner = NULL;
   	  Brush_AddToList (pClone, &g_brClipboard);
     }
     else
     {
       if (!OnList(pBrush->owner, &holdArray))
       {
         entity_t* e = pBrush->owner;
         holdArray.Add(reinterpret_cast<void*>(e));
         entity_t* pEClone = Entity_CopyClone(e);
 			  for (brush_t* pEB = e->brushes.onext ; pEB != &e->brushes ; pEB=pEB->onext)
 			  {
           brush_t* pClone = Brush_Clone(pEB);
 	        //Brush_AddToList (pClone, &g_brClipboard);
           Entity_LinkBrush(pEClone, pClone);
           Brush_Build(pClone);
 			  }
       }
     }
   }
 #endif
 }
 
 void CXYWnd::Undo()
 {
 /*
   if (g_brUndo.next != &g_brUndo)
   {
     g_bScreenUpdates = false; 
     Select_Delete();
 	  for (brush_t* pBrush = g_brUndo.next ; pBrush != NULL && pBrush != &g_brUndo ; pBrush=pBrush->next)
     {
       brush_t* pClone = Brush_Clone(pBrush);
     	Brush_AddToList (pClone, &active_brushes);
 			Entity_LinkBrush (pBrush->pUndoOwner, pClone);
       Brush_Build(pClone);
       Select_Brush(pClone);
     }
     CleanList(&g_brUndo);
     g_bScreenUpdates = true; 
     Sys_UpdateWindows(W_ALL);
   }
   else Sys_Printf("Nothing to undo.../n");
 */
 }
 
 void CXYWnd::UndoClear()
 {
 /*  
   CleanList(&g_brUndo);
 */
 }
 
 void CXYWnd::UndoCopy()
 {
 /*
   CleanList(&g_brUndo);
 	for (brush_t* pBrush = selected_brushes.next ; pBrush != NULL && pBrush != &selected_brushes ; pBrush=pBrush->next)
   {
     brush_t* pClone = Brush_Clone(pBrush);
     pClone->pUndoOwner = pBrush->owner;
 	  Brush_AddToList (pClone, &g_brUndo);
   }
 */
 }
 
 bool CXYWnd::UndoAvailable()
 {
   return (g_brUndo.next != &g_brUndo);
 }
 
 
 
 void CXYWnd::Paste()
 {
 #if 1
 
   CWaitCursor WaitCursor; 
   bool bPasted = false;
   UINT nClipboard = ::RegisterClipboardFormat("RadiantClippings");
   if (nClipboard > 0 && OpenClipboard() && ::IsClipboardFormatAvailable(nClipboard))
   {
     HANDLE h = ::GetClipboardData(nClipboard);
     if (h)
     {
       g_Clipboard.SetLength(0);
 			unsigned char *cp = reinterpret_cast<unsigned char*>(::GlobalLock(h));
 			long lSize = 0;
 			memcpy(&lSize, cp, sizeof(long));
 			cp += sizeof(long);
       g_Clipboard.Write(cp, lSize);
     }
     ::GlobalUnlock(h);
     ::CloseClipboard();
   }
 
   if (g_Clipboard.GetLength() > 0)
   {
     g_Clipboard.SeekToBegin();
     int nLen = g_Clipboard.GetLength();
     char* pBuffer = new char[nLen+1];
 	  memset( pBuffer, 0, sizeof(pBuffer) );
     g_Clipboard.Read(pBuffer, nLen);
     pBuffer[nLen] = '\0';
     Map_ImportBuffer(pBuffer);
     delete []pBuffer;
   }
 
 #if 0
   if (g_PatchClipboard.GetLength() > 0)
   {
     g_PatchClipboard.SeekToBegin();
     int nLen = g_PatchClipboard.GetLength();
     char* pBuffer = new char[nLen+1];
     g_PatchClipboard.Read(pBuffer, nLen);
     pBuffer[nLen] = '\0';
     Patch_ReadBuffer(pBuffer, true);
     delete []pBuffer;
   }
 #endif
 
 #else
   if (g_brClipboard.next != &g_brClipboard || g_enClipboard.next != &g_enClipboard)
   {
     Select_Deselect();
 
 	  for (brush_t* pBrush = g_brClipboard.next ; pBrush != NULL && pBrush != &g_brClipboard ; pBrush=pBrush->next)
     {
       brush_t* pClone = Brush_Clone(pBrush);
 	    //pClone->owner = pBrush->owner;
       if (pClone->owner == NULL)
 			  Entity_LinkBrush (world_entity, pClone);
     	
       Brush_AddToList (pClone, &selected_brushes);
       Brush_Build(pClone);
     }
 
     for (entity_t* pEntity = g_enClipboard.next; pEntity != NULL && pEntity != &g_enClipboard; pEntity = pEntity->next)
     {
       entity_t* pEClone = Entity_Clone(pEntity);
 			for (brush_t* pEB = pEntity->brushes.onext ; pEB != &pEntity->brushes ; pEB=pEB->onext)
 			{
         brush_t* pClone = Brush_Clone(pEB);
 	      Brush_AddToList (pClone, &selected_brushes);
         Entity_LinkBrush(pEClone, pClone);
         Brush_Build(pClone);
         if (pClone->owner && pClone->owner != world_entity)
         {
 			    UpdateEntitySel(pClone->owner->eclass);
         }
 			}
     }
 
     Sys_UpdateWindows(W_ALL);
   }
   else Sys_Printf("Nothing to paste.../n");
 #endif
 }
 
 
 vec3_t& CXYWnd::Rotation()
 {
   return g_vRotation;
 }
 
 vec3_t& CXYWnd::RotateOrigin()
 {
   return g_vRotateOrigin;
 }
 
 
 void CXYWnd::OnTimer(UINT nIDEvent) 
 {
   int nDim1 = (m_nViewType == YZ) ? 1 : 0;
   int nDim2 = (m_nViewType == XY) ? 1 : 2;
 	m_vOrigin[nDim1] += m_ptDragAdj.x / m_fScale;
 	m_vOrigin[nDim2] -= m_ptDragAdj.y / m_fScale;
   Sys_UpdateWindows(W_XY | W_CAMERA);
   //int nH = (m_ptDrag.y == 0) ? -1 : m_ptDrag.y;
   m_ptDrag += m_ptDragAdj;
   m_ptDragTotal += m_ptDragAdj;
   XY_MouseMoved (m_ptDrag.x, m_nHeight - 1 - m_ptDrag.y , m_nScrollFlags);
 	//m_vOrigin[nDim1] -= m_ptDrag.x / m_fScale;
 	//m_vOrigin[nDim1] -= m_ptDrag.x / m_fScale;
 }
 
 void CXYWnd::OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags) 
 {
   g_pParentWnd->HandleKey(nChar, nRepCnt, nFlags, false);
   //CWnd::OnKeyUp(nChar, nRepCnt, nFlags);
 }
 
 void CXYWnd::OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS FAR* lpncsp) 
 {
 	CWnd::OnNcCalcSize(bCalcValidRects, lpncsp);
 }
 
 void CXYWnd::OnKillFocus(CWnd* pNewWnd) 
 {
 	CWnd::OnKillFocus(pNewWnd);
 	SendMessage(WM_NCACTIVATE, FALSE , 0 );
 }
 
 void CXYWnd::OnSetFocus(CWnd* pOldWnd) 
 {
 	CWnd::OnSetFocus(pOldWnd);
 	SendMessage(WM_NCACTIVATE, TRUE , 0 );
 }
 
 void CXYWnd::OnClose() 
 {
 	CWnd::OnClose();
 }
 
 // should be static as should be the rotate scale stuff
 bool CXYWnd::AreaSelectOK()
 {
   return RotateMode() ? false : ScaleMode() ? false : true;
 }