DrawPalette.cpp

Go to the documentation of this file.

//DrawPalette.cpp

/*************************************************************/
//
// DrawPaletteDialog
//
// Object drawing palette
//
//-------------------------------------------------------------
//
// v 1.3 - 2007/02/17 - Added distance display
// v 1.2 - 2007/02/08 - Save draw directory
// v 1.1 - 2007/02/07 - Fixed positioning of elements
// v 1.0 - 2007/01/06 - Initial release
//
// See LICENSE.txt for distribution and usage restrictions
// Copyright (c) 2006-2007 Simon Chorley
// www.mylaboratory.co.uk - greylab@mylaboratory.co.uk
//
/*************************************************************/


///Drawing palette (Implementation)
/**
 * Provides implementation of DrawPaletteDialog window class to manage creation of drawing primatives on the colourscale and linescan graphs.
 * @file DrawPalette.cpp
 * @version 1.3 - 2007/02/17
 */


#include "DrawPalette.h"


#include "GreyLab.h"


#include <fstream>


FXDEFMAP(DrawPaletteDialog) DrawPaletteDialogMap[]={
        FXMAPFUNC(SEL_COMMAND,                  DrawPaletteDialog::ID_DRAW_CHANGED,                     DrawPaletteDialog::cmdUpdateData),
        FXMAPFUNC(SEL_CHANGED,                  DrawPaletteDialog::ID_DRAW_CHANGED,                     DrawPaletteDialog::cmdUpdateData),

        FXMAPFUNC(SEL_COMMAND,                  DrawPaletteDialog::ID_DRAW_NEWLINE,                     DrawPaletteDialog::cmdNewLine),
        FXMAPFUNC(SEL_COMMAND,                  DrawPaletteDialog::ID_DRAW_NEWTEXT,                     DrawPaletteDialog::cmdNewText),
        FXMAPFUNC(SEL_COMMAND,                  DrawPaletteDialog::ID_DRAW_NEWRECT,                     DrawPaletteDialog::cmdNewRect),
        FXMAPFUNC(SEL_COMMAND,                  DrawPaletteDialog::ID_DRAW_NEWELLIPSE,          DrawPaletteDialog::cmdNewEllipse),
        FXMAPFUNC(SEL_COMMAND,                  DrawPaletteDialog::ID_DRAW_NEWIMAGE,            DrawPaletteDialog::cmdNewImage),
        FXMAPFUNC(SEL_COMMAND,                  DrawPaletteDialog::ID_DRAW_NEWFUNCTION,         DrawPaletteDialog::cmdNewFunction),

        FXMAPFUNC(SEL_COMMAND,                  DrawPaletteDialog::ID_DRAW_ITEMDN,                      DrawPaletteDialog::cmdItemUp),
        FXMAPFUNC(SEL_COMMAND,                  DrawPaletteDialog::ID_DRAW_ITEMUP,                      DrawPaletteDialog::cmdItemDown),

        FXMAPFUNC(SEL_SELECTED,                 DrawPaletteDialog::ID_DRAW_ITEMSEL,                     DrawPaletteDialog::cmdItemSelect),
        FXMAPFUNC(SEL_DOUBLECLICKED,    DrawPaletteDialog::ID_DRAW_ITEMSEL,                     DrawPaletteDialog::cmdItemDelete),

        FXMAPFUNC(SEL_COMMAND,                  DrawPaletteDialog::ID_DRAW_IMAGEBROWSE,         DrawPaletteDialog::cmdImageBrowse),

        FXMAPFUNC(SEL_COMMAND,                  DrawPaletteDialog::ID_DRAW_NEW,                         DrawPaletteDialog::cmdNew),
        FXMAPFUNC(SEL_COMMAND,                  DrawPaletteDialog::ID_DRAW_LOAD,                        DrawPaletteDialog::cmdLoad),
        FXMAPFUNC(SEL_COMMAND,                  DrawPaletteDialog::ID_DRAW_APPEND,                      DrawPaletteDialog::cmdAppend),
        FXMAPFUNC(SEL_COMMAND,                  DrawPaletteDialog::ID_DRAW_SAVE,                        DrawPaletteDialog::cmdSave),
        FXMAPFUNC(SEL_COMMAND,                  DrawPaletteDialog::ID_DRAW_SAVEAS,                      DrawPaletteDialog::cmdSaveAs)

};


FXIMPLEMENT(DrawPaletteDialog, FXDialogBox, DrawPaletteDialogMap, ARRAYNUMBER(DrawPaletteDialogMap))


DrawPaletteDialog::~DrawPaletteDialog()
{
}


///Palette window class constructor
/**
 * @param owner Parent window object.
 * @param target Graph to draw primatives onto.
 */
