slider.cpp

Go to the documentation of this file.

#ifndef SLIDER_IMPLEMENTATION_FILE
#define SLIDER_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : slider                                                            *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1991-$now By Author.  This program is free software; you can  *
* redistribute it and/or modify it under the terms of the GNU General Public  *
* License as published by the Free Software Foundation; either version 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

// Implementation Details:
//
// Methods:
//
//   real_h_or_v(to_translate)
//
//     Returns the real windowing h_or_v needed for our virtual
//     h_or_v.

#include "slider.h"

#include <wp_passive/wp_implementation.h>

#include <math.h>

#ifdef __XWINDOWS__
  #include <Xm/Scale.h>
  #include <Xm/ArrowB.h>
  #include <Xm/RowColumn.h>
#elif defined(OS_2)
#elif defined(MS_WINDOWS)
#endif

const int SLIDER_MINIMUM = 0;
const int SLIDER_MAXIMUM = 32767;  // suitable for short ints...

const double ONE_HALF = 0.5;

const char *sliderSuffix = "slider";
const char *arrowSuffix = "arrow";
const char *minimum_Suffix = "min";
const char *maximum_Suffix = "max";
    
slider::slider(manager &parent, const c_point &origin, const char *name,
    slider_orientation h_or_v, double minValue, double maxValue,
    double granularity, const color &foreground, const color &background)
: worker(parent, c_rectangle(origin, origin),
    create_holder(parent.self(), name, h_or_v),
    foreground, background),
  slider_w(NIL), maximum_ArrowName(name), minimum_ArrowName(name),
  sliderName(name), current_value(minValue), minimum_value(minValue),
  maximum_value(maxValue), granularity(granularity)
{
  sliderName += sliderSuffix;
  minimum_ArrowName += minimum_Suffix;
  minimum_ArrowName += arrowSuffix;
  maximum_ArrowName += maximum_Suffix;
  maximum_ArrowName += arrowSuffix;

  // Note: Xt toolkit checks assertion that minValue is less than maxValue.

  int maximum_Dir, minimum_Dir;

  if (h_or_v == HORIZONTAL_SLIDER) {
    maximum_Dir = XmARROW_LEFT;
    minimum_Dir = XmARROW_RIGHT;
  } else {
    maximum_Dir = XmARROW_UP;
    minimum_Dir = XmARROW_DOWN;
  }

  if (granularity != 0.0) {
    /* create left (up) arrow */
    argument_list wargs;
    wargs.add(XmNarrowDirection, maximum_Dir);
    wargs.add(XtNborderWidth, XtArgVal(0));
    wargs.add(XmNshadowThickness, XtArgVal(0));
    maximum_Arrow = XtCreateManagedWidget
      (maximum_ArrowName.s(), xmArrowButtonWidgetClass, self(), wargs.generate(),
       wargs.number());
    nub temp(maximum_Arrow, maximum_Arrow);
    temp.set_foreground(foreground);
    temp.set_background(background);
    XtAddCallback
      (maximum_Arrow, XmNactivateCallback, XtCallbackProc(more_arrow_callback),
       XtPointer(this));
  }

  /* Create slider bar */
  slider_w = create_slider
    (self(), sliderName.s(), h_or_v, SLIDER_MINIMUM, SLIDER_MAXIMUM);
  nub temp(slider_w, slider_w);
  temp.set_foreground(foreground);
  temp.set_background(background);

  if (granularity != 0.0) {
    /* Create right (down) arrow */
    argument_list wargs;
    wargs.add(XmNarrowDirection, minimum_Dir);
    wargs.add(XtNborderWidth, XtArgVal(0));
    wargs.add(XmNshadowThickness, XtArgVal(0));
    minimum_Arrow = XtCreateManagedWidget
      (minimum_ArrowName.s(), xmArrowButtonWidgetClass, self(),
       wargs.generate(), wargs.number());
    nub temp(minimum_Arrow, minimum_Arrow);
    temp.set_foreground(foreground);
    temp.set_background(background);
    XtAddCallback
      (minimum_Arrow, XmNactivateCallback, XtCallbackProc(less_arrow_callback),
       XtPointer(this));
  }

  XtManageChild(self());
  if (granularity != 0.0) {
    XtManageChild(maximum_Arrow);
    XtManageChild(minimum_Arrow);
  }
}

slider::~slider()
{
  XtRemoveCallback(slider_w, XmNvalueChangedCallback,
    (XtCallbackProc)slider_callback, XtPointer(this));
  XtRemoveCallback(slider_w, XmNdragCallback,
    (XtCallbackProc)slider_callback, XtPointer(this));
  if (granularity != 0.0) {
    XtRemoveCallback
      (maximum_Arrow, XmNactivateCallback, XtCallbackProc(more_arrow_callback),
       XtPointer(this));
    XtRemoveCallback
      (minimum_Arrow, XmNactivateCallback, XtCallbackProc(less_arrow_callback),
       XtPointer(this));
  }
}

