PanelForDoubleValueWx.cpp

/*
 This file is part of the BIAS library (Basic ImageAlgorithmS).

 Copyright (C) 2003-2009    (see file CONTACT for details)
 Multimediale Systeme der Informationsverarbeitung
 Institut fuer Informatik
 Christian-Albrechts-Universitaet Kiel


 BIAS is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation; either version 2.1 of the License, or
 (at your option) any later version.

 BIAS is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public License
 along with BIAS; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <Gui/PanelForDoubleValueWx.hh>
#include <wx/event.h>
#include <wx/valtext.h>

using namespace BIAS;

PanelForDoubleValueWx::PanelForDoubleValueWx(wxWindow* parent,
                                             wxWindowID id,
                                             const wxString& label,
                                             const double minlimit,
                                             const double maxlimit,
                                             const double initialval,
                                             const int stepsize,
                                             const wxPoint& pos,
                                             const wxSize& size,
                                             long style)
: wxPanel(parent, id, pos, size, style),
  MainSizer(new wxBoxSizer(wxHORIZONTAL)),
  Label(new wxStaticText(this,
                         wxID_STATIC,
                         label,
                         wxDefaultPosition,
                         wxDefaultSize)),
  StepSizeLabel(new wxStaticText(this,
                                 wxID_STATIC,
                                 wxT("STEPSIZE:"),
                                 wxDefaultPosition,
                                 wxDefaultSize)),
  TextCtrl(new wxTextCtrl(this,
                          PanelForDoubleValueWx::ID_TEXT_CTRL,
                          wxT(""))),
  Slider(new wxSlider(this,
                      PanelForDoubleValueWx::ID_SLIDER,
                      0,
                      0,
                      INT_MAX,
                      wxDefaultPosition,
                      wxSize(250, -1),
                      wxSL_HORIZONTAL | wxSL_AUTOTICKS)),
  SpinCtrl(new wxSpinCtrl(this,
                          PanelForDoubleValueWx::ID_SPIN_CTRL,
                          wxEmptyString,
                          wxDefaultPosition,
                          wxDefaultSize,
                          wxSP_ARROW_KEYS,
                          100,
                          INT_MAX,
                          stepsize)),
  StepSize(stepsize),
  TextCtrlValue(0.0),
  ParamMaxLimit(maxlimit),
  ParamMinLimit(minlimit)
{
  if (this->ParamMaxLimit <= this->ParamMinLimit) {

  }

  this->SetSizer(MainSizer);

  this->MainSizer->Add(this->Label, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  this->MainSizer->Add(this->TextCtrl, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  this->MainSizer->Add(this->Slider, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  this->MainSizer->Add(this->StepSizeLabel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
  this->MainSizer->Add(this->SpinCtrl, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);

  Connect(PanelForDoubleValueWx::ID_TEXT_CTRL,
          wxEVT_COMMAND_TEXT_UPDATED,
          wxCommandEventHandler(PanelForDoubleValueWx::OnTextCtrl));
  Connect(PanelForDoubleValueWx::ID_SLIDER,
          wxEVT_COMMAND_SLIDER_UPDATED,
          wxCommandEventHandler(PanelForDoubleValueWx::OnSlider));
  Connect(PanelForDoubleValueWx::ID_SPIN_CTRL,
          wxEVT_COMMAND_SPINCTRL_UPDATED,
          wxSpinEventHandler(PanelForDoubleValueWx::OnSpinCtrl));

  // Feed TextCtrl with initialval twice...because somehow on the first time
  // it doesn't take the intended value
  wxString strVal(wxT(""));
  strVal = wxString::Format(wxT("%f"), initialval);
  this->TextCtrl->SetValue(strVal);
  this->TextCtrl->SetValue(strVal);

  // apply the range for Slider
  this->Slider->SetRange(0, stepsize);

  this->MainSizer->Fit(this);
}


PanelForDoubleValueWx::~PanelForDoubleValueWx() { }


double PanelForDoubleValueWx::GetParamValue() const
{
  wxString strVal = this->TextCtrl->GetValue();
  double val;
  strVal.ToDouble(&val);
  return val;
}


double PanelForDoubleValueWx::GetParamMaxLimit() const
{
  return this->ParamMaxLimit;
}


double PanelForDoubleValueWx::GetParamMinLimit() const
{
  return this->ParamMinLimit;
}


int PanelForDoubleValueWx::GetStepSize() const
{
  return this->StepSize;
}


bool PanelForDoubleValueWx::SetParamMaxLimit(const double maxlimit)
{
  if (maxlimit >= this->ParamMinLimit) {

    if (maxlimit < this->TextCtrlValue) {
      this->TextCtrlValue = maxlimit;
      this->TextCtrl->SetValue(wxString::Format(wxT("%f"), this->TextCtrlValue));
    }

    this->ParamMaxLimit = maxlimit;
    this->UpdateSlider();
    return true;

  } else {

    return false;

  }
}


bool PanelForDoubleValueWx::SetParamMinLimit(const double minlimit)
{
  if (minlimit <= this->ParamMaxLimit) {

    if (minlimit > this->TextCtrlValue) {
      this->TextCtrlValue = minlimit;
      this->TextCtrl->SetValue(wxString::Format(wxT("%f"), this->TextCtrlValue));
    }

    this->ParamMinLimit = minlimit;
    this->UpdateSlider();
    return true;

  } else {

    return false;

  }
}


void PanelForDoubleValueWx::SetParamLabel(const wxString& label)
{
  this->Label->SetLabel(label);
}


void PanelForDoubleValueWx::SetStepSize(const int stepsize)
{
  this->StepSize = stepsize;
  this->Slider->SetRange(0, this->StepSize);
  this->UpdateSlider();
}


/* ============================= private ====================================*/