DrawPaletteDialog::DrawPaletteDialog(FXWindow* owner, int target) : FXDialogBox(owner, "Drawing Palette", DECOR_TITLE|DECOR_CLOSE)
{
        FXVerticalFrame *frame = new FXVerticalFrame(this, LAYOUT_FILL_X|LAYOUT_FILL_Y, 0, 0, 0, 0, 0, 0, 0, 0);

        FXHorizontalFrame *penFrame = new FXHorizontalFrame(frame, LAYOUT_TOP|LAYOUT_FILL_X|FRAME_NONE, 0, 0, 0, 0, 0, 0, 0, 0);
        new FXLabel(penFrame, "FG:", NULL, LAYOUT_SIDE_TOP|LAYOUT_LEFT|PACK_UNIFORM_WIDTH|LAYOUT_LEFT|LAYOUT_CENTER_Y);
        drawfgColourwell = new FXColorWell(penFrame, FXRGBA(0,0,0, 255), this, ID_DRAW_CHANGED, LAYOUT_SIDE_TOP|LAYOUT_FIX_WIDTH|LAYOUT_LEFT|LAYOUT_CENTER_Y, 0, 0, 50, 0);
        new FXLabel(penFrame, " BG:", NULL, LAYOUT_SIDE_TOP|LAYOUT_LEFT|PACK_UNIFORM_WIDTH|LAYOUT_LEFT|LAYOUT_CENTER_Y);
        drawbgColourwell = new FXColorWell(penFrame, FXRGBA(255,255,255, 0), this, ID_DRAW_CHANGED, LAYOUT_SIDE_TOP|LAYOUT_FIX_WIDTH|LAYOUT_LEFT|LAYOUT_CENTER_Y, 0, 0, 50, 0);
        new FXLabel(penFrame, " Stroke:", NULL, LAYOUT_SIDE_TOP|LAYOUT_LEFT|PACK_UNIFORM_WIDTH|LAYOUT_LEFT|LAYOUT_CENTER_Y);
        drawstrokeTextfield = new FXTextField(penFrame, 2, this, ID_DRAW_CHANGED, TEXTFIELD_INTEGER|FRAME_SUNKEN|PACK_UNIFORM_WIDTH|LAYOUT_LEFT|LAYOUT_CENTER_Y);

        FXHorizontalFrame *posFrame = new FXHorizontalFrame(frame, LAYOUT_TOP|LAYOUT_FILL_X|FRAME_NONE, 0, 0, 0, 0, 0, 0, 0, 0);
        new FXLabel(posFrame, "Position:", NULL, LAYOUT_SIDE_TOP|LAYOUT_LEFT|PACK_UNIFORM_WIDTH|LAYOUT_LEFT|LAYOUT_CENTER_Y);
        drawxposTextfield = new FXTextField(posFrame, 8, this, ID_DRAW_CHANGED, TEXTFIELD_REAL|FRAME_SUNKEN|PACK_UNIFORM_WIDTH|LAYOUT_LEFT|LAYOUT_CENTER_Y);
        drawyposTextfield = new FXTextField(posFrame, 8, this, ID_DRAW_CHANGED, TEXTFIELD_REAL|FRAME_SUNKEN|PACK_UNIFORM_WIDTH|LAYOUT_LEFT|LAYOUT_CENTER_Y);
        drawbasisPopup = new FXPopup(this);
        drawaxisOption = new FXOption(drawbasisPopup, "Axes space\tCo-ordinates based on axes values\tCo-ordinates based on axes values", NULL, this, ID_DRAW_CHANGED, JUSTIFY_HZ_APART|ICON_AFTER_TEXT);
        drawfractionalOption = new FXOption(drawbasisPopup, "Image fractional\tCo-ordinates are a percentage of the whole image\tCo-ordinates are a percentage of the whole image", NULL, this, ID_DRAW_CHANGED, JUSTIFY_HZ_APART|ICON_AFTER_TEXT);
        drawabsoluteOption = new FXOption(drawbasisPopup, "Absolute\tCo-ordinates are absolute\tCo-ordinates are absolute", NULL, this, ID_DRAW_CHANGED, JUSTIFY_HZ_APART|ICON_AFTER_TEXT);
        drawaxisfractionalOption = new FXOption(drawbasisPopup, "Axes fractional\tCo-ordinates are a percentage of the axes\tCo-ordinates are a percentage of the axes", NULL, this, ID_DRAW_CHANGED, JUSTIFY_HZ_APART|ICON_AFTER_TEXT);
        drawborderOption = new FXOption(drawbasisPopup, "Border fractional\tCo-ordinates are positioned in the image borders\tCo-ordinates are positioned in the image borders", NULL, this, ID_DRAW_CHANGED, JUSTIFY_HZ_APART|ICON_AFTER_TEXT);
        drawbasisOptionmenu = new FXOptionMenu(posFrame, drawbasisPopup, LAYOUT_CENTER_Y|FRAME_RAISED|JUSTIFY_HZ_APART|ICON_AFTER_TEXT);

        FXHorizontalFrame *dimsFrame = new FXHorizontalFrame(frame, LAYOUT_TOP|LAYOUT_FILL_X|FRAME_NONE, 0, 0, 0, 0, 0, 0, 0, 0);
        new FXLabel(dimsFrame, "Dimensions:", NULL, LAYOUT_SIDE_TOP|LAYOUT_LEFT|PACK_UNIFORM_WIDTH|LAYOUT_LEFT|LAYOUT_CENTER_Y);
        drawxsizeTextfield = new FXTextField(dimsFrame, 8, this, ID_DRAW_CHANGED, TEXTFIELD_REAL|FRAME_SUNKEN|PACK_UNIFORM_WIDTH|LAYOUT_LEFT|LAYOUT_CENTER_Y);
        drawysizeTextfield = new FXTextField(dimsFrame, 8, this, ID_DRAW_CHANGED, TEXTFIELD_REAL|FRAME_SUNKEN|PACK_UNIFORM_WIDTH|LAYOUT_LEFT|LAYOUT_CENTER_Y);
        drawsizebasisPopup = new FXPopup(this);
        drawsizeaxisOption = new FXOption(drawsizebasisPopup, "Axes space\tCo-ordinates based on axes values\tCo-ordinates based on axes values", NULL, this, ID_DRAW_CHANGED, JUSTIFY_HZ_APART|ICON_AFTER_TEXT);
        drawsizefractionalOption = new FXOption(drawsizebasisPopup, "Image fractional\tCo-ordinates are a percentage of the whole image\tCo-ordinates are a percentage of the whole image", NULL, this, ID_DRAW_CHANGED, JUSTIFY_HZ_APART|ICON_AFTER_TEXT);
        drawsizeabsoluteOption = new FXOption(drawsizebasisPopup, "Absolute\tCo-ordinates are absolute\tCo-ordinates are absolute", NULL, this, ID_DRAW_CHANGED, JUSTIFY_HZ_APART|ICON_AFTER_TEXT);
        drawsizeaxisfractionalOption = new FXOption(drawsizebasisPopup, "Axes fractional\tCo-ordinates are a percentage of the axes\tCo-ordinates are a percentage of the axes", NULL, this, ID_DRAW_CHANGED, JUSTIFY_HZ_APART|ICON_AFTER_TEXT);
        drawsizeborderOption = new FXOption(drawsizebasisPopup, "Border fractional\tCo-ordinates are positioned in the image borders\tCo-ordinates are positioned in the image borders", NULL, this, ID_DRAW_CHANGED, JUSTIFY_HZ_APART|ICON_AFTER_TEXT);
        drawsizebasisOptionmenu = new FXOptionMenu(dimsFrame, drawsizebasisPopup, LAYOUT_CENTER_Y|FRAME_RAISED|JUSTIFY_HZ_APART|ICON_AFTER_TEXT);

        drawobjectSwitcher = new FXSwitcher(frame, LAYOUT_FILL_X, 0, 0, 0, 0, 0, 0, 0, 0);

        FXHorizontalFrame *arrowFrame = new FXHorizontalFrame(drawobjectSwitcher, LAYOUT_TOP|LAYOUT_FILL_X|FRAME_NONE, 0, 0, 0, 0, 0, 0, 0, 0);
        drawstartarrowCheckbutton = new FXCheckButton(arrowFrame, "Start arrow", this, ID_DRAW_CHANGED, CHECKBUTTON_NORMAL|LAYOUT_LEFT|LAYOUT_CENTER_Y);
        drawendarrowCheckbutton = new FXCheckButton(arrowFrame, "End arrow", this, ID_DRAW_CHANGED, CHECKBUTTON_NORMAL|LAYOUT_LEFT|LAYOUT_CENTER_Y);
        new FXLabel(arrowFrame, "Size:", NULL, LAYOUT_SIDE_TOP|LAYOUT_LEFT|PACK_UNIFORM_WIDTH|LAYOUT_LEFT|LAYOUT_CENTER_Y);
        drawarrowlengthTextfield = new FXTextField(arrowFrame, 5, this, ID_DRAW_CHANGED, TEXTFIELD_REAL|FRAME_SUNKEN|PACK_UNIFORM_WIDTH|LAYOUT_LEFT|LAYOUT_CENTER_Y);
        drawarrowwidthTextfield = new FXTextField(arrowFrame, 5, this, ID_DRAW_CHANGED, TEXTFIELD_REAL|FRAME_SUNKEN|PACK_UNIFORM_WIDTH|LAYOUT_LEFT|LAYOUT_CENTER_Y);

        FXHorizontalFrame *textFrame = new FXHorizontalFrame(drawobjectSwitcher, LAYOUT_TOP|LAYOUT_FILL_X|FRAME_NONE, 0, 0, 0, 0, 0, 0, 0, 0);
        new FXLabel(textFrame, "Text:", NULL, LAYOUT_SIDE_TOP|LAYOUT_LEFT|PACK_UNIFORM_WIDTH|LAYOUT_LEFT|LAYOUT_CENTER_Y);
        drawtextTextfield = new FXTextField(textFrame, 37, this, ID_DRAW_CHANGED, FRAME_SUNKEN|PACK_UNIFORM_WIDTH|LAYOUT_LEFT|LAYOUT_CENTER_Y);
        drawjustifyPopup = new FXPopup(this);
        drawtljustifyOption = new FXOption(drawjustifyPopup, "TL\tTop-left justified\tTop-left justified", NULL, this, ID_DRAW_CHANGED, JUSTIFY_HZ_APART|ICON_AFTER_TEXT);
        drawtrjustifyOption = new FXOption(drawjustifyPopup, "TR\tTop-right justified\tTop-right justified", NULL, this, ID_DRAW_CHANGED, JUSTIFY_HZ_APART|ICON_AFTER_TEXT);
        drawbljustifyOption = new FXOption(drawjustifyPopup, "BL\tBottom-left justified\tBottom-left justified", NULL, this, ID_DRAW_CHANGED, JUSTIFY_HZ_APART|ICON_AFTER_TEXT);
        drawbrjustifyOption = new FXOption(drawjustifyPopup, "BR\tBottom-right justified\tBottom-right justified", NULL, this, ID_DRAW_CHANGED, JUSTIFY_HZ_APART|ICON_AFTER_TEXT);
        drawcjustifyOption = new FXOption(drawjustifyPopup, "C\tCentre justified\tCentre justified", NULL, this, ID_DRAW_CHANGED, JUSTIFY_HZ_APART|ICON_AFTER_TEXT);
        drawjustifyOptionmenu = new FXOptionMenu(textFrame, drawjustifyPopup, LAYOUT_CENTER_Y|FRAME_RAISED|JUSTIFY_HZ_APART|ICON_AFTER_TEXT);

        FXHorizontalFrame *rectangleFrame = new FXHorizontalFrame(drawobjectSwitcher, LAYOUT_TOP|LAYOUT_FILL_X|FRAME_NONE, 0, 0, 0, 0, 0, 0, 0, 0);
        FXHorizontalFrame *ellipseFrame = new FXHorizontalFrame(drawobjectSwitcher, LAYOUT_TOP|LAYOUT_FILL_X|FRAME_NONE, 0, 0, 0, 0, 0, 0, 0, 0);

        FXHorizontalFrame *imageFrame = new FXHorizontalFrame(drawobjectSwitcher, LAYOUT_TOP|LAYOUT_FILL_X|FRAME_NONE, 0, 0, 0, 0, 0, 0, 0, 0);
        new FXLabel(imageFrame, "Image:", NULL, LAYOUT_SIDE_TOP|LAYOUT_LEFT|PACK_UNIFORM_WIDTH|LAYOUT_LEFT|LAYOUT_CENTER_Y);
        drawimageTextfield = new FXTextField(imageFrame, 30, this, ID_DRAW_CHANGED, FRAME_SUNKEN|PACK_UNIFORM_WIDTH|LAYOUT_LEFT|LAYOUT_CENTER_Y);
        new FXButton(imageFrame, "...", NULL, this, ID_DRAW_IMAGEBROWSE, FRAME_RAISED|LAYOUT_LEFT|ICON_BEFORE_TEXT);

        FXHorizontalFrame *functionFrame = new FXHorizontalFrame(drawobjectSwitcher, LAYOUT_TOP|LAYOUT_FILL_X|FRAME_NONE, 0, 0, 0, 0, 0, 0, 0, 0);
        new FXLabel(functionFrame, "Function:", NULL, LAYOUT_SIDE_TOP|LAYOUT_LEFT|PACK_UNIFORM_WIDTH|LAYOUT_LEFT|LAYOUT_CENTER_Y);
        drawfunctionTextfield = new FXTextField(functionFrame, 25, this, ID_DRAW_CHANGED, FRAME_SUNKEN|LAYOUT_FILL_X|LAYOUT_LEFT|LAYOUT_CENTER_Y);
        draw2dCheckbutton = new FXCheckButton(functionFrame, "2D", this, ID_DRAW_CHANGED, CHECKBUTTON_NORMAL|LAYOUT_LEFT|LAYOUT_CENTER_Y);
/*      new FXLabel(functionFrame, "Scale:", NULL, LAYOUT_SIDE_TOP|LAYOUT_LEFT|PACK_UNIFORM_WIDTH|LAYOUT_LEFT|LAYOUT_CENTER_Y);
        drawscaleTextfield = new FXTextField(functionFrame, 4, this, ID_DRAW_CHANGED, TEXTFIELD_REAL|FRAME_SUNKEN|PACK_UNIFORM_WIDTH|LAYOUT_LEFT|LAYOUT_CENTER_Y);*/

        FXHorizontalFrame *labelsFrame = new FXHorizontalFrame(frame, LAYOUT_TOP|LAYOUT_FILL_X|FRAME_NONE, 0, 0, 0, 0, 0, 0, 0, 0);
        drawstartlCheckbutton = new FXCheckButton(labelsFrame, "Start coords", this, ID_DRAW_CHANGED, CHECKBUTTON_NORMAL|LAYOUT_LEFT|LAYOUT_CENTER_Y);
        drawendlCheckbutton = new FXCheckButton(labelsFrame, "End coords", this, ID_DRAW_CHANGED, CHECKBUTTON_NORMAL|LAYOUT_LEFT|LAYOUT_CENTER_Y);
        drawgradlCheckbutton = new FXCheckButton(labelsFrame, "Gradient", this, ID_DRAW_CHANGED, CHECKBUTTON_NORMAL|LAYOUT_LEFT|LAYOUT_CENTER_Y);
        drawdistlCheckbutton = new FXCheckButton(labelsFrame, "Distance", this, ID_DRAW_CHANGED, CHECKBUTTON_NORMAL|LAYOUT_LEFT|LAYOUT_CENTER_Y);

        FXHorizontalFrame *newFrame = new FXHorizontalFrame(frame, LAYOUT_TOP|LAYOUT_FILL_X|FRAME_NONE, 0, 0, 0, 0, 0, 0, 0, 0);
        new FXButton(newFrame, "  /  ", NULL, this, ID_DRAW_NEWLINE, FRAME_RAISED|LAYOUT_LEFT|ICON_BEFORE_TEXT);
        new FXButton(newFrame, "  T  ", NULL, this, ID_DRAW_NEWTEXT, FRAME_RAISED|LAYOUT_LEFT|ICON_BEFORE_TEXT);
        new FXButton(newFrame, "  []  ", NULL, this, ID_DRAW_NEWRECT, FRAME_RAISED|LAYOUT_LEFT|ICON_BEFORE_TEXT);
        new FXButton(newFrame, "  o  ", NULL, this, ID_DRAW_NEWELLIPSE, FRAME_RAISED|LAYOUT_LEFT|ICON_BEFORE_TEXT);
        new FXButton(newFrame, "  i  ", NULL, this, ID_DRAW_NEWIMAGE, FRAME_RAISED|LAYOUT_LEFT|ICON_BEFORE_TEXT);
        new FXButton(newFrame, "  ~  ", NULL, this, ID_DRAW_NEWFUNCTION, FRAME_RAISED|LAYOUT_LEFT|ICON_BEFORE_TEXT);
        new FXButton(newFrame, " Dn ", NULL, this, ID_DRAW_ITEMDN, FRAME_RAISED|LAYOUT_RIGHT|ICON_BEFORE_TEXT);
        new FXButton(newFrame, " Up ", NULL, this, ID_DRAW_ITEMUP, FRAME_RAISED|LAYOUT_RIGHT|ICON_BEFORE_TEXT);

        drawitemsColourlist = new FXColorList(frame, this, ID_DRAW_ITEMSEL, LIST_BROWSESELECT|LAYOUT_FILL_X|LAYOUT_FIX_HEIGHT, 0, 0, 0, 300);

        FXHorizontalFrame *filesFrame = new FXHorizontalFrame(frame, LAYOUT_TOP|LAYOUT_FILL_X|FRAME_NONE, 0, 0, 0, 0, 0, 0, 0, 0);
        new FXButton(filesFrame, "Save As", NULL, this, ID_DRAW_SAVEAS, FRAME_RAISED|LAYOUT_RIGHT|ICON_BEFORE_TEXT);
        new FXButton(filesFrame, "Save", NULL, this, ID_DRAW_SAVE, FRAME_RAISED|LAYOUT_RIGHT|ICON_BEFORE_TEXT);
        new FXButton(filesFrame, "Append", NULL, this, ID_DRAW_APPEND, FRAME_RAISED|LAYOUT_RIGHT|ICON_BEFORE_TEXT);
        new FXButton(filesFrame, "Load", NULL, this, ID_DRAW_LOAD, FRAME_RAISED|LAYOUT_RIGHT|ICON_BEFORE_TEXT);
        new FXButton(filesFrame, "New", NULL, this, ID_DRAW_NEW, FRAME_RAISED|LAYOUT_RIGHT|ICON_BEFORE_TEXT);

        nPrimatives = 0;
        primatives = NULL;

        startpx = 0;
        startpy = 0;
        startax = 0.0;
        startay = 0.0;
        currentpx = 0;
        currentpy = 0;
        
        drawing = false;

        updatetarget = target;
}


