solvespace/ui.h

//-----------------------------------------------------------------------------
// Declarations relating to our user interface, in both the graphics and
// text browser window.
//
// Copyright 2008-2013 Jonathan Westhues.
//-----------------------------------------------------------------------------

#ifndef __UI_H
#define __UI_H

class TextWindow {
public:
    enum {
        MAX_COLS = 100,
        MIN_COLS = 45,
        MAX_ROWS = 2000
    };

#ifndef RGB
#define RGB(r, g, b) ((r) | ((g) << 8) | ((b) << 16))
#endif
#define RGBf(r, g, b) RGB((int)(255*(r)), (int)(255*(g)), (int)(255*(b)))
#define RED(v)      (((v) >>  0) & 0xff)
#define GREEN(v)    (((v) >>  8) & 0xff)
#define BLUE(v)     (((v) >> 16) & 0xff)
#define REDf(v)     (RED  (v) / 255.0f)
#define GREENf(v)   (GREEN(v) / 255.0f)
#define BLUEf(v)    (BLUE (v) / 255.0f)
    typedef struct {
        char    c;
        int     color;
    } Color;
    static const Color fgColors[];
    static const Color bgColors[];

    float bgColorTable[256*3];
    float fgColorTable[256*3];

    enum {
        CHAR_WIDTH     = 9,
        CHAR_HEIGHT    = 16,
        LINE_HEIGHT    = 20,
        LEFT_MARGIN    = 6,

        CHECK_FALSE    = 0x80,
        CHECK_TRUE     = 0x81,
        RADIO_FALSE    = 0x82,
        RADIO_TRUE     = 0x83
    };

    int scrollPos;      // The scrollbar position, in half-row units
    int halfRows;       // The height of our window, in half-row units

    BYTE    text[MAX_ROWS][MAX_COLS];
    typedef void LinkFunction(int link, DWORD v);
    enum { NOT_A_LINK = 0 };
    struct {
        char            fg;
        int             bg;
        int             link;
        DWORD           data;
        LinkFunction   *f;
        LinkFunction   *h;
    }       meta[MAX_ROWS][MAX_COLS];
    int hoveredRow, hoveredCol;


    int top[MAX_ROWS]; // in half-line units, or -1 for unused
    int rows;

    // The row of icons at the top of the text window, to hide/show things
    typedef struct {
        bool       *var;
        BYTE       *icon;
        const char *tip;
    } HideShowIcon;
    static HideShowIcon hideShowIcons[];
    static bool SPACER;

    // These are called by the platform-specific code.
    void Paint(void);
    void MouseEvent(bool isClick, bool leftDown, double x, double y);
    void MouseScroll(double x, double y, int delta);
    void MouseLeave(void);
    void ScrollbarEvent(int newPos);

    enum {
        PAINT = 0,
        HOVER = 1,
        CLICK = 2
    };
    void DrawOrHitTestIcons(int how, double mx, double my);
    void TimerCallback(void);
    Point2d oldMousePos;
    HideShowIcon *hoveredIcon, *tooltippedIcon;

    Vector HsvToRgb(Vector hsv);
    BYTE *HsvPattern2d(void);
    BYTE *HsvPattern1d(double h, double s);
    void ColorPickerDone(void);
    bool DrawOrHitTestColorPicker(int how, bool leftDown, double x, double y);
   
    void Init(void);
    void MakeColorTable(const Color *in, float *out);
    void Printf(bool half, const char *fmt, ...);
    void ClearScreen(void);
   
    void Show(void);

    // State for the screen that we are showing in the text window.
    enum {
        SCREEN_LIST_OF_GROUPS      = 0,
        SCREEN_GROUP_INFO          = 1,
        SCREEN_GROUP_SOLVE_INFO    = 2,
        SCREEN_CONFIGURATION       = 3,
        SCREEN_STEP_DIMENSION      = 4,
        SCREEN_LIST_OF_STYLES      = 5,
        SCREEN_STYLE_INFO          = 6,
        SCREEN_PASTE_TRANSFORMED   = 7,
        SCREEN_EDIT_VIEW           = 8,
        SCREEN_TANGENT_ARC         = 9
    };
    typedef struct {
        int         screen;

        hGroup      group;
        hStyle      style;

        hConstraint constraint;
        bool        dimIsDistance;
        double      dimFinish;
        int         dimSteps;

        struct {
            int         times;
            Vector      trans;
            double      theta;
            Vector      origin;
            double      scale;
        }           paste;
    } ShownState;
    ShownState shown;

