RTVolumeRendering/Source/TransferFunctionWidget.cpp

Go to the documentation of this file.

#include <sstream>
#include "TransferFunctionWidget.h"
#include "Error.h"
#include <wx/busyinfo.h>

#ifdef APPLE_APPLICATION_BUNDLE
        #include <CoreFoundation/CFBundle.h>
#endif

const int ID_DRAWALL_CHECKBOX    = wxID_HIGHEST + 42;
const int ID_HISTOGRAM_CHECKBOX  = wxID_HIGHEST + 43;
const int ID_ACTIVEPLOT_RADIOBOX = wxID_HIGHEST + 44;
const int ID_PLOTMODE_RADIOBOX   = wxID_HIGHEST + 45;
const int ID_SAVE_BUTTON                 = wxID_HIGHEST + 46;
const int ID_LOAD_BUTTON                 = wxID_HIGHEST + 47;
const int ID_REFRESH_BUTTON              = wxID_HIGHEST + 48;
const int ID_RESET_BUTTON        = wxID_HIGHEST + 49;

const int MIN_DATAVALUE = 0;
const int MAX_DATAVALUE = 255;

const int MAX_PLOT_POINTS = 64;

const int PLOT_PEN_WIDTH = 1;
const int PLOT_PEN_STYLE = wxSOLID;

const int PLOT_POINT_STYLE = wxSOLID;
const int PLOT_POINT_SIZE = 8;
const int PLOT_POINT_SIZE_HALF = PLOT_POINT_SIZE / 2;

const int PLOT_WIDTH = 510;
const int PLOT_HEIGHT = 128;
const int PLOT_BORDER = 20;

// RGBA color that the histrogram will be drawn in
const unsigned char HISTOGRAM_COLOR_R = 25;
const unsigned char HISTOGRAM_COLOR_G = 25;
const unsigned char HISTOGRAM_COLOR_B = 25;

// Tool tip text
const wxString SAVE_TOOLTIP                       = wxT("Saves the current transfer function to a file.");
const wxString LOAD_TOOLTIP                       = wxT("Loads a transfer function form a file.");
const wxString REFRESH_TOOLTIP            = wxT("Updates the renderer with the transfer function (only needed if Realtime mode is disabled).");
const wxString RESET_TOOLTIP              = wxT("Reverts the transfer function to its original state.");
const wxString DRAWALL_TOOLTIP            = wxT("Draws the Red, Green, Blue and Alpha functions.");
const wxString HISTOGRAM_TOOLTIP          = wxT("Enables/Disables drawing of the histogram.");
const wxString PLOT_MODE_TOOLTIP          = wxT("Choose the tool for altering the transfer function:\n *Move - Allows for moving the individual plot points.\n *Add - Allows for new plot points to be created.\n *Remove - Allows for the removal of plot points.");
const wxString PLOT_SELECTION_TOOLTIP = wxT("Select the active function.");

BEGIN_EVENT_TABLE(TransferFunctionPlot, wxWindow)
        EVT_PAINT(TransferFunctionPlot::OnPaint)
        EVT_MOTION(TransferFunctionPlot::MouseMove)
        EVT_LEFT_UP(TransferFunctionPlot::MouseLeftUp)
        EVT_LEFT_DOWN(TransferFunctionPlot::MouseLeftDown)
        EVT_MOUSEWHEEL(TransferFunctionPlot::MouseWheel)
        EVT_LEAVE_WINDOW(TransferFunctionPlot::MouseLeave)
END_EVENT_TABLE()

BEGIN_EVENT_TABLE(TransferFunctionWidget, wxWindow)
        EVT_CHECKBOX(ID_DRAWALL_CHECKBOX, TransferFunctionWidget::OnDrawAllClick)
        EVT_CHECKBOX(ID_HISTOGRAM_CHECKBOX, TransferFunctionWidget::OnDrawHistogramClick)
        EVT_RADIOBOX(ID_ACTIVEPLOT_RADIOBOX, TransferFunctionWidget::OnActivePlotSelection)
        EVT_RADIOBOX(ID_PLOTMODE_RADIOBOX, TransferFunctionWidget::OnPlotModeSelection)
        EVT_BUTTON(ID_SAVE_BUTTON, TransferFunctionWidget::OnSaveClick)
        EVT_BUTTON(ID_LOAD_BUTTON, TransferFunctionWidget::OnLoadClick)
        EVT_BUTTON(ID_REFRESH_BUTTON, TransferFunctionWidget::OnRefreshClick)
        EVT_BUTTON(ID_RESET_BUTTON, TransferFunctionWidget::OnResetClick)