///Hide palette
void DrawPaletteDialog::hide()
{
        this->getOwner()->handle(this, FXSEL(SEL_COMMAND, GreyLabWindow::ID_DRAWMODEOFF), NULL);
        FXDialogBox::hide();
}


///Create new primative
/**
 * Creates a new primative and initialises it.
 * @param p New primative type.
 */
void DrawPaletteDialog::createPrimative(primative::typemode p)
{
        primative *temp;
        if (nPrimatives > 0)
        {
                temp = new primative[nPrimatives];
                memcpy(temp, primatives, nPrimatives*sizeof(primative));
                delete[] primatives;
                primatives = new primative[nPrimatives+1];
                memcpy(primatives, temp, nPrimatives*sizeof(primative));
                delete[] temp;
        }
        else
        {
                primatives = new primative[1];
        }
        primatives[nPrimatives].type = p;
        primatives[nPrimatives].text = new FXString;
        primatives[nPrimatives].file = new FXString;
        primatives[nPrimatives].func = new FXString;
        if (p == primative::FUNCTION)
                primatives[nPrimatives].datafunc = new CDataFunc;
        if (p == primative::IMAGE)
        {
                ilGenImages(1, &primatives[nPrimatives].imageid);
                primatives[nPrimatives].validimage = false;
        }
        ++nPrimatives;
}