    enum {
        EDIT_NOTHING               = 0,
        // For multiple groups
        EDIT_TIMES_REPEATED        = 1,
        EDIT_GROUP_NAME            = 2,
        EDIT_GROUP_SCALE           = 3,
        EDIT_GROUP_COLOR           = 4,
        // For the configuraiton screen
        EDIT_LIGHT_DIRECTION       = 100,
        EDIT_LIGHT_INTENSITY       = 101,
        EDIT_COLOR                 = 102,
        EDIT_CHORD_TOLERANCE       = 103,
        EDIT_MAX_SEGMENTS          = 104,
        EDIT_CAMERA_TANGENT        = 105,
        EDIT_GRID_SPACING          = 106,
        EDIT_DIGITS_AFTER_DECIMAL  = 107,
        EDIT_EXPORT_SCALE          = 108,
        EDIT_EXPORT_OFFSET         = 109,
        EDIT_CANVAS_SIZE           = 110,
        EDIT_G_CODE_DEPTH          = 120,
        EDIT_G_CODE_PASSES         = 121,
        EDIT_G_CODE_FEED           = 122,
        EDIT_G_CODE_PLUNGE_FEED    = 123,
        // For TTF text
        EDIT_TTF_TEXT              = 300,
        // For the step dimension screen
        EDIT_STEP_DIM_FINISH       = 400,
        EDIT_STEP_DIM_STEPS        = 401,
        // For the styles stuff
        EDIT_STYLE_WIDTH           = 500,
        EDIT_STYLE_TEXT_HEIGHT     = 501,
        EDIT_STYLE_TEXT_ANGLE      = 502,
        EDIT_STYLE_COLOR           = 503,
        EDIT_STYLE_FILL_COLOR      = 504,
        EDIT_STYLE_NAME            = 505,
        EDIT_BACKGROUND_COLOR      = 506,
        EDIT_BACKGROUND_IMG_SCALE  = 507,
        // For paste transforming
        EDIT_PASTE_TIMES_REPEATED  = 600,
        EDIT_PASTE_ANGLE           = 601,
        EDIT_PASTE_SCALE           = 602,
        // For view
        EDIT_VIEW_SCALE            = 700,
        EDIT_VIEW_ORIGIN           = 701,
        EDIT_VIEW_PROJ_RIGHT       = 702,
        EDIT_VIEW_PROJ_UP          = 703,
        // For tangent arc
        EDIT_TANGENT_ARC_RADIUS    = 800
    };
    struct {
        bool        showAgain;
        int         meaning;
        int         i;
        hGroup      group;
        hRequest    request;
        hStyle      style;
    } edit;

    static void ReportHowGroupSolved(hGroup hg);

    struct {
        int     halfRow;
        int     col;

        struct {
            DWORD   rgb;
            double  h, s, v;
            bool    show;
            bool    picker1dActive;
            bool    picker2dActive;
        }       colorPicker;
    } editControl;

    void HideEditControl(void);
    void ShowEditControl(int halfRow, int col, char *s);
    void ShowEditControlWithColorPicker(int halfRow, int col, DWORD rgb);

    void ClearSuper(void);

    void ShowHeader(bool withNav);
    // These are self-contained screens, that show some information about
    // the sketch.
    void ShowListOfGroups(void);
    void ShowGroupInfo(void);
    void ShowGroupSolveInfo(void);
    void ShowConfiguration(void);
    void ShowListOfStyles(void);
    void ShowStyleInfo(void);
    void ShowStepDimension(void);
    void ShowPasteTransformed(void);
    void ShowEditView(void);
    void ShowTangentArc(void);
    // Special screen, based on selection
    void DescribeSelection(void);

    void GoToScreen(int screen);

    // All of these are callbacks from the GUI code; first from when
    // we're describing an entity
    static void ScreenEditTtfText(int link, DWORD v);
    static void ScreenSetTtfFont(int link, DWORD v);
    static void ScreenUnselectAll(int link, DWORD v);