END_EVENT_TABLE()

//----------------------------------------------------------------
TransferFunctionPlot::TransferFunctionPlot(wxWindow *parent)
:
wxWindow(parent, wxID_ANY, wxDefaultPosition, wxSize(PLOT_WIDTH + 2*PLOT_BORDER, PLOT_HEIGHT + 2*PLOT_BORDER)),
delayUpdates(false),
drawHistogram(false),
drawAll(false),
currDataValue(0),
currValue(1.0f),
selectedPoint(-1),
mode(MOVE),
listner(NULL)
{
        SetBackgroundColour(wxColor(0, 0, 0));
        
        ResetPlot();
        
        activePlot = &alphaPlot;
        activePlotColor = Colors::Grey;
        
#ifdef APPLE_APPLICATION_BUNDLE
        
        CFBundleRef bundle = CFBundleGetMainBundle();
        CFURLRef gridUrl = CFBundleCopyResourceURL(bundle, CFSTR("grid"), CFSTR("bmp"), NULL);

        CFStringRef gridStr = CFURLCopyPath(gridUrl);
        
        CFIndex len = CFStringGetLength(gridStr);
        char *str = new char[len + 1];
        CFStringGetCString(gridStr, str, len + 1, kCFStringEncodingASCII);
        
        bgGrid.LoadFile(str, wxBITMAP_TYPE_BMP);
        
        delete [] str;

        CFRelease(gridStr);
        CFRelease(gridUrl);
        
#else
        
        bgGrid.LoadFile("./grid.bmp", wxBITMAP_TYPE_BMP);
        
#endif

        wxImage im(PLOT_WIDTH - 2, PLOT_HEIGHT - 2);
        histogram = wxBitmap(im);
}

//----------------------------------------------------------------
TransferFunctionPlot::~TransferFunctionPlot()
{
}

//----------------------------------------------------------------
void TransferFunctionPlot::ResetPlot()
{
        redPlot.clear();
        greenPlot.clear();
        bluePlot.clear();
        alphaPlot.clear();

        PlotPoint start;
        start.value = 0.0f;
        start.dataValue = MIN_DATAVALUE;
        
        PlotPoint end;
        end.value = 1.0f;
        end.dataValue = MAX_DATAVALUE;
        
        redPlot.push_back(start);
        greenPlot.push_back(start);
        bluePlot.push_back(start);
        alphaPlot.push_back(start);
        
        redPlot.push_back(end);
        greenPlot.push_back(end);
        bluePlot.push_back(end);
        alphaPlot.push_back(end);

        RefreshListner();
        Refresh();
}

//----------------------------------------------------------------
void TransferFunctionPlot::OnPaint(wxPaintEvent& event)
{
        wxPaintDC dc(this);
        
        dc.DrawBitmap(bgGrid, 0, 0);
        
        if(drawHistogram)
                dc.DrawBitmap(histogram, PLOT_BORDER + 2, PLOT_BORDER + 1);
        
        if(drawAll)
        {
                DrawPlot(dc, redPlot, Colors::Red);
                DrawPlot(dc, greenPlot, Colors::Green);
                DrawPlot(dc, bluePlot, Colors::Blue);
                DrawPlot(dc, alphaPlot, Colors::Grey);
        }
        
        if(activePlot)
        {
                DrawPlot(dc, *activePlot, activePlotColor);
                DrawPlotPoints(dc, *activePlot, activePlotColor);
        }
        
        dc.SetTextForeground(wxColor(255, 255, 255));
        dc.SetFont(wxFont(10, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL));
        
        wxString val = wxT("Value = ");
        val << currValue;
        
        wxString dataVal = wxT("Data Value = ");
        dataVal << currDataValue;
        
        dc.DrawText(val, PLOT_BORDER, 3);
        dc.DrawText(dataVal, PLOT_WIDTH - 63, 3);
}

