HeightWin.cpp

Go to the documentation of this file.

//HeightWin.cpp

/*************************************************************/
//
// HeightWinDialog
//
// Window for displaying the 3D heightmap
//
//-------------------------------------------------------------
//
// v 1.4 - 2007/03/31 - Changes to drawing options
// v 1.3 - 2007/02/17 - Improved data output
// v 1.2 - 2006/08/27 - Using near-zero rounding text output
// v 1.1 - 2006/07/07 - Maximum number of grid lines
// v 1.0 - 2006/04/19 - Initial release
//
// See LICENSE.txt for distribution and usage restrictions
// Copyright (c) 2005-2007 Simon Chorley
// www.mylaboratory.co.uk - greylab@mylaboratory.co.uk
//
/*************************************************************/


///HeightMap window (Implementation)
/**
 * Provides implementation of HeightWinDialog class to draw the heightmap graph.
 * @file HeightWin.cpp
 * @version 1.4 - 2007/03/31
 */


#include "HeightWin.h"

#include "icons.h"
#include <iostream>


FXDEFMAP(HeightWinDialog) HeightWinDialogMap[] =
{ 
        //________Message_Type______________ID______________________________Message_Handler_____________
        FXMAPFUNC(SEL_PAINT,                            HeightWinDialog::ID_CANVAS,             HeightWinDialog::onGLExpose),
        FXMAPFUNC(SEL_CONFIGURE,                        HeightWinDialog::ID_CANVAS,             HeightWinDialog::onGLConfigure),
        FXMAPFUNC(SEL_FOCUSIN,                          HeightWinDialog::ID_CANVAS,             HeightWinDialog::onGLSelect),
        FXMAPFUNC(SEL_MOTION,                           HeightWinDialog::ID_CANVAS,             HeightWinDialog::onGLMouseMotion),
        FXMAPFUNC(SEL_LEFTBUTTONPRESS,          HeightWinDialog::ID_CANVAS,             HeightWinDialog::onGLMouseDown),
        FXMAPFUNC(SEL_LEFTBUTTONRELEASE,        HeightWinDialog::ID_CANVAS,             HeightWinDialog::onGLMouseUp),
        FXMAPFUNC(SEL_MIDDLEBUTTONPRESS,        HeightWinDialog::ID_CANVAS,             HeightWinDialog::onGLMouseDown),
        FXMAPFUNC(SEL_MIDDLEBUTTONRELEASE,      HeightWinDialog::ID_CANVAS,             HeightWinDialog::onGLMouseUp),
        FXMAPFUNC(SEL_RIGHTBUTTONPRESS,         HeightWinDialog::ID_CANVAS,             HeightWinDialog::onGLMouseDown),
        FXMAPFUNC(SEL_RIGHTBUTTONRELEASE,       HeightWinDialog::ID_CANVAS,             HeightWinDialog::onGLMouseUp),
        FXMAPFUNC(SEL_MOUSEWHEEL,                       HeightWinDialog::ID_CANVAS,             HeightWinDialog::onGLMouseWheel)
}; 

FXIMPLEMENT(HeightWinDialog, FXDialogBox, HeightWinDialogMap, ARRAYNUMBER(HeightWinDialogMap))


///Destructor
/**
 * Delete data, GL canvas etc and sphere quadric.
 */
HeightWinDialog::~HeightWinDialog()
{
        if (sphereQuadric != NULL)
                gluDeleteQuadric(sphereQuadric);
        if (crosshair != NULL) delete crosshair;
        if (hmdata != NULL) delete[] hmdata;
        delete GLCanvas;
        delete GLVisual;
}


///Constructor
/**
 * @param app Application object.
 * @param win Parent window.
 * @param ft Pointer the to the font class instance.
 */