void PanelForDoubleValueWx::OnTextCtrl(wxCommandEvent& WXUNUSED(event))
{
  wxString strVal = this->TextCtrl->GetValue();
  double val;

  if (strVal.ToDouble(&val)) {  // conversion to float succeeded

    // we MUST check if value contains e or E (e = Exponent)
    if (strVal.Contains(wxT("e")) || strVal.Contains(wxT("E"))) {
      // if so then take the old value
      strVal = wxString::Format(wxT("%f"), this->TextCtrlValue);
      this->TextCtrl->SetValue(strVal);

    } else {

      // so no exponent expression
      // now check ranges ([ParamMinLimit, ParamMaxLimit])
      if (val > this->ParamMaxLimit) {
        this->TextCtrlValue = this->ParamMaxLimit;
        strVal = wxString::Format(wxT("%f"), this->TextCtrlValue);
        this->TextCtrl->SetValue(strVal);
      } else if (val < this->ParamMinLimit) {
        this->TextCtrlValue = this->ParamMinLimit;
        strVal = wxString::Format(wxT("%f"), this->TextCtrlValue);
        this->TextCtrl->SetValue(strVal);
      } else {
        this->TextCtrlValue = val;
      }
    }

  } else { // conversion error --> we stay with our old values
    strVal = wxString::Format(wxT("%f"), this->TextCtrlValue);
    this->TextCtrl->SetValue(strVal);
  }

  this->UpdateSlider();
}


void PanelForDoubleValueWx::OnSlider(wxCommandEvent& WXUNUSED(event))
{
  // we have to disconnect textctrl and later connect again
  // else slider won't react as expected
  Disconnect(PanelForDoubleValueWx::ID_TEXT_CTRL,
             wxEVT_COMMAND_TEXT_UPDATED,
             wxCommandEventHandler(PanelForDoubleValueWx::OnTextCtrl));
  int sliderValue = this->Slider->GetValue();
  double ratio = static_cast<double>(sliderValue) / this->StepSize;
  double diffMinMax = this->ParamMaxLimit - this->ParamMinLimit;
  double distance = this->ParamMinLimit + (diffMinMax * ratio);
  wxString strVal = wxString::Format(wxT("%f"), distance);
  this->TextCtrlValue = distance;
  this->TextCtrl->SetValue(strVal);
  Connect(PanelForDoubleValueWx::ID_TEXT_CTRL,
          wxEVT_COMMAND_TEXT_UPDATED,
          wxCommandEventHandler(PanelForDoubleValueWx::OnTextCtrl));
}


void PanelForDoubleValueWx::OnSpinCtrl(wxSpinEvent& WXUNUSED(event))
{
  this->SetStepSize(this->SpinCtrl->GetValue());
}


void PanelForDoubleValueWx::UpdateSlider()
{
  double diffMinMax = this->ParamMaxLimit - this->ParamMinLimit;
  double distance = this->TextCtrlValue - this->ParamMinLimit;
  double ratio = distance / diffMinMax;
  int newSliderVal = ratio * this->StepSize;
  this->Slider->SetValue(newSliderVal);
}