//----------------------------------------------------------------
void TransferFunctionPlot::MouseMove(wxMouseEvent &m)
{
        if(selectedPoint != -1 && mode == MOVE)
        {
                int x = m.GetX() - PLOT_BORDER;
                int y = m.GetY() - PLOT_BORDER;
                
                int low = 0;
                int high = PLOT_WIDTH;
                if(selectedPoint == 0)
                {
                        x = 0;
                }
                else
                {
                        low = PlotDataValueToXCoord(activePlot->at(selectedPoint - 1).dataValue);
                }
                
                int last = (int)activePlot->size() - 1;
                if(selectedPoint == last)
                {
                        x = PLOT_WIDTH;
                }
                else
                {
                        high = PlotDataValueToXCoord(activePlot->at(selectedPoint + 1).dataValue);
                }
                
                x = Clamp(x, low, high);
                y = Clamp(y, 0, PLOT_HEIGHT);
                
                PlotPoint &p = activePlot->at(selectedPoint);
                ScreenToPlotPoint(x, y, p);
                
                currDataValue = p.dataValue;
                currValue = p.value;
                
                Refresh();
                
                if(!delayUpdates)
                        RefreshListner();
        }
}

//----------------------------------------------------------------
void TransferFunctionPlot::MouseLeftDown(wxMouseEvent &m)
{
        int x = m.GetX() - PLOT_BORDER;
        int y = m.GetY() - PLOT_BORDER;
        
        switch(mode)
        {
                case MOVE:
                        SelectPoint(x, y);
                        break;
                case ADD:
                        AddPoint(x, y);
                        break;
                case REMOVE:
                        RemovePoint(x, y);
                        break;
        };
        
        PlotPoint p;
        ScreenToPlotPoint(x, y, p);
        
        currDataValue = p.dataValue;
        currValue = p.value;
        
        bool mouseDown = true;
}

//----------------------------------------------------------------
void TransferFunctionPlot::MouseLeftUp(wxMouseEvent &m)
{
        mouseDown = false;
        selectedPoint = -1;
}

//----------------------------------------------------------------
void TransferFunctionPlot::MouseWheel(wxMouseEvent &m)
{
}

//----------------------------------------------------------------
void TransferFunctionPlot::MouseLeave(wxMouseEvent &m)
{
        if(mouseDown && selectedPoint != -1 && !delayUpdates)
                RefreshListner();

        mouseDown = false;
        selectedPoint = -1;
}

//----------------------------------------------------------------
void TransferFunctionPlot::SetPlotMode(PlotMode m)
{
        mode = m;
}

//----------------------------------------------------------------
void TransferFunctionPlot::DrawAll(bool b)
{
        drawAll = b;
        Refresh();
}

//----------------------------------------------------------------
void TransferFunctionPlot::DrawHistogram(bool b)
{
        drawHistogram = b;
        Refresh();
}

//----------------------------------------------------------------
void TransferFunctionPlot::MakeRedActive()
{
        selectedPoint = -1;
        activePlot = &redPlot;
        activePlotColor = Colors::Red;
        Refresh();
}

//----------------------------------------------------------------
void TransferFunctionPlot::MakeGreenActive()
{
        selectedPoint = -1;
        activePlot = &greenPlot;
        activePlotColor = Colors::Green;
        Refresh();
}

//----------------------------------------------------------------
void TransferFunctionPlot::MakeBlueActive()
{
        selectedPoint = -1;
        activePlot = &bluePlot;
        activePlotColor = Colors::Blue;
        Refresh();
}

//----------------------------------------------------------------
void TransferFunctionPlot::MakeAlphaActive()
{
        selectedPoint = -1;
        activePlot = &alphaPlot;
        activePlotColor = Colors::Grey;
        Refresh();
}

//----------------------------------------------------------------
void TransferFunctionPlot::SetListner(TransferPlotChangeListner *l)
{
        listner = l;
        RefreshListner();
}

//----------------------------------------------------------------
void TransferFunctionPlot::UpdateTexture(TransferTexture *tex)
{
        if(tex)
                tex->CreateFunction(redPlot, greenPlot, bluePlot, alphaPlot);
}

//----------------------------------------------------------------
void TransferFunctionPlot::PlotPointToScreen(const PlotPoint &p, int &x, int &y) const
{
        x = PlotDataValueToXCoord(p.dataValue);
        y = PlotValueToYCoord(p.value);
}

//----------------------------------------------------------------
int TransferFunctionPlot::PlotDataValueToXCoord(int dataValue) const
{
        return (int)(((float)dataValue / MAX_DATAVALUE) * PLOT_WIDTH);
}