///Creates new primative and updates the display
/**
 * @param p New primative type.
 */
void DrawPaletteDialog::newPrimative(primative::typemode p)
{
        createPrimative(p);
        drawitemsColourlist->setCurrentItem(nPrimatives-1);
        cmdUpdateAllData(NULL, 0, NULL);
        drawobjectSwitcher->setCurrent((int)p);
        return;
}


///New line button handler
long DrawPaletteDialog::cmdNewLine(FXObject*, FXSelector, void*)
{
        drawitemsColourlist->appendItem("LINE", drawfgColourwell->getRGBA());
        newPrimative(primative::LINE);
        return(1);
}


///New text button handler
long DrawPaletteDialog::cmdNewText(FXObject*, FXSelector, void*)
{
        drawitemsColourlist->appendItem("TEXT", drawfgColourwell->getRGBA());
        newPrimative(primative::TEXT);
        return(1);
}


///New rectangle button handler
long DrawPaletteDialog::cmdNewRect(FXObject*, FXSelector, void*)
{
        drawitemsColourlist->appendItem("RECT", drawfgColourwell->getRGBA());
        newPrimative(primative::RECT);
        return(1);
}


///New ellipse button handler
long DrawPaletteDialog::cmdNewEllipse(FXObject*, FXSelector, void*)
{
        drawitemsColourlist->appendItem("ELLIPSE", drawfgColourwell->getRGBA());
        newPrimative(primative::ELLIPSE);
        return(1);
}


