XYWnd.cpp

Go to the documentation of this file.

/*
===========================================================================
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