//----------------------------------------------------------------
int TransferFunctionPlot::PlotValueToYCoord(float value) const
{
        return (int)((1.0f - value) * PLOT_HEIGHT);
}

//----------------------------------------------------------------
void TransferFunctionPlot::ScreenToPlotPoint(int x, int y, PlotPoint &p) const
{
        p.dataValue = (int)(((float)x / PLOT_WIDTH) * MAX_DATAVALUE);
        p.value     = 1.0f - ((float)y / PLOT_HEIGHT);
}

//----------------------------------------------------------------
void TransferFunctionPlot::DrawPlot(wxPaintDC &dc, const std::vector<PlotPoint> &plot, const Color4f &color) const
{
        byte r, g, b;
        color.Get(r, g, b);
        
        wxPen pen(wxColor(r, g, b), PLOT_PEN_WIDTH, PLOT_PEN_STYLE);
        
        dc.SetPen(pen);
        
        size_t len = plot.size() - 1;
        for(size_t i = 0; i < len; i++)
        {               
                wxCoord x1, x2, y1, y2;
                PlotPointToScreen(plot[i], x1, y1);
                PlotPointToScreen(plot[i + 1], x2, y2);
                
                dc.DrawLine(x1 + PLOT_BORDER, y1 + PLOT_BORDER, x2 + PLOT_BORDER, y2 + PLOT_BORDER);
        }
}

//----------------------------------------------------------------
void TransferFunctionPlot::DrawPlotPoints(wxPaintDC &dc, const std::vector<PlotPoint> &plot, const Color4f &color) const
{
        byte r, g, b;
        color.Get(r, g, b);
        
        wxPen pen(wxColor(r, g, b));
        wxBrush brush(wxColor(r, g, b));
        
        dc.SetPen(pen);
        dc.SetBrush(brush);
        
        size_t len = plot.size();
        for(size_t i = 0; i < len; i++)
        {               
                int x, y;
                PlotPointToScreen(plot[i], x, y);

                x += PLOT_BORDER;
                y += PLOT_BORDER;
                
                dc.DrawRectangle(x - PLOT_POINT_SIZE_HALF, 
                                                 y - PLOT_POINT_SIZE_HALF, 
                                                 PLOT_POINT_SIZE, 
                                                 PLOT_POINT_SIZE);
        }
}

//----------------------------------------------------------------
bool TransferFunctionPlot::SelectPoint(wxCoord x, wxCoord y)
{
        if(activePlot)
        {
                int sel = SelectPoint(x, y, *activePlot);
                selectedPoint = sel;
                return sel != -1;
        }
        
        return false;
}

//----------------------------------------------------------------
int TransferFunctionPlot::SelectPoint(wxCoord x, wxCoord y, const std::vector<PlotPoint> &plot) const
{
        size_t len = plot.size();
        for(size_t i = 0; i < len; i++)
        {
                int x1, y1;
                PlotPointToScreen(plot[i], x1, y1);
                
                ScreenRect r;
                r.x1 = x1 - PLOT_POINT_SIZE_HALF;
                r.x2 = x1 + PLOT_POINT_SIZE_HALF;
                r.y1 = y1 + PLOT_POINT_SIZE_HALF;
                r.y2 = y1 - PLOT_POINT_SIZE_HALF;
                
                if(Inside(x, y, r))
                        return (int)i;
        }
        
        return -1;
}

//----------------------------------------------------------------
void TransferFunctionPlot::AddPoint(wxCoord x, wxCoord y)
{
        if(activePlot)
        {
                int len = (int)activePlot->size();
                if(len == MAX_PLOT_POINTS)
                        return;
                
                int xpos = 0;
                int curr = 0;
                
                do
                {
                        xpos = PlotDataValueToXCoord(activePlot->at(curr).dataValue);
                        if(x == xpos)
                                return;
                        
                        curr++;
                } while(curr < len && x > xpos);
                
                PlotPoint p;
                ScreenToPlotPoint(x, y, p);

                activePlot->insert(activePlot->begin() + curr - 1, p);
                Refresh();
                
                if(!delayUpdates)
                        RefreshListner();
        }
}

//----------------------------------------------------------------
void TransferFunctionPlot::RemovePoint(wxCoord x, wxCoord y)
{
        if(activePlot)
        {
                int sel = SelectPoint(x, y, *activePlot);
                if(sel > 0 && sel < ((int)activePlot->size() - 1))
                {
                        activePlot->erase(activePlot->begin() + sel);
                        Refresh();
                        
                        if(!delayUpdates)
                                RefreshListner();
                }
        }
}