///New image button handler
long DrawPaletteDialog::cmdNewImage(FXObject*, FXSelector, void*)
{
        drawitemsColourlist->appendItem("IMAGE", drawfgColourwell->getRGBA());
        newPrimative(primative::IMAGE);
        return(1);
}


///New function button handler
long DrawPaletteDialog::cmdNewFunction(FXObject*, FXSelector, void*)
{
        drawitemsColourlist->appendItem("FUNC", drawfgColourwell->getRGBA());
        newPrimative(primative::FUNCTION);
        return(1);
}


///Move current item down the draw order list
long DrawPaletteDialog::cmdItemDown(FXObject*, FXSelector, void*)
{
        int i = drawitemsColourlist->getCurrentItem();
        if (i > 0)
        {
                drawitemsColourlist->moveItem(i-1, i);
                primative temp;
                memcpy(&temp, &primatives[i], sizeof(primative));
                memcpy(&primatives[i], &primatives[i-1], sizeof(primative));
                memcpy(&primatives[i-1], &temp, sizeof(primative));

                this->getOwner()->handle(this, FXSEL(SEL_COMMAND, updatetarget), NULL);
        }
        return(1);
}


///Move current item up the draw order list
long DrawPaletteDialog::cmdItemUp(FXObject*, FXSelector, void*)
{
        int i = drawitemsColourlist->getCurrentItem();
        if ((i >= 0) && (i < drawitemsColourlist->getNumItems()-1))
        {
                drawitemsColourlist->moveItem(i+1, i);

                primative temp;
                memcpy(&temp, &primatives[i], sizeof(primative));
                memcpy(&primatives[i], &primatives[i+1], sizeof(primative));
                memcpy(&primatives[i+1], &temp, sizeof(primative));

                this->getOwner()->handle(this, FXSEL(SEL_COMMAND, updatetarget), NULL);
        }

        return(1);
}


