worldspawn/radiant/xywindow.h

/*
   Copyright (C) 1999-2006 Id Software, Inc. and contributors.
   For a list of contributors, see the accompanying CONTRIBUTORS file.

   This file is part of GtkRadiant.

   GtkRadiant 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.

   GtkRadiant 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 GtkRadiant; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#if !defined( INCLUDED_XYWINDOW_H )
#define INCLUDED_XYWINDOW_H

#include "math/matrix.h"
#include "signal/signal.h"

#include "gtkutil/cursor.h"
#include "gtkutil/window.h"
#include "gtkutil/xorrectangle.h"
#include "view.h"
#include "map.h"
#include "texturelib.h"

#include "qerplugin.h"

class Shader;

class SelectionSystemWindowObserver;
namespace scene {
    class Node;
}


void FlipClip();

void SplitClip();

void Clip();

void OnClipMode(bool enabled);

bool ClipMode();

inline const char *ViewType_getTitle(VIEWTYPE viewtype)
{
    if (viewtype == XY) {
        return "XY Top";
    }
    if (viewtype == XZ) {
        return "XZ Front";
    }
    if (viewtype == YZ) {
        return "YZ Side";
    }
    return "";
}

class XYWnd {
    ui::GLArea m_gl_widget;
    guint m_sizeHandler;
    guint m_exposeHandler;

    DeferredDraw m_deferredDraw;
    DeferredMotion m_deferred_motion;
public:
    ui::Window m_parent;

    XYWnd();

    ~XYWnd();

    void queueDraw()
    {
        m_deferredDraw.draw();
    }

    ui::GLArea GetWidget()
    {
        return m_gl_widget;
    }

public:
    SelectionSystemWindowObserver *m_window_observer;
    XORRectangle m_XORRectangle;
    WindowPositionTracker m_positionTracker;

    static void captureStates();

    static void releaseStates();

    void PositionView(const Vector3 &position);

    const Vector3 &GetOrigin();

    void SetOrigin(const Vector3 &origin);

    void Scroll(int x, int y);

    void XY_Draw();

    void DrawCameraIcon(const Vector3 &origin, const Vector3 &angles);

    void XY_DrawBlockGrid();

    void XY_DrawAxis();

    void XY_DrawGrid();

    void XY_DrawBackground();

    void XY_LoadBackgroundImage(const char *name);

    void XY_DisableBackground();

    void XY_MouseUp(int x, int y, unsigned int buttons);

    void XY_MouseDown(int x, int y, unsigned int buttons);

    void XY_MouseMoved(int x, int y, unsigned int buttons);

    void NewBrushDrag_Begin(int x, int y);

    void NewBrushDrag(int x, int y);

    void NewBrushDrag_End(int x, int y);

    void XY_ToPoint(int x, int y, Vector3 &point);

    void XY_SnapToGrid(Vector3 &point);

    void Move_Begin();

    void Move_End();

    bool m_move_started;
    guint m_move_focusOut;

    void Zoom_Begin();

    void Zoom_End();

    bool m_zoom_started;
    guint m_zoom_focusOut;

    void SetActive(bool b)
    {
        m_bActive = b;
    };

    bool Active()
    {
        return m_bActive;
    };

    void Clipper_OnLButtonDown(int x, int y);

    void Clipper_OnLButtonUp(int x, int y);

    void Clipper_OnMouseMoved(int x, int y);

    void Clipper_Crosshair_OnMouseMoved(int x, int y);

    void DropClipPoint(int pointx, int pointy);

    void SetViewType(VIEWTYPE n);

    bool m_bActive;

    static ui::Menu m_mnuDrop;
    static ui::Menu m_mnuDropSingle;
    static ui::Menu m_mnuDropMultiple;

    int m_chasemouse_current_x, m_chasemouse_current_y;
    int m_chasemouse_delta_x, m_chasemouse_delta_y;


    guint m_chasemouse_handler;

    void ChaseMouse();

    bool chaseMouseMotion(int pointx, int pointy);

    void updateModelview();

    void updateProjection();

    Matrix4 m_projection;
    Matrix4 m_modelview;

    int m_nWidth;
    int m_nHeight;
// background image stuff
    qtexture_t *m_tex;
    bool m_backgroundActivated;
    float m_alpha;   // vertex alpha
    float m_xmin, m_ymin, m_xmax, m_ymax;
private:
    float m_fScale;
    Vector3 m_vOrigin;


    View m_view;
    static Shader *m_state_selected;

    int m_ptCursorX, m_ptCursorY;

    unsigned int m_buttonstate;

    int m_nNewBrushPressx;
    int m_nNewBrushPressy;
    scene::Node *m_NewBrushDrag;
    bool m_bNewBrushDrag;

    Vector3 m_mousePosition;

    VIEWTYPE m_viewType;

    void OriginalButtonUp(guint32 nFlags, int point, int pointy);

    void OriginalButtonDown(guint32 nFlags, int point, int pointy);

    void OnContextMenu();

    void PaintSizeInfo(int nDim1, int nDim2, Vector3 &vMinBounds, Vector3 &vMaxBounds);

    int m_entityCreate_x, m_entityCreate_y;
    bool m_entityCreate;

public:
    void ButtonState_onMouseDown(unsigned int buttons)
    {
        m_buttonstate |= buttons;
    }

    void ButtonState_onMouseUp(unsigned int buttons)
    {
        m_buttonstate &= ~buttons;
    }

    unsigned int getButtonState() const
    {
        return m_buttonstate;
    }

    void EntityCreate_MouseDown(int x, int y);

    void EntityCreate_MouseMove(int x, int y);

    void EntityCreate_MouseUp(int x, int y);

    void OnEntityCreate(const char *item);

    VIEWTYPE GetViewType()
    {
        return m_viewType;
    }

    void SetScale(float f);

    float Scale()
    {
        return m_fScale;
    }

    int Width()
    {
        return m_nWidth;
    }

    int Height()
    {
        return m_nHeight;
    }

    Signal0 onDestroyed;
    Signal3<const WindowVector &, ButtonIdentifier, ModifierFlags> onMouseDown;

    void mouseDown(const WindowVector &position, ButtonIdentifier button, ModifierFlags modifiers);

    typedef Member<XYWnd, void(const WindowVector &, ButtonIdentifier,
                               ModifierFlags), &XYWnd::mouseDown> MouseDownCaller;
};

inline void XYWnd_Update(XYWnd &xywnd)
{
    xywnd.queueDraw();
}


struct xywindow_globals_t {
    Vector3 color_gridback;
    Vector3 color_gridminor;
    Vector3 color_gridmajor;
    Vector3 color_gridblock;
    Vector3 color_gridtext;
    Vector3 color_brushes;
    Vector3 color_selbrushes;
    Vector3 color_clipper;
    Vector3 color_viewname;
    Vector3 color_gridminor_alt;
    Vector3 color_gridmajor_alt;
    Vector3 AxisColorX;
    Vector3 AxisColorY;
    Vector3 AxisColorZ;

    bool m_bRightClick;
    bool m_bNoStipple;

    xywindow_globals_t() :
		color_gridback(0.0f, 0.0f, 0.0f),
		color_gridmajor(0.45f, 0.45f, 0.45f),
		color_gridminor(0.2f, 0.2f, 0.2f),
		color_gridblock(0.39f, 0.18f, 0.0f),
		color_gridtext(0.0f, 0.0f, 0.0f),
		color_brushes(0.55f, 0.55f, 0.55f),
		color_selbrushes(1.0f, 0.0f, 0.0f),
		color_clipper(0.0f, 0.0f, 1.0f),
		color_viewname(0.7f, 0.7f, 0.0f),
		color_gridminor_alt(0.f, 0.f, 0.f),
		color_gridmajor_alt(0.f, 0.f, 0.f),

		AxisColorX(1.f, 0.f, 0.f),
		AxisColorY(0.f, 1.f, 0.f),
		AxisColorZ(0.f, 0.f, 1.f),
		m_bRightClick(true),
		m_bNoStipple(false)
    {
    }

};

extern xywindow_globals_t g_xywindow_globals;


VIEWTYPE GlobalXYWnd_getCurrentViewType();

void XY_Top_Shown_Construct(ui::Window parent);

void YZ_Side_Shown_Construct(ui::Window parent);

void XZ_Front_Shown_Construct(ui::Window parent);

void XYWindow_Construct();

void XYWindow_Destroy();

void WXY_Print();

void WXY_BackgroundSelect();

void XYShow_registerCommands();

void XYWnd_registerShortcuts();

#endif