HeightWinDialog::HeightWinDialog(FXApp *app, FXWindow* win, CGraphFont *ft) : FXDialogBox(app, "3D Height Map", DECOR_BORDER|DECOR_RESIZE|DECOR_TITLE|DECOR_MENU|DECOR_MINIMIZE|DECOR_MAXIMIZE, 0, 0, 500, 500)
{
        setIcon((FXIcon*)(new FXGIFIcon(app, ic_hm32, 0, IMAGE_OPAQUE)));       //set icons
        setMiniIcon((FXIcon*)(new FXGIFIcon(app, ic_hm16, 0, IMAGE_OPAQUE)));

        crosshair = NULL;

        GLVisual = new FXGLVisual(app, VISUAL_DOUBLEBUFFER|VISUAL_BEST|VISUAL_TRUECOLOR);       //create visual
        GLVisual->setAlphaSize(0);
        GLCanvas = new FXGLCanvas(this, GLVisual, this, ID_CANVAS, LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_TOP|LAYOUT_LEFT);

        crosshair = new FXCursor(app, CURSOR_CROSS);
        GLCanvas->setDefaultCursor(crosshair);
        
        //Initialise default settings for everything
        canvasSettings.fov = 60.0;
        canvasSettings.vp[0] = 0.01; canvasSettings.vp[1] = 100.0;
        canvasSettings.eye = CVector(0.0, 2.0, 0.0);
        canvasSettings.look = CVector(0.0, 0.5, 0.0);
        canvasSettings.up = CVector(0.0, 0.0, 1.0);
        
        perspective = true;
        box = 0;
        plate = true;
        boxcolour[0] = 0; boxcolour[1] = 0; boxcolour[2] = 0;
        platecolour[0] = 200; platecolour[1] = 200; platecolour[2] = 200;
        diffusecolour[0] = 0.5; diffusecolour[1] = 0.5; diffusecolour[2] = 0.5; diffusecolour[3] = 1.0;
        specularcolour[0] = 1.0; specularcolour[1] = 1.0; specularcolour[2] = 1.0; specularcolour[3] = 1.0;
        motiontype = false;
        lightpos[0] = 0.0; lightpos[1] = 1.5; lightpos[2] = 0.0; lightpos[3] = 1.0;
        
        hmdata = NULL;
        xdatapts = 0;
        ydatapts = 0;

        drawmode = 0;
        switchdir = false;
        zbackgrid = true;
        
        xmin.on = false;
        xmaj.on = false;
        ymin.on = false;
        ymaj.on = false;
        zmin.on = false;
        zmaj.on = false;
        
        mouseData[0].state = false;
        mouseData[1].state = false;
        mouseData[2].state = false;

        sphereQuadric = gluNewQuadric();
        fnt = ft;

}


///Sets up the GL window and draws it for the first time
/**
 * @param sender Object exposed that requires drawing.
 * @return Returns 1 to show that the message was handled.
 */
long HeightWinDialog::onGLExpose(FXObject* sender, FXSelector, void*)
{
        // Make context current
        ((FXGLCanvas*)sender)->makeCurrent();

        glEnable(GL_DEPTH_TEST);
//      glCullFace(GL_BACK);
//      glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
        glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
        glDisable(GL_DITHER);
//      glEnable(GL_BLEND);
//      glEnable(GL_CULL_FACE);
//      glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        glShadeModel(GL_SMOOTH);
//      glLineStipple(1, 0xAAAAAAAA);
        glDrawBuffer(GL_BACK);
        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
        glPixelStorei(GL_PACK_ALIGNMENT, 1);
        glPolygonOffset(1.0, 1.0);
        glClearColor(1.0, 1.0, 1.0, 1.0);
        
        onGLRefresh();
        return(1);
}


///Sets the viewport after the window is resized
/**
 * @param sender Object that requires resizing.
 * @return Returns 1 to show that the message was handled.
 */
long HeightWinDialog::onGLConfigure(FXObject* sender, FXSelector, void*)
{
        if(((FXGLCanvas*)sender)->makeCurrent())
        {
                glViewport(0, 0, ((FXGLCanvas*)sender)->getWidth(), ((FXGLCanvas*)sender)->getHeight());
                ((FXGLCanvas*)sender)->makeNonCurrent();
        }
        return(1);
}


long HeightWinDialog::onGLSelect(FXObject*, FXSelector, void*)
{
        return(1);
}


///Changes the viewpoint or light position when the mouse moves
/**
 * @param sender Object that sent the message.
 * @param ptr Mouse settings.
 * @return Returns 1 to show that the message was handled.
 */
long HeightWinDialog::onGLMouseMotion(FXObject* sender, FXSelector, void* ptr)
{
        FXEvent *event = (FXEvent*)ptr;

        int dx, dy;

        if (sender == GLCanvas)
        {
                if (mouseData[0].state == true) //lmb
                {
                        dx = event->win_x-mouseData[0].x;
                        dy = event->win_y-mouseData[0].y;
                        if (motiontype == false)        //Move camera around
                        {
                                CVector right = (canvasSettings.look-canvasSettings.eye)*canvasSettings.up;
                                right.normalise();
                                canvasSettings.eye.rotate(right, (float)dy/100.0);
                                canvasSettings.up.rotate(right, (float)dy/100.0);
                                canvasSettings.up.normalise();

                                CVector vert; vert[0] = 0.0; vert[1] = 1.0, vert[2] = 0.0;
                                canvasSettings.up.rotate(vert, (float)dx/100.0);
                                canvasSettings.up.normalise();
                                canvasSettings.eye.rotate(vert, (float)dx/100.0);
                        }
                        else    //Move light in x-z plane
                        {
                                CVector right = (canvasSettings.look-canvasSettings.eye)*canvasSettings.up;
                                right.normalise();
                                CVector forwards = right*CVector(0.0, 1.0, 0.0);
                                forwards.normalise();
                                forwards *= (float)dy/100.0;
                                right *= (float)dx/100.0;
                                lightpos[0] += forwards[0]+right[0];
                                lightpos[2] += forwards[2]+right[2];
                        }
                        mouseData[0].x = event->win_x;
                        mouseData[0].y = event->win_y;

                        onGLRefresh();
                }
                else if (mouseData[2].state == true)    //rmb
                {
                        dy = event->win_y-mouseData[2].y;
                        if (motiontype == false)        //Move camera towards and away from (0,0,0)
                        {
                                CVector forward = canvasSettings.eye-canvasSettings.look;
                                forward = canvasSettings.eye+forward*(float)dy/100.0;
                                if (((forward-canvasSettings.look).mag() > 0.2) && (forward.mag() < 99.0))
                                        canvasSettings.eye = forward;
                        }
                        else    //Move light up and down
                        {
                                lightpos[1] -= (float)dy/100.0;
                        }
                        mouseData[2].y = event->win_y;
                        onGLRefresh();
                }
        }
        return(1);
}


