radio_box.cpp

Go to the documentation of this file.

#ifndef RADIO_BOX_IMPLEMENTATION_FILE
#define RADIO_BOX_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : radio_box                                                         *
*  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                               *
\*****************************************************************************/

// An earlier version was implemented by Douglas Young

#include "radio_box.h"

#include <basis/guards.h>
#include <wp_passive/argument_list.h>
#include <wp_passive/resources.h>
#include <wp_passive/wp_implementation.h>

#include <Xm/ToggleB.h>
#include <Xm/RowColumn.h>


class radio_mouse : public mouse
{
public:
  radio_mouse(radio_box *to_connect)
      : mouse(*(nub *)to_connect), _radio_box(to_connect) {}
  IMPLEMENT_CLASS_NAME("radio_mouse");
  virtual void button_event(const c_point &, int , button_positions ) {
    FUNCDEF("button_event");
    LOG(isprintf("radmous: but_event: [%d]", _radio_box->current()));
    _radio_box->press(_radio_box->current(), false); 
  }

private:
  radio_box *_radio_box;
};


radio_box_button::radio_box_button(radio_box *parent,
    const istring &button_name, int number)
: worker(parent->root(), c_rectangle(0,0,0,0),
      XtCreateWidget(button_name.s(), xmToggleButtonWidgetClass,
          parent->self(), NULL, 0)),
  _name(button_name), button_number(number), interactive_press(true),
  _parent(parent)
{
  XtAddCallback(self(), XmNvalueChangedCallback, 
  XtCallbackProc(radio_box::radio_box_callback), XtPointer(this));
  engage();
}

radio_box_button::~radio_box_button()
{
  // remove the button's callbacks.
  XtRemoveCallback(self(), XmNvalueChangedCallback,
  XtCallbackProc(radio_box::radio_box_callback), XtPointer(_parent));
}


radio_box::radio_box(manager &parent, const c_point &origin,
    const color &foreground, const color &background)
: worker(parent, c_rectangle(origin, origin), NIL, foreground, background),
  array<radio_box_button *> (0),
  active(NIL),
  touched_box_manager(NIL)
{
  argument_list wargs;
  wargs.add(XmNentryClass, XtArgVal(xmToggleButtonWidgetClass));
  self(XmCreateRadioBox(parent.self(), (char *)"radio_box",
      wargs.generate(), wargs.number()));
  wargs.apply(self());
  engage();
  touched_box_manager = new radio_mouse(this);
}

radio_box::~radio_box() { delete touched_box_manager; }

istring radio_box::lookup(int index) const { return get(index)->_name; }

int radio_box::current() const
  { return (active? lookup(active->_name) : RB_NO_BUTTON); }

int radio_box::buttons() const { return length(); }

int radio_box::add(const istring &butname)
{
  radio_box_button *new_button = new radio_box_button(this, butname, length());
  insert(length(), 1);
  put(length() - 1, new_button);
  if (!active) {
    active = new_button;
    // the press below should be moved to a radio_box draw function at some
    // point so that the press is never attempted before the box is on the
    // screen.
    press(0, false);
  }
  return length() - 1;
}

int radio_box::lookup(const istring &to_find) const
{
  for (int i = 0; i < length(); i++) if (get(i)->_name == to_find) return i;
  return RB_NO_BUTTON;
}

void radio_box::press(int index, bool call_back)
{
  FUNCDEF("press");
  if ( (index < 0) || (index > length() - 1) ) return;
  active = get(index);
  if (!active) {
LOG("rb: press: active=nil!");
return;
  }
  active->interactive_press = call_back;
  argument_list wargs;
  wargs.add(XmNset, true);
  wargs.apply(active->self());
  active->interactive_press = true;
}

void radio_box::radio_box_callback(window_handle formal(w),
    radio_box_button *pressed,
    XmToggleButtonCallbackStruct *call_data)
{
  FUNCDEF("radio_box_callback");
  // ignore calls that are not for a button set.
  if (call_data->set) {
    pressed->_parent->active = pressed;
    if (pressed->interactive_press) {
LOG("priv rad call: interactive");
      // this callback occurs due to the user pressing the button with
      // the mouse, and so the appearance of the button is dealt with by X.
      pressed->_parent->button_event
          (pressed->_parent->lookup(pressed->_name));
    } else {
      // This callback is the result of a press_button request, and we are
      // causing the appearance to change.
LOG("priv rad call: non-interactive");
      argument_list wargs;
      wargs.add(XmNset, true);
      wargs.apply(pressed->self());
    }
  }
}

void radio_box::button_event(int index)
{
  FUNCDEF("button_event");
  LOG(isprintf("radio_box::button_event: [%s] hit in blank event function.",
      lookup(index).s()));
}


#endif //RADIO_BOX_IMPLEMENTATION_FILE

---