///Loads an image to draw
void DrawPaletteDialog::ImageLoad(void)
{
        int idx = drawitemsColourlist->getCurrentItem();
        if (idx > -1)
        {
                ilBindImage(primatives[idx].imageid);
                if (ilLoadImage((char*)primatives[idx].file->text()) == IL_FALSE)
                {
                        FXMessageBox::error(this, FX::MBOX_OK, "Error!", "Could not load image (image library error).");
                }
                primatives[idx].validimage = true;
                this->getOwner()->handle(this, FXSEL(SEL_COMMAND, updatetarget), NULL);
        }
}


///Browse for an image to draw
long DrawPaletteDialog::cmdImageBrowse(FXObject*, FXSelector, void*)
{
        FXFileDialog openFiledialog(this, "Image file", PLACEMENT_OWNER);
        openFiledialog.setSelectMode(SELECTFILE_EXISTING);
        openFiledialog.setPatternList("All Files (*)");
        openFiledialog.setCurrentPattern(0);
//      openFiledialog.setDirectory(graddirectory);

        if(openFiledialog.execute())
        {
                FXString imagefile = openFiledialog.getFilename();
                drawimageTextfield->setText(imagefile);
//              graddirectory = openFiledialog.getDirectory();
                int idx = drawitemsColourlist->getCurrentItem();
                if (idx > -1)
                {
                        primatives[idx].file->assign(imagefile);
                        ImageLoad();
                }
        }
        return(1);
}


#ifndef WIN32
///Sort coordinate into order
/**
 * @remark Required for Linux X drawing of the objects
 * @param[out] xmin Smallest x.
 * @param[out] xmax Largest x.
 * @param[out] ymin Smallest y.
 * @param[out] ymax Largest y.
 * @param spx X1.
 * @param epx X2.
 * @param spy Y1.
 * @param epy Y2.
 */
void DrawPaletteDialog::coordSort(int &xmin, int &xmax, int &ymin, int &ymax, int spx, int epx, int spy, int epy)
{
        if (spx < epx)
        {
                xmin = spx;
                xmax = epx;
        }
        else
        {
                xmin = epx;
                xmax = spx;
        }
        if (spy < epy)
        {
                ymin = spy;
                ymax = epy;
        }
        else
        {
                ymin = epy;
                ymax = spy;
        }
}
#endif