///Sets the mouse state variables when buttons pushed down
/**
 * @param ptr Mouse settings.
 * @return Returns 1 to show that the message was handled.
 */
long HeightWinDialog::onGLMouseDown(FXObject*, FXSelector, void* ptr)
{
        FXEvent *event = (FXEvent*)ptr;
        mouseData[0].state = false;
        mouseData[1].state = false;
        mouseData[2].state = false;
        mouseData[event->click_button-1].state = true;
        mouseData[event->click_button-1].x = event->click_x;
        mouseData[event->click_button-1].y = event->click_y;

        return(1);
}


///Resets mouse state on button up
/**
 * @param ptr Mouse settings.
 * @return Returns 1 to show that the message was handled.
 */
long HeightWinDialog::onGLMouseUp(FXObject*, FXSelector, void* ptr)
{
        mouseData[((FXEvent*)ptr)->click_button-1].state = false;
        onGLRefresh();
        return(1);
}


///Changes field of view on mouse wheel
/**
 * @param ptr Mouse settings.
 * @return Returns 1 to show that the message was handled.
 */
long HeightWinDialog::onGLMouseWheel(FXObject*, FXSelector, void* ptr)
{
        //event code is +/-120 for wheel up/down
        float d = (float)(((FXEvent*)ptr)->code)/60.0;
        canvasSettings.fov += d;
        if (canvasSettings.fov < 2.0)
                canvasSettings.fov = 2.0;
        if (canvasSettings.fov > 178.0)
                canvasSettings.fov = 178.0;

        onGLRefresh();
        return(1);
}