window_handle slider::create_holder
  (window_handle parent, const char *name, slider_orientation h_or_v)
{
  /* Create a row columun widget to hold the arrow slider components */
  argument_list wargs;
  wargs.add
    (XmNorientation, real_orientation(h_or_v));
  window_handle holder = XtCreateManagedWidget
    (name, xmRowColumnWidgetClass, parent, wargs.generate(), wargs.number());
  nub temp(holder, holder);
  color f = foreground();
  color b = background();
  temp.set_foreground(f);
  temp.set_background(b);
  return holder;
}

window_handle slider::create_slider
  (window_handle parent, const char *name, slider_orientation h_or_v, int minValue,
   int maxValue)
{
  argument_list wargs;
  wargs.add(XmNminimum, minValue);
  wargs.add(XmNmaximum, maxValue);
  wargs.add(XmNorientation, real_orientation(h_or_v));
  wargs.add(XtNborderWidth, XtArgVal(0));
  window_handle w = XtCreateManagedWidget
    (name, xmScaleWidgetClass, parent, wargs.generate(), wargs.number());
  nub temp(w, w);
  color f = foreground();
  color b = background();
  temp.set_foreground(f);
  temp.set_background(b);

  XtAddCallback(w, XmNvalueChangedCallback, 
    (XtCallbackProc)slider_callback, XtPointer(this));
  XtAddCallback(w, XmNdragCallback,
    (XtCallbackProc)slider_callback, XtPointer(this));

  XtManageChild(w);
  return w;
}

void slider::value(double value, bool trigger_event)
{
  FUNCDEF("value");
  check_value(value);

  double percent = (current_value - minimum_value) / (maximum_value - minimum_value);
  int real_value = int(percent * ((double) SLIDER_MAXIMUM));
//  int integerValue = (int) ((double) floor((double) (intRangeVal + ONE_HALF)));
//  intCurrent_Value = integerValue;

LOG(isprintf("setting slider in value to %d", real_value));
  // set the value on the widget
  argument_list wargs;
  wargs.add(XmNvalue, real_value);
  XtSetValues(slider_w, wargs.generate(), wargs.number());

  if (trigger_event) slider_moved_event(current_value);
}

void slider::check_value(double value)
{
  FUNCDEF("check_value");
  if ( (value < minimum_value) || (value > maximum_value) ) {
    continuable_error(class_name(), func, isprintf("warning: the value is not within the selectable range of the slider (%f passed, %f is the max)", value, maximum_value).s());
  }

  if (value < minimum_value) value = minimum_value;
  if (value > maximum_value) value = maximum_value;

  double rounded = round_to_granularity(value, minimum_value, granularity);

  current_value = rounded;
}

double slider::value() { return current_value; }

void slider::less_arrow_callback(window_handle, slider *the_slider, XmAnyCallbackStruct *)
{
  FUNCDEF("less_arrow_callback");
LOG("less arrow");
LOG(isprintf("curr=%d, min=%d", the_slider->current_value, the_slider->minimum_value));
  if (the_slider->current_value - the_slider->granularity
      < the_slider->minimum_value)
    the_slider->value(the_slider->minimum_value, true);
  else
    the_slider->value(the_slider->current_value - the_slider->granularity, true);
}

void slider::more_arrow_callback(window_handle, slider *the_slider, XmAnyCallbackStruct *)
{
  FUNCDEF("more_arrow_callback");
LOG(isprintf("more arrow: curr=%d, max=%d", the_slider->current_value, the_slider->maximum_value));
  if (the_slider->current_value + the_slider->granularity
      > the_slider->maximum_value)
    the_slider->value(the_slider->maximum_value, true);
  else
    the_slider->value(the_slider->current_value + the_slider->granularity, true);
}

void slider::slider_callback(window_handle , slider *me, XmScaleCallbackStruct *call_data)
{
  FUNCDEF("slider_callback");
LOG("slider callback:");
  me->current_value = call_data->value;
LOG(isprintf("at value=%d", me->current_value));
  double percent = (me->current_value / double(SLIDER_MAXIMUM));
LOG(isprintf(" at percent=%d", percent));
  double unrounded = me->minimum_value
    + (percent * (me->maximum_value - me->minimum_value));
LOG(isprintf(" unrounded=%d", unrounded));
  me->current_value = me->round_to_granularity
    (unrounded, me->minimum_value, me->granularity);
  me->slider_moved_event(me->current_value);
}

double slider::round_to_granularity
  (double unrounded, double minimum_value, double granularity)
{
  return floor( (unrounded - minimum_value) / granularity + ONE_HALF) *
     granularity + minimum_value;
}

void slider::slider_moved_event(double value)
{
  FUNCDEF("slider_moved_event");
  LOG(isprintf("slider got moved to %d.", value));
}

#ifdef __XWINDOWS__
int slider::real_orientation(slider_orientation to_translate)
  { return (to_translate == HORIZONTAL_SLIDER)? XmHORIZONTAL : XmVERTICAL; }
#elif defined(OS_2)
#elif defined(MS_WINDOWS)
#endif


#endif //SLIDER_IMPLEMENTATION_FILE

---