    // and the rest from the stuff in textscreens.cpp
    static void ScreenSelectGroup(int link, DWORD v);
    static void ScreenActivateGroup(int link, DWORD v);
    static void ScreenToggleGroupShown(int link, DWORD v);
    static void ScreenHowGroupSolved(int link, DWORD v);
    static void ScreenShowGroupsSpecial(int link, DWORD v);
    static void ScreenDeleteGroup(int link, DWORD v);

    static void ScreenHoverConstraint(int link, DWORD v);
    static void ScreenHoverRequest(int link, DWORD v);
    static void ScreenSelectRequest(int link, DWORD v);
    static void ScreenSelectConstraint(int link, DWORD v);

    static void ScreenChangeGroupOption(int link, DWORD v);
    static void ScreenColor(int link, DWORD v);

    static void ScreenShowListOfStyles(int link, DWORD v);
    static void ScreenShowStyleInfo(int link, DWORD v);
    static void ScreenDeleteStyle(int link, DWORD v);
    static void ScreenChangeStyleYesNo(int link, DWORD v);
    static void ScreenCreateCustomStyle(int link, DWORD v);
    static void ScreenLoadFactoryDefaultStyles(int link, DWORD v);
    static void ScreenAssignSelectionToStyle(int link, DWORD v);
    static void ScreenBackgroundImage(int link, DWORD v);

    static void ScreenShowConfiguration(int link, DWORD v);
    static void ScreenShowEditView(int link, DWORD v);
    static void ScreenGoToWebsite(int link, DWORD v);

    static void ScreenChangeFixExportColors(int link, DWORD v);
    static void ScreenChangeBackFaces(int link, DWORD v);
    static void ScreenChangeCheckClosedContour(int link, DWORD v);
    static void ScreenChangePwlCurves(int link, DWORD v);
    static void ScreenChangeCanvasSizeAuto(int link, DWORD v);
    static void ScreenChangeCanvasSize(int link, DWORD v);
    static void ScreenChangeShadedTriangles(int link, DWORD v);

    static void ScreenStepDimSteps(int link, DWORD v);
    static void ScreenStepDimFinish(int link, DWORD v);
    static void ScreenStepDimGo(int link, DWORD v);

    static void ScreenChangeTangentArc(int link, DWORD v);

    static void ScreenPasteTransformed(int link, DWORD v);

    static void ScreenHome(int link, DWORD v);

    // These ones do stuff with the edit control
    static void ScreenChangeExprA(int link, DWORD v);
    static void ScreenChangeGroupName(int link, DWORD v);
    static void ScreenChangeGroupScale(int link, DWORD v);
    static void ScreenChangeLightDirection(int link, DWORD v);
    static void ScreenChangeLightIntensity(int link, DWORD v);
    static void ScreenChangeColor(int link, DWORD v);
    static void ScreenChangeChordTolerance(int link, DWORD v);
    static void ScreenChangeMaxSegments(int link, DWORD v);
    static void ScreenChangeCameraTangent(int link, DWORD v);
    static void ScreenChangeGridSpacing(int link, DWORD v);
    static void ScreenChangeDigitsAfterDecimal(int link, DWORD v);
    static void ScreenChangeExportScale(int link, DWORD v);
    static void ScreenChangeExportOffset(int link, DWORD v);
    static void ScreenChangeGCodeParameter(int link, DWORD v);
    static void ScreenChangeStyleName(int link, DWORD v);
    static void ScreenChangeStyleWidthOrTextHeight(int link, DWORD v);
    static void ScreenChangeStyleTextAngle(int link, DWORD v);
    static void ScreenChangeStyleColor(int link, DWORD v);
    static void ScreenChangeBackgroundColor(int link, DWORD v);
    static void ScreenChangeBackgroundImageScale(int link, DWORD v);
    static void ScreenChangePasteTransformed(int link, DWORD v);
    static void ScreenChangeViewScale(int link, DWORD v);
    static void ScreenChangeViewOrigin(int link, DWORD v);
    static void ScreenChangeViewProjection(int link, DWORD v);

    bool EditControlDoneForStyles(char *s);
    bool EditControlDoneForConfiguration(char *s);
    bool EditControlDoneForPaste(char *s);
    bool EditControlDoneForView(char *s);
    void EditControlDone(char *s);
};

class GraphicsWindow {
public:
    void Init(void);