//----------------------------------------------------------------
void TransferFunctionPlot::Load(const char *file)
{
        std::ifstream f(file);

        if(!f.is_open())
        {
                std::stringstream msg;
                msg << "Could not open the file '" << file << "'";
                ErrorMessage(msg.str().c_str());
        }

        std::vector<PlotPoint> r;
        std::vector<PlotPoint> g;
        std::vector<PlotPoint> b;
        std::vector<PlotPoint> a;
        
        std::string line;
        
        while(getline(f, line))
        {
                if(line.length() == 0 || line[0] == '\n' || line[0] == '\r')
                        continue;
                
                std::stringstream data(line);
                
                char type;
                int n;

                if((data >> type).fail())
                {
                        std::stringstream msg;
                        msg << "The plot file '" << file << "' is improperly formatted.";
                        ErrorMessage(msg.str().c_str());
                        return;
                }

                if((data >> n).fail() || n < 0)
                {
                        std::stringstream msg;
                        msg << "The plot file '" << file << "' is improperly formatted.";
                        ErrorMessage(msg.str().c_str());
                        return;
                }
                
                std::vector<PlotPoint> *sel;
                switch(type)
                {
                        case 'r':
                                sel = &r;
                                break;
                        case 'g':
                                sel = &g;
                                break;
                        case 'b':
                                sel = &b;
                                break;
                        case 'a':
                                sel = &a;
                                break;
                        default:
                        {
                                std::stringstream msg;
                                msg << "The plot file '" << file << "' is improperly formatted.";
                                ErrorMessage(msg.str().c_str());
                                return;
                        }
                };

                sel->clear();
                bool res = LoadPlot(f, *sel, n);

                if(sel->size() == 0)
                {
                                std::stringstream msg;
                                msg << "The plot file '" << file << "' is improperly formatted.";
                                ErrorMessage(msg.str().c_str());
                                return;
                }

                unsigned char v0 = sel->front().dataValue;
                unsigned char v1 = sel->back().dataValue;

                if( !res || v0 != MIN_DATAVALUE || v1 != MAX_DATAVALUE )
                {
                        std::stringstream msg;
                        msg << "The plot file '" << file << "' is improperly formatted.";
                        ErrorMessage(msg.str().c_str());
                        return;
                }
        }

        redPlot = r;
        greenPlot = g;
        bluePlot = b;
        alphaPlot = a;

        Refresh();

        RefreshListner();
}

//----------------------------------------------------------------
void TransferFunctionPlot::Save(const char *file)
{
        std::ofstream f(file);

        if(f.is_open())
        {
                f << "r " << redPlot.size() << "\n";
                SavePlot(f, redPlot);

                f << "g " << greenPlot.size() << "\n";
                SavePlot(f, greenPlot);

                f << "b " << bluePlot.size() << "\n";
                SavePlot(f, bluePlot);

                f << "a " << alphaPlot.size() << "\n";
                SavePlot(f, alphaPlot);
        }
        else
        {
                std::stringstream msg;
                msg << "Could not create or open the file '" << file << "'";
                ErrorMessage(msg.str().c_str());
        }
}

//----------------------------------------------------------------
void TransferFunctionPlot::RefreshListner()
{
        if(listner)
                listner->TransferPlotChanged(this);
}

//----------------------------------------------------------------
bool TransferFunctionPlot::LoadPlot(std::ifstream &file, std::vector<PlotPoint> &plot, int n)
{
        for(int i = 0; i < n; i++)
        {
                int dataValue;
                float value;

                if( (file >> dataValue).fail() )
                        return false;

                if( (file >> value).fail() )
                        return false;

                PlotPoint p;
                p.dataValue = dataValue;
                p.value = value;
                plot.push_back(p);
        }

        return true;
}

//----------------------------------------------------------------
void TransferFunctionPlot::SavePlot(std::ofstream &file, const std::vector<PlotPoint> &plot)
{
        size_t len = plot.size();
        for(size_t i = 0; i < len; i++)
        {
                // streams write chars as character symbols and not as decimal digits.  We get around this by
                // converting the value to an int.
                int dataValue = (int)plot[i].dataValue; 
                file << dataValue << " " << plot[i].value << "\n";
        }
}