///Draws the heightmap graph
void HeightWinDialog::onGLRefresh()
{
        GLdouble width = GLCanvas->getWidth();
        GLdouble height = GLCanvas->getHeight();
        GLdouble aspect = height > 0 ? width/height : 1.0;

        GLCanvas->makeCurrent();

        //Set the viewport and perspective projection
        glViewport(0, 0, (int)width, (int)height);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        if (perspective == false)
                glOrtho(-aspect*0.5*(canvasSettings.vp[0]+canvasSettings.vp[1])*sin(0.25*canvasSettings.fov*PI/180.0),
                aspect*0.5*(canvasSettings.vp[0]+canvasSettings.vp[1])*sin(0.25*canvasSettings.fov*PI/180.0),
                -0.5*(canvasSettings.vp[0]+canvasSettings.vp[1])*sin(0.25*canvasSettings.fov*PI/180.0),
                0.5*(canvasSettings.vp[0]+canvasSettings.vp[1])*sin(0.25*canvasSettings.fov*PI/180.0),
                canvasSettings.vp[0], canvasSettings.vp[1]);
        else
                gluPerspective(canvasSettings.fov, aspect, canvasSettings.vp[0], canvasSettings.vp[1]);

        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();

        //Clear the buffers and set the camera
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
        gluLookAt(canvasSettings.eye[0], canvasSettings.eye[1], canvasSettings.eye[2],
                canvasSettings.look[0], canvasSettings.look[1], canvasSettings.look[2],
                canvasSettings.up[0], canvasSettings.up[1], canvasSettings.up[2]);

        //Turn off lighting
        float acolour[4] = {0.01, 0.01, 0.01, 1.0};
        glDisable(GL_COLOR_MATERIAL);
        glDisable(GL_LIGHTING);
        glLightfv(GL_LIGHT0, GL_POSITION, lightpos);
        glLightfv(GL_LIGHT0, GL_AMBIENT, acolour);
        glLightfv(GL_LIGHT0, GL_SPECULAR, specularcolour);
        glLightfv(GL_LIGHT0, GL_DIFFUSE, diffusecolour);
        glEnable(GL_LIGHT0);
        float lcolour[4] = {1.0, 0.0, 1.0, 1.0};
        if (motiontype == true) //if in light mode draw a sphere to represtent the light
        {
                glColor4fv(lcolour);
//              cerr << 'R' << diffusecolour[0] << ',' << diffusecolour[1] << ',' << diffusecolour[2] << '\n';
                glPushMatrix();
                        glTranslated(lightpos[0], lightpos[1], lightpos[2]);
                        gluSphere(sphereQuadric, 0.05, 10, 10);
                glPopMatrix();
        }
        
        if (plate == true)      //Draw the plate if required
        {
                glEnable(GL_POLYGON_OFFSET_FILL);       //so we don't get z-fighting with the lines
                glColor3ubv(platecolour);
                glBegin(GL_QUADS);
                        glVertex3f(-1.0, 0.0, -1.0);
                        glVertex3f(-1.0, 0.0, 1.0);
                        glVertex3f(1.0, 0.0, 1.0);
                        glVertex3f(1.0, 0.0, -1.0);
                glEnd();
                glDisable(GL_POLYGON_OFFSET_FILL);
        }

        //Get the matrix projection so we can calulate screen positions from 3D positions 
        GLint viewport[4];
        GLdouble mvmatrix[16], pmatrix[16];
        GLdouble px[4][3];
        GLdouble temppx[2][3];
        glGetIntegerv(GL_VIEWPORT, viewport);
        glGetDoublev(GL_MODELVIEW_MATRIX, mvmatrix);
        glGetDoublev(GL_PROJECTION_MATRIX, pmatrix);
        float xandz[3][2];

        glLineWidth(1.0);
        if (box == 1)   //Draw the outer box
        {
                glColor3ubv(boxcolour);
                glBegin(GL_LINES);
                        glVertex3f(-1.0, 0.0, -1.0);
                        glVertex3f(-1.0, 1.0, -1.0);
                        glVertex3f(-1.0, 0.0, 1.0);
                        glVertex3f(-1.0, 1.0, 1.0);
                        glVertex3f(1.0, 0.0, 1.0);
                        glVertex3f(1.0, 1.0, 1.0);
                        glVertex3f(1.0, 0.0, -1.0);
                        glVertex3f(1.0, 1.0, -1.0);
                        glVertex3f(-1.0, 1.0, -1.0);
                        glVertex3f(1.0, 1.0, -1.0);
                        glVertex3f(1.0, 1.0, -1.0);
                        glVertex3f(1.0, 1.0, 1.0);
                        glVertex3f(1.0, 1.0, 1.0);
                        glVertex3f(-1.0, 1.0, 1.0);
                        glVertex3f(-1.0, 1.0, 1.0);
                        glVertex3f(-1.0, 1.0, -1.0);
                        glVertex3f(-1.0, 0.0, 1.0);
                        glVertex3f(-1.0, 0.0, -1.0);
                        glVertex3f(-1.0, 0.0, -1.0);
                        glVertex3f(1.0, 0.0, -1.0);
                        glVertex3f(1.0, 0.0, -1.0);
                        glVertex3f(1.0, 0.0, 1.0);
                        glVertex3f(1.0, 0.0, 1.0);
                        glVertex3f(-1.0, 0.0, 1.0);
                glEnd();
        }
        else if (box == 2)      //Draw the partial outer box
        {
                //calculate corners
                gluProject(1.0, 0.0, 1.0, mvmatrix, pmatrix, viewport, &px[0][0], &px[0][1], &px[0][2]);
                gluProject(1.0, 0.0, -1.0, mvmatrix, pmatrix, viewport, &px[1][0], &px[1][1], &px[1][2]);
                gluProject(-1.0, 0.0, -1.0, mvmatrix, pmatrix, viewport, &px[2][0], &px[2][1], &px[2][2]);
                gluProject(-1.0, 0.0, 1.0, mvmatrix, pmatrix, viewport, &px[3][0], &px[3][1], &px[3][2]);
                glColor3ubv(boxcolour);
                glBegin(GL_LINES);
                        glVertex3f(-1.0, 0.0, 1.0);
                        glVertex3f(-1.0, 0.0, -1.0);
                        glVertex3f(-1.0, 0.0, -1.0);
                        glVertex3f(1.0, 0.0, -1.0);
                        glVertex3f(1.0, 0.0, -1.0);
                        glVertex3f(1.0, 0.0, 1.0);
                        glVertex3f(1.0, 0.0, 1.0);
                        glVertex3f(-1.0, 0.0, 1.0);

                        //work out which one is at the back
                        if ((px[0][1] < px[1][1]) && (px[0][1] < px[2][1]) && (px[0][1] < px[3][1]))
                        {
                                glVertex3f(-1.0, 0.0, -1.0);
                                glVertex3f(-1.0, 1.0, -1.0);
                                glVertex3f(-1.0, 0.0, 1.0);
                                glVertex3f(-1.0, 1.0, 1.0);
                                glVertex3f(1.0, 0.0, -1.0);
                                glVertex3f(1.0, 1.0, -1.0);
                                glVertex3f(-1.0, 1.0, -1.0);
                                glVertex3f(1.0, 1.0, -1.0);
                                glVertex3f(-1.0, 1.0, 1.0);
                                glVertex3f(-1.0, 1.0, -1.0);
                        }
                        else if ((px[1][1] < px[2][1]) && (px[1][1] < px[3][1]))
                        {
                                glVertex3f(-1.0, 0.0, -1.0);
                                glVertex3f(-1.0, 1.0, -1.0);
                                glVertex3f(-1.0, 0.0, 1.0);
                                glVertex3f(-1.0, 1.0, 1.0);
                                glVertex3f(1.0, 0.0, 1.0);
                                glVertex3f(1.0, 1.0, 1.0);
                                glVertex3f(1.0, 1.0, 1.0);
                                glVertex3f(-1.0, 1.0, 1.0);
                                glVertex3f(-1.0, 1.0, 1.0);
                                glVertex3f(-1.0, 1.0, -1.0);
                        }
                        else if (px[2][1] < px[3][1])
                        {
                                glVertex3f(-1.0, 0.0, 1.0);
                                glVertex3f(-1.0, 1.0, 1.0);
                                glVertex3f(1.0, 0.0, 1.0);
                                glVertex3f(1.0, 1.0, 1.0);
                                glVertex3f(1.0, 0.0, -1.0);
                                glVertex3f(1.0, 1.0, -1.0);
                                glVertex3f(1.0, 1.0, -1.0);
                                glVertex3f(1.0, 1.0, 1.0);
                                glVertex3f(1.0, 1.0, 1.0);
                                glVertex3f(-1.0, 1.0, 1.0);
                        }
                        else
                        {
                                glVertex3f(-1.0, 0.0, -1.0);
                                glVertex3f(-1.0, 1.0, -1.0);
                                glVertex3f(1.0, 0.0, 1.0);
                                glVertex3f(1.0, 1.0, 1.0);
                                glVertex3f(1.0, 0.0, -1.0);
                                glVertex3f(1.0, 1.0, -1.0);
                                glVertex3f(-1.0, 1.0, -1.0);
                                glVertex3f(1.0, 1.0, -1.0);
                                glVertex3f(1.0, 1.0, -1.0);
                                glVertex3f(1.0, 1.0, 1.0);
                        }
                glEnd();
        }

        float p;
        int c;
        if (xmin.on == true)    //if we require a x-minor grid then draw it
        {
                c = 0;
                glColor4ubv((unsigned char*)&xmin.colour);
                glBegin(GL_LINES);
                        p = xmin.start;
                        while ((p <= 1.0005) && (c < 1000))
                        {
                                if (p >= -1.0)
                                {
                                        glVertex3f(p, 0.0, 1.02);
                                        glVertex3f(p, 0.0, -1.02);
                                }
                                p += xmin.delta;
                                ++c;    //bail out if more than 1000 lines
                        }
                glEnd();
        }
        if (xmaj.on == true)    //similarly with the x-major
        {
                c = 0;
                glDisable(GL_DEPTH_TEST);
                glColor4ubv((unsigned char*)&xmaj.colour);
                glBegin(GL_LINES);
                        p = xmaj.start;
                        while ((p <= 1.0005) && (c < 1000))
                        {
                                if (p >= -1.0)
                                {
                                        glVertex3f(p, 0.0, 1.04);
                                        glVertex3f(p, 0.0, -1.04);
                                }
                                p += xmaj.delta;
                                ++c;
                        }
                glEnd();
                glEnable(GL_DEPTH_TEST);
        }
        if (ymin.on == true)    //and other grids
        {
                c = 0;
                glColor4ubv((unsigned char*)&ymin.colour);
                glBegin(GL_LINES);
                        p = ymin.start;
                        while ((p <= 1.0005) && (c < 1000))
                        {
                                if (p >= -1.0)
                                {
                                        glVertex3f(1.02, 0.0, p);
                                        glVertex3f(-1.02, 0.0, p);
                                }
                                p += ymin.delta;
                                ++c;
                        }
                glEnd();
        }
        if (ymaj.on == true)
        {
                c = 0;
                glDisable(GL_DEPTH_TEST);
                glColor4ubv((unsigned char*)&ymaj.colour);
                glBegin(GL_LINES);
                        p = ymaj.start;
                        while ((p <= 1.0005) && (c < 1000))
                        {
                                if (p >= -1.0)
                                {
                                        glVertex3f(1.04, 0.0, p);
                                        glVertex3f(-1.04, 0.0, p);
                                }
                                p += ymaj.delta;
                                ++c;
                        }
                glEnd();
                glEnable(GL_DEPTH_TEST);
        }
        
        //Get the matrix projection so we can calulate screen positions from 3D positions 
//      GLint viewport[4];
//      GLdouble mvmatrix[16], pmatrix[16];
//      GLdouble px[4][3];
//      GLdouble temppx[2][3];
//      glGetIntegerv(GL_VIEWPORT, viewport);
//      glGetDoublev(GL_MODELVIEW_MATRIX, mvmatrix);
//      glGetDoublev(GL_PROJECTION_MATRIX, pmatrix);
//      float xandz[3][2];
        //If the z-grid is on then calculate the co-ordinates of the lines to draw
        if ((zmin.on == true) || (zmaj.on == true))
        {
                //calculate corners
                gluProject(1.0, 0.0, 1.0, mvmatrix, pmatrix, viewport, &px[0][0], &px[0][1], &px[0][2]);
                gluProject(1.0, 0.0, -1.0, mvmatrix, pmatrix, viewport, &px[1][0], &px[1][1], &px[1][2]);
                gluProject(-1.0, 0.0, -1.0, mvmatrix, pmatrix, viewport, &px[2][0], &px[2][1], &px[2][2]);
                gluProject(-1.0, 0.0, 1.0, mvmatrix, pmatrix, viewport, &px[3][0], &px[3][1], &px[3][2]);
                //work out which one is at the back
                if ((px[0][1] < px[1][1]) && (px[0][1] < px[2][1]) && (px[0][1] < px[3][1]))
                {
                        if (zbackgrid == true)
                        {
                                xandz[0][0] = -1.0; xandz[0][1] = 1.0;
                                xandz[1][0] = -1.0; xandz[1][1] = -1.0;
                                xandz[2][0] = 1.0; xandz[2][1] = -1.0;
                        }
                        else
                        {
                                xandz[0][0] = 0.98; xandz[0][1] = -0.98;
                                xandz[1][0] = 1.02; xandz[1][1] = -1.02;
                                xandz[2][0] = 1.04; xandz[2][1] = -1.04;
                        }
                }
                else if ((px[1][1] < px[2][1]) && (px[1][1] < px[3][1]))
                {
                        if (zbackgrid == true)
                        {
                                xandz[0][0] = 1.0; xandz[0][1] = 1.0;
                                xandz[1][0] = -1.0; xandz[1][1] = 1.0;
                                xandz[2][0] = -1.0; xandz[2][1] = -1.0;
                        }
                        else
                        {
                                xandz[0][0] = -0.98; xandz[0][1] = -0.98;
                                xandz[1][0] = -1.02; xandz[1][1] = -1.02;
                                xandz[2][0] = -1.04; xandz[2][1] = -1.04;
                        }
                }
                else if (px[2][1] < px[3][1])
                {
                        if (zbackgrid == true)
                        {
                                xandz[0][0] = -1.0; xandz[0][1] = 1.0;
                                xandz[1][0] = 1.0; xandz[1][1] = 1.0;
                                xandz[2][0] = 1.0; xandz[2][1] = -1.0;
                        }
                        else
                        {
                                xandz[0][0] = -0.98; xandz[0][1] = 0.98;
                                xandz[1][0] = -1.02; xandz[1][1] = 1.02;
                                xandz[2][0] = -1.04; xandz[2][1] = 1.04;
                        }
                }
                else
                {
                        if (zbackgrid == true)
                        {
                                xandz[0][0] = -1.0; xandz[0][1] = -1.0;
                                xandz[1][0] = 1.0; xandz[1][1] = -1.0;
                                xandz[2][0] = 1.0; xandz[2][1] = 1.0;
                        }
                        else
                        {
                                xandz[0][0] = 0.98; xandz[0][1] = 0.98;
                                xandz[1][0] = 1.02; xandz[1][1] = 1.02;
                                xandz[2][0] = 1.04; xandz[2][1] = 1.04;
                        }
                }
        }
        
        //Actually draw the z grid
        if (zmin.on == true)
        {
                c = 0;
                glColor4ubv((unsigned char*)&zmin.colour);
                glBegin(GL_LINES);
                        p = zmin.start;
                        while ((p <= 1.0005) && (c < 1000))
                        {
                                if (p >= 0.0)
                                {
                                        if (zbackgrid == true)
                                        {
                                                glVertex3f(xandz[0][0], p, xandz[0][1]);
                                                glVertex3f(xandz[1][0], p, xandz[1][1]);
                                                glVertex3f(xandz[1][0], p, xandz[1][1]);
                                                glVertex3f(xandz[2][0], p, xandz[2][1]);
                                        }
                                        else
                                        {
                                                glVertex3f(xandz[0][0], p, xandz[0][1]);
                                                glVertex3f(xandz[1][0], p, xandz[1][1]);
                                        }
                                }
                                p += zmin.delta;
                                ++c;
                        }
                glEnd();
        }
        if (zmaj.on == true)
        {
                c = 0;
                glDisable(GL_DEPTH_TEST);
                glColor4ubv((unsigned char*)&zmaj.colour);
                glBegin(GL_LINES);
                        p = zmaj.start;
                        while ((p <= 1.0005) && (c < 1000))
                        {
                                if (p >= 0.0)
                                {
                                        if (zbackgrid == true)
                                        {
                                                glVertex3f(xandz[0][0], p, xandz[0][1]);
                                                glVertex3f(xandz[1][0], p, xandz[1][1]);
                                                glVertex3f(xandz[1][0], p, xandz[1][1]);
                                                glVertex3f(xandz[2][0], p, xandz[2][1]);
                                        }
                                        else
                                        {
                                                glVertex3f(xandz[0][0], p, xandz[0][1]);
                                                glVertex3f(xandz[2][0], p, xandz[2][1]);
                                        }
                                }
                                p += zmaj.delta;
                                ++c;
                        }
                glEnd();
                glEnable(GL_DEPTH_TEST);
        }
        
        //Draw the data
        int i;
        float j;
        glEnable(GL_COLOR_MATERIAL);
        glEnable(GL_LIGHTING);
        glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specularcolour);
        glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shininess);
        glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