    // This table describes the top-level menus in the graphics winodw.
    typedef enum {
        // File
        MNU_NEW = 100,
        MNU_OPEN,
        MNU_OPEN_RECENT,
        MNU_SAVE,
        MNU_SAVE_AS,
        MNU_EXPORT_PNG,
        MNU_EXPORT_MESH,
        MNU_EXPORT_SURFACES,
        MNU_EXPORT_VIEW,
        MNU_EXPORT_SECTION,
        MNU_EXPORT_WIREFRAME,
        MNU_EXIT,
        // View
        MNU_ZOOM_IN,
        MNU_ZOOM_OUT,
        MNU_ZOOM_TO_FIT,
        MNU_SHOW_GRID,
        MNU_PERSPECTIVE_PROJ,
        MNU_ONTO_WORKPLANE,
        MNU_NEAREST_ORTHO,
        MNU_NEAREST_ISO,
        MNU_CENTER_VIEW,
        MNU_SHOW_TEXT_WND,
        MNU_SHOW_TOOLBAR,
        MNU_UNITS_INCHES,
        MNU_UNITS_MM,
        // Edit
        MNU_UNDO,
        MNU_REDO,
        MNU_CUT,
        MNU_COPY,
        MNU_PASTE,
        MNU_PASTE_TRANSFORM,
        MNU_DELETE,
        MNU_SELECT_CHAIN,
        MNU_SELECT_ALL,
        MNU_SNAP_TO_GRID,
        MNU_ROTATE_90,
        MNU_UNSELECT_ALL,
        MNU_REGEN_ALL,
        // Request
        MNU_SEL_WORKPLANE,
        MNU_FREE_IN_3D,
        MNU_DATUM_POINT,
        MNU_WORKPLANE,
        MNU_LINE_SEGMENT,
        MNU_CIRCLE,
        MNU_ARC,
        MNU_RECTANGLE,
        MNU_CUBIC,
        MNU_TTF_TEXT,
        MNU_SPLIT_CURVES,
        MNU_TANGENT_ARC,
        MNU_CONSTRUCTION,
        // Group
        MNU_GROUP_3D,
        MNU_GROUP_WRKPL,
        MNU_GROUP_EXTRUDE,
        MNU_GROUP_LATHE,
        MNU_GROUP_ROT,
        MNU_GROUP_TRANS,
        MNU_GROUP_IMPORT,
        MNU_GROUP_RECENT,
        // Constrain
        MNU_DISTANCE_DIA,
        MNU_ANGLE,
        MNU_OTHER_ANGLE,
        MNU_REFERENCE,
        MNU_EQUAL,
        MNU_RATIO,
        MNU_ON_ENTITY,
        MNU_SYMMETRIC,
        MNU_AT_MIDPOINT,
        MNU_HORIZONTAL,
        MNU_VERTICAL,
        MNU_PARALLEL,
        MNU_PERPENDICULAR,
        MNU_ORIENTED_SAME,
        MNU_WHERE_DRAGGED,
        MNU_COMMENT,
        // Analyze
        MNU_VOLUME,
        MNU_AREA,
        MNU_INTERFERENCE,
        MNU_NAKED_EDGES,
        MNU_SHOW_DOF,
        MNU_TRACE_PT,
        MNU_STOP_TRACING,
        MNU_STEP_DIM,
        // Help,
        MNU_WEBSITE,
        MNU_ABOUT
    } MenuId;
    typedef void MenuHandler(int id);
    typedef struct {
        int         level;          // 0 == on menu bar, 1 == one level down
        const char *label;          // or NULL for a separator
        int         id;             // unique ID
        int         accel;          // keyboard accelerator
        MenuHandler *fn;
    } MenuEntry;
    static const MenuEntry menu[];
    static void MenuView(int id);
    static void MenuEdit(int id);
    static void MenuRequest(int id);
    void DeleteSelection(void);
    void CopySelection(void);
    void PasteClipboard(Vector trans, double theta, double scale);
    static void MenuClipboard(int id);

    // The width and height (in pixels) of the window.
    double width, height;
    // These parameters define the map from 2d screen coordinates to the
    // coordinates of the 3d sketch points. We will use an axonometric
    // projection.
    Vector  offset;
    Vector  projRight;
    Vector  projUp;
    double  scale;
    struct {
        bool    mouseDown;
        Vector  offset;
        Vector  projRight;
        Vector  projUp;
        Point2d mouse;
        Point2d mouseOnButtonDown;
        Vector  marqueePoint;
        bool    startedMoving;
    }       orig;