//----------------------------------------------------------------
void TransferFunctionPlot::SetHistogram(const unsigned int *h)
{
        // ignores data value 0 because it is almost always null data
        int maxValue = 1;
        for(int i = 1; i < 255; i++)
        {
                if(h[i] > h[maxValue])
                        maxValue = i;
        }
        
        unsigned int max = h[maxValue];
        
        wxImage im;
        im.Create(PLOT_WIDTH - 2, PLOT_HEIGHT - 2, true);

        int colWidth = (PLOT_WIDTH - 2) / (MAX_DATAVALUE - 2);

        for(int i = 1; i < 255; i++)
        {
                unsigned int value = h[i];
                float scale = std::min((float)value / max, 1.0f);
                unsigned int height = (unsigned int)(scale * (PLOT_HEIGHT - 2));
                
                for(unsigned int j = 0; j < height; j++)
                {
                        for(int k = 0; k < colWidth; k++)
                        {
                                int x = PLOT_WIDTH - 2 - i*colWidth + k;
                                int y = PLOT_HEIGHT - 3 - j;
                                im.SetRGB(x, y, HISTOGRAM_COLOR_R, HISTOGRAM_COLOR_G, HISTOGRAM_COLOR_B);
                        }
                }
        }

        histogram = wxBitmap(im);
        Refresh();
}

//----------------------------------------------------------------
TransferFunctionWidget::TransferFunctionWidget(wxWindow *parent)
:
wxWindow(parent, wxID_ANY)
{       
        wxSizer *topLevel = new wxBoxSizer(wxVERTICAL);
        
        wxStaticBoxSizer *box = new wxStaticBoxSizer(new wxStaticBox(this, wxID_ANY, wxT("Transfer Function")), wxHORIZONTAL);  
        topLevel->Add(box, 0, wxALIGN_CENTER | wxLEFT, 5);
        
        wxSizer *vert = new wxBoxSizer(wxVERTICAL);
        wxSizer *horizontal = new wxBoxSizer(wxHORIZONTAL);

        wxButton *save = new wxButton(this, ID_SAVE_BUTTON, wxT("Save"));
        wxButton *load = new wxButton(this, ID_LOAD_BUTTON, wxT("Load"));
        wxButton *refresh = new wxButton(this, ID_REFRESH_BUTTON, wxT("Refresh"));
        wxButton *reset = new wxButton(this, ID_RESET_BUTTON, wxT("Reset"));

        save->SetToolTip(SAVE_TOOLTIP);
        load->SetToolTip(LOAD_TOOLTIP);
        refresh->SetToolTip(REFRESH_TOOLTIP);
        reset->SetToolTip(RESET_TOOLTIP);

        horizontal->Add(reset);
        horizontal->AddSpacer(25);
        horizontal->Add(refresh);
        horizontal->AddSpacer(25);
        horizontal->Add(save);
        horizontal->AddSpacer(4);
        horizontal->Add(load);

        wxSizer *top = new wxBoxSizer(wxVERTICAL);
        top->Add(horizontal, 0, wxALIGN_CENTER);
        
        plot = new TransferFunctionPlot(this);
        top->Add(plot, 0, wxALL, 5);
        box->Add(top);

        wxArrayString plotStrings;
        plotStrings.Add(wxT("Red"));
        plotStrings.Add(wxT("Green"));
        plotStrings.Add(wxT("Blue"));
        plotStrings.Add(wxT("Alpha"));
        
        wxRadioBox *plotSelection = new wxRadioBox(this,
                                                                                   ID_ACTIVEPLOT_RADIOBOX,
                                                                                           wxT("Select"),
                                                                                       wxDefaultPosition,
                                                                                       wxDefaultSize,
                                                                                       plotStrings,
                                                                                       4,
                                                                                       wxRA_SPECIFY_ROWS);
        plotSelection->Select(3);
        plotSelection->SetToolTip(PLOT_SELECTION_TOOLTIP);
        vert->Add(plotSelection, 0, wxALIGN_CENTER_VERTICAL);
        vert->AddSpacer(5);
        
        drawAll = new wxCheckBox(this, ID_DRAWALL_CHECKBOX, wxT("Draw All"));
        drawAll->SetToolTip(DRAWALL_TOOLTIP);
        vert->Add(drawAll);
        
        drawHistogram = new wxCheckBox(this, ID_HISTOGRAM_CHECKBOX, wxT("Histogram"));
        drawHistogram->SetToolTip(HISTOGRAM_TOOLTIP);
        vert->Add(drawHistogram);
        
        box->Add(vert, 0, wxALIGN_CENTER);
        
        wxArrayString plotModeStrings;
        plotModeStrings.Add(wxT("Move"));
        plotModeStrings.Add(wxT("Add"));
        plotModeStrings.Add(wxT("Remove"));
        
        wxRadioBox *plotMode = new wxRadioBox(this,
                                                                                  ID_PLOTMODE_RADIOBOX,
                                                                                  wxT("Point Mode"),
                                                                                  wxDefaultPosition,
                                                                                  wxDefaultSize,
                                                                                  plotModeStrings,
                                                                                  3,
                                                                                  wxRA_SPECIFY_COLS);
        plotMode->SetToolTip(PLOT_MODE_TOOLTIP);
        top->Add(plotMode, 0, wxALIGN_CENTER);
        
        SetSizerAndFit(topLevel);
        Layout();
        Center();
}

