---

Spindle.cc

Go to the documentation of this file.

#define SPINDLE
#include "Spindle.hh"
#undef SPINDLE

Widget
SpindleControl (Dimension x0, Dimension x1, Dimension y1, Dimension y2,
                Dimension boxMarginWidth, Dimension boxMarginHeight,
                Widget parent)
{
  arrowFrame =
    XtVaCreateManagedWidget ("arrowFrame", xmFrameWidgetClass, parent,
                             XmNfractionBase, 5,
                             XmNleftPosition, x0,
                             XmNrightPosition, x1,
                             XmNtopPosition, y1,
                             XmNbottomPosition, y2,
                             XmNmarginWidth, boxMarginWidth,
                             XmNmarginHeight, boxMarginHeight,
                             XmNtopAttachment, XmATTACH_POSITION,
                             XmNbottomAttachment, XmATTACH_POSITION,
                             XmNleftAttachment, XmATTACH_POSITION,
                             XmNrightAttachment, XmATTACH_POSITION,
                             XmNmarginWidth, 5,
                             XmNmarginHeight, 5,
                             XmNmappedWhenManaged, False,
                             XmNtraversalOn, False, NULL);

  arrowForm =
    XtVaCreateManagedWidget ("arrowForm", xmFormWidgetClass, arrowFrame,
                             XmNmarginWidth, 5, XmNmarginHeight, 5, NULL);
  Dimension width = 100;
  Dimension height = 50;
  XmPushButtonWidget pb;

  reverseButton = XtVaCreateManagedWidget (SPINDLE_REVERSE_STR,
                                           xmPushButtonWidgetClass, arrowForm,
                                           XmNtopAttachment, XmATTACH_FORM,
                                           XmNbottomAttachment, XmATTACH_NONE,
                                           XmNleftAttachment, XmATTACH_FORM,
                                           XmNrightAttachment, XmATTACH_NONE,
                                           XmNshadowThickness, 4,
                                           XmNwidth, width,
                                           XmNheight, height, NULL);

  pb = (XmPushButtonWidget) reverseButton;
  pb->pushbutton.armed = false;

  XtAddCallback (reverseButton, XmNarmCallback,
                 buttonCB, (XtPointer) SPINDLE_REVERSE);

  XmString SpindleLabel =
    XmStringCreateLtoR ((char *) SPINDLE_LABEL_STR, XmSTRING_DEFAULT_CHARSET);

  spindleButton =
    XtVaCreateManagedWidget ("button", xmPushButtonWidgetClass, arrowForm,
                             XmNtopAttachment, XmATTACH_FORM,
                             XmNbottomAttachment, XmATTACH_NONE,
                             XmNleftAttachment, XmATTACH_WIDGET,
                             XmNleftWidget, reverseButton,
                             XmNleftOffset, 50,
                             XmNrightAttachment, XmATTACH_NONE,
                             XmNshadowThickness, 4,
                             XmNwidth, width,
                             XmNheight, height,
                             XmNlabelString, SpindleLabel, NULL);

  XmStringFree (SpindleLabel);

  pb = (XmPushButtonWidget) spindleButton;
  pb->pushbutton.armed = false;

  XtAddCallback (spindleButton, XmNarmCallback,
                 buttonCB, (XtPointer) SPINDLE_ON_OFF);

  forwardButton = XtVaCreateManagedWidget (SPINDLE_FORWARD_STR,
                                           xmPushButtonWidgetClass, arrowForm,
                                           XmNtopAttachment, XmATTACH_FORM,
                                           XmNbottomAttachment, XmATTACH_NONE,
                                           XmNleftAttachment, XmATTACH_WIDGET,
                                           XmNleftWidget, spindleButton,
                                           XmNleftOffset, 50,
                                           XmNrightAttachment, XmATTACH_NONE,
                                           XmNshadowThickness, 4,
                                           XmNwidth, width,
                                           XmNheight, height, NULL);

  pb = (XmPushButtonWidget) forwardButton;
  pb->pushbutton.armed = false;

  XtAddCallback (forwardButton, XmNarmCallback,
                 buttonCB, (XtPointer) SPINDLE_FORWARD);
  // Save the original colors so we can go back to this state.
  XtVaGetValues (forwardButton, XmNtopShadowColor, &original_tsc,
                 XmNbottomShadowColor, &original_bsc,
                 XmNarmColor, &original_ac,
                 XmNbackground, &original_bg, NULL);

  if (get_speed () >= 0)
    {
      PRESS (forwardButton);
      UNPRESS (reverseButton);
    }
  else
    {
      PRESS (reverseButton);
      UNPRESS (forwardButton);
    }


  SEPARATOR ();

  CREATE_PIXMAP (r_arrow, r_pixmap);
  CREATE_PIXMAP (r_arrow_in, r_pixmap_in);
  CREATE_PIXMAP (l_arrow, l_pixmap);
  CREATE_PIXMAP (l_arrow_in, l_pixmap_in);
  CREATE_PIXMAP (right_arrows, rr_pixmap);
  CREATE_PIXMAP (right_arrows_in, rr_pixmap_in);
  CREATE_PIXMAP (left_arrows, ll_pixmap);
  CREATE_PIXMAP (left_arrows_in, ll_pixmap_in);

  SPINDLE_AXIS (arrowB1, XmATTACH_FORM, NULL, 0, ll_pixmap, ARROW_LEFT_FAST);
  SPINDLE_AXIS (arrowB2, XmATTACH_WIDGET, arrowB1, 5, l_pixmap, ARROW_LEFT);

  SPINDLE_AXIS (arrowB3, XmATTACH_WIDGET, arrowB2, 225, r_pixmap,
                ARROW_RIGHT);
  SPINDLE_AXIS (arrowB4, XmATTACH_WIDGET, arrowB3, 5, rr_pixmap,
                ARROW_RIGHT_FAST);

  double mySpeed = get_speed ();
  LABEL_SPEED (mySpeed);

  updateSpindleSpeed ();

  return arrowFrame;
}