    // Most recent mouse position, updated every time the mouse moves.
    Point2d currentMousePosition;

    // When the user is dragging a point, don't solve multiple times without
    // allowing a paint in between. The extra solves are wasted if they're
    // not displayed.
    bool    havePainted;

    // Some state for the context menu.
    struct {
        bool        active;
    }       context;

    void NormalizeProjectionVectors(void);
    Point2d ProjectPoint(Vector p);
    Vector ProjectPoint3(Vector p);
    Vector ProjectPoint4(Vector p, double *w);
    Vector UnProjectPoint(Point2d p);
    void AnimateOnto(Quaternion quatf, Vector offsetf);
    void AnimateOntoWorkplane(void);
    Vector VectorFromProjs(Vector rightUpForward);
    void HandlePointForZoomToFit(Vector p, Point2d *pmax, Point2d *pmin,
                                           double *wmin, bool div);
    void LoopOverPoints(Point2d *pmax, Point2d *pmin, double *wmin, bool div,
                            bool includingInvisibles);
    void ZoomToFit(bool includingInvisibles);

    hGroup  activeGroup;
    void EnsureValidActives(void);
    bool LockedInWorkplane(void);
    void SetWorkplaneFreeIn3d(void);
    hEntity ActiveWorkplane(void);
    void ForceTextWindowShown(void);

    // Operations that must be completed by doing something with the mouse
    // are noted here. These occupy the same space as the menu ids.
    enum {
        FIRST_PENDING               = 0x0f000000,
        DRAGGING_POINTS             = 0x0f000000,
        DRAGGING_NEW_POINT          = 0x0f000001,
        DRAGGING_NEW_LINE_POINT     = 0x0f000002,
        DRAGGING_NEW_CUBIC_POINT    = 0x0f000003,
        DRAGGING_NEW_ARC_POINT      = 0x0f000004,
        DRAGGING_CONSTRAINT         = 0x0f000005,
        DRAGGING_RADIUS             = 0x0f000006,
        DRAGGING_NORMAL             = 0x0f000007,
        DRAGGING_NEW_RADIUS         = 0x0f000008,
        DRAGGING_MARQUEE            = 0x0f000009
    };
    struct {
        int             operation;

        hEntity         point;
        List<hEntity>   points;
        hEntity         circle;
        hEntity         normal;
        hConstraint     constraint;
        
        const char     *description;
    } pending;
    void ClearPending(void);
    // The constraint that is being edited with the on-screen textbox.
    hConstraint constraintBeingEdited;

    Vector SnapToGrid(Vector p);
    bool ConstrainPointByHovered(hEntity pt);
    void DeleteTaggedRequests(void);
    hRequest AddRequest(int type, bool rememberForUndo);
    hRequest AddRequest(int type);

    class ParametricCurve {
    public:
        bool isLine; // else circle
        Vector p0, p1;
        Vector u, v;
        double r, theta0, theta1, dtheta;
        
        void MakeFromEntity(hEntity he, bool reverse);
        Vector PointAt(double t);
        Vector TangentAt(double t);
        double LengthForAuto(void);

        hRequest CreateRequestTrimmedTo(double t, bool extraConstraints,
            hEntity orig, hEntity arc, bool arcFinish);
        void ConstrainPointIfCoincident(hEntity hpt);
    };
    void MakeTangentArc(void);
    void SplitLinesOrCurves(void);
    hEntity SplitEntity(hEntity he, Vector pinter);
    hEntity SplitLine(hEntity he, Vector pinter);
    hEntity SplitCircle(hEntity he, Vector pinter);
    hEntity SplitCubic(hEntity he, Vector pinter);
    void ReplacePointInConstraints(hEntity oldpt, hEntity newpt);
    void FixConstraintsForRequestBeingDeleted(hRequest hr);
    void FixConstraintsForPointBeingDeleted(hEntity hpt);
    
    // The current selection.
    class Selection {
    public:
        int         tag;

        hEntity     entity;
        hConstraint constraint;
        bool        emphasized;

        void Draw(void);