///Set image sizes
/**
 * Initialises the size of the image so the palette knows where to draw objects.
 * @param tw Image width.
 * @param th Image height.
 * @param xp Data width.
 * @param yp Data height.
 * @param bl Left border width.
 * @param bb Bottom border height.
 */
void DrawPaletteDialog::setImageCoords(int tw, int th, int xp, int yp, int bl, int bb)
{
        totalwidth = tw;
        totalheight = th;
        xpixels = xp;
        ypixels = yp;
        borderleft = bl;
        borderbottom = bb;
        borderright = totalwidth-xpixels-borderleft;
        bordertop = totalheight-ypixels-borderbottom;
}


///Draw outline of current primative
/**
 * Draws the current primative as it is dragged out with the mouse.
 * @param dcw Window to draw to.
 * @param x Axis space x coordinate.
 * @param y Axis space y coordinate.
 * @param mx Mouse x.
 * @param my Mouse y.
 * @param xpx Image space x coordinate.
 * @param ypx Image space y coordinate.
 */
void DrawPaletteDialog::drawPrimative(FXDCWindow *dcw, double x, double y, int mx, int my, int xpx, int ypx)
{
        if (drawing == false)
                return;
        int idx = drawitemsColourlist->getCurrentItem();
        if (idx > -1)
        {
#ifndef WIN32
                FXFunction func = dcw->getFunction();
#endif
                dcw->setFunction(FX::BLT_NOT_DST);
                switch (primatives[idx].type)
                {
                case primative::LINE:
                        {
                                if ((startpx != currentpx) || (startpy != currentpy))
                                        dcw->drawLine(startpx, startpy, currentpx, currentpy);
                                dcw->drawLine(startpx, startpy, mx, my);
                        }
                        break;
                case primative::RECT:
                case primative::IMAGE:
                case primative::FUNCTION:
                        {
#ifdef WIN32
                                if ((startpx != currentpx) || (startpy != currentpy))
                                        dcw->drawRectangle(startpx, startpy, currentpx-startpx, currentpy-startpy);
                                dcw->drawRectangle(startpx, startpy, mx-startpx, my-startpy);
#else
                                int xmin, xmax, ymin, ymax;
                                if ((startpx != currentpx) || (startpy != currentpy))
                                {
                                        coordSort(xmin, xmax, ymin, ymax, startpx, currentpx, startpy, currentpy);
                                        dcw->drawRectangle(xmin, ymin, xmax-xmin, ymax-ymin);
                                }
                                coordSort(xmin, xmax, ymin, ymax, startpx, mx, startpy, my);
                                dcw->drawRectangle(xmin, ymin, xmax-xmin, ymax-ymin);
#endif
                        }
                        break;
                case primative::ELLIPSE:
                        {
#ifdef WIN32
                                if ((startpx != currentpx) || (startpy != currentpy))
                                        dcw->drawEllipse(startpx-(currentpx-startpx), startpy-(currentpy-startpy), 2*(currentpx-startpx), 2*(currentpy-startpy));
                                dcw->drawEllipse(startpx-(mx-startpx), startpy-(my-startpy), 2*(mx-startpx), 2*(my-startpy));
#else
                                int xmin, xmax, ymin, ymax;
                                if ((startpx != currentpx) || (startpy != currentpy))
                                {
                                        coordSort(xmin, xmax, ymin, ymax, startpx, currentpx, startpy, currentpy);
                                        dcw->drawEllipse(startpx-abs(currentpx-startpx), startpy-abs(currentpy-startpy), 2*(xmax-xmin), 2*(ymax-ymin));
                                }
                                coordSort(xmin, xmax, ymin, ymax, startpx, mx, startpy, my);
                                dcw->drawEllipse(startpx-abs(mx-startpx), startpy-abs(my-startpy), 2*(xmax-xmin), 2*(ymax-ymin));
#endif
                        }
                        break;
                default:
                        break;
                }
#ifndef WIN32
                dcw->setFunction(func);
#endif
                currentpx = mx;
                currentpy = my;
        }
        switch (drawsizebasisOptionmenu->getCurrentNo())
        {
        case 0:         //Axes space
                {
                        drawxsizeTextfield->setText(FXStringVal(x, 4));
                        drawysizeTextfield->setText(FXStringVal(y, 4));
                }
                break;
        case 1:         //Image fractional
                {
                        drawxsizeTextfield->setText(FXStringVal((float)xpx/totalwidth));
                        drawysizeTextfield->setText(FXStringVal((float)ypx/totalheight));
                }
                break;
        case 2:         //Absolute
                {
                        drawxsizeTextfield->setText(FXStringVal(xpx));
                        drawysizeTextfield->setText(FXStringVal(ypx));
                }
                break;
        case 3:         //Axes fractional
                {
                        drawxsizeTextfield->setText(FXStringVal((float)(xpx-borderleft)/(float)xpixels));
                        drawysizeTextfield->setText(FXStringVal((float)(ypx-borderbottom)/(float)ypixels));
                }
                break;
        case 4:         //Border fractional
                {
                        if (xpx < borderleft)
                                drawxsizeTextfield->setText(FXStringVal((float)xpx/(float)borderleft));
                        else if (xpx < borderleft+xpixels)
                                drawxsizeTextfield->setText(FXStringVal(1.0+(float)(xpx-borderleft)/(float)xpixels));
                        else
                                drawxsizeTextfield->setText(FXStringVal(2.0+(float)(xpx-borderleft-xpixels)/(float)borderright));
                        if (ypx < borderbottom)
                                drawysizeTextfield->setText(FXStringVal((float)ypx/(float)borderbottom));
                        else if (ypx < borderbottom+ypixels)
                                drawysizeTextfield->setText(FXStringVal(1.0+(float)(ypx-borderbottom)/(float)ypixels));
                        else
                                drawysizeTextfield->setText(FXStringVal(2.0+(float)(ypx-borderbottom-ypixels)/(float)bordertop));
                }
                break;
        default:
                break;
        }
        return;
}