static void
buttonCB (Widget mw, XtPointer cd, XtPointer cb)
{
  switch ((int) cd)
    {
    case ARROW_LEFT_FAST:
      XtVaSetValues (mw, XmNarmPixmap, ll_pixmap_in, NULL);
      break;
    case ARROW_LEFT:
      XtVaSetValues (mw, XmNarmPixmap, l_pixmap_in, NULL);
      break;
    case ARROW_RIGHT:
      XtVaSetValues (mw, XmNarmPixmap, r_pixmap_in, NULL);
      break;
    case ARROW_RIGHT_FAST:
      XtVaSetValues (mw, XmNarmPixmap, rr_pixmap_in, NULL);
      break;
    case SPINDLE_FORWARD:
      LOCK (forwardButton);
      UNLOCK (reverseButton);
      break;
    case SPINDLE_REVERSE:
      LOCK (reverseButton);
      UNLOCK (forwardButton);
      break;
    case SPINDLE_ON_OFF:
      isSpindleOn = !isSpindleOn;
      if (isSpindleOn)
        {
          PRESS (spindleButton);
          turnSpindleOn ();
        }
      else
        {
          UNPRESS (spindleButton);
          turnSpindleOff ();
        }
      updateSpindleSpeed ();
      return;
    default:
      return;
    }

  // We separate our change call since it involves our emc interface
  change_spindle ((int) cd);

  // If our spindle changes from positive to negative or vice versa
  checkSpindleReversal ();

  updateSpindleSpeed ();

}

static void
unbuttonCB (Widget mw, XtPointer cd, XtPointer cb)
{
  switch ((int) cd)
    {
    case ARROW_LEFT_FAST:
    case ARROW_LEFT:
    case ARROW_RIGHT:
    case ARROW_RIGHT_FAST:
      stop_changing_spindle ((int) cd);
      break;
    default:
      return;
    }

  updateSpindleSpeed ();
}

static void
change_spindle (int type)
{

// TODO: call the emc spindle interface code here to change speed.
// Note: call updateSpeed () to periodically update the GUI.

#ifdef DEBUG
  char *whichWay[6] =
    { "Left fast", "Left", "Right", "Right fast", "Forward", "Reverse" };
  cout << "Start " << whichWay[type] << " change of spindle" << endl;
#endif

  // Dummy: showing a synthetic change in speed
  switch (type)
    {
    case ARROW_LEFT_FAST:
      theSpeed -= FAST_CHANGE;
      break;
    case ARROW_LEFT:
      theSpeed -= SLOW_CHANGE;
      break;
    case ARROW_RIGHT:
      theSpeed += SLOW_CHANGE;
      break;
    case ARROW_RIGHT_FAST:
      theSpeed += FAST_CHANGE;
      break;
    case SPINDLE_FORWARD:
    case SPINDLE_REVERSE:
      changeDirection ();
      break;
    }
  // End of dummy code

  updateSpindleSpeed ();
}

static void
checkSpindleReversal ()
{
  if (wasForward && get_speed () < 0 || !wasForward && get_speed () >= 0)

    {
      wasForward = !wasForward;

      TOGGLE (forwardButton);
      TOGGLE (reverseButton);
    }
}
static void
stop_changing_spindle (int type)
{

// TODO: call the emc spindle interface code here to stop changing speed

#ifdef DEBUG
  char *whichWay[4] = { "Left fast", "Left", "Right", "Right fast" };
  cout << "Stop " << whichWay[type] << " change of spindle" << endl;
#endif

}

static double
get_speed ()
{
// TODO: call the emc spindle interface code here to get the actual speed
//
// set the global "theSpeed" to the actual speed.

  return theSpeed;
}

static void
turnSpindleOn ()
{
#ifdef DEBUG
  cout << "Spindle is now On" << endl;
#endif
}

static void
turnSpindleOff ()
{
#ifdef DEBUG
  cout << "Spindle is now Off" << endl;
#endif
}

// External callable
void
updateSpindleSpeed ()
{
  double newSpeed = get_speed ();
  LABEL_SPEED_UPDATE (newSpeed);

  // Don't let them change spindle direction while moving
  if (isSpindleOn)
    {
      LOCK (forwardButton);
      LOCK (reverseButton);
    }
  else
    {
      if (wasForward)
        {
          LOCK (forwardButton);
          UNLOCK (reverseButton);
        }
      else
        {
          LOCK (reverseButton);
          UNLOCK (forwardButton);
        }
    }
}

// The following should be called by emc interface that knows the actual speed
void
setSpindleSpeed (double speed)
{
  theSpeed = speed;
  LABEL_SPEED_UPDATE (speed);
}

// The following should be called by emc interface to toggle the spindle direction
void
changeDirection ()
{
  // Dummy: for now, assume instant reversal of spindle with same speed
  theSpeed = -(theSpeed);
}

void
showSpindle (void)
{
  if (arrowFrame)
    XtVaSetValues (arrowFrame, XmNmappedWhenManaged, True, NULL);
}

void
hideSpindle (void)
{
  if (arrowFrame)
    XtVaSetValues (arrowFrame, XmNmappedWhenManaged, False, NULL);
}

void
stopSpindle (void)
{
  isSpindleOn = False;
  UNPRESS (spindleButton);
  turnSpindleOff ();
}

---