        void Clear(void);
        bool IsEmpty(void);
        bool Equals(Selection *b);
        bool IsStylable(void);
        bool HasEndpoints(void);
    };
    Selection hover;
    bool hoverWasSelectedOnMousedown;
    List<Selection> selection;
    void HitTestMakeSelection(Point2d mp);
    void ClearSelection(void);
    void ClearNonexistentSelectionItems(void);
    enum { MAX_SELECTED = 32 };
    struct {
        hEntity     point[MAX_SELECTED];
        hEntity     entity[MAX_SELECTED];
        hEntity     anyNormal[MAX_SELECTED];
        hEntity     vector[MAX_SELECTED];
        hEntity     face[MAX_SELECTED];
        hConstraint constraint[MAX_SELECTED];
        int         points;
        int         entities;
        int         workplanes;
        int         faces;
        int         lineSegments;
        int         circlesOrArcs;
        int         arcs;
        int         cubics;
        int         periodicCubics;
        int         anyNormals;
        int         vectors;
        int         constraints;
        int         stylables;
        int         comments;
        int         withEndpoints;
        int         n;
    } gs;
    void GroupSelection(void);
    bool IsSelected(Selection *s);
    bool IsSelected(hEntity he);
    void MakeSelected(hEntity he);
    void MakeSelected(Selection *s);
    void MakeUnselected(hEntity he, bool coincidentPointTrick);
    void MakeUnselected(Selection *s, bool coincidentPointTrick);
    void SelectByMarquee(void);
    void ClearSuper(void);

    enum {
        CMNU_UNSELECT_ALL     = 0x100,
        CMNU_UNSELECT_HOVERED = 0x101,
        CMNU_CUT_SEL          = 0x102,
        CMNU_COPY_SEL         = 0x103,
        CMNU_PASTE_SEL        = 0x104,
        CMNU_DELETE_SEL       = 0x105,
        CMNU_SELECT_CHAIN     = 0x106,
        CMNU_NEW_CUSTOM_STYLE = 0x110,
        CMNU_NO_STYLE         = 0x111,
        CMNU_GROUP_INFO       = 0x120,
        CMNU_STYLE_INFO       = 0x121,
        CMNU_REFERENCE_DIM    = 0x130,
        CMNU_OTHER_ANGLE      = 0x131,
        CMNU_DEL_COINCIDENT   = 0x132,
        CMNU_SNAP_TO_GRID     = 0x140,
        CMNU_FIRST_STYLE      = 0x40000000
    };
    void ContextMenuListStyles(void);
    SDWORD contextMenuCancelTime;

    // The toolbar, in toolbar.cpp
    bool ToolbarDrawOrHitTest(int x, int y, bool paint, int *menu);
    void ToolbarDraw(void);
    bool ToolbarMouseMoved(int x, int y);
    bool ToolbarMouseDown(int x, int y);
    static void TimerCallback(void);
    int toolbarHovered;
    int toolbarTooltipped;
    int toolbarMouseX, toolbarMouseY;

    // This sets what gets displayed.
    bool    showWorkplanes;
    bool    showNormals;
    bool    showPoints;
    bool    showConstraints;
    bool    showTextWindow;
    bool    showShaded;
    bool    showEdges;
    bool    showFaces;
    bool    showMesh;
    bool    showHdnLines;
    void ToggleBool(bool *v);

    bool    showSnapGrid;

    void AddPointToDraggedList(hEntity hp);
    void StartDraggingByEntity(hEntity he);
    void StartDraggingBySelection(void);
    void UpdateDraggedNum(Vector *pos, double mx, double my);
    void UpdateDraggedPoint(hEntity hp, double mx, double my);

    // These are called by the platform-specific code.
    void Paint(void);
    void MouseMoved(double x, double y, bool leftDown, bool middleDown,
                                bool rightDown, bool shiftDown, bool ctrlDown);
    void MouseLeftDown(double x, double y);
    void MouseLeftUp(double x, double y);
    void MouseLeftDoubleClick(double x, double y);
    void MouseMiddleOrRightDown(double x, double y);
    void MouseRightUp(double x, double y);
    void MouseScroll(double x, double y, int delta);
    void MouseLeave(void);
    bool KeyDown(int c);
    void EditControlDone(char *s);

    SDWORD lastSpaceNavigatorTime;
    hGroup lastSpaceNavigatorGroup;
    void SpaceNavigatorMoved(double tx, double ty, double tz,
                             double rx, double ry, double rz, bool shiftDown);
    void SpaceNavigatorButtonUp(void);
};


#endif