///Start drawing a new primative
/**
 * Sets initial coordinate of the primative.
 * @param dcw Window to draw to.
 * @param x Axis space x coordinate.
 * @param y Axis space y coordinate.
 * @param mx Mouse x.
 * @param my Mouse y.
 * @param xpx Image space x coordinate.
 * @param ypx Image space y coordinate.
 */
void DrawPaletteDialog::startDraw(double x, double y, int mx, int my, int xpx, int ypx)
{
        drawing = true;
        
        startpx = mx;
        startax = x;
        currentpx = mx;
        startpy = my;
        startay = y;
        currentpy = my;
        switch (drawbasisOptionmenu->getCurrentNo())
        {
        case 0:         //Axes space
                {
                        drawxposTextfield->setText(FXStringVal(x, 4));
                        drawyposTextfield->setText(FXStringVal(y, 4));
                }
                break;
        case 1:         //Image fractional
                {
                        drawxposTextfield->setText(FXStringVal((float)xpx/totalwidth));
                        drawyposTextfield->setText(FXStringVal((float)ypx/totalheight));
                }
                break;
        case 2:         //Absolute
                {
                        drawxposTextfield->setText(FXStringVal(xpx));
                        drawyposTextfield->setText(FXStringVal(ypx));
                }
                break;
        case 3:         //Axes fractional
                {
                        drawxposTextfield->setText(FXStringVal((float)(xpx-borderleft)/(float)xpixels));
                        drawyposTextfield->setText(FXStringVal((float)(ypx-borderbottom)/(float)ypixels));
                }
                break;
        case 4:         //Border fractional
                {
                        if (xpx < borderleft)
                                drawxposTextfield->setText(FXStringVal((float)xpx/(float)borderleft));
                        else if (xpx < borderleft+xpixels)
                                drawxposTextfield->setText(FXStringVal(1.0+(float)(xpx-borderleft)/(float)xpixels));
                        else
                                drawxposTextfield->setText(FXStringVal(2.0+(float)(xpx-borderleft-xpixels)/(float)borderright));
                        if (ypx < borderbottom)
                                drawyposTextfield->setText(FXStringVal((float)ypx/(float)borderbottom));
                        else if (ypx < borderbottom+ypixels)
                                drawyposTextfield->setText(FXStringVal(1.0+(float)(ypx-borderbottom)/(float)ypixels));
                        else
                                drawyposTextfield->setText(FXStringVal(2.0+(float)(ypx-borderbottom-ypixels)/(float)bordertop));
                }
                break;
        default:
                break;
        }
        return;
}


///End drawing a new primative
/**
 * Sets final position/dimension coordinate of the primative.
 * @param dcw Window to draw to.
 * @param x Axis space x coordinate.
 * @param y Axis space y coordinate.
 * @param mx Mouse x.
 * @param my Mouse y.
 * @param xpx Image space x coordinate.
 * @param ypx Image space y coordinate.
 */
void DrawPaletteDialog::endDraw(FXDCWindow *dcw, double x, double y, int mx, int my, int xpx, int ypx)
{
        drawing = false;
        
        int idx = drawitemsColourlist->getCurrentItem();
        if (idx > -1)
        {
#ifndef WIN32
                FXFunction func = dcw->getFunction();
#endif
                dcw->setFunction(FX::BLT_NOT_DST);
                switch (primatives[idx].type)
                {
                case primative::LINE:
                        {
                                dcw->drawLine(startpx, startpy, currentpx, currentpy);
                        }
                        break;
                case primative::RECT:
                case primative::IMAGE:
                case primative::FUNCTION:
                        {
#ifdef WIN32
                                dcw->drawRectangle(startpx, startpy, currentpx-startpx, currentpy-startpy);
#else
                                int xmin, xmax, ymin, ymax;
                                coordSort(xmin, xmax, ymin, ymax, startpx, currentpx, startpy, currentpy);
                                dcw->drawRectangle(xmin, ymin, xmax-xmin, ymax-ymin);
#endif
                        }
                        break;
                case primative::ELLIPSE:
                        {
#ifdef WIN32
                                dcw->drawEllipse(startpx-(currentpx-startpx), startpy-(currentpy-startpy), 2*(currentpx-startpx), 2*(currentpy-sta