//----------------------------------------------------------------
TransferFunctionWidget::~TransferFunctionWidget()
{
}

//----------------------------------------------------------------
void TransferFunctionWidget::OnDrawAllClick(wxCommandEvent &e)
{
        plot->DrawAll(e.IsChecked());
}

//----------------------------------------------------------------
void TransferFunctionWidget::OnDrawHistogramClick(wxCommandEvent &e)
{
        plot->DrawHistogram(e.IsChecked());
}

//----------------------------------------------------------------
void TransferFunctionWidget::OnActivePlotSelection(wxCommandEvent &e)
{
        int sel = e.GetSelection();
        switch(sel)
        {
                case 0: // Red
                        plot->MakeRedActive();
                        break;
                case 1: // Green
                        plot->MakeGreenActive();
                        break;
                case 2: // Blue
                        plot->MakeBlueActive();
                        break;
                case 3: // Alpha
                        plot->MakeAlphaActive();
                        break;
        };
}

//----------------------------------------------------------------
void TransferFunctionWidget::OnPlotModeSelection(wxCommandEvent &e)
{
        int sel = e.GetSelection();
        switch(sel)
        {
                case 0: // Move
                        plot->SetPlotMode(TransferFunctionPlot::MOVE);
                        break;
                case 1: // Add
                        plot->SetPlotMode(TransferFunctionPlot::ADD);
                        break;
                case 2: // Remove
                        plot->SetPlotMode(TransferFunctionPlot::REMOVE);
                        break;
        };
}

//----------------------------------------------------------------
void TransferFunctionWidget::OnSaveClick(wxCommandEvent &e)
{
        wxFileDialog dialog(this, 
                                                wxT("Save Plot"), 
                                                wxT("./DataSets"), 
                                                wxEmptyString, 
                                                wxT("Plot (*.plot)|*.plot"),
                                                wxSAVE | wxOVERWRITE_PROMPT);
        
        if(dialog.ShowModal() == wxID_OK)
        {
                wxWindowDisabler disableAll;
                
                wxString msg = "Saving ";
                msg += dialog.GetFilename();
                msg += "...";

                wxBusyInfo info(msg, this);

                plot->Save(dialog.GetPath().c_str());
        }
}
        
//----------------------------------------------------------------
void TransferFunctionWidget::OnLoadClick(wxCommandEvent &e)
{
        wxFileDialog dialog(this, 
                                                wxT("Load Plot"), 
                                                wxT("./DataSets"), 
                                                wxEmptyString, 
                                                wxT("Plot (*.plot)|*.plot"),
                                                wxOPEN | wxFILE_MUST_EXIST);
        
        if(dialog.ShowModal() == wxID_OK)
        {
                wxWindowDisabler disableAll;
                
                wxString msg = "Loading ";
                msg += dialog.GetFilename();
                msg += "...";

                wxBusyInfo info(msg, this);

                plot->Load(dialog.GetPath().c_str());
        }
}
        
//----------------------------------------------------------------
void TransferFunctionWidget::OnRefreshClick(wxCommandEvent &e)
{
        plot->RefreshListner();
}

//----------------------------------------------------------------
void TransferFunctionWidget::OnResetClick(wxCommandEvent &e)
{
        plot->ResetPlot();
}

---