//      cerr << ydatapts << ',' << xdatapts << '\n';
        if (ydatapts*xdatapts > 0)
        {
                //set up the clip planes
                double plane[4] = {0.0, 1.0, 0.0, 0.0};
                glClipPlane(GL_CLIP_PLANE0, plane);     //bottom
                plane[1] = -1.0; plane[3] = 1.0;
                glClipPlane(GL_CLIP_PLANE1, plane); //top
                plane[0] = 1.0; plane[1] = 0.0;
                glClipPlane(GL_CLIP_PLANE2, plane);
                plane[0] = -1.0; //plane[3] = 1.0;
                glClipPlane(GL_CLIP_PLANE3, plane);
                plane[0] = 0.0; plane[2] = -1.0;
                glClipPlane(GL_CLIP_PLANE4, plane);
                plane[2] = 1.0; //plane[3] = 1.0;
                glClipPlane(GL_CLIP_PLANE5, plane);

                glEnable(GL_CLIP_PLANE0);
                glEnable(GL_CLIP_PLANE1);
                glEnable(GL_CLIP_PLANE2);
                glEnable(GL_CLIP_PLANE3);
                glEnable(GL_CLIP_PLANE4);
                glEnable(GL_CLIP_PLANE5);
                //Draw
                if (switchdir == false)
                {
                        for (i = 0; i < (ydatapts-1); ++i)
                        {
                                if (drawmode == 0)
                                        glBegin(GL_TRIANGLE_STRIP);
                                else if (drawmode == 1)
                                        glBegin(GL_LINES);
                                else
                                        glBegin(GL_POINTS);
                                for (j = 0.0; j < (float)xdatapts; j += (float)xdatapts/(float)xdatadisplay)
                                {
                                        if (((int)(j+0.5) < xdatapts) && ((1+i) < ydatapts))
                                        {
                                                glColor3ubv(hmdata[(int)(j+0.5)+xdatapts*i].colour);
                                                glNormal3fv(hmdata[(int)(j+0.5)+xdatapts*i].normal);
                                                glVertex3fv(hmdata[(int)(j+0.5)+xdatapts*i].position);
                                                glColor3ubv(hmdata[(int)(j+0.5)+xdatapts*(1+i)].colour);
                                                glNormal3fv(hmdata[(int)(j+0.5)+xdatapts*(1+i)].normal);
                                                glVertex3fv(hmdata[(int)(j+0.5)+xdatapts*(1+i)].position);
                                        }
                                }
                                if ((int)(j+0.5) > (xdatapts-1))
                                {
                                                glColor3ubv(hmdata[(xdatapts-1)+xdatapts*i].colour);
                                                glNormal3fv(hmdata[(xdatapts-1)+xdatapts*i].normal);
                                                glVertex3fv(hmdata[(xdatapts-1)+xdatapts*i].position);
                                                glColor3ubv(hmdata[(xdatapts-1)+xdatapts*(1+i)].colour);
                                                glNormal3fv(hmdata[(xdatapts-1)+xdatapts*(1+i)].normal);
                                                glVertex3fv(hmdata[(xdatapts-1)+xdatapts*(1+i)].position);
                                }
/*                              for (j = 0.0; j < (float)xdatapts; j += (float)xdatapts/(float)xdatadisplay)
                                {
                                        glColor3ubv(hmdata[(int)(j+0.5)+xdatapts*i].colour);
                                        glNormal3fv(hmdata[(int)(j+0.5)+xdatapts*i].normal);
                                        glVertex3fv(hmdata[(int)(j+0.5)+xdatapts*i].position);
                                        glColor3ubv(hmdata[(int)(j+0.5)+xdatapts*(1+i)].colour);
                                        glNormal3fv(hmdata[(int)(j+0.5)+xdatapts*(1+i)].normal);
                                        glVertex3fv(hmdata[(int)(j+0.5)+xdatapts*(1+i)].position);
                                }
                                if ((j-(float)xdatapts/(float)xdatadisplay) < xdatapts-1)
                                {
                                                glColor3ubv(hmdata[(xdatapts-1)+xdatapts*i].colour);
                                                glNormal3fv(hmdata[(xdatapts-1)+xdatapts*i].normal);
                                                glVertex3fv(hmdata[(xdatapts-1)+xdatapts*i].position);
                                                glColor3ubv(hmdata[(xdatapts-1)+xdatapts*(1+i)].colour);
                                                glNormal3fv(hmdata[(xdatapts-1)+xdatapts*(1+i)].normal);
                                                glVertex3fv(hmdata[(xdatapts-1)+xdatapts*(1+i)].position);
                                }*/
                                glEnd();
                        }
                }
                else
                {
                        int jprime;
                        for (j = 0.0; j < (float)xdatapts; j += (float)xdatapts/(float)xdatadisplay)
                        {
                                if (drawmode == 0)
                                        glBegin(GL_TRIANGLE_STRIP);
                                else if (drawmode == 1)
                                        glBegin(GL_LINES);
                                else
                                        glBegin(GL_POINTS);
                                jprime = (int)(j+0.5+(float)xdatapts/(float)xdatadisplay);
                                if (jprime > xdatapts-1)
                                        jprime = xdatapts-1;
                                if (j < xdatapts-1)
                                {
                                        for (i = 0; i < ydatapts; ++i)
                                        {
                                                glColor3ubv(hmdata[jprime+xdatapts*i].colour);
                                                glNormal3fv(hmdata[jprime+xdatapts*i].normal);
                                                glVertex3fv(hmdata[jprime+xdatapts*i].position);
                                                glColor3ubv(hmdata[(int)(j+0.5)+xdatapts*i].colour);
                                                glNormal3fv(hmdata[(int)(j+0.5)+xdatapts*i].normal);
                                                glVertex3fv(hmdata[(int)(j+0.5)+xdatapts*i].position);
                                        }
                                }
                                glEnd();
                        }
/*                      if ((j-(float)xdatapts/(float)xdatadisplay) < xdatapts-1)
                        {
                                if (drawmode == 0)
                                        glBegin(GL_TRIANGLE_STRIP);
                                else if (drawmode == 1)
                                        glBegin(GL_LINES);
                                else
                                        glBegin(GL_POINTS);
                                for (i = 0; i < ydatapts; ++i)
                                {
                                        glColor3ubv(hmdata[(xdatapts-1)+xdatapts*i].colour);
                                        glNormal3fv(hmdata[(xdatapts-1)+xdatapts*i].normal);
                                        glVertex3fv(hmdata[(xdatapts-1)+xdatapts*i].position);
                                        glColor3ubv(hmdata[(int)(j+0.5-(float)xdatapts/(float)xdatadisplay)+xdatapts*i].colour);
                                        glNormal3fv(hmdata[(int)(j+0.5-(float)xdatapts/(float)xdatadisplay)+xdatapts*i].normal);
                                        glVertex3fv(hmdata[(int)(j+0.5-(float)xdatapts/(float)xdatadisplay)+xdatapts*i].position);
                                }
                                glEnd();
                        }*/
                }
                glDisable(GL_CLIP_PLANE0);
                glDisable(GL_CLIP_PLANE1);
                glDisable(GL_CLIP_PLANE2);
                glDisable(GL_CLIP_PLANE3);
                glDisable(GL_CLIP_PLANE4);
                glDisable(GL_CLIP_PLANE5);
        }


#define CHARGAP 10
#define NORMALISE temppx[0][0] -= temppx[1][0]; temppx[0][1] -= temppx[1][1]; m = sqrt(temppx[0][0]*temppx[0][0]+temppx[0][1]*temppx[0][1]); temppx[0][0] *= CHARGAP/m; temppx[0][1] *= CHARGAP/m;

        //If no mouse buttons are pushed draw the text labels
        if ((mouseData[0].state == false) && (mouseData[1].state == false) && (mouseData[2].state == false))
        {
                if (drawlabels == 1)
                {
#define L_YMAX 0
#define L_YMIN 1
#define L_YLBL 2
#define L_XMAX 3
#define L_XMIN 4
#define L_XLBL 5
#define L_ZMAX 6
#define L_ZMIN 7
#define L_ZLBL 8
#define L_TIT 9
#define L_STIT 10
                        //Calculate the size of each string
                        int labeldims[11][3];   //ymax, ymin, ylabel, x versions, z versions, title, subtitle (length, x, y)
                        labeldims[L_YMAX][0] = fnt->getStringDimensions(FXDoubleVal(axes[2]));
                        labeldims[L_YMIN][0] = fnt->getStringDimensions(FXDoubleVal(axes[3]));
                        labeldims[L_YLBL][0] = fnt->getStringDimensions(labels[3]);
//                      if (ylabelrotCheckbutton->getCheck() == false)
//                              leftlegend = CHARGAP+largest(labeldims[0], labeldims[1], labeldims[2]); //longest y string
//                      else
//                              leftlegend = CHARGAP+largest(labeldims[0], labeldims[1], fnt->fontheight);      //longest y string
                        labeldims[L_XMAX][0] = fnt->getStringDimensions(FXDoubleVal(axes[1]));
                        labeldims[L_XMIN][0] = fnt->getStringDimensions(FXDoubleVal(axes[0]));
                        labeldims[L_XLBL][0] = fnt->getStringDimensions(