---

yemc.cc

Go to the documentation of this file.

/*
  yemc.cc - new X GUI for the EMC, that splits Cartesian and joint modes

  Modification history:

  30-May-2001 WPS added reading EMC_NMLFILE to iniLoad().
  30-May-2001 WPS added reading EMC_DEBUG to iniLoad().
  16-Jan-2001 WPS added teleop mode stuff. The teleop mode is intended for joystick control of non-slideways machines. The "$" toggles on/off telop mode inaddition to toggling between world and joint display. When the display is world and mode manual the gui will use teleop mode and otherwise not.
  30-Mar-2000 WPS added ferrorCurrent and ferrorHighMark junk.
  20-Mar-2000 WPS made the EMC_DEBUG_NML flag enable NML error messages.
  3-Sep-1999  FMP looked in both [TASK] and [DISPLAY] for PROGRAM_PREFIX
  17-Aug-1999  FMP added pre-send of program open when stepping
  5-Aug-1999  FMP added POS_FRAME for world, joint coords, and menu to
  select this
  3-Aug-1999  FMP created from xemc.cc; changed XEMC_NUM_AXES to 6;
  changed posLabel[] array to be index-based rather than hard-coded
 */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <values.h>             // DBL_MAX, maybe
#include <limits.h>             // DBL_MAX, maybe
#include <stdarg.h>
#include <sys/stat.h>           // struct stat, stat()
#include <unistd.h>
#include <fcntl.h>              // O_CREAT

#include "rcs.hh"               // etime()
#include "emc.hh"               // EMC NML
#include "emcglb.h"             // EMC_NMLFILE, TRAJ_MAX_VELOCITY, TOOL_TABLE_FILE
#include "emccfg.h"             // DEFAULT_TRAJ_MAX_VELOCITY
#include "inifile.h"            // INIFILE
#include "posemath.h"           // PmPose, pmQuatRpyConvert(), etc.
#include "emcpos.h"             // EmcPose

/*
 * Include files required for all Toolkit programs
 */
#include <X11/Intrinsic.h>      /* Intrinsics Definitions */
#include <X11/StringDefs.h>     /* Standard Name-String definitions */

/*
 * Public include file for widgets we actually use in this file.
 */
#include <X11/Xaw/Form.h>
#include <X11/Xaw/Box.h>
#include <X11/Xaw/Command.h>
#include <X11/Xaw/Label.h>
#include <X11/Xaw/AsciiText.h>
#include <X11/Xaw/MenuButton.h>
#include <X11/Xaw/SimpleMenu.h>
#include <X11/Xaw/SmeBSB.h>
#include <X11/Xaw/SmeLine.h>
#include <X11/Xaw/Dialog.h>

#define UPDATE_MSECS 100

// the NML channels to the EMC task
static RCS_CMD_CHANNEL *emcCommandBuffer = 0;
static RCS_STAT_CHANNEL *emcStatusBuffer = 0;
EMC_STAT *emcStatus = 0;

// the NML channel for errors
static NML *emcErrorBuffer = 0;
static char error_string[EMC_OPERATOR_ERROR_LEN] = "";

// the current command numbers, set up updateStatus(), used in main()
static int emcCommandSerialNumber = 0;

static int coordNum[6] = { 0, 1, 2, 3, 4, 5};
// forward decls

// forward decls for error popup
static void errorReturnAction(Widget w, XEvent *event, String *params, Cardinal *num_params);
static void errorDoneCB(Widget w, XtPointer client_data, XtPointer call_data);
static int createErrorShell();
static int destroyErrorShell();
static void popupError(const char *fmt, ...);

// forward decl for quit() function
static void quit();

static int emcTaskNmlGet()
{
  int retval = 0;

  // try to connect to EMC cmd
  if (emcCommandBuffer == 0)
    {
      emcCommandBuffer = new RCS_CMD_CHANNEL(emcFormat, "emcCommand", "xemc", EMC_NMLFILE);
      if (! emcCommandBuffer->valid())
        {
          delete emcCommandBuffer;
          emcCommandBuffer = 0;
          retval = -1;
        }
    }

  // try to connect to EMC status
  if (emcStatusBuffer == 0)
    {
      emcStatusBuffer = new RCS_STAT_CHANNEL(emcFormat, "emcStatus", "xemc", EMC_NMLFILE);
      if (! emcStatusBuffer->valid() ||
          EMC_STAT_TYPE != emcStatusBuffer->peek())
        {
          delete emcStatusBuffer;
          emcStatusBuffer = 0;
          emcStatus = 0;
          retval = -1;
        }
      else
        {
          emcStatus = (EMC_STAT *) emcStatusBuffer->get_address();
        }
    }

  return retval;
}

static int emcErrorNmlGet()
{
  int retval = 0;

  if (emcErrorBuffer == 0)
    {
      emcErrorBuffer = new NML(nmlErrorFormat, "emcError", "xemc", EMC_NMLFILE);
      if (! emcErrorBuffer->valid())
        {
          delete emcErrorBuffer;
          emcErrorBuffer = 0;
          retval = -1;
        }
    }

  return retval;
}

static void printError(char *error)
{
  printf("%s\n", error);
}

static int updateStatus()
{
  NMLTYPE type;

  if (0 == emcStatus ||
      0 == emcStatusBuffer ||
      ! emcStatusBuffer->valid())
    {
      return -1;
    }

  switch (type = emcStatusBuffer->peek())
    {
    case -1:
      // error on CMS channel
      return -1;
      break;

    case 0:                     // no new data
    case EMC_STAT_TYPE: // new data
      // new data
      break;

    default:
      return -1;
      break;
    }

  return 0;
}

static int updateError()
{
  NMLTYPE type;

  if (0 == emcErrorBuffer ||
      ! emcErrorBuffer->valid())
    {
      return -1;
    }

  switch (type = emcErrorBuffer->read())
    {
    case -1:
      // error reading channel
      return -1;
      break;

    case 0:
      // nothing new
      error_string[0] = 0;
      break;

    case EMC_OPERATOR_ERROR_TYPE:
      strncpy(error_string,
             ((EMC_OPERATOR_ERROR *) (emcErrorBuffer->get_address()))->error,
              EMC_OPERATOR_ERROR_LEN - 1);
      error_string[EMC_OPERATOR_ERROR_LEN - 1] = 0;
      break;

    case EMC_OPERATOR_TEXT_TYPE:
      strncpy(error_string,
             ((EMC_OPERATOR_TEXT *) (emcErrorBuffer->get_address()))->text,
              EMC_OPERATOR_ERROR_LEN - 1);
      error_string[EMC_OPERATOR_ERROR_LEN - 1] = 0;
      break;

    case EMC_OPERATOR_DISPLAY_TYPE:
      strncpy(error_string,
             ((EMC_OPERATOR_DISPLAY *) (emcErrorBuffer->get_address()))->display,
              EMC_OPERATOR_ERROR_LEN - 1);
      error_string[EMC_OPERATOR_ERROR_LEN - 1] = 0;
      break;

    case NML_ERROR_TYPE:
      strncpy(error_string,
             ((NML_ERROR *) (emcErrorBuffer->get_address()))->error,
              NML_ERROR_LEN - 1);
      error_string[NML_ERROR_LEN - 1] = 0;
      break;

    case NML_TEXT_TYPE:
      strncpy(error_string,
             ((NML_TEXT *) (emcErrorBuffer->get_address()))->text,
              NML_ERROR_LEN - 1);
      error_string[NML_ERROR_LEN - 1] = 0;
      break;

    case NML_DISPLAY_TYPE:
      strncpy(error_string,
             ((NML_DISPLAY *) (emcErrorBuffer->get_address()))->display,
              NML_ERROR_LEN - 1);
      error_string[NML_ERROR_LEN - 1] = 0;
      break;

    default:
      sprintf(error_string, "unrecognized error %ld",type);
      return -1;
      break;
    }

  return 0;
}

#define EMC_COMMAND_TIMEOUT 1.0 // how long to wait until timeout
#define EMC_COMMAND_DELAY   0.1 // how long to sleep between checks

/*
  emcCommandWaitReceived() waits until the EMC reports that it got
  the command with the indicated serial_number.
  emcCommandWaitDone() waits until the EMC reports that it got the
  command with the indicated serial_number, and it's done, or error.
*/

static int emcCommandWaitReceived(int serial_number)
{
  double start = etime();

  while (etime() - start < EMC_COMMAND_TIMEOUT) {
    updateStatus();

    if (emcStatus->echo_serial_number == serial_number) {
      return 0;
    }

    esleep(EMC_COMMAND_DELAY);
  }

  return -1;
}

static int emcCommandWaitDone(int serial_number)
{
  double start = etime();

  while (etime() - start < EMC_COMMAND_TIMEOUT) {
    updateStatus();

    if (emcStatus->echo_serial_number == serial_number) {
      if (emcStatus->status == RCS_DONE) {
        return 0;
      }
      else if (emcStatus->status == RCS_ERROR) {
        return -1;
      }
    }

    esleep(EMC_COMMAND_DELAY);
  }

  return -1;
}

/*
  functions for handling the windowing of a file, where you
  give the line you wish to window and it produces an array
  of string, or single string, of the file's contents
  at that point and some lines beyond
  */

#define LF 10
#define CR 13

typedef struct {
  /* the array holding the window of lines in the file */
  char *fileWindow;

  /* the number of lines in the window */
  int maxWindowLines;

  /* the max length of each line */
  int maxLineLen;

  /* which array index holds the first filled slot */
  int windowStart;

  /* which array index holds the next open slot */
  int windowEnd;

  /* number in ring, also used to differentiate start = end as full/empty */
  int windowCount;

  /* the file to window */
  FILE * fileFp;

  /* the line currently at the top of the window */
  int fileFpLine;

  /* flag that the line should be kept */
  int keepNextLine;

} FILE_WINDOW;

static int fwClear(FILE_WINDOW *fw)
{
  int t;

  if (NULL == fw) {
    return -1;
  }

  for (t = 0; t < fw->maxWindowLines; t++) {
    fw->fileWindow[t * fw->maxLineLen] = 0;
  }

  fw->windowStart = 0;
  fw->windowEnd = 0;
  fw->windowCount = 0;

  fw->fileFpLine = 0;

  fw->keepNextLine = 1;

  return 0;
}

static int fwInit(FILE_WINDOW *fw, int _maxWindowLines, int _maxLineLen)
{
  if (NULL == fw) {
    return -1;
  }

  fw->fileWindow = (char *) malloc(_maxLineLen * _maxWindowLines);

  fw->maxWindowLines = _maxWindowLines;
  fw->maxLineLen = _maxLineLen;

  /* clear out the remaining vars */
  if (0 != fwClear(fw)) {
    return -1;
  }

  /* mark the file closed */
  fw->fileFp = NULL;

  return 0;
}

static int fwOpen(FILE_WINDOW *fw, const char *file)
{
  if (NULL == fw) {
    return -1;
  }

  /* close any open file */
  if (NULL != fw->fileFp) {
    fclose(fw->fileFp);
    fw->fileFp = NULL;
  }

  if (NULL == (fw->fileFp = fopen(file, "r"))) {
    return -1;
  }

  fw->keepNextLine = 1;

  return 0;
}

static int fwClose(FILE_WINDOW *fw)
{
  int retval = 0;

  if (NULL == fw) {
    return -1;
  }

  /* first clear out the window */
  if (0 != fwClear(fw)) {
    retval = -1;
  }

  if (NULL != fw->fileFp) {
    fclose(fw->fileFp);
  }
  fw->fileFp = NULL;

  return retval;
}

#if 0
static int fwDelete(FILE_WINDOW *fw)
{
  if (NULL == fw) {
    return -1;
  }

  /* should have been closed by call to fwClose(), but make sure */
  if (NULL != fw->fileFp) {
    fclose(fw->fileFp);
    fw->fileFp = NULL;
  }

  free(fw->fileWindow);

  return 0;
}
#endif

#if 0
static int fwPrintWindow(FILE_WINDOW *fw)
{
  int start;

  if (NULL == fw) {
    return -1;
  }

  start = fw->windowStart;

  if (0 == fw->windowCount) {
    return 0;
  }

  do {
    printf("%s\n", &(fw->fileWindow[start * fw->maxLineLen]));
    if (++start >= fw->maxWindowLines) {
      start = 0;
    }
  } while (start != fw->windowEnd);

  return 0;
}
#endif

static int fwAddLine(FILE_WINDOW *fw, const char *line)
{
  if (NULL == fw) {
    return -1;
  }

  strncpy(&fw->fileWindow[fw->windowEnd * fw->maxLineLen], line, fw->maxLineLen - 1);
  fw->fileWindow[fw->windowEnd * fw->maxLineLen + fw->maxLineLen - 1] = 0;

  if (fw->windowEnd == fw->windowStart &&
      0 != fw->windowCount) {
    /* we're full, so move fw->windowStart up */
    /* and don't increment fw->windowCount */
    if (++fw->windowStart >= fw->maxWindowLines) {
      fw->windowStart = 0;
    }
  }
  else {
    /* we're not full, so no need to move fw->windowStart up */
    /* but do increment fw->windowCount */
    ++fw->windowCount;
  }

  /* now increment fw->windowEnd to point to next slot */
  if (++fw->windowEnd >= fw->maxWindowLines) {
    fw->windowEnd = 0;
  }

  return 0;
}

#if 0
static int fwDeleteLine(FILE_WINDOW *fw)
{
  if (NULL == fw) {
    return -1;
  }

  if (0 == fw->windowCount) {
    return 0;
  }

  fw->fileWindow[fw->windowStart * fw->maxLineLen] = 0;
  if (++fw->windowStart >= fw->maxWindowLines) {
    fw->windowStart = 0;
  }

  --fw->windowCount;

  return 0;
}
#endif


static int fwSyncLine(FILE_WINDOW *fw, int syncLine)
{
  char line[256];               // FIXME-- hardcoded
  int pad;
  int len;
  int sawEol;

  if (NULL == fw) {
    return -1;
  }

  if (NULL == fw->fileFp) {
    return -1;
  }

  /* if syncLine is <= 0, make it 1 */
  if (syncLine <= 0) {
    syncLine = 1;
  }

  /* reset syncLine so that it means the first line is synched */
  syncLine += fw->maxWindowLines - 1;

  /* check if our window is ahead of file, and rewind if so */
  if (syncLine < fw->fileFpLine) {
    /* we're ahead of program, so rewind */
    rewind(fw->fileFp);
    /* and clear out fw->fileWindow */
    fwClear(fw);
  }

  /* now the window is at or behind the file */
  /* so fill it up */
  while (fw->fileFpLine < syncLine) {
    if (NULL == fgets(line, fw->maxLineLen, fw->fileFp)) {
      /* end file */
      /* pad remainder if any */
      pad = syncLine - fw->fileFpLine;
      while (pad-- > 0) {
        fwAddLine(fw, "");
      }
      fw->fileFpLine = syncLine;
      break;
    }

    sawEol = 0;
    len = strlen(line);
    while (--len >= 0) {
      if (CR == line[len] ||
          LF == line[len]) {
        line[len] = 0;
        sawEol = 1;
      }
      else {
        break;
      }
    }

    if (fw->keepNextLine) {
      fwAddLine(fw, line);
      ++fw->fileFpLine;
    }

    fw->keepNextLine = sawEol;
  }

  return 0;
}

static int fwString(FILE_WINDOW *fw, char *string)
{
  int start;

  if (NULL == fw) {
    return -1;
  }

  start = fw->windowStart;
  string[0] = 0;

  if (0 == fw->windowCount) {
    return 0;
  }

  do {
    strncat(string, &(fw->fileWindow[start * fw->maxLineLen]),
            fw->maxLineLen - 2);
    strcat(string, "\n");
    if (++start >= fw->maxWindowLines) {
      start = 0;
    }
  } while (start != fw->windowEnd);

  return 0;
}

// the file window structure for the program window and related stuff

#define PROGRAM_FW_NUM_LINES 10
#define PROGRAM_FW_LEN_LINES 80

static char *programFwString = NULL;
static FILE_WINDOW programFw;

// number of axes supported
#define XEMC_NUM_AXES 6

// number of joints in ini file
static int numJoints = 3;

// number of coordinate values from ini file
static int numCoords = 3;

// number of labels needed to hold both joints and coords,
// the max of the two
static int numPosLabels = 3;

// string for ini file version num
static char version_string[INIFILE_MAX_LINELEN] = "";

// interpreter parameter file name, from ini file
static char PARAMETER_FILE[EMC_TASK_FILENAME_LEN] = "";

// the program path prefix
static char programPrefix[EMC_TASK_FILENAME_LEN] = "";
// the program name currently displayed
static char programFile[EMC_TASK_FILENAME_LEN] = "*";
// the program last loaded by the controller
static char lastProgramFile[EMC_TASK_FILENAME_LEN] = "*";

// integer version of ini file max scale factor
static int maxFeedOverride = 100;

#define MDI_LINELEN 80
static char active_g_codes_string[MDI_LINELEN] = "";
static char active_m_codes_string[MDI_LINELEN] = "";

// type of kinematics in machine
typedef enum {
  KINEMATICS_IDENTITY = 1,
  KINEMATICS_SERIAL,
  KINEMATICS_PARALLEL
} KINEMATICS_TYPE;

static KINEMATICS_TYPE kinematicsType = KINEMATICS_IDENTITY;

// array for marking which coordinate values out of X Y Z R P W to display
// with a default of X Y Z
static unsigned char coordinateMark[6] = {1, 1, 1, 0, 0, 0};

// how position is to be displayed-- relative or machine
typedef enum {
  COORD_RELATIVE = 1,
  COORD_MACHINE
} COORD_TYPE;

static COORD_TYPE coords = COORD_RELATIVE;

// how position is to be displayed-- actual or commanded
typedef enum {
  POS_DISPLAY_ACT = 1,
  POS_DISPLAY_CMD
} POS_DISPLAY_TYPE;

static POS_DISPLAY_TYPE posDisplay = POS_DISPLAY_ACT;

// which position coordinate frame is to be displayed-- world or joint
typedef enum {
  POS_FRAME_WORLD = 1,
  POS_FRAME_JOINT
} POS_FRAME_TYPE;

static POS_FRAME_TYPE posFrame = POS_FRAME_WORLD;

// marker for the active coord or joint
static int activeJoint = 0;     // default is 0, first joint
static int oldActiveJoint = -1; // force an update at startup
static int activeCoord = 0;     // default is X, first coordinate
static int oldActiveCoord = -1; // force an update at startup

/*
  Note: the X key press/release events with multiple keys behave such that
  if key a is pressed, then b, then a released, its key-release event
  won't go through. So, multi-axis jogging has been disallowed in xemc,
  although it's supported in the motion system.
*/
// flag that an axis is jogging, so other jogs won't go out
static int axisJogging = -1;

// current jog speed setting
static int jogSpeed = 1;        // overridden in iniLoad()
static int maxJogSpeed = 1;     // overridden in iniLoad()
static int jogSpeedChange = 0;  // 0 means no change, +/- means inc/dec

// current jog increment setting, non-positive means continuous
static double jogIncrement = 0.0;

// polarities for axis jogging, from ini file
static int jogPol[XEMC_NUM_AXES];

static int oldFeedOverride = -1; // forces an update at startup
static int feedOverride;        // 100% integer copy of EMC status
static int feedOverrideChange = 0; // same as jogSpeedChange
#define FEED_OVERRIDE_DELAY_COUNT 1
// timer delays until dec/inc appears
static int feedOverrideDelayCount = FEED_OVERRIDE_DELAY_COUNT;

// command sending functions

static int sendEstop()
{
  EMC_TASK_SET_STATE state_msg;

  state_msg.state = EMC_TASK_STATE_ESTOP;
  state_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(state_msg);

  return 0;
}

static int sendEstopReset()
{
  EMC_TASK_SET_STATE state_msg;

  state_msg.state = EMC_TASK_STATE_ESTOP_RESET;
  state_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(state_msg);

  return 0;
}

static int sendMachineOn()
{
  EMC_TASK_SET_STATE state_msg;

  state_msg.state = EMC_TASK_STATE_ON;
  state_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(state_msg);

  return 0;
}

static int sendMachineOff()
{
  EMC_TASK_SET_STATE state_msg;

  state_msg.state = EMC_TASK_STATE_OFF;
  state_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(state_msg);

  return 0;
}

static int sendManual()
{
  EMC_TASK_SET_MODE mode_msg;

  mode_msg.mode = EMC_TASK_MODE_MANUAL;
  mode_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(mode_msg);

  return 0;
}

static int sendAuto()
{
  EMC_TASK_SET_MODE mode_msg;

  mode_msg.mode = EMC_TASK_MODE_AUTO;
  mode_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(mode_msg);

  return 0;
}

static int sendMdi()
{
  EMC_TASK_SET_MODE mode_msg;

  mode_msg.mode = EMC_TASK_MODE_MDI;
  mode_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(mode_msg);

  return 0;
}

static int sendToolSetOffset(int tool, double length, double diameter)
{
  EMC_TOOL_SET_OFFSET emc_tool_set_offset_msg;

  emc_tool_set_offset_msg.tool = tool;
  emc_tool_set_offset_msg.length = length;
  emc_tool_set_offset_msg.diameter = diameter;
  emc_tool_set_offset_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_tool_set_offset_msg);

  return 0;
}

static int sendMistOn()
{
  EMC_COOLANT_MIST_ON emc_coolant_mist_on_msg;

  emc_coolant_mist_on_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_coolant_mist_on_msg);

  return 0;
}

static int sendMistOff()
{
  EMC_COOLANT_MIST_OFF emc_coolant_mist_off_msg;

  emc_coolant_mist_off_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_coolant_mist_off_msg);

  return 0;
}

static int sendFloodOn()
{
  EMC_COOLANT_FLOOD_ON emc_coolant_flood_on_msg;

  emc_coolant_flood_on_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_coolant_flood_on_msg);

  return 0;
}

static int sendFloodOff()
{
  EMC_COOLANT_FLOOD_OFF emc_coolant_flood_off_msg;

  emc_coolant_flood_off_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_coolant_flood_off_msg);

  return 0;
}

static int sendSpindleForward()
{
  EMC_SPINDLE_ON emc_spindle_on_msg;

  emc_spindle_on_msg.speed = +1;
  emc_spindle_on_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_spindle_on_msg);

  return 0;
}

static int sendSpindleReverse()
{
  EMC_SPINDLE_ON emc_spindle_on_msg;

  emc_spindle_on_msg.speed = -1;
  emc_spindle_on_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_spindle_on_msg);

  return 0;
}

static int sendSpindleOff()
{
  EMC_SPINDLE_OFF emc_spindle_off_msg;

  emc_spindle_off_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_spindle_off_msg);

  return 0;
}

static int sendSpindleIncrease()
{
  EMC_SPINDLE_INCREASE emc_spindle_increase_msg;

  emc_spindle_increase_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_spindle_increase_msg);

  return 0;
}

static int sendSpindleDecrease()
{
  EMC_SPINDLE_DECREASE emc_spindle_decrease_msg;

  emc_spindle_decrease_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_spindle_decrease_msg);

  return 0;
}

static int sendSpindleConstant()
{
  EMC_SPINDLE_CONSTANT emc_spindle_constant_msg;

  emc_spindle_constant_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_spindle_constant_msg);

  return 0;
}

static int sendBrakeEngage()
{
  EMC_SPINDLE_BRAKE_ENGAGE emc_spindle_brake_engage_msg;

  emc_spindle_brake_engage_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_spindle_brake_engage_msg);

  return 0;
}

static int sendBrakeRelease()
{
  EMC_SPINDLE_BRAKE_RELEASE emc_spindle_brake_release_msg;

  emc_spindle_brake_release_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_spindle_brake_release_msg);

  return 0;
}

static int sendAbort()
{
  EMC_TASK_ABORT task_abort_msg;

  task_abort_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(task_abort_msg);

  return 0;
}

static int sendJogStop(int axis)
{
  EMC_AXIS_ABORT emc_axis_abort_msg;

  if (axis < 0 || axis >= XEMC_NUM_AXES) {
    return -1;
  }

  // don't send request to jog if none are jogging
  if (axisJogging == -1) {
    return 0;
  }

  emc_axis_abort_msg.serial_number = ++emcCommandSerialNumber;
  emc_axis_abort_msg.axis = axisJogging;
  emcCommandBuffer->write(emc_axis_abort_msg);

  axisJogging = -1;

  return 0;
}

static int sendJogCont(int axis, double speed)
{
  EMC_AXIS_JOG emc_axis_jog_msg;
  EMC_TRAJ_SET_TELEOP_VECTOR emc_set_teleop_vector;

  if (axis < 0 || axis >= XEMC_NUM_AXES) {
    return -1;
  }

  if (axisJogging != -1) {
    // ignore request to jog, if an axis is already jogging
    return 0;
  }

  if(posFrame == POS_FRAME_JOINT)
    {
      if (0 == jogPol[axis]) {
        speed = -speed;
      }
      
      emc_axis_jog_msg.serial_number = ++emcCommandSerialNumber;
      emc_axis_jog_msg.axis = axis;
      emc_axis_jog_msg.vel = speed / 60.0;
      emcCommandBuffer->write(emc_axis_jog_msg);
    }
  else
    {
      emc_set_teleop_vector.serial_number = ++emcCommandSerialNumber;
      emc_set_teleop_vector.vector.tran.x = 0.0;
      emc_set_teleop_vector.vector.tran.y = 0.0;
      emc_set_teleop_vector.vector.tran.z = 0.0;

      switch(axis)
        {
        case 0:
          emc_set_teleop_vector.vector.tran.x = speed/60.0;
          break;
        case 1:
          emc_set_teleop_vector.vector.tran.y = speed/60.0;
          break;
        case 2:
          emc_set_teleop_vector.vector.tran.z = speed/60.0;
          break;
        case 3:
          emc_set_teleop_vector.vector.a = speed/60.0;
          break;
        case 4:
          emc_set_teleop_vector.vector.b = speed/60.0;
          break;
        case 5:
          emc_set_teleop_vector.vector.c = speed/60.0;
          break;
        }
      emcCommandBuffer->write(emc_set_teleop_vector);
    }

          
      
  axisJogging = axis;

  return 0;
}

static int sendJogIncr(int axis, double speed, double incr)
{
  EMC_AXIS_INCR_JOG emc_axis_incr_jog_msg;

  if (axis < 0 || axis >= XEMC_NUM_AXES) {
    return -1;
  }

  if (axisJogging != -1) {
    // ignore request to jog, if an axis is already jogging
    return 0;
  }

  if (0 == jogPol[axis]) {
    speed = -speed;
  }

  emc_axis_incr_jog_msg.serial_number = ++emcCommandSerialNumber;
  emc_axis_incr_jog_msg.axis = axis;
  emc_axis_incr_jog_msg.vel = speed / 60.0;
  emc_axis_incr_jog_msg.incr = jogIncrement;
  emcCommandBuffer->write(emc_axis_incr_jog_msg);

  // don't flag incremental jogs as jogging an axis-- we can
  // allow multiple incremental jogs since we don't need a key release

  return 0;
}

static int sendHome(int axis)
{
  EMC_AXIS_HOME emc_axis_home_msg;

  emc_axis_home_msg.serial_number = ++emcCommandSerialNumber;
  emc_axis_home_msg.axis = axis;
  emcCommandBuffer->write(emc_axis_home_msg);

  return 0;
}

static int sendFeedOverride(double override)
{
  EMC_TRAJ_SET_SCALE emc_traj_set_scale_msg;

  if (override < 0.0) {
    override = 0.0;
  }
  else if (override > (double) maxFeedOverride / 100.0) {
    override = (double) maxFeedOverride / 100.0;
  }
  emc_traj_set_scale_msg.serial_number = ++emcCommandSerialNumber;
  emc_traj_set_scale_msg.scale = override;
  emcCommandBuffer->write(emc_traj_set_scale_msg);

  return 0;
}

static int sendTaskPlanInit()
{
  EMC_TASK_PLAN_INIT task_plan_init_msg;

  task_plan_init_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(task_plan_init_msg);

  return 0;
}

static int sendProgramOpen(char *program)
{
  EMC_TASK_PLAN_OPEN emc_task_plan_open_msg;

  // first put in auto mode if it's not
  if (0 == emcStatus->task.mode != EMC_TASK_MODE_AUTO) {
    // send a request to go to auto mode
    sendAuto();
  }

  // wait for any previous one to go out
  if (0 != emcCommandWaitDone(emcCommandSerialNumber)) {
    printError("error executing command\n");
    return -1;
  }

  emc_task_plan_open_msg.serial_number = ++emcCommandSerialNumber;
  strcpy(emc_task_plan_open_msg.file, program);
  emcCommandBuffer->write(emc_task_plan_open_msg);

  // now clear out our stored version of the program, in case
  // the file contents have changed but the name is the same
  programFile[0] = 0;

  return 0;
}

// line in program to run from; set it in GUI when user clicks on a line,
// and pass it in calls to sendProgramRun(). sendProgramRun() won't use
// this directly.
static int programStartLine = 0;
static int programStartLineLast = 0;

static int sendProgramRun(int line)
{
  EMC_TASK_PLAN_RUN emc_task_plan_run_msg;

  // first reopen program if it's not open
  if (0 == emcStatus->task.file[0]) {
    // send a request to open last one
    sendProgramOpen(lastProgramFile);

    // wait for command to go out
    if (0 != emcCommandWaitDone(emcCommandSerialNumber)) {
      printError("error executing command\n");
      return -1;
    }
  }

  emc_task_plan_run_msg.serial_number = ++emcCommandSerialNumber;
  emc_task_plan_run_msg.line = line;
  emcCommandBuffer->write(emc_task_plan_run_msg);

  programStartLineLast = programStartLine;
  programStartLine = 0;

  return 0;
}

static int sendProgramPause()
{
  EMC_TASK_PLAN_PAUSE emc_task_plan_pause_msg;

  emc_task_plan_pause_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_task_plan_pause_msg);

  return 0;
}

static int sendProgramResume()
{
  EMC_TASK_PLAN_RESUME emc_task_plan_resume_msg;

  emc_task_plan_resume_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_task_plan_resume_msg);

  return 0;
}

static int sendProgramStep()
{
  EMC_TASK_PLAN_STEP emc_task_plan_step_msg;

  // first reopen program if it's not open
  if (0 == emcStatus->task.file[0]) {
    // send a request to open last one
    sendProgramOpen(lastProgramFile);

    // wait for command to go out
    if (0 != emcCommandWaitDone(emcCommandSerialNumber)) {
      printError("error executing command\n");
      return -1;
    }
  }

  emc_task_plan_step_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_task_plan_step_msg);

  programStartLineLast = programStartLine;
  programStartLine = 0;

  return 0;
}

static int sendMdiCmd(char *mdi)
{
  EMC_TASK_PLAN_EXECUTE emc_task_plan_execute_msg;

  strcpy(emc_task_plan_execute_msg.command, mdi);
  emc_task_plan_execute_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_task_plan_execute_msg);

  return 0;
}

static int sendLoadToolTable(const char *file)
{
  EMC_TOOL_LOAD_TOOL_TABLE emc_tool_load_tool_table_msg;

  strcpy(emc_tool_load_tool_table_msg.file, file);
  emc_tool_load_tool_table_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_tool_load_tool_table_msg);

  return 0;
}

static int sendAxisCycleTime(int axis, double cycleTime)
{
  EMC_AXIS_SET_CYCLE_TIME emc_axis_set_cycle_time_msg;

  emc_axis_set_cycle_time_msg.axis = axis;
  emc_axis_set_cycle_time_msg.cycleTime = cycleTime;
  emc_axis_set_cycle_time_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_axis_set_cycle_time_msg);

  return 0;
}

static int sendAxisSetGains(int axis, double p, double i, double d, double ff0, double ff1, double ff2, double backlash, double bias, double maxError)
{
  EMC_AXIS_SET_GAINS emc_axis_set_gains_msg;

  emc_axis_set_gains_msg.axis = axis;
  emc_axis_set_gains_msg.p = p;
  emc_axis_set_gains_msg.i = i;
  emc_axis_set_gains_msg.d = d;
  emc_axis_set_gains_msg.ff0 = ff0;
  emc_axis_set_gains_msg.ff1 = ff1;
  emc_axis_set_gains_msg.ff2 = ff2;
  emc_axis_set_gains_msg.backlash = backlash;
  emc_axis_set_gains_msg.bias = bias;
  emc_axis_set_gains_msg.maxError = maxError;
  emc_axis_set_gains_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_axis_set_gains_msg);

  return 0;
}

static int sendAxisSetOutputScale(int axis, double scale, double offset)
{
  EMC_AXIS_SET_OUTPUT_SCALE emc_axis_set_output_scale_msg;

  emc_axis_set_output_scale_msg.axis = axis;
  emc_axis_set_output_scale_msg.scale = scale;
  emc_axis_set_output_scale_msg.offset = offset;
  emc_axis_set_output_scale_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_axis_set_output_scale_msg);

  return 0;
}

static int sendAxisSetFerror(int axis, double ferror)
{
  EMC_AXIS_SET_FERROR emc_axis_set_ferror_msg;

  emc_axis_set_ferror_msg.axis = axis;
  emc_axis_set_ferror_msg.ferror = ferror;
  emc_axis_set_ferror_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_axis_set_ferror_msg);

  return 0;
}

// saved log file params
static char saveLogFile[EMC_LOG_FILENAME_LEN] = "/tmp/emc.plot.sh";
static int saveLogType = EMC_LOG_TYPE_AXES_FERROR;
static int saveLogSize = 1000;
static int saveLogSkip = 0;

// paths to awk and xgraph, using to plot logs
// fill these in for your system, if these are not in user's path
#define AWK_PATH "awk"
#define XGRAPH_PATH "xgraph"
#define SYSTEM_STRING_LEN 1024

static int plotLog(const char * logfile, int logtype)
{
  char string[SYSTEM_STRING_LEN];
  int retval;

  if (logfile == 0)
    {
      return -1;
    }

  switch (logtype)
    {
    case EMC_LOG_TYPE_AXIS_POS:
    case EMC_LOG_TYPE_AXIS_VEL:
      sprintf(string, "( %s '{print $1 \" \" $2}' < %s ; echo \"\" ; %s '{print $1 \" \" $3}' < %s ) 2> /dev/null | %s -m 1> /dev/null 2> /dev/null", AWK_PATH, logfile, AWK_PATH, logfile, XGRAPH_PATH);
      break;

    case EMC_LOG_TYPE_AXES_INPOS:
    case EMC_LOG_TYPE_AXES_OUTPOS:
      sprintf(string, "%s '{print $2 \" \" $3}' < %s 2> /dev/null | %s -m 1> /dev/null 2> /dev/null", AWK_PATH, logfile, XGRAPH_PATH);
      break;

    case EMC_LOG_TYPE_AXES_FERROR:
    case EMC_LOG_TYPE_TRAJ_POS:
      /* we want to compose:
         ( awk '{print $1 " " $2}' < emc.log ; echo "" ; awk '{print $1 " " $3}' < emc.log ; echo "" ; awk '{print $1 " " $4}' < emc.log ) 2> /dev/null | xgraph -m 1> /dev/null 2> /dev/null"
       */
      sprintf(string, "( %s '{print $1 \" \" $2}' < %s ; echo \"\" ; %s '{print $1 \" \" $3}' < %s ; echo \"\" ; %s '{print $1 \" \" $4}' < %s ) 2> /dev/null | %s -m 1> /dev/null 2> /dev/null", AWK_PATH, logfile, AWK_PATH, logfile, AWK_PATH, logfile, XGRAPH_PATH);
      break;

    case EMC_LOG_TYPE_TRAJ_VEL:
    case EMC_LOG_TYPE_TRAJ_ACC:
      /* we want to compose:
         ( awk '{print $1 " " $2}' < emc.log ; echo "" ; awk '{print $1 " " $3}' < emc.log ; echo "" ; awk '{print $1 " " $4}' < emc.log ; echo "" ; awk '{print $1 " " $5}' < emc.log) 2> /dev/null | xgraph -m 1> /dev/null 2> /dev/null"
       */
      sprintf(string, "( %s '{print $1 \" \" $2}' < %s ; echo \"\" ; %s '{print $1 \" \" $3}' < %s ; echo \"\" ; %s '{print $1 \" \" $4}' < %s ; echo \"\" ; %s '{print $1 \" \" $5}' < %s) 2> /dev/null | %s -m 1> /dev/null 2> /dev/null", AWK_PATH, logfile, AWK_PATH, logfile, AWK_PATH, logfile, AWK_PATH, logfile, XGRAPH_PATH);
      break;

    default:
      return -1;
      break;
    }

  retval = system(string);

  return retval;
}

static int sendLogStart()
{
  EMC_LOG_OPEN emc_log_open_msg;
  EMC_LOG_START emc_log_start_msg;

  // check for open log file first; if not, and old one saved, open it
  if (! emcStatus->logOpen) {
    if (saveLogFile[0] != 0) {
      strcpy(emc_log_open_msg.file, saveLogFile);
      emc_log_open_msg.type = saveLogType;
      emc_log_open_msg.size = saveLogSize;
      emc_log_open_msg.skip = saveLogSkip;
      emc_log_open_msg.which = activeJoint;
      emc_log_open_msg.serial_number = ++emcCommandSerialNumber;
      emcCommandBuffer->write(emc_log_open_msg);
    }
    else {
      // log is not opened, and no name saved, so ignore
      popupError("No log file selected");
      return -1;
    }
  }

  // wait for previous one to go out
  emcCommandWaitReceived(emcCommandSerialNumber);

  // now send log start message
  emc_log_start_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_log_start_msg);

  return 0;
}

static int sendLogStop()
{
  EMC_LOG_STOP emc_log_stop_msg;

  emc_log_stop_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_log_stop_msg);

  return 0;
};

static int sendLogClose()
{
  EMC_LOG_CLOSE emc_log_close_msg;

  emc_log_close_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_log_close_msg);

  return 0;
}

// X stuff starts here

// flag signifying that window needs to be redrawn
static int redraw = 1;

// global context and widgets, accessed during periodic timer
static XtAppContext app_context;
static Atom killAtom;
static Widget topLevel;
static Widget topForm;
static Widget barMenuForm;
static Widget abortCommand;
static Widget fileMenu;
static Widget viewMenu;
static Widget settingsMenu;
static Widget helpMenu;
static Widget commandMenuForm;
static Widget stateMenu;
static Widget modeMenu;
static Widget mistMenu;
static Widget floodMenu;
static Widget spindleMenu;
static Widget spindleIncLabel, spindleDecLabel;
static Widget brakeMenu;
static Widget toolTableShell = NULL, toolTableForm, toolTableLabel, toolTableText, toolTableDone, toolTableCancel;
static Widget varFileShell = NULL, varFileForm, varFileLabel, varFileText, varFileDone, varFileCancel;
static Widget toolNumberForm, toolNumberFormTitle, toolNumberFormName;
static Widget toolOffsetForm, toolOffsetFormTitle, toolOffsetFormName;
static Widget toolSetOffsetShell, toolSetOffsetForm, toolSetOffsetToolLabel, toolSetOffsetTool, toolSetOffsetLengthLabel, toolSetOffsetLength, toolSetOffsetDiameterLabel, toolSetOffsetDiameter, toolSetOffsetDone, toolSetOffsetCancel;
static Widget positionTypeForm, positionTypeFormTitle, positionTypeFormName;
static Widget workOffsetForm, workOffsetFormTitle, workOffsetFormName;
static Widget posLabel[XEMC_NUM_AXES];
static Widget posOffsetShell, posOffsetDialog;
static Widget jogSpeedForm, jogSpeedTitleLabel,
  jogSpeedLabel, jogSpeedIncLabel, jogSpeedDecLabel;
static Widget jogSpeedShell, jogSpeedDialog;
static Widget jogIncrementForm, jogIncrementTitleLabel, jogIncrementMenu;
static Widget jogForm, jogTitleLabel,
  jogMinusLabel, homeCommand, jogPlusLabel;
static Widget feedOverrideForm, feedOverrideTitleLabel,
  feedOverrideLabel, feedOverrideIncLabel, feedOverrideDecLabel;
static Widget feedOverrideShell, feedOverrideDialog;
static Widget loggingStatusForm, loggingStatusTitleLabel,
  loggingStatusOpenLabel, loggingStatusStartedLabel, loggingStatusPointsLabel;
static Widget mdiForm, mdiFormTitle, mdiFormText;
static Widget mdiCodesLabel;
static Widget programForm, programFormTitle, programFormName, programFormStateTitle, programFormState;
static Widget programOpenCommand, programRunCommand, programPauseCommand, programResumeCommand, programStepCommand, programVerifyCommand;
static Widget programText;
static Widget fileOpenShell, fileOpenDialog, fileOpenDone, fileOpenCancel;
static char EDITOR_FILE[256] = ""; // FIXME-- hardcoded
static Widget fileEditShell, fileEditDialog, fileEditDone, fileEditCancel;
static Widget fileEditorShell = NULL, fileEditorForm, fileEditorLabel, fileEditorText, fileEditorDone, fileEditorCancel, fileEditorMark;
static Widget fileQuitShell, fileQuitDialog, fileQuitDone, fileQuitCancel;
static Widget helpXemcShell = NULL, helpXemcForm, helpXemcLabel, helpXemcText, helpXemcDone;
static Widget helpAboutShell, helpAboutDialog, helpAboutDone;
static Widget errorShell = 0, errorDialog = 0, errorDone = 0;

// Pixel values inited from strings, for hard-coded colors
static Pixel pixelBlack;
static Pixel pixelRed;
static Pixel pixelYellow;
static Pixel pixelGreen;

// saved background and border colors for position labels,
// cleared and restored when highlighting
static Pixel posLabelBackground[XEMC_NUM_AXES];
static Pixel posLabelBorderColor[XEMC_NUM_AXES];

static int getColor(Widget w, Pixel *pixel, int foreground)
{
  Arg args;

  if (foreground)
    XtSetArg(args, XtNforeground, pixel);
  else
    XtSetArg(args, XtNbackground, pixel);
  XtGetValues(w, &args, 1);

  return 0;
}

static int setColor(Widget w, Pixel pixel, int foreground)
{
  if (foreground)
    XtVaSetValues(w, XtNforeground, pixel, NULL);
  else
    XtVaSetValues(w, XtNbackground, pixel, NULL);

  return 0;
}

static int stringToPixel(Widget w, String string, Pixel *pixel)
{
  XrmValue from, to;

  from.addr = string;
  from.size = strlen(string) + 1;
  to.addr = (char *) pixel;
  to.size = sizeof(Pixel);

  if (False == XtConvertAndStore(w, XtRString, &from, XtRPixel, &to))
    return -1;
  return 0;
}

static int getBorderColor(Widget w, Pixel *pixel)
{
  Arg args;

  XtSetArg(args, XtNborderColor, pixel);
  XtGetValues(w, &args, 1);

  return 0;
}

static int setBorderColor(Widget w, Pixel pixel)
{
  XtVaSetValues(w, XtNborderColor, pixel, NULL);

  return 0;
}

static int setLabel(Widget w, char *label)
{
  Arg args;
  int width;

  XtSetArg(args, XtNwidth, &width);
  XtGetValues(w, &args, 1);
  XtVaSetValues(w, XtNlabel, label, NULL);
  XtVaSetValues(w, XtNwidth, width, NULL);
  return(0);
}

static int setProgramText(char *text)
{
  XtVaSetValues(programText, XtNstring, text, NULL);
  return(0);
}

// index is diff between top and line to highlight, 0..max
static int highlightProgramText(char *text, int index)
{
  int start, end;

  // position 'start' to first char on index line
  for (start = 0; ; start++) {
    if (index <= 0) {
      break;
    }
    if (text[start] == 0 || text[start] == '\n') {
      index--;
    }
  }

  // position 'end' to last char on index line
  for (end = start; ; end++) {
    if (text[end] == 0 || text[end] == '\n') {
      break;
    }
  }

  XawTextSetSelection(programText, start, end);
  return(0);
}

// dialogPopup() is an XtNcallback that expects a
// transientShellWidget class as the client_data.
// Widget w is not used, but is required if this is to be used
// as a callback function. If you call it directly you can put NULL
// in for w and call_data.
static void dialogPopup(Widget w, XtPointer client_data, XtPointer call_data)
{
  Position x, y;
  Dimension width, height;

  // get the coordinates of the middle of topLevel widget
  XtVaGetValues(topForm,
                XtNwidth, &width,
                XtNheight, &height,
                NULL);

  // translate coordinates in application top-level window
  // into coordinates from root window origin
  XtTranslateCoords(topForm,
                    (Position) 100,
                    (Position) 100,
                    &x, &y);

  // move popup shell to this position (it's not visible yet)
  XtVaSetValues((Widget) client_data,
                XtNx, x,
                XtNy, y,
                NULL);

  XtPopup((Widget) client_data, XtGrabNone);
}

// command callbacks

static void abortCB(Widget w, XtPointer client_data, XtPointer call_data)
{
  sendAbort();
}

static void homeCB(Widget w, XtPointer client_data, XtPointer call_data)
{
  sendHome(activeJoint);
}

// flag to prevent errors from popping up multiple times
static int errorIsPopped = 0;

static void errorReturnAction(Widget w, XEvent *event, String *params, Cardinal *num_params)
{
  XtPopdown(errorShell);
  errorIsPopped = 0;
  destroyErrorShell();
}

static void errorDoneCB(Widget w, XtPointer client_data, XtPointer call_data)
{
  XtPopdown(errorShell);
  errorIsPopped = 0;
  destroyErrorShell();
}

// createErrorShell() creates the error dialog widget afresh,
// so that it gets sized correctly for each different error message.
// Otherwise, the widget is sized for the first message, and then
// that size is used for all subsequent messages.

static int createErrorShell()
{
  if (NULL != errorShell) {
    return 0;
  }

  errorShell =
    XtVaCreatePopupShell("errorShell",
                         transientShellWidgetClass,
                         topLevel,
                         NULL);

  errorDialog =
    XtVaCreateManagedWidget("errorDialog",
                            dialogWidgetClass,
                            errorShell,
                            NULL);

  errorDone =
    XtVaCreateManagedWidget("errorDone",
                            commandWidgetClass,
                            errorDialog,
                            NULL);

  XtAddCallback(errorDone, XtNcallback, errorDoneCB, errorShell);

  return 0;
}

static int destroyErrorShell()
{
  if (0 != errorDone)
    {
      XtDestroyWidget(errorDone);
      errorDone = 0;
    }

  if (0 != errorDialog)
    {
      XtDestroyWidget(errorDialog);
      errorDialog = 0;
    }

  if (0 != errorShell)
    {
      XtDestroyWidget(errorShell);
      errorShell = 0;
    }

  return 0;
}

static void popupError(const char *fmt, ...)
{
  va_list ap;
  char string[256];             // FIXME-- hardcoded value

  va_start(ap, fmt);
  vsprintf(string, fmt, ap);
  va_end(ap);

  if (errorIsPopped) {
    // we're popped up already, so just print the error to stdout
    fprintf(stderr, "error: %s\n", string);
    return;
  }

  destroyErrorShell();
  createErrorShell();

  XtVaSetValues(errorDialog, XtNlabel, string, NULL);
  errorIsPopped = 1;
  dialogPopup(NULL, errorShell, NULL);
  // trap window kill
  XSetWMProtocols(XtDisplay(topLevel), XtWindow(errorShell), &killAtom, 1);
}

// file edit forward decls
static void fileEditorDoneCB(Widget w, XtPointer client_data, XtPointer call_data);
static void fileEditorCancelCB(Widget w, XtPointer client_data, XtPointer call_data);
static void fileEditorMarkCB(Widget w, XtPointer client_data, XtPointer call_data);
static int createFileEditorShell(int writeable);
static int destroyFileEditorShell();
static void doFileEditorDone(int get);

static void fileEditorDoneCB(Widget w, XtPointer client_data, XtPointer call_data)
{
  doFileEditorDone(1);
}

static void fileEditorCancelCB(Widget w, XtPointer client_data, XtPointer call_data)
{
  doFileEditorDone(0);
}

static void fileEditorMarkCB(Widget w, XtPointer client_data, XtPointer call_data)
{
  FILE *fp;
  XawTextPosition pos;
  int charcount = 0;
  int line = 1;
  char buffer[256];             // FIXME-- hardcoded

  if (NULL == (fp = fopen(EDITOR_FILE, "r"))) {
    return;
  }

  programStartLine = 0;
  pos = XawTextGetInsertionPoint(fileEditorText);

  while (! feof(fp)) {
    if (NULL == fgets(buffer, 256, fp)) {
      // hmmm... never found line
      popupError("Can't mark line-- character position\n%d outside range of file", pos);
      break;
    }

    charcount += strlen(buffer);
    if (charcount > pos) {
      // found it
      sendProgramOpen(EDITOR_FILE);
      popupError("Marking program to start here:\n%s", buffer);
      programStartLine = line;
      break;
    }

    line++;
  }

  fclose(fp);
}

static int createFileEditorShell(int writeable)
{
  char label[256];              // FIXME-- hardcoded

  if (NULL != fileEditorShell) {
    return 0;
  }

  strcpy(label, EDITOR_FILE);
  if (! writeable) {
    strcat(label, " (read only)");
  }

  fileEditorShell =
    XtVaCreatePopupShell("fileEditorShell",
                         topLevelShellWidgetClass,
                         topLevel,
                         XtNallowShellResize, True,
                         NULL);

  fileEditorForm =
    XtVaCreateManagedWidget("fileEditorForm",
                            formWidgetClass,
                            fileEditorShell,
                            NULL);

  fileEditorLabel =
    XtVaCreateManagedWidget("fileEditorLabel",
                            labelWidgetClass,
                            fileEditorForm,
                            XtNlabel, label,
                            NULL);

  fileEditorText =
    XtVaCreateManagedWidget("fileEditorText",
                            asciiTextWidgetClass,
                            fileEditorForm,
                            XtNfromVert, fileEditorLabel,
                            XtNeditType, (writeable ? XawtextEdit :
                                          XawtextRead),
                            XtNtype, XawAsciiFile,
                            XtNstring, EDITOR_FILE,
                            XtNscrollVertical, XawtextScrollWhenNeeded,
                            NULL);

  fileEditorDone =
    XtVaCreateManagedWidget("fileEditorDone",
                            commandWidgetClass,
                            fileEditorForm,
                            XtNfromVert, fileEditorText,
                            NULL);

  XtAddCallback(fileEditorDone, XtNcallback, fileEditorDoneCB, fileEditorShell);

  if (writeable) {
    XtSetSensitive(fileEditorDone, True);
  }
  else {
    XtSetSensitive(fileEditorDone, False);
  }

  fileEditorCancel =
    XtVaCreateManagedWidget("fileEditorCancel",
                            commandWidgetClass,
                            fileEditorForm,
                            XtNfromVert, fileEditorText,
                            XtNfromHoriz, fileEditorDone,
                            NULL);

  XtAddCallback(fileEditorCancel, XtNcallback, fileEditorCancelCB, fileEditorShell);

  fileEditorMark =
    XtVaCreateManagedWidget("fileEditorMark",
                            commandWidgetClass,
                            fileEditorForm,
                            XtNfromVert, fileEditorText,
                            XtNfromHoriz, fileEditorCancel,
                            NULL);

  XtAddCallback(fileEditorMark, XtNcallback, fileEditorMarkCB, fileEditorShell);

  return 0;
}

static int destroyFileEditorShell()
{
  if (fileEditorMark != NULL) {
    XtDestroyWidget(fileEditorMark);
    fileEditorMark = NULL;
  }

  if (fileEditorCancel != NULL) {
    XtDestroyWidget(fileEditorCancel);
    fileEditorCancel = NULL;
  }

  if (fileEditorDone != NULL) {
    XtDestroyWidget(fileEditorDone);
    fileEditorDone = NULL;
  }

  if (fileEditorText != NULL) {
    XtDestroyWidget(fileEditorText);
    fileEditorText = NULL;
  }

  if (fileEditorLabel != NULL) {
    XtDestroyWidget(fileEditorLabel);
    fileEditorLabel = NULL;
  }

  if (fileEditorForm != NULL) {
    XtDestroyWidget(fileEditorForm);
    fileEditorForm = NULL;
  }

  if (fileEditorShell != NULL) {
    XtDestroyWidget(fileEditorShell);
    fileEditorShell = NULL;
  }

  return 0;
}

static void doFileEditorDone(int get)
{
  Widget source;
  String string;

  if (get) {
    XtVaGetValues(fileEditorText,
                  XtNtextSource, &source,
                  XtNstring, &string,
                  NULL);

    XawAsciiSave(source);
  }

  XtPopdown(fileEditorShell);

  destroyFileEditorShell();
}

// tool table forward decls
static void toolTableDoneCB(Widget w, XtPointer client_data, XtPointer call_data);
static void toolTableCancelCB(Widget w, XtPointer client_data, XtPointer call_data);
static int createToolTableShell();
static int destroyToolTableShell();
static void doToolTableDone(int get);

static void toolTableDoneCB(Widget w, XtPointer client_data, XtPointer call_data)
{
  doToolTableDone(1);
}

static void toolTableCancelCB(Widget w, XtPointer client_data, XtPointer call_data)
{
  doToolTableDone(0);
}

static int createToolTableShell()
{
  if (NULL != toolTableShell) {
    return 0;
  }

  toolTableShell =
    XtVaCreatePopupShell("toolTableShell",
                         topLevelShellWidgetClass,
                         topLevel,
                         XtNallowShellResize, True,
                         NULL);

  toolTableForm =
    XtVaCreateManagedWidget("toolTableForm",
                            formWidgetClass,
                            toolTableShell,
                            NULL);

  toolTableLabel =
    XtVaCreateManagedWidget("toolTableLabel",
                            labelWidgetClass,
                            toolTableForm,
                            XtNlabel, TOOL_TABLE_FILE,
                            NULL);

  toolTableText =
    XtVaCreateManagedWidget("toolTableText",
                            asciiTextWidgetClass,
                            toolTableForm,
                            XtNfromVert, toolTableLabel,
                            XtNeditType, XawtextEdit,
                            XtNtype, XawAsciiFile,
                            XtNstring, TOOL_TABLE_FILE,
                            XtNscrollVertical, XawtextScrollWhenNeeded,
                            NULL);

  toolTableDone =
    XtVaCreateManagedWidget("toolTableDone",
                            commandWidgetClass,
                            toolTableForm,
                            XtNfromVert, toolTableText,
                            NULL);

  XtAddCallback(toolTableDone, XtNcallback, toolTableDoneCB, toolTableShell);

  toolTableCancel =
    XtVaCreateManagedWidget("toolTableCancel",
                            commandWidgetClass,
                            toolTableForm,
                            XtNfromVert, toolTableText,
                            XtNfromHoriz, toolTableDone,
                            NULL);

  XtAddCallback(toolTableCancel, XtNcallback, toolTableCancelCB, toolTableShell);

  return 0;
}

static int destroyToolTableShell()
{
  if (toolTableCancel != NULL) {
    XtDestroyWidget(toolTableCancel);
    toolTableCancel = NULL;
  }

  if (toolTableDone != NULL) {
    XtDestroyWidget(toolTableDone);
    toolTableDone = NULL;
  }

  if (toolTableText != NULL) {
    XtDestroyWidget(toolTableText);
    toolTableText = NULL;
  }

  if (toolTableLabel != NULL) {
    XtDestroyWidget(toolTableLabel);
    toolTableLabel = NULL;
  }

  if (toolTableForm != NULL) {
    XtDestroyWidget(toolTableForm);
    toolTableForm = NULL;
  }

  if (toolTableShell != NULL) {
    XtDestroyWidget(toolTableShell);
    toolTableShell = NULL;
  }

  return 0;
}

static void doToolTableDone(int get)
{
  Widget source;
  String string;

  if (get) {
    XtVaGetValues(toolTableText,
                  XtNtextSource, &source,
                  XtNstring, &string,
                  NULL);

    XawAsciiSave(source);
    sendLoadToolTable(string);
  }

  XtPopdown(toolTableShell);

  destroyToolTableShell();
}

// forward decls

static void varFileDoneCB(Widget w, XtPointer client_data, XtPointer call_data);
static void varFileCancelCB(Widget w, XtPointer client_data, XtPointer call_data);
static int createVarFileShell();
static int destroyVarFileShell();
static void doVarFileDone(int get);

static void varFileDoneCB(Widget w, XtPointer client_data, XtPointer call_data)
{
  doVarFileDone(1);
}

static void varFileCancelCB(Widget w, XtPointer client_data, XtPointer call_data)
{
  doVarFileDone(0);
}

static int createVarFileShell()
{
  if (NULL != varFileShell) {
    return 0;
  }

  varFileShell =
    XtVaCreatePopupShell("varFileShell",
                         topLevelShellWidgetClass,
                         topLevel,
                         XtNallowShellResize, True,
                         NULL);

  varFileForm =
    XtVaCreateManagedWidget("varFileForm",
                            formWidgetClass,
                            varFileShell,
                            NULL);

  varFileLabel =
    XtVaCreateManagedWidget("varFileLabel",
                            labelWidgetClass,
                            varFileForm,
                            XtNlabel, PARAMETER_FILE,
                            NULL);

  varFileText =
    XtVaCreateManagedWidget("varFileText",
                            asciiTextWidgetClass,
                            varFileForm,
                            XtNfromVert, varFileLabel,
                            XtNeditType, XawtextEdit,
                            XtNtype, XawAsciiFile,
                            XtNstring, PARAMETER_FILE,
                            XtNscrollVertical, XawtextScrollWhenNeeded,
                            NULL);

  varFileDone =
    XtVaCreateManagedWidget("varFileDone",
                            commandWidgetClass,
                            varFileForm,
                            XtNfromVert, varFileText,
                            NULL);

  XtAddCallback(varFileDone, XtNcallback, varFileDoneCB, varFileShell);

  varFileCancel =
    XtVaCreateManagedWidget("varFileCancel",
                            commandWidgetClass,
                            varFileForm,
                            XtNfromVert, varFileText,
                            XtNfromHoriz, varFileDone,
                            NULL);

  XtAddCallback(varFileCancel, XtNcallback, varFileCancelCB, varFileShell);

  return 0;
}

static int destroyVarFileShell()
{
  if (varFileCancel != NULL) {
    XtDestroyWidget(varFileCancel);
    varFileCancel = NULL;
  }

  if (varFileDone != NULL) {
    XtDestroyWidget(varFileDone);
    varFileDone = NULL;
  }

  if (varFileText != NULL) {
    XtDestroyWidget(varFileText);
    varFileText = NULL;
  }

  if (varFileLabel != NULL) {
    XtDestroyWidget(varFileLabel);
    varFileLabel = NULL;
  }

  if (varFileForm != NULL) {
    XtDestroyWidget(varFileForm);
    varFileForm = NULL;
  }

  if (varFileShell != NULL) {
    XtDestroyWidget(varFileShell);
    varFileShell = NULL;
  }

  return 0;
}

static void doVarFileDone(int get)
{
  Widget source;
  String string;

  if (get) {
  XtVaGetValues(varFileText,
                XtNtextSource, &source,
                XtNstring, &string,
                NULL);

  XawAsciiSave(source);
  sendTaskPlanInit();
  }

  XtPopdown(varFileShell);

  destroyVarFileShell();
}

// diagnostics dialog

static Widget diagnosticsShell = NULL;
static Widget diagnosticsForm = NULL;
static Widget diagnosticsLabel = NULL;
static Widget diagnosticsTaskHBLabel = NULL;
static Widget diagnosticsTaskHB = NULL;
static Widget diagnosticsIoHBLabel = NULL;
static Widget diagnosticsIoHB = NULL;
static Widget diagnosticsMotionHBLabel = NULL;
static Widget diagnosticsMotionHB= NULL;
static Widget diagnosticsFerrorLabel = NULL;
static Widget diagnosticsFerror = NULL;
static Widget diagnosticsDone = NULL;

// flag that window is up, so we don't waste time updating labels
static int diagnosticsIsPopped = 0;

static void diagnosticsDoDone()
{
  diagnosticsIsPopped = 0;
  XtPopdown(diagnosticsShell);
}

static void diagnosticsDoneCB(Widget w, XtPointer client_data, XtPointer call_data)
{
  diagnosticsDoDone();
}

static void diagnosticsReturnAction(Widget w, XEvent *event, String *params, Cardinal *num_params)
{
  diagnosticsDoDone();
}

static Pixel fileOpenBorderColor;
static int fileOpenDoDone = 1;

static void doFileOpenDone()
{
  String string;

  if (fileOpenDoDone) {
    // note: "*value: " must be set in resources for input box
    // to appear, and for this to be valid (and not dump core)
    string = XawDialogGetValueString(fileOpenDialog);
    // set value to be the same in file edit dialog
    strcpy(EDITOR_FILE, string);
    XtVaSetValues(fileEditDialog, XtNvalue, EDITOR_FILE, NULL);
    sendProgramOpen(string);
  }

  setBorderColor(fileOpenDone, pixelRed);
  setBorderColor(fileOpenCancel, fileOpenBorderColor);
  fileOpenDoDone = 1;

  XtPopdown(fileOpenShell);
}

static void fileOpenDoneCB(Widget w, XtPointer client_data, XtPointer call_data)
{
  doFileOpenDone();
}

static void fileOpenReturnAction(Widget w, XEvent *event, String *params, Cardinal *num_params)
{
  doFileOpenDone();
}

static void fileOpenTabAction(Widget w, XEvent *event, String *params, Cardinal *num_params)
{
  if (fileOpenDoDone) {
    setBorderColor(fileOpenDone, fileOpenBorderColor);
    setBorderColor(fileOpenCancel, pixelRed);
    fileOpenDoDone = 0;
  }
  else {
    setBorderColor(fileOpenDone, pixelRed);
    setBorderColor(fileOpenCancel, fileOpenBorderColor);
    fileOpenDoDone = 1;
  }
}

static Pixel fileQuitBorderColor;
static int fileQuitDoDone = 1;

static void doFileQuitDone()
{
  XtPopdown(fileQuitShell);

  if (fileQuitDoDone) {
    quit();
  }
  else {
    setBorderColor(fileQuitDone, pixelRed);
    setBorderColor(fileQuitCancel, fileQuitBorderColor);
    fileQuitDoDone = 1;
  }
}

static void fileQuitDoneCB(Widget w, XtPointer client_data, XtPointer call_data)
{
  doFileQuitDone();
}

static void fileQuitReturnAction(Widget w, XEvent *event, String *params, Cardinal *num_params)
{
  doFileQuitDone();
}

static void fileQuitTabAction(Widget w, XEvent *event, String *params, Cardinal *num_params)
{
  if (fileQuitDoDone) {
    setBorderColor(fileQuitDone, fileQuitBorderColor);
    setBorderColor(fileQuitCancel, pixelRed);
    fileQuitDoDone = 0;
  }
  else {
    setBorderColor(fileQuitDone, pixelRed);
    setBorderColor(fileQuitCancel, fileQuitBorderColor);
    fileQuitDoDone = 1;
  }
}

static Pixel fileEditBorderColor;
static int fileEditDoDone = 1;

static void doFileEditDone()
{
  String string;
  struct stat buf;
  int fd;

  if (fileEditDoDone) {
    string = XawDialogGetValueString(fileEditDialog);
    // set value to be the same in file open dialog
    strcpy(EDITOR_FILE, string);
    XtVaSetValues(fileOpenDialog, XtNvalue, EDITOR_FILE, NULL);
  }

  XtPopdown(fileEditShell);

  if (fileEditDoDone) {
    if (-1 == stat(EDITOR_FILE, &buf)) {
      // file not found-- it's a new one. Touch it so that it
      // exists and the text widget won't barf
      fd = open(EDITOR_FILE, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR);
      close(fd);
      createFileEditorShell(1);
      dialogPopup(NULL, fileEditorShell, NULL);
      // trap window kill
      XSetWMProtocols(XtDisplay(topLevel), XtWindow(fileEditorShell), &killAtom, 1);
    }
    else {
      // file is there-- check type and permissions
      if (! S_ISREG(buf.st_mode)) {
        // file is not a regular file
        popupError("Can't edit %S: not a text file", EDITOR_FILE);
      }
      else if ((S_IWUSR & buf.st_mode)) {
        // file is writeable
        createFileEditorShell(1);
        dialogPopup(NULL, fileEditorShell, NULL);
        // trap window kill
        XSetWMProtocols(XtDisplay(topLevel), XtWindow(fileEditorShell), &killAtom, 1);
      }
      else {
        // file is read-only
        createFileEditorShell(0);
        dialogPopup(NULL, fileEditorShell, NULL);
        // trap window kill
        XSetWMProtocols(XtDisplay(topLevel), XtWindow(fileEditorShell), &killAtom, 1);
      }
    }
  }

  setBorderColor(fileEditDone, pixelRed);
  setBorderColor(fileEditCancel, fileEditBorderColor);
  fileEditDoDone = 1;
}

static void fileEditDoneCB(Widget w, XtPointer client_data, XtPointer call_data)
{
  doFileEditDone();
}

static void fileEditReturnAction(Widget w, XEvent *event, String *params, Cardinal *num_params)
{
  doFileEditDone();
}

static void fileEditTabAction(Widget w, XEvent *event, String *params, Cardinal *num_params)
{
  if (fileEditDoDone) {
    setBorderColor(fileEditDone, fileEditBorderColor);
    setBorderColor(fileEditCancel, pixelRed);
    fileEditDoDone = 0;
  }
  else {
    setBorderColor(fileEditDone, pixelRed);
    setBorderColor(fileEditCancel, fileEditBorderColor);
    fileEditDoDone = 1;
  }
}

static void toolSetOffsetDoDone(int done)
{
  String str1, str2, str3;
  int tool;
  double length;
  double diameter;

  if (done) {
    XtVaGetValues(toolSetOffsetTool, XtNstring, &str1, NULL);
    XtVaGetValues(toolSetOffsetLength, XtNstring, &str2, NULL);
    XtVaGetValues(toolSetOffsetDiameter, XtNstring, &str3, NULL);

    if (1 == sscanf(str1, "%d", &tool) &&
        1 == sscanf(str2, "%lf", &length) &&
        1 == sscanf(str3, "%lf", &diameter)) {
      sendToolSetOffset(tool, length, diameter);
    }
  }

  XtPopdown(toolSetOffsetShell);
}

static void toolSetOffsetUpAction(Widget w, XEvent *event, String *params, Cardinal *num_params)
{
  char string[256];

  sprintf(string, "%d", emcStatus->io.tool.toolInSpindle);
  XtVaSetValues(toolSetOffsetTool, XtNstring, string, NULL);
  sprintf(string, "%f",
          emcStatus->motion.traj.actualPosition.tran.z -
          emcStatus->task.origin.tran.z);
  XtVaSetValues(toolSetOffsetLength, XtNstring, string, NULL);
  XtVaSetValues(toolSetOffsetDiameter, XtNstring, "0.0", NULL);

  dialogPopup(NULL, toolSetOffsetShell, NULL);
  // trap window kill
  XSetWMProtocols(XtDisplay(topLevel), XtWindow(toolSetOffsetShell), &killAtom, 1);
}

static Pixel toolSetOffsetFormBorderColor;
static int toolSetOffsetReturnIsDone = 1;

static void toolSetOffsetReturnAction(Widget w, XEvent *event, String *params, Cardinal *num_params)
{
  if (toolSetOffsetReturnIsDone) {
    toolSetOffsetDoDone(1);
  }
  else {
    toolSetOffsetDoDone(0);
  }
}

static void toolSetOffsetDoneCB(Widget w, XtPointer client_data, XtPointer call_data)
{
  toolSetOffsetDoDone(1);
}

static void toolSetOffsetCancelCB(Widget w, XtPointer client_data, XtPointer call_data)
{
  toolSetOffsetDoDone(0);
}

static void toolSetOffsetTabAction(Widget w, XEvent *event, String *params, Cardinal *num_params)
{
  if (toolSetOffsetReturnIsDone) {
    setBorderColor(toolSetOffsetDone, toolSetOffsetFormBorderColor);
    setBorderColor(toolSetOffsetCancel, pixelRed);
    toolSetOffsetReturnIsDone = 0;
  }
  else {
    setBorderColor(toolSetOffsetDone, pixelRed);
    setBorderColor(toolSetOffsetCancel, toolSetOffsetFormBorderColor);
    toolSetOffsetReturnIsDone = 1;
  }
}

static void doPosOffsetDone()
{
  String string;
  char cmd[256];
  double val;

  string = XawDialogGetValueString(posOffsetDialog);

  if (1 == sscanf(string, "%lf", &val)) {
    // send MDI command
    // FIXME-- this RS-274-NGC specific; need to add NML way to do this
    sprintf(cmd, "G92%s%f\n",
            activeCoord == 0 ? "X" :
            activeCoord == 1 ? "Y" :
            activeCoord == 2 ? "Z" : "X",
            val);
    sendMdiCmd(cmd);
  }

  XtPopdown(posOffsetShell);
}

static void posOffsetUpAction(Widget w, XEvent *event, String *params, Cardinal *num_params)
{
  int axis;

  // disallow pos offset if joints are displayed
  if (posFrame == POS_FRAME_JOINT) {
    return;
  }

  for (axis = 0; axis < numPosLabels; axis++) {
    if (w == posLabel[axis]) {
      activeCoord = axis;
      break;
    }
  }

  XtVaSetValues(posOffsetDialog, XtNvalue, "0.0", NULL);
  dialogPopup(NULL, posOffsetShell, NULL);
  // trap window kill
  XSetWMProtocols(XtDisplay(topLevel), XtWindow(posOffsetShell), &killAtom, 1);
}

static void posOffsetReturnAction(Widget w, XEvent *event, String *params, Cardinal *num_params)
{
  doPosOffsetDone();
}

static void doJogSpeedDone()
{
  String string;
  int val;
  char labelString[80];

  string = XawDialogGetValueString(jogSpeedDialog);

  if (1 == sscanf(string, "%d", &val)) {
    jogSpeed = val;
    if (jogSpeed > maxJogSpeed) {
      jogSpeed = maxJogSpeed;
    }
    sprintf(labelString, "%d", jogSpeed);
    setLabel(jogSpeedLabel, labelString);
    redraw = 1;
  }

  XtPopdown(jogSpeedShell);
}

static void jogSpeedReturnAction(Widget w, XEvent *event, String *params, Cardinal *num_params)
{
  doJogSpeedDone();
}

static void doFeedOverrideDone()
{
  String string;
  double val;

  string = XawDialogGetValueString(feedOverrideDialog);

  if (1 == sscanf(string, "%lf", &val)) {
    sendFeedOverride(val / 100.0);
  }

  XtPopdown(feedOverrideShell);
}

static void feedOverrideReturnAction(Widget w, XEvent *event, String *params, Cardinal *num_params)
{
  doFeedOverrideDone();
}

static void programRunCB(Widget w, XtPointer client_data, XtPointer call_data)
{
  sendProgramRun(programStartLine);
}

static void programPauseCB(Widget w, XtPointer client_data, XtPointer call_data)
{
  sendProgramPause();
}

static void programResumeCB(Widget w, XtPointer client_data, XtPointer call_data)
{
  sendProgramResume();
}

static void programStepCB(Widget w, XtPointer client_data, XtPointer call_data)
{
  sendProgramStep();
}

static void programVerifyCB(Widget w, XtPointer client_data, XtPointer call_data)
{
  programStartLine = -1;
  sendProgramRun(programStartLine);
}

static void helpXemcReturnAction(Widget w, XEvent *event, String *params, Cardinal *num_params)
{
  XtPopdown(helpXemcShell);
}

static void helpAboutReturnAction(Widget w, XEvent *event, String *params, Cardinal *num_params)
{
  XtPopdown(helpAboutShell);
}

static void genericDoneCB(Widget w, XtPointer client_data, XtPointer call_data)
{
  XtPopdown((Widget) client_data);
}

// button handling code

static void downAction(Widget w,
                       XEvent *ev,
                       String *params,
                       Cardinal *numParams)
{
  int axis;
  char string[80];

  for (axis = 0; axis < numPosLabels; axis++) {
    if (w == posLabel[axis]) {
        activeJoint = axis;
        activeCoord = axis;
        return;
    }
  }

  if (w == spindleIncLabel) {
    sendSpindleIncrease();
  }
  else if (w == spindleDecLabel) {
    sendSpindleDecrease();
  }
  else if (w == jogMinusLabel) {
    if (jogIncrement > 0.0) {
      sendJogIncr(activeJoint, -jogSpeed, jogIncrement);
    }
    else {
         if (posFrame == POS_FRAME_JOINT) 
           {
             sendJogCont(activeJoint, -jogSpeed);
           }
         else
           {
             sendJogCont(coordNum[activeCoord], -jogSpeed);
           }
    }
  }
  else if (w == jogPlusLabel) {
    if (jogIncrement > 0.0) {
      sendJogIncr(activeJoint, jogSpeed, jogIncrement);
    }
    else {
         if (posFrame == POS_FRAME_JOINT) 
           {
             sendJogCont(activeJoint, -jogSpeed);
           }
         else
           {
             sendJogCont(coordNum[activeCoord], -jogSpeed);
           }
    }
  }
  else if (w == jogSpeedLabel) {
    // pop up menu to change jog speed
    XtVaSetValues(jogSpeedDialog,
                  XtNvalue, "",
                  NULL);
    dialogPopup(NULL, jogSpeedShell, NULL);
    // trap window kill
    XSetWMProtocols(XtDisplay(topLevel), XtWindow(jogSpeedShell), &killAtom, 1);
  }
  else if (w == jogSpeedDecLabel) {
    // change it once here and redraw
    if (--jogSpeed <= 0) {
      jogSpeed = 1;
    }
    sprintf(string, "%d", jogSpeed);
    setLabel(jogSpeedLabel, string);
    redraw = 1;

    // set jogSpeedChange so that timer callback will continue to change
    // until button up clears it
    jogSpeedChange = -1;
  }
  else if (w == jogSpeedIncLabel) {
    // change it once here and redraw
    if (++jogSpeed > maxJogSpeed) {
      jogSpeed = maxJogSpeed;
    }
    sprintf(string, "%d", jogSpeed);
    setLabel(jogSpeedLabel, string);
    redraw = 1;

    // set jogSpeedChange so that timer callback will continue to change
    // until button up clears it
    jogSpeedChange = +1;
  }
  else if (w == feedOverrideLabel) {
    // pop up menu to change feed override
    XtVaSetValues(feedOverrideDialog,
                  XtNvalue, "",
                  NULL);
    dialogPopup(NULL, feedOverrideShell, NULL);
    // trap window kill
    XSetWMProtocols(XtDisplay(topLevel), XtWindow(feedOverrideShell), &killAtom, 1);
  }
  else if (w == feedOverrideDecLabel) {
    // change it once here and redraw
    if ((feedOverride -= 10) <= 0) {
      feedOverride = 0;
    }
    sprintf(string, "%3d", feedOverride);
    setLabel(feedOverrideLabel, string);
    redraw = 1;

    // set feedOverrideChange so that timer callback will continue to change
    // until button up clears it
    feedOverrideChange = -1;
  }
  else if (w == feedOverrideIncLabel) {
    // change it once here and redraw
    if ((feedOverride += 10) > maxFeedOverride) {
      feedOverride = maxFeedOverride;
    }
    sprintf(string, "%3d", feedOverride);
    setLabel(feedOverrideLabel, string);
    redraw = 1;

    // set feedOverrideChange so that timer callback will continue to change
    // until button up clears it
    feedOverrideChange = +1;
  }
  else {
    printf("down\n");
  }
}

static void upAction(Widget w,
                     XEvent *ev,
                     String *params,
                     Cardinal *numParams)
{
  int axis;

  for (axis = 0; axis < numPosLabels; axis++) {
    if (w == posLabel[axis]) {
      return;
    }
  }

  if (w == spindleIncLabel) {
    sendSpindleConstant();
  }
  else if (w == spindleDecLabel) {
    sendSpindleConstant();
  }
  else if (w == jogMinusLabel) {
    // only stop it if it's continuous jogging
    if (jogIncrement <= 0.0) {
      sendJogStop(axisJogging);
    }
  }
  else if (w == jogPlusLabel) {
    // only stop it if it's continuous jogging
    if (jogIncrement <= 0.0) {
      sendJogStop(axisJogging);
    }
  }
  else if (w == jogSpeedDecLabel) {
    jogSpeedChange = 0;
  }
  else if (w == jogSpeedIncLabel) {
    jogSpeedChange = 0;
  }
  else if (w == feedOverrideDecLabel) {
    feedOverrideChange = 0;
    sendFeedOverride((double) feedOverride / 100.0);
  }
  else if (w == feedOverrideIncLabel) {
    feedOverrideChange = 0;
    sendFeedOverride((double) feedOverride / 100.0);
  }
  else {
    printf("up\n");
  }
}

static void mdiReturnAction(Widget w, XEvent *event, String *params, Cardinal *num_params)
{
  String string;

  XtVaGetValues(mdiFormText, XtNstring, &string, NULL);

  sendMdiCmd(string);
}

// key handling code

// FIXME-- better way to get these?
#define XEVENT_TYPE_XKEY_KEY_PRESS_EVENT 2
#define XEVENT_TYPE_XKEY_KEY_RELEASE_EVENT 3
#define XKEY_EVENT_STATE_NONE    0x00
#define XKEY_EVENT_STATE_SHIFT   0x01
#define XKEY_EVENT_STATE_CONTROL 0x04
#define XKEY_EVENT_STATE_ALT     0x08

#define KEY_ESC     9
#define KEY_F1     67
#define KEY_F2     68
#define KEY_F3     69
#define KEY_F4     70
#define KEY_F5     71
#define KEY_F6     72
#define KEY_F7     73
#define KEY_F8     74
#define KEY_F9     75
#define KEY_F10    76
#define KEY_F11    95
#define KEY_F12    96
#define KEY_PGUP   99
#define KEY_PGDN  105
#define KEY_LEFT  100
#define KEY_RIGHT 102
#define KEY_UP     98
#define KEY_DOWN  104
#define KEY_X      53
#define KEY_Y      29
#define KEY_Z      52
#define KEY_HOME   97
#define KEY_END   103
#define KEY_1      10
#define KEY_2      11
#define KEY_3      12
#define KEY_4      13
#define KEY_5      14
#define KEY_6      15
#define KEY_7      16
#define KEY_8      17
#define KEY_9      18
#define KEY_0      19
#define KEY_Q      24
#define KEY_W      25
#define KEY_E      26
#define KEY_R      27
#define KEY_T      28
#define KEY_Y      29
#define KEY_I      31
#define KEY_O      32
#define KEY_P      33
#define KEY_A      38
#define KEY_S      39
#define KEY_D      40
#define KEY_F      41
#define KEY_G      42
#define KEY_H      43
#define KEY_V      55
#define KEY_B      56
#define KEY_COMMA  59
#define KEY_PERIOD 60
#define KEY_C      54

static int keyReleaseOut = 0;   // set if we saw a release, cleared right away
                                // if the key repeat kicks back on, else it
                                // goes through as a true key release
static double keyReleaseTime = 0.0;
static unsigned int keyPressState;
static unsigned int keyPressKeycode;
static unsigned int keyReleaseState;
static unsigned int keyReleaseKeycode;

static void keyPressAction(unsigned int state, unsigned int keycode)
{
  char string[256];
  static double saveJogIncrement = 0.1000;

  switch (keycode) {

  case KEY_ESC:
    sendAbort();
    break;

  case KEY_F1:
    // estop toggle
    if (emcStatus->task.state == EMC_TASK_STATE_ESTOP) {
      sendEstopReset();
    }
    else {
      sendEstop();
    }
    break;

  case KEY_F2:
    // estop toggle
    if (emcStatus->task.state == EMC_TASK_STATE_ESTOP_RESET) {
      sendMachineOn();
    }
    else {
      sendMachineOff();
    }
    break;

  case KEY_F3:
    // manual mode
    sendManual();
    break;

  case KEY_F4:
    // auto mode
    sendAuto();
    break;

  case KEY_F5:
    // mdi mode
    sendMdi();
    break;

  case KEY_F6:
    sendTaskPlanInit();
    break;

  case KEY_F7:
    // mist toggle
    if (emcStatus->io.coolant.mist) {
      sendMistOff();
    }
    else {
      sendMistOn();
    }
    break;

  case KEY_F8:
    // flood toggle
    if (emcStatus->io.coolant.flood) {
      sendFloodOff();
    }
    else {
      sendFloodOn();
    }
    break;

  case KEY_F9:
    // spindle fwd/off
    if (emcStatus->io.spindle.direction == 0) {
      // it's off, so turn forward
      sendSpindleForward();
    }
    else
      {
        // it's not off, so turn off
        sendSpindleOff();
      }
    break;

  case KEY_F10:
    // spindle rev/off
    if (emcStatus->io.spindle.direction == 0) {
      // it's off, so turn reverse
      sendSpindleReverse();
    }
    else
      {
        // it's not off, so turn off
        sendSpindleOff();
      }
    break;

  case KEY_F11:
    // spindle decrease
    if (emcStatus->io.spindle.direction != 0) {
      sendSpindleDecrease();
    }
    break;

  case KEY_F12:
    // spindle increase
    if (emcStatus->io.spindle.direction != 0) {
      sendSpindleIncrease();
    }
    break;

  case KEY_RIGHT:
    switch (state) {
    case XKEY_EVENT_STATE_ALT:
      activeJoint = 3;
      break;
    default:
      activeJoint = 0;
      break;
    }
    if (jogIncrement > 0.0) {
      sendJogIncr(activeJoint, jogSpeed, jogIncrement);
    }
    else {
      sendJogCont(activeJoint, jogSpeed);
    }
    break;

  case KEY_LEFT:
    switch (state) {
    case XKEY_EVENT_STATE_ALT:
      activeJoint = 3;
      break;
    default:
      activeJoint = 0;
      break;
    }
    if (jogIncrement > 0.0) {
      sendJogIncr(activeJoint, -jogSpeed, jogIncrement);
    }
    else {
      sendJogCont(activeJoint, -jogSpeed);
    }
    break;

  case KEY_UP:
    switch (state) {
    case XKEY_EVENT_STATE_ALT:
      activeJoint = 4;
      break;
    default:
      activeJoint = 1;
      break;
    }
    if (jogIncrement > 0.0) {
      sendJogIncr(activeJoint, jogSpeed, jogIncrement);
    }
    else {
      sendJogCont(activeJoint, jogSpeed);
    }
    break;

  case KEY_DOWN:
    switch (state) {
    case XKEY_EVENT_STATE_ALT:
      activeJoint = 4;
      break;
    default:
      activeJoint = 1;
      break;
    }
    if (jogIncrement > 0.0) {
      sendJogIncr(activeJoint, -jogSpeed, jogIncrement);
    }
    else {
      sendJogCont(activeJoint, -jogSpeed);
    }
    break;

  case KEY_PGUP:
    switch (state) {
    case XKEY_EVENT_STATE_ALT:
      activeJoint = 5;
      break;
    default:
      activeJoint = 2;
      break;
    }
    if (jogIncrement > 0.0) {
      sendJogIncr(activeJoint, jogSpeed, jogIncrement);
    }
    else {
      sendJogCont(activeJoint, jogSpeed);
    }
    break;

  case KEY_PGDN:
    switch (state) {
    case XKEY_EVENT_STATE_ALT:
      activeJoint = 5;
      break;
    default:
      activeJoint = 2;
      break;
    }
    if (jogIncrement > 0.0) {
      sendJogIncr(activeJoint, -jogSpeed, jogIncrement);
    }
    else {
      sendJogCont(activeJoint, -jogSpeed);
    }
    break;

  case KEY_Q:
    if (emcStatus->task.mode == EMC_TASK_MODE_MANUAL) {
      if (numJoints <= 0)
        break; // joint out of range
      activeJoint = 0;
      if (jogIncrement > 0.0) {
        sendJogIncr(activeJoint, jogSpeed, jogIncrement);
      }
      else {
        sendJogCont(activeJoint, jogSpeed);
      }
    }
    break;

  case KEY_W:
    if (emcStatus->task.mode == EMC_TASK_MODE_MANUAL) {
      if (numJoints <= 1)
        break; // joint out of range
      activeJoint = 1;
      if (jogIncrement > 0.0) {
        sendJogIncr(activeJoint, jogSpeed, jogIncrement);
      }
      else {
        sendJogCont(activeJoint, jogSpeed);
      }
    }
    break;

  case KEY_E:
    if (emcStatus->task.mode == EMC_TASK_MODE_MANUAL) {
      if (numJoints <= 2)
        break; // joint out of range
      activeJoint = 2;
      if (jogIncrement > 0.0) {
        sendJogIncr(activeJoint, jogSpeed, jogIncrement);
      }
      else {
        sendJogCont(activeJoint, jogSpeed);
      }
    }
    else {
      dialogPopup(NULL, fileEditShell, NULL);
      // trap window kill
      XSetWMProtocols(XtDisplay(topLevel), XtWindow(fileEditShell), &killAtom, 1);
    }
    break;

  case KEY_R:
    if (emcStatus->task.mode == EMC_TASK_MODE_MANUAL) {
      if (numJoints <= 3)
        break; // joint out of range
      activeJoint = 3;
      if (jogIncrement > 0.0) {
        sendJogIncr(activeJoint, jogSpeed, jogIncrement);
      }
      else {
        sendJogCont(activeJoint, jogSpeed);
      }
    }
    else {
      sendProgramRun(programStartLine);
    }
    break;

  case KEY_T:
    if (emcStatus->task.mode == EMC_TASK_MODE_MANUAL) {
      if (numJoints <= 4)
        break; // joint out of range
      activeJoint = 4;
      if (jogIncrement > 0.0) {
        sendJogIncr(activeJoint, jogSpeed, jogIncrement);
      }
      else {
        sendJogCont(activeJoint, jogSpeed);
      }
    }
    else {
      switch (state) {
      case XKEY_EVENT_STATE_ALT:
        sprintf(string, "%d", emcStatus->io.tool.toolInSpindle);
        XtVaSetValues(toolSetOffsetTool, XtNstring, string, NULL);
        sprintf(string, "%f",
                emcStatus->motion.traj.actualPosition.tran.z -
                emcStatus->task.origin.tran.z);
        XtVaSetValues(toolSetOffsetLength, XtNstring, string, NULL);
        XtVaSetValues(toolSetOffsetDiameter, XtNstring, "0.0", NULL);
        dialogPopup(NULL, toolSetOffsetShell, NULL);
        // trap window kill
        XSetWMProtocols(XtDisplay(topLevel), XtWindow(toolSetOffsetShell), &killAtom, 1);
        break;
      }
    }
    break;

  case KEY_Y:
    if (emcStatus->task.mode == EMC_TASK_MODE_MANUAL) {
      if (numJoints <= 5)
        break; // joint out of range
      activeJoint = 5;
      if (jogIncrement > 0.0) {
        sendJogIncr(activeJoint, jogSpeed, jogIncrement);
      }
      else {
        sendJogCont(activeJoint, jogSpeed);
      }
    }
    break;

  case KEY_X:
    break;

  case KEY_Z:
    break;

  case KEY_HOME:
    sendHome(activeJoint);
    break;

  case KEY_END:
    dialogPopup(NULL, fileQuitShell, NULL);
    // trap window kill
    XSetWMProtocols(XtDisplay(topLevel), XtWindow(fileQuitShell), &killAtom, 1);
    break;

  case KEY_1:
      sendFeedOverride(0.1);
    break;

  case KEY_2:
    switch (state) {
    case XKEY_EVENT_STATE_NONE:
      sendFeedOverride(0.2);
      break;

    case XKEY_EVENT_STATE_SHIFT:
      // @
      if (posDisplay == POS_DISPLAY_CMD) {
        posDisplay = POS_DISPLAY_ACT;
      }
      else {
        posDisplay = POS_DISPLAY_CMD;
      }
      break;

    }
    break;

  case KEY_3:
    switch (state) {
    case XKEY_EVENT_STATE_NONE:
      sendFeedOverride(0.3);
      break;

    case XKEY_EVENT_STATE_SHIFT:
      if (coords == COORD_RELATIVE) {
        coords = COORD_MACHINE;
      }
      else {
        coords = COORD_RELATIVE;
      }
      break;

    }
    break;

  case KEY_4:
    switch (state) {
    case XKEY_EVENT_STATE_NONE:
      sendFeedOverride(0.4);
      break;

    case XKEY_EVENT_STATE_SHIFT:
      EMC_TRAJ_SET_TELEOP_ENABLE emc_traj_set_teleop_enable;
      if (posFrame == POS_FRAME_WORLD) {
        posFrame = POS_FRAME_JOINT;
        emc_traj_set_teleop_enable.enable = 0;
      }
      else {
        posFrame = POS_FRAME_WORLD;
        emc_traj_set_teleop_enable.enable = 1;
      }
      emc_traj_set_teleop_enable.serial_number = ++emcCommandSerialNumber;
      emcCommandBuffer->write(&emc_traj_set_teleop_enable);
      break;

    }
    break;

  case KEY_5:
    sendFeedOverride(0.5);
    break;

  case KEY_6:
    sendFeedOverride(0.6);
    break;

  case KEY_7:
    sendFeedOverride(0.7);
    break;

  case KEY_8:
    sendFeedOverride(0.8);
    break;

  case KEY_9:
    sendFeedOverride(0.9);
    break;

  case KEY_0:
    sendFeedOverride(1.0);
    break;

  case KEY_O:
    dialogPopup(NULL, fileOpenShell, NULL);
    // trap window kill
    XSetWMProtocols(XtDisplay(topLevel), XtWindow(fileOpenShell), &killAtom, 1);
    break;

  case KEY_P:
    switch (state) {
    case XKEY_EVENT_STATE_NONE:
    case XKEY_EVENT_STATE_SHIFT:
      sendProgramPause();
      break;

    case XKEY_EVENT_STATE_ALT:
      sendLogStop();
      break;

    case XKEY_EVENT_STATE_CONTROL:
      plotLog(saveLogFile, saveLogType);
      break;
    }
    break;

  case KEY_V:
    programStartLine = -1;
    sendProgramRun(programStartLine);
    break;

  case KEY_A:
    if (emcStatus->task.mode == EMC_TASK_MODE_MANUAL) {
      if (numJoints <= 0)
        break; // joint out of range
      activeJoint = 0;
      if (jogIncrement > 0.0) {
        sendJogIncr(activeJoint, -jogSpeed, jogIncrement);
      }
      else {
        sendJogCont(activeJoint, -jogSpeed);
      }
    }
    else {
      sendProgramStep();
    }
    break;

  case KEY_S:
    if (emcStatus->task.mode == EMC_TASK_MODE_MANUAL) {
      if (numJoints <= 1)
        break; // joint out of range
      activeJoint = 1;
      if (jogIncrement > 0.0) {
        sendJogIncr(activeJoint, -jogSpeed, jogIncrement);
      }
      else {
        sendJogCont(activeJoint, -jogSpeed);
      }
    }
    else {
      switch (state) {
      case XKEY_EVENT_STATE_NONE:
      case XKEY_EVENT_STATE_SHIFT:
        sendProgramResume();
        break;

      case XKEY_EVENT_STATE_ALT:
        sendLogStart();
        break;
      }
    }
    break;

  case KEY_D:
    if (emcStatus->task.mode == EMC_TASK_MODE_MANUAL) {
      if (numJoints <= 2)
        break; // joint out of range
      activeJoint = 2;
      if (jogIncrement > 0.0) {
        sendJogIncr(activeJoint, -jogSpeed, jogIncrement);
      }
      else {
        sendJogCont(activeJoint, -jogSpeed);
      }
    }
    break;

  case KEY_F:
    if (emcStatus->task.mode == EMC_TASK_MODE_MANUAL) {
      if (numJoints <= 3)
        break; // joint out of range
      activeJoint = 3;
      if (jogIncrement > 0.0) {
        sendJogIncr(activeJoint, -jogSpeed, jogIncrement);
      }
      else {
        sendJogCont(activeJoint, -jogSpeed);
      }
    }
    else {
      switch (state) {
      case XKEY_EVENT_STATE_ALT:
        sendLogClose();
        break;
      }
    }
    break;

  case KEY_G:
    if (emcStatus->task.mode == EMC_TASK_MODE_MANUAL) {
      if (numJoints <= 4)
        break; // joint out of range
      activeJoint = 4;
      if (jogIncrement > 0.0) {
        sendJogIncr(activeJoint, -jogSpeed, jogIncrement);
      }
      else {
        sendJogCont(activeJoint, -jogSpeed);
      }
    }
    break;

  case KEY_H:
    if (emcStatus->task.mode == EMC_TASK_MODE_MANUAL) {
      if (numJoints <= 5)
        break; // joint out of range
      activeJoint = 5;
      if (jogIncrement > 0.0) {
        sendJogIncr(activeJoint, -jogSpeed, jogIncrement);
      }
      else {
        sendJogCont(activeJoint, -jogSpeed);
      }
    }
    break;

  case KEY_B:
    switch (state) {
    case XKEY_EVENT_STATE_NONE:
      sendBrakeRelease();
      break;

    case XKEY_EVENT_STATE_SHIFT:
      sendBrakeEngage();
      break;

    }
    break;

  case KEY_I:
    // check for entering from continuous jog, and restore saved increment
    if (jogIncrement <= 0.0) {
      jogIncrement = saveJogIncrement;
    }
    // go from 0.1000 to 0.0100
    else if (jogIncrement > 0.0500) {
      jogIncrement = 0.0100;
    }
    // go from 0.0100 to 0.0010
    else if (jogIncrement > 0.0050) {
      jogIncrement = 0.0010;
    }
    // go from 0.0010 to 0.0001
    else if (jogIncrement > 0.0005) {
      jogIncrement = 0.0001;
    }
    // go from 0.0001 to 0.1000
    else {
      jogIncrement = 0.1000;
    }
    saveJogIncrement = jogIncrement;
    break;

  case KEY_C:
    // change to continuous jog, but save increment for restoring
    jogIncrement = 0.0;
    break;

  case KEY_COMMA:
    // change it once here and redraw
    if (--jogSpeed <= 0) {
      jogSpeed = 1;
    }
    sprintf(string, "%d", jogSpeed);
    setLabel(jogSpeedLabel, string);
    redraw = 1;

    // set jogSpeedChange so that timer callback will continue to change
    // until button up clears it
    jogSpeedChange = -1;
    break;

  case KEY_PERIOD:
    // change it once here and redraw
    if (++jogSpeed > maxJogSpeed) {
      jogSpeed = maxJogSpeed;
    }
    sprintf(string, "%d", jogSpeed);
    setLabel(jogSpeedLabel, string);
    redraw = 1;

    // set jogSpeedChange so that timer callback will continue to change
    // until button up clears it
    jogSpeedChange = +1;
    break;

  default:
    printf("key press %d %d\n", state, keycode);
  }
}

static void keyReleaseAction(unsigned int state, unsigned int keycode)
{
  switch (keycode) {

  case KEY_LEFT:
  case KEY_RIGHT:
  case KEY_UP:
  case KEY_DOWN:
  case KEY_PGUP:
  case KEY_PGDN:
  case KEY_Q:
  case KEY_W:
  case KEY_E:
  case KEY_R:
  case KEY_T:
  case KEY_Y:
  case KEY_A:
  case KEY_S:
  case KEY_D:
  case KEY_F:
  case KEY_G:
  case KEY_H:
    if (jogIncrement <= 0.0) {
      // only stop it if it's continuous jogging
      sendJogStop(axisJogging);
    }
    break;

  case KEY_F11:
  case KEY_F12:
    sendSpindleConstant();
    break;

  case KEY_COMMA:
  case KEY_PERIOD:
    jogSpeedChange = 0;
    break;

  default:
    printf("key release %d %d\n", state, keycode);
    break;
  }
}

static void keyAction(Widget w,
                      XEvent *ev,
                      String *params,
                      Cardinal *numParams)
{
  if (ev->type == XEVENT_TYPE_XKEY_KEY_PRESS_EVENT) {
    keyPressKeycode = ev->xkey.keycode;
    keyPressState = ev->xkey.state;

    if (keyReleaseOut) {
      if (keyPressKeycode == keyReleaseKeycode &&
          keyPressState == keyReleaseState) {
        // the press matched the release before the timeout, so it's
        // a key repeat on this key and we won't signal a key release
        keyReleaseOut = 0;
      }
      else {
        // it's a key press on a different key than the previous release,
        // so allow the release to go through by leaving keyReleaseOut set
      }
    }
    else {
      keyPressAction(ev->xkey.state, ev->xkey.keycode);
    }
  }
  else if (ev->type == XEVENT_TYPE_XKEY_KEY_RELEASE_EVENT) {
    keyReleaseKeycode = ev->xkey.keycode;
    keyReleaseState = ev->xkey.state;
    keyReleaseTime = etime();
    keyReleaseOut = 1;
  }

  return;
}

static String fileMenuEntryNames[] = {
  "[O]    Open...",
  "[E]     Edit...",
  "[F6]   Reset",
  "-",
  "[End] Quit",
  NULL
};

static String viewMenuEntryNames[] = {
  "Tools...",
  "Offsets and Variables...",
  "Diagnostics...",
  NULL
};

static String settingsMenuEntryNames[] = {
  "[#] Relative Values",
  "[#] Machine Values",
  "-",
  "[@] Actual Position",
  "[@] Commanded Position",
  "-",
  "[$] World Frame",
  "[$] Joint Frame",
  "-",
  "Calibration...",
  "Logging...",
  NULL
};

static String helpMenuEntryNames[] = {
  "Help...",
  "-",
  "About...",
  NULL
};

static String stateMenuEntryNames[] = {
  "[F1] Estop on",
  "[F1] Estop off",
  "-",
  "[F2] Machine on",
  "[F2] Machine off",
  NULL
};

static String modeMenuEntryNames[] = {
  "[F3] Manual",
  "[F4] Auto",
  "[F5] MDI",
  NULL
};

static String mistMenuEntryNames[] = {
  "[F7] Mist on",
  "[F7] Mist off",
  NULL
};

static String floodMenuEntryNames[] = {
  "[F8] Flood on",
  "[F8] Flood off",
  NULL
};

static String spindleMenuEntryNames[] = {
  "[F9]        Spindle forward",
  "[F10]      Spindle reverse",
  "[F9/F10] Spindle off",
  NULL
};

static String brakeMenuEntryNames[] = {
  "[B] Brake on",
  "[b] Brake off",
  NULL
};

static String jogIncrementMenuEntryNames[] = {
  "0.0001",
  "0.0010",
  "0.0100",
  "0.1000",
  "-",
  "continuous",
  NULL
};

static String loggingTypeMenuEntryNames[] = {
  "Axis Position",
  "All Input Positions",
  "All Output Positions",
  "Axis Velocity",
  "All Following Errors",
  "All Trajectory Points",
  "All Trajectory Vels",
  "All Trajectory Accels",
  NULL
};

static void fileMenuSelect(Widget w, XtPointer client_data, XtPointer call_data)
{
  switch ((int) client_data) {
  case 0:                       // Open...
    dialogPopup(NULL, fileOpenShell, NULL);
    // trap window kill
    XSetWMProtocols(XtDisplay(topLevel), XtWindow(fileOpenShell), &killAtom, 1);
    break;

  case 1:                       // Edit...
    dialogPopup(NULL, fileEditShell, NULL);
    // trap window kill
    XSetWMProtocols(XtDisplay(topLevel), XtWindow(fileEditShell), &killAtom, 1);
    break;

  case 2:                       // Reset
    sendTaskPlanInit();
    break;

    // case 3 is separator

  case 4:                       // Quit
    dialogPopup(NULL, fileQuitShell, NULL);
    // trap window kill
    XSetWMProtocols(XtDisplay(topLevel), XtWindow(fileQuitShell), &killAtom, 1);
    break;

  default:
    break;
  }
}

static void viewMenuSelect(Widget w, XtPointer client_data, XtPointer call_data)
{
  char string[256];

  switch ((int) client_data) {
  case 0:                       // Tools
    createToolTableShell();
    dialogPopup(NULL, toolTableShell, NULL);
    // trap window kill
    XSetWMProtocols(XtDisplay(topLevel), XtWindow(toolTableShell), &killAtom, 1);
    break;

  case 1:                       // Variables
    createVarFileShell();
    dialogPopup(NULL, varFileShell, NULL);
    // trap window kill
    XSetWMProtocols(XtDisplay(topLevel), XtWindow(varFileShell), &killAtom, 1);
    break;

  case 2:                       // Diagnostics
    sprintf(string, "Axis %d Diagnostics", activeJoint);
    setLabel(diagnosticsLabel, string);
    dialogPopup(NULL, diagnosticsShell, NULL);
    diagnosticsIsPopped = 1;
    // trap window kill
    XSetWMProtocols(XtDisplay(topLevel), XtWindow(diagnosticsShell), &killAtom, 1);
    break;

  default:
    break;
  }
}

// calibration dialog

static Widget calibShell = NULL;
static Widget calibForm = NULL;
static Widget calibLabel = NULL;
static Widget calibCycleTimeLabel = NULL;
static Widget calibCycleTime = NULL;
static Widget calibPGainLabel = NULL;
static Widget calibPGain = NULL;
static Widget calibIGainLabel = NULL;
static Widget calibIGain = NULL;
static Widget calibDGainLabel = NULL;
static Widget calibDGain = NULL;
static Widget calibFF0GainLabel = NULL;
static Widget calibFF0Gain = NULL;
static Widget calibFF1GainLabel = NULL;
static Widget calibFF1Gain = NULL;
static Widget calibFF2GainLabel = NULL;
static Widget calibFF2Gain = NULL;
static Widget calibBacklashLabel = NULL;
static Widget calibBacklash = NULL;
static Widget calibBiasLabel = NULL;
static Widget calibBias = NULL;
static Widget calibMaxErrorLabel = NULL;
static Widget calibMaxError = NULL;
static Widget calibOutputScaleLabel = NULL;
static Widget calibOutputScale = NULL;
static Widget calibOutputOffsetLabel = NULL;
static Widget calibOutputOffset = NULL;
static Widget calibFerrorLabel = NULL;
static Widget calibFerror = NULL;
static Widget calibDone = NULL;
static Widget calibCancel = NULL;

static int calibReturnIsDone = 1;
static Pixel calibFormBorderColor;
static void calibDoDone(int done);
static void calibDoneCB(Widget w, XtPointer client_data, XtPointer call_data);
static void calibCancelCB(Widget w, XtPointer client_data, XtPointer call_data);
static void calibReturnAction(Widget w, XEvent *event, String *params, Cardinal *num_params);
static void calibTabAction(Widget w, XEvent *event, String *params, Cardinal *num_params);

static void calibDoDone(int done)
{
  int iserror = 0;
  String str1, str2, str3, str4, str5, str6, str7, str8, str9, str10, str11, str12, str13;
  double cycleTime;
  double p;
  double i;
  double d;
  double ff0;
  double ff1;
  double ff2;
  double bias;
  double backlash;
  double maxError;
  double outputScale;
  double outputOffset;
  double ferror;

  if (done) {
    // get current values for rest of gains
    cycleTime = emcStatus->motion.axis[activeJoint].cycleTime;
    p = emcStatus->motion.axis[activeJoint].p;
    i = emcStatus->motion.axis[activeJoint].i;
    d = emcStatus->motion.axis[activeJoint].d;
    ff0 = emcStatus->motion.axis[activeJoint].ff0;
    ff1 = emcStatus->motion.axis[activeJoint].ff1;
    ff2 = emcStatus->motion.axis[activeJoint].ff2;
    backlash = emcStatus->motion.axis[activeJoint].backlash;
    bias = emcStatus->motion.axis[activeJoint].bias;
    maxError = emcStatus->motion.axis[activeJoint].maxError;
    outputScale = emcStatus->motion.axis[activeJoint].outputScale;
    outputOffset = emcStatus->motion.axis[activeJoint].outputOffset;

    XtVaGetValues(calibCycleTime, XtNstring, &str1, NULL);
    XtVaGetValues(calibPGain, XtNstring, &str2, NULL);
    XtVaGetValues(calibIGain, XtNstring, &str3, NULL);
    XtVaGetValues(calibDGain, XtNstring, &str4, NULL);
    XtVaGetValues(calibFF0Gain, XtNstring, &str5, NULL);
    XtVaGetValues(calibFF1Gain, XtNstring, &str6, NULL);
    XtVaGetValues(calibFF2Gain, XtNstring, &str7, NULL);
    XtVaGetValues(calibBacklash, XtNstring, &str8, NULL);
    XtVaGetValues(calibBias, XtNstring, &str9, NULL);
    XtVaGetValues(calibMaxError, XtNstring, &str10, NULL);
    XtVaGetValues(calibOutputScale, XtNstring, &str11, NULL);
    XtVaGetValues(calibOutputOffset, XtNstring, &str12, NULL);
    XtVaGetValues(calibFerror, XtNstring, &str13, NULL);

    if (1 == sscanf(str1, "%lf", &cycleTime) &&
        1 == sscanf(str2, "%lf", &p) &&
        1 == sscanf(str3, "%lf", &i) &&
        1 == sscanf(str4, "%lf", &d) &&
        1 == sscanf(str5, "%lf", &ff0) &&
        1 == sscanf(str6, "%lf", &ff1) &&
        1 == sscanf(str7, "%lf", &ff2) &&
        1 == sscanf(str8, "%lf", &backlash) &&
        1 == sscanf(str9, "%lf", &bias) &&
        1 == sscanf(str10, "%lf", &maxError) &&
        1 == sscanf(str11, "%lf", &outputScale) &&
        1 == sscanf(str12, "%lf", &outputOffset) &&
        1 == sscanf(str13, "%lf", &ferror)) {
      sendAxisCycleTime(activeJoint, cycleTime);
      emcCommandWaitDone(emcCommandSerialNumber);
      sendAxisSetGains(activeJoint, p, i, d, ff0, ff1, ff2, backlash, bias, maxError);
      emcCommandWaitDone(emcCommandSerialNumber);
      sendAxisSetOutputScale(activeJoint, outputScale, outputOffset);
      emcCommandWaitDone(emcCommandSerialNumber);
      sendAxisSetFerror(activeJoint, ferror);
    }
    else {
      iserror = 1;
    }
  }

  calibReturnIsDone = 1;
  XtPopdown(calibShell);

  if (iserror) {
    popupError("Bad gain values");
  }
}

static void calibDoneCB(Widget w, XtPointer client_data, XtPointer call_data)
{
  calibDoDone(1);
}

static void calibCancelCB(Widget w, XtPointer client_data, XtPointer call_data)
{
  calibDoDone(0);
}

static void calibReturnAction(Widget w, XEvent *event, String *params, Cardinal *num_params)
{
  if (calibReturnIsDone) {
    calibDoDone(1);
  }
  else {
    calibDoDone(0);
  }
}

static void calibTabAction(Widget w, XEvent *event, String *params, Cardinal *num_params)
{
  if (calibReturnIsDone) {
    setBorderColor(calibDone, calibFormBorderColor);
    setBorderColor(calibCancel, pixelRed);
    calibReturnIsDone = 0;
  }
  else {
    setBorderColor(calibDone, pixelRed);
    setBorderColor(calibCancel, calibFormBorderColor);
    calibReturnIsDone = 1;
  }
}

// logging dialog

static Widget loggingShell = NULL;
static Widget loggingForm = NULL;
static Widget loggingLabel = NULL;
static Widget loggingFileLabel = NULL;
static Widget loggingFile = NULL;
static Widget loggingTypeLabel = NULL;
static Widget loggingTypeMenu = NULL;
static Widget loggingSizeLabel = NULL;
static Widget loggingSize = NULL;
static Widget loggingSkipLabel = NULL;
static Widget loggingSkip = NULL;
static Widget loggingStart = NULL;
static Widget loggingStop = NULL;
static Widget loggingSave = NULL;
static Widget loggingPlot = NULL;

static Widget loggingDone = NULL;
static Widget loggingCancel = NULL;

static int loggingReturnIsDone = 1;
static Pixel loggingFormBorderColor;
static int loggingGetStrings();
static void loggingDoDone(int done);
static void loggingStartCB(Widget w, XtPointer client_data, XtPointer call_data);
static void loggingStopCB(Widget w, XtPointer client_data, XtPointer call_data);
static void loggingSaveCB(Widget w, XtPointer client_data, XtPointer call_data);
static void loggingPlotCB(Widget w, XtPointer client_data, XtPointer call_data);
static void loggingDoneCB(Widget w, XtPointer client_data, XtPointer call_data);
static void loggingCancelCB(Widget w, XtPointer client_data, XtPointer call_data);
static void loggingReturnAction(Widget w, XEvent *event, String *params, Cardinal *num_params);
static void loggingTabAction(Widget w, XEvent *event, String *params, Cardinal *num_params);

static int loggingGetStrings()
{
  int iserror = 0;
  String str1, str2, str3;

  XtVaGetValues(loggingFile, XtNstring, &str1, NULL);
  XtVaGetValues(loggingSize, XtNstring, &str2, NULL);
  XtVaGetValues(loggingSkip, XtNstring, &str3, NULL);

  strcpy(saveLogFile, str1);
  if (1 == sscanf(str2, "%d", &saveLogSize) &&
      1 == sscanf(str3, "%d", &saveLogSkip)) {
    iserror = 0;
  }
  else {
    iserror = 1;
  }

  return iserror;
}

static void loggingDoDone(int done)
{
  int retval;

  if (done) {
  retval = loggingGetStrings();
  }

  loggingReturnIsDone = 1;
  XtPopdown(loggingShell);

  if (done &&
      0 != retval) {
    popupError("Bad log values");
  }
}

static void loggingStartCB(Widget w, XtPointer client_data, XtPointer call_data)
{
  int retval;

  retval = loggingGetStrings();

  if (0 != retval) {
    popupError("Bad log values");
  }
  else {
    sendLogStart();
  }
}

static void loggingStopCB(Widget w, XtPointer client_data, XtPointer call_data)
{
  sendLogStop();
}

static void loggingSaveCB(Widget w, XtPointer client_data, XtPointer call_data)
{
  sendLogClose();
}

static void loggingPlotCB(Widget w, XtPointer client_data, XtPointer call_data)
{
  plotLog(saveLogFile, saveLogType);
}

static void loggingDoneCB(Widget w, XtPointer client_data, XtPointer call_data)
{
  loggingDoDone(1);
}

static void loggingCancelCB(Widget w, XtPointer client_data, XtPointer call_data)
{
  loggingDoDone(0);
}

static void loggingReturnAction(Widget w, XEvent *event, String *params, Cardinal *num_params)
{
  if (loggingReturnIsDone) {
    loggingDoDone(1);
  }
  else {
    loggingDoDone(0);
  }
}

static void loggingTabAction(Widget w, XEvent *event, String *params, Cardinal *num_params)
{
  if (loggingReturnIsDone) {
    setBorderColor(loggingDone, loggingFormBorderColor);
    setBorderColor(loggingCancel, pixelRed);
    loggingReturnIsDone = 0;
  }
  else {
    setBorderColor(loggingDone, pixelRed);
    setBorderColor(loggingCancel, loggingFormBorderColor);
    loggingReturnIsDone = 1;
  }
}

// menu select functions

static void settingsMenuSelect(Widget w, XtPointer client_data, XtPointer call_data)
{
  char string[256];             // FIXME-- hardcoded value

  switch ((int) client_data) {
  case 0:                       // Relative
    coords = COORD_RELATIVE;
    break;

  case 1:                       // Machine
    coords = COORD_MACHINE;
    break;

    // case 2 is separator

  case 3:                       // Actual
    posDisplay = POS_DISPLAY_ACT;
    break;

  case 4:                       // Commanded
    posDisplay = POS_DISPLAY_CMD;
    break;

    // case 5 is separator

  case 6:                       // World
    posFrame = POS_FRAME_WORLD;
    break;

  case 7:                       // Joint
    posFrame = POS_FRAME_JOINT;
    break;

    // case 8 is separator

  case 9:                       // Calibration...

    sprintf(string, "Axis %d Calibration", activeJoint);
    XtVaSetValues(calibLabel, XtNlabel, string, NULL);

    sprintf(string, "%f", emcStatus->motion.axis[activeJoint].cycleTime);
    XtVaSetValues(calibCycleTime, XtNstring, string, NULL);

    sprintf(string, "%f", emcStatus->motion.axis[activeJoint].p);
    XtVaSetValues(calibPGain, XtNstring, string, NULL);
    sprintf(string, "%f", emcStatus->motion.axis[activeJoint].i);
    XtVaSetValues(calibIGain, XtNstring, string, NULL);
    sprintf(string, "%f", emcStatus->motion.axis[activeJoint].d);
    XtVaSetValues(calibDGain, XtNstring, string, NULL);

    sprintf(string, "%f", emcStatus->motion.axis[activeJoint].ff0);
    XtVaSetValues(calibFF0Gain, XtNstring, string, NULL);
    sprintf(string, "%f", emcStatus->motion.axis[activeJoint].ff1);
    XtVaSetValues(calibFF1Gain, XtNstring, string, NULL);
    sprintf(string, "%f", emcStatus->motion.axis[activeJoint].ff2);
    XtVaSetValues(calibFF2Gain, XtNstring, string, NULL);

    sprintf(string, "%f", emcStatus->motion.axis[activeJoint].backlash);
    XtVaSetValues(calibBacklash, XtNstring, string, NULL);
    sprintf(string, "%f", emcStatus->motion.axis[activeJoint].bias);
    XtVaSetValues(calibBias, XtNstring, string, NULL);
    sprintf(string, "%f", emcStatus->motion.axis[activeJoint].maxError);
    XtVaSetValues(calibMaxError, XtNstring, string, NULL);

    sprintf(string, "%f", emcStatus->motion.axis[activeJoint].outputScale);
    XtVaSetValues(calibOutputScale, XtNstring, string, NULL);
    sprintf(string, "%f", emcStatus->motion.axis[activeJoint].outputOffset);
    XtVaSetValues(calibOutputOffset, XtNstring, string, NULL);

    sprintf(string, "%f", emcStatus->motion.axis[activeJoint].maxFerror);
    XtVaSetValues(calibFerror, XtNstring, string, NULL);

    dialogPopup(NULL, calibShell, NULL);
    // trap window kill
    XSetWMProtocols(XtDisplay(topLevel), XtWindow(calibShell), &killAtom, 1);
    break;

  case 10:                      // Logging...
    XtVaSetValues(loggingFile, XtNstring, saveLogFile, NULL);
    sprintf(string,
            saveLogType == EMC_LOG_TYPE_AXIS_POS ?    "Axis Position" :
            saveLogType == EMC_LOG_TYPE_AXES_INPOS ?  "All Input Positions" :
            saveLogType == EMC_LOG_TYPE_AXES_OUTPOS ? "All Output Positions" :
            saveLogType == EMC_LOG_TYPE_AXIS_VEL ?    "Axis Velocity" :
            saveLogType == EMC_LOG_TYPE_AXES_FERROR ? "All Following Errors" :
            saveLogType == EMC_LOG_TYPE_TRAJ_POS ? "All Trajectory Points" :
            saveLogType == EMC_LOG_TYPE_TRAJ_VEL ? "All Trajectory Vels" :
            saveLogType == EMC_LOG_TYPE_TRAJ_ACC ? "All Trajectory Accels" :
            "(unknown)");
    XtVaSetValues(loggingTypeMenu, XtNlabel, string, NULL);
    sprintf(string, "%d", saveLogSize);
    XtVaSetValues(loggingSize, XtNstring, string, NULL);
    sprintf(string, "%d", saveLogSkip);
    XtVaSetValues(loggingSkip, XtNstring, string, NULL);

    dialogPopup(NULL, loggingShell, NULL);
    // trap window kill
    XSetWMProtocols(XtDisplay(topLevel), XtWindow(loggingShell), &killAtom, 1);
    break;

  default:
    break;
  }
}

static void helpMenuSelect(Widget w, XtPointer client_data, XtPointer call_data)
{
  switch ((int) client_data) {
  case 0:                       // Help...
    dialogPopup(w, helpXemcShell, NULL);
    // trap window kill
    XSetWMProtocols(XtDisplay(topLevel), XtWindow(helpXemcShell), &killAtom, 1);
    break;

    // case 1 is separator

  case 2:                       // About...
    dialogPopup(NULL, helpAboutShell, NULL);
    XSetWMProtocols(XtDisplay(topLevel), XtWindow(helpAboutShell), &killAtom, 1);
    break;

  default:
    break;
  }
}

static void stateMenuSelect(Widget w, XtPointer client_data, XtPointer call_data)
{
  switch ((int) client_data) {
  case 0:
    sendEstop();
    break;

  case 1:
    sendEstopReset();
    break;

    // case 2 is separator

  case 3:
    sendMachineOn();
    break;

  case 4:
    sendMachineOff();
    break;

  default:
    break;
  }
}

static void modeMenuSelect(Widget w, XtPointer client_data, XtPointer call_data)
{
  switch ((int) client_data) {
  case 0:
    sendManual();
    break;

  case 1:
    sendAuto();
    break;

  case 2:
    sendMdi();
    break;

  default:
    break;
  }
}

static void mistMenuSelect(Widget w, XtPointer client_data, XtPointer call_data)
{
  switch ((int) client_data) {
  case 0:
    sendMistOn();
    break;

  case 1:
    sendMistOff();
    break;

  default:
    break;
  }
}

static void floodMenuSelect(Widget w, XtPointer client_data, XtPointer call_data)
{
  switch ((int) client_data) {
  case 0:
    sendFloodOn();
    break;

  case 1:
    sendFloodOff();
    break;

  default:
    break;
  }
}

static void spindleMenuSelect(Widget w, XtPointer client_data, XtPointer call_data)
{
  switch ((int) client_data) {
  case 0:
    sendSpindleForward();
    break;

  case 1:
    sendSpindleReverse();
    break;

  case 2:
    sendSpindleOff();
    break;

  default:
    break;
  }
}

static void brakeMenuSelect(Widget w, XtPointer client_data, XtPointer call_data)
{
  switch ((int) client_data) {
  case 0:
    sendBrakeEngage();
    break;

  case 1:
    sendBrakeRelease();
    break;

  default:
    break;
  }
}

static void jogIncrementMenuSelect(Widget w, XtPointer client_data, XtPointer call_data)
{
  switch ((int) client_data) {
  case 0:
    jogIncrement = 0.0001;
    break;

  case 1:
    jogIncrement = 0.0010;
    break;

  case 2:
    jogIncrement = 0.0100;
    break;

  case 3:
    jogIncrement = 0.1000;
    break;

    // case 4 is separator

  case 5:
    jogIncrement = -1.0;
    break;

  default:
    break;
  }
}

static void loggingTypeMenuSelect(Widget w, XtPointer client_data, XtPointer call_data)
{
  char string[256];

  switch ((int) client_data) {
  case 0:
    saveLogType = EMC_LOG_TYPE_AXIS_POS;
    break;

  case 1:
    saveLogType = EMC_LOG_TYPE_AXES_INPOS;
    break;

  case 2:
    saveLogType = EMC_LOG_TYPE_AXES_OUTPOS;
    break;

  case 3:
    saveLogType = EMC_LOG_TYPE_AXIS_VEL;
    break;

  case 4:
    saveLogType = EMC_LOG_TYPE_AXES_FERROR;
    break;

  case 5:
    saveLogType = EMC_LOG_TYPE_TRAJ_POS;
    break;

  case 6:
    saveLogType = EMC_LOG_TYPE_TRAJ_VEL;
    break;

  case 7:
    saveLogType = EMC_LOG_TYPE_TRAJ_ACC;
    break;

  default:
    break;
  }

  sprintf(string,
          saveLogType == EMC_LOG_TYPE_AXIS_POS ?    "Axis Position" :
          saveLogType == EMC_LOG_TYPE_AXES_INPOS ?  "All Input Positions" :
          saveLogType == EMC_LOG_TYPE_AXES_OUTPOS ? "All Output Positions" :
          saveLogType == EMC_LOG_TYPE_AXIS_VEL ?    "Axis Velocity" :
          saveLogType == EMC_LOG_TYPE_AXES_FERROR ? "All Following Errors" :
          saveLogType == EMC_LOG_TYPE_TRAJ_POS ? "All Trajectory Points" :
          saveLogType == EMC_LOG_TYPE_TRAJ_VEL ? "All Trajectory Vels" :
          saveLogType == EMC_LOG_TYPE_TRAJ_ACC ? "All Trajectory Accels" :
          "(unknown)");
  XtVaSetValues(loggingTypeMenu, XtNlabel, string, NULL);
}

// menu dimming

static void enableAuxMenus(Boolean torf)
{
  static Boolean auxMenusEnabled = True;

  if (auxMenusEnabled != torf) {
    XtSetSensitive(mistMenu, torf);
    XtSetSensitive(floodMenu, torf);
    XtSetSensitive(spindleMenu, torf);
    XtSetSensitive(brakeMenu, torf);
    auxMenusEnabled = torf;
  }
}

static void enableManualMenus(Boolean torf)
{
  static Boolean manualMenusEnabled = True;

  if (manualMenusEnabled != torf) {
    XtSetSensitive(jogMinusLabel, torf);
    XtSetSensitive(homeCommand, torf);
    XtSetSensitive(jogPlusLabel, torf);
    XtSetSensitive(programPauseCommand, torf);
    XtSetSensitive(programResumeCommand, torf);
    manualMenusEnabled = torf;
  }
}

static void enableAutoMenus(Boolean torf)
{
  static Boolean autoMenusEnabled = True;

  if (autoMenusEnabled != torf) {
    XtSetSensitive(programOpenCommand, torf);
    XtSetSensitive(programRunCommand, torf);
    XtSetSensitive(programPauseCommand, torf);
    XtSetSensitive(programResumeCommand, torf);
    XtSetSensitive(programStepCommand, torf);
    XtSetSensitive(programVerifyCommand, torf);
    autoMenusEnabled = torf;
  }
}

static void enableMdiMenus(Boolean torf)
{
  static Boolean mdiMenusEnabled = True;

  if (mdiMenusEnabled != torf) {
    //FIXME    XtSetSensitive(mdiFormText, torf);
    XtSetSensitive(programPauseCommand, torf);
    XtSetSensitive(programResumeCommand, torf);
    mdiMenusEnabled = torf;
  }

  if (torf) {
    /* set focus to mdi window */
    XtSetKeyboardFocus(topForm, mdiFormText);
  }
  else {
    XtSetKeyboardFocus(topForm, None);
  }
}

// saved old values, used to determine if redraw is necessary.
// Make them invalid so that everything is updated at startup, or
// at least make them the same as the initial labels.
static unsigned long int oldTaskHeartbeat =0;
static unsigned long int oldIoHeartbeat =0;
static unsigned long int oldMotionHeartbeat =0;
static double oldAxisFerror[XEMC_NUM_AXES]; // inited to invalid in main()
static int oldState = -1;
static int oldMode = -1;
static int oldMist = -1;
static int oldFlood = -1;
static int oldSpindleIncreasing = -1;
static int oldSpindleDirection = -2;
static int oldBrake = -1;
static int oldTool = -1;
static double oldToolOffset = DBL_MAX; // invalid val forces first print
static EmcPose oldOrigin ={ { DBL_MAX, DBL_MAX, DBL_MAX }, 
                         DBL_MAX, DBL_MAX, DBL_MAX };
static double newPosLabelValue[XEMC_NUM_AXES]; // inited to 0 in main
static double oldPosLabelValue[XEMC_NUM_AXES]; // inited to DBL_MAX in main()
static char posLabelWorld[XEMC_NUM_AXES] = {'X', 'Y', 'Z', 'R', 'P', 'W'};
static char posLabelJoint[XEMC_NUM_AXES] = {'1', '2', '3', '4', '5', '6'};
static int oldCoords = 0; // invalid val forces first print
static int oldPosDisplay = 0; // ditto
static int oldPosFrame = 0; // ditto
static double oldJogIncrement = -1.0; // invalid val forces first print
static Pixel posColor[XEMC_NUM_AXES]; // inited to invalid in main()
static int oldLogOpen = -1;
static int oldLogStarted = -1;
static int oldLogPoints = -1;
static char oldMdiCodes[256] = ""; // FIXME-- harcoded
static int oldProgramActiveLine = -1;
static char oldProgramString[256] = "";

/*
  mapPoseToLabels(EmcPose pose) takes the pose and sets the global floating
  point newPosLabelValue[] as a side effect. newPosLabelValue[] will be
  compared with the old one to inhibit redraws of the same value.
*/
static void mapPoseToLabels(EmcPose pose)
{
  int m;
  int p;


  // run through all 6 possible markers, pick out when there's a 1 and put
  // appropriate coordinate value in next posLabel slot
  for (m = 0, p = 0; m < 6; m++) {
    if (coordinateMark[m]) {
      if (m == 0)
        newPosLabelValue[p] = pose.tran.x;
      else if (m == 1)
        newPosLabelValue[p] = pose.tran.y;
      else if (m == 2)
        newPosLabelValue[p] = pose.tran.z;
      else if (m == 3)
        newPosLabelValue[p] = pose.a;
      else if (m == 4)
        newPosLabelValue[p] = pose.b;
      else if (m == 5)
        newPosLabelValue[p] = pose.c;
      p++;
    }
  }
}

void timeoutCB(XtPointer clientdata, XtIntervalId *id)
{
  double now;
  char string[256];             // FIXME-- hardcoded
  int t;
  unsigned char changedPosDisplayType = 0;
  unsigned char changedCoordType = 0;
  unsigned char changedPosFrameType = 0;
  int code;
  int programActiveLine;
  int programTopLine;
  char mdiCodes[256];           // FIXME-- hardcoded
  int axis;
  EmcPose offsetPose;

  // set the time
  now = etime();

  // read the EMC status
  if (0 != updateStatus()) {
    sprintf(error_string, "bad status");
  }

  // read the EMC errors
  if (0 != updateError()) {
    sprintf(error_string, "bad status");
  }

  // print any result stored by updateError() in error_string
  if (error_string[0] != 0) {
    popupError(error_string);
    error_string[0] = 0;
  }

  // handle key up events
  if (keyReleaseOut &&
      now - keyReleaseTime > 0.100) {
    // key up event has occurred
    keyReleaseOut = 0;
    keyReleaseAction(keyReleaseState, keyReleaseKeycode);
  }

  // handle button press repeats

  if (jogSpeedChange < 0) {
    if (--jogSpeed <= 0) {
      jogSpeed = 1;
    }
    sprintf(string, "%d", jogSpeed);
    setLabel(jogSpeedLabel, string);
    redraw = 1;
  }
  else if (jogSpeedChange > 0) {
    if (++jogSpeed > maxJogSpeed) {
      jogSpeed = maxJogSpeed;
    }
    sprintf(string, "%d", jogSpeed);
    setLabel(jogSpeedLabel, string);
    redraw = 1;
  }

  if (feedOverrideChange < 0) {
    if (--feedOverrideDelayCount < 0) {
      if ((feedOverride -= 10) < 0) {
        feedOverride = 0;
      }
      sprintf(string, "%3d", feedOverride);
      setLabel(feedOverrideLabel, string);
      feedOverrideDelayCount = FEED_OVERRIDE_DELAY_COUNT;

      redraw = 1;
    }
  }
  else if (feedOverrideChange > 0) {
    if (--feedOverrideDelayCount < 0) {
      if ((feedOverride += 10) > maxFeedOverride) {
        feedOverride = maxFeedOverride;
      }
      sprintf(string, "%3d", feedOverride);
      setLabel(feedOverrideLabel, string);
      feedOverrideDelayCount = FEED_OVERRIDE_DELAY_COUNT;
      redraw = 1;
    }
  }
  else {
    // we're not changing it, so update it from EMC value
    feedOverride = (int) (emcStatus->motion.traj.scale * 100.0 + 0.5);
    if (feedOverride != oldFeedOverride) {
      oldFeedOverride = feedOverride;
      sprintf(string, "%3d", feedOverride);
      setLabel(feedOverrideLabel, string);
      redraw = 1;
    }
  }

  // handle internal status changes

  // flag changes in display types
  if (posDisplay != oldPosDisplay) {
    changedPosDisplayType = 1;
    oldPosDisplay = posDisplay;
  }
  if (coords != oldCoords) {
    changedCoordType = 1;
    oldCoords = coords;
  }
  if (posFrame != oldPosFrame) {
    changedPosFrameType = 1;
    oldPosFrame = posFrame;
  }

  if (posFrame == POS_FRAME_JOINT) {
    if (activeJoint != oldActiveJoint ||
        changedPosFrameType) {
      /* first clear the border for them all */
      for (axis = 0; axis < numPosLabels; axis++) {
        setBorderColor(posLabel[axis], posLabelBackground[axis]);
      }
      /* now set the border for the selected one */
      setBorderColor(posLabel[activeJoint], posLabelBorderColor[activeJoint]);
      redraw = 1;

      oldActiveJoint = activeJoint;
    }
  }
  else {
    if (activeCoord != oldActiveCoord ||
        changedPosFrameType) {
      /* first clear the border for them all */
      for (axis = 0; axis < numPosLabels; axis++) {
        setBorderColor(posLabel[axis], posLabelBackground[axis]);
      }
      /* now set the border for the selected one */
      setBorderColor(posLabel[activeCoord], posLabelBorderColor[activeCoord]);
      redraw = 1;

      oldActiveCoord = activeCoord;
    }
  }

  if (jogIncrement != oldJogIncrement) {
    if (jogIncrement > 0.0) {
      sprintf(string, "%1.4f", jogIncrement);
    }
    else {
      sprintf(string, "continuous");
    }
    setLabel(jogIncrementMenu, string);
    redraw = 1;

    oldJogIncrement = jogIncrement;
  }

  // handle EMC status changes
  /*
    Note that changing the label changes the size of the label,
    but not the size of the enclosing box. So, the initial label
    width will set the size of the enclosing box, but won't have
    any other effect during the life of the label. For this reason
    label widths for dynamically labeled labels are not specified,
    and they are set manually before the labels are realized to a
    blank string the same width of the labels. If you use proportional
    fonts for the labels, they will change in size.
  */

  if (diagnosticsIsPopped) {
    if (emcStatus->task.heartbeat != oldTaskHeartbeat) {
      sprintf(string, "%ld %ld %d %d %d",
              emcStatus->task.heartbeat,
              emcStatus->task.command_type,
              emcStatus->task.echo_serial_number,
              emcStatus->task.status,
              emcStatus->task.execState);
      setLabel(diagnosticsTaskHB, string);
      redraw = 1;

      oldTaskHeartbeat = emcStatus->task.heartbeat;
    }

    if (emcStatus->io.heartbeat != oldIoHeartbeat) {
      sprintf(string, "%ld %ld %d %d",
              emcStatus->io.heartbeat,
              emcStatus->io.command_type,
              emcStatus->io.echo_serial_number,
              emcStatus->io.status);
      setLabel(diagnosticsIoHB, string);
      redraw = 1;

      oldIoHeartbeat = emcStatus->io.heartbeat;
    }

    if (emcStatus->motion.heartbeat != oldMotionHeartbeat) {
      sprintf(string, "%ld %ld %d %d",
              emcStatus->motion.heartbeat,
              emcStatus->motion.command_type,
              emcStatus->motion.echo_serial_number,
              emcStatus->motion.status);
      setLabel(diagnosticsMotionHB, string);
      redraw = 1;

      oldMotionHeartbeat = emcStatus->motion.heartbeat;
    }

    if (emcStatus->motion.axis[activeJoint].ferrorHighMark !=
        oldAxisFerror[activeJoint]) {
      sprintf(string, "%.3f", emcStatus->motion.axis[activeJoint].ferrorHighMark);
      setLabel(diagnosticsFerror, string);
      redraw = 1;

      oldAxisFerror[activeJoint] = emcStatus->motion.axis[activeJoint].ferrorHighMark;
    }
  }

  if (emcStatus->task.state != oldState) {
    switch(emcStatus->task.state) {
    case EMC_TASK_STATE_OFF:
      sprintf(string, "OFF");
      break;
    case EMC_TASK_STATE_ON:
      sprintf(string, "ON");
      break;
    case EMC_TASK_STATE_ESTOP:
      sprintf(string, "ESTOP");
      break;
    case EMC_TASK_STATE_ESTOP_RESET:
      sprintf(string, "ESTOP RESET");
      break;
    default:
      sprintf(string, "?");
      break;
    }

    setLabel(stateMenu, string);
    redraw = 1;

    oldState = emcStatus->task.state;
  }

  if (emcStatus->task.mode != oldMode) {
    switch(emcStatus->task.mode) {
    case EMC_TASK_MODE_MANUAL:
      sprintf(string, "MANUAL");
      break;
    case EMC_TASK_MODE_AUTO:
      sprintf(string, "AUTO");
      break;
    case EMC_TASK_MODE_MDI:
      sprintf(string, "MDI");
      break;
    default:
      sprintf(string, "?");
      break;
    }

    setLabel(modeMenu, string);
    redraw = 1;

    oldMode = emcStatus->task.mode;
  }

  if (emcStatus->io.coolant.mist != oldMist) {
    if (emcStatus->io.coolant.mist) {
      sprintf(string, "MIST ON");
    }
    else {
      sprintf(string, "MIST OFF");
    }

    setLabel(mistMenu, string);
    redraw = 1;

    oldMist = emcStatus->io.coolant.mist;
  }

  if (emcStatus->io.coolant.flood != oldFlood) {
    if (emcStatus->io.coolant.flood) {
      sprintf(string, "FLOOD ON");
    }
    else {
      sprintf(string, "FLOOD OFF");
    }

    setLabel(floodMenu, string);
    redraw = 1;

    oldFlood = emcStatus->io.coolant.flood;
  }

  if (emcStatus->io.spindle.increasing != oldSpindleIncreasing) {
    if (emcStatus->io.spindle.increasing > 0) {
      sprintf(string, "SPINDLE INC");
    }
    else if (emcStatus->io.spindle.increasing < 0) {
      sprintf(string, "SPINDLE DEC");
    }
    else {
      // spindle constant-- flag invalid oldSpindleDirection
      // so code below will pick up a redraw
      oldSpindleDirection = -2;
    }

    setLabel(spindleMenu, string);
    redraw = 1;

    oldSpindleIncreasing = emcStatus->io.spindle.increasing;
  }

  if (emcStatus->io.spindle.direction != oldSpindleDirection) {
    if (emcStatus->io.spindle.direction > 0) {
      sprintf(string, "SPINDLE FWD");
      XtSetSensitive(spindleDecLabel, True);
      XtSetSensitive(spindleIncLabel, True);
    }
    else if (emcStatus->io.spindle.direction < 0) {
      sprintf(string, "SPINDLE REV");
      XtSetSensitive(spindleDecLabel, True);
      XtSetSensitive(spindleIncLabel, True);
    }
    else {
      sprintf(string, "SPINDLE OFF");
      XtSetSensitive(spindleDecLabel, False);
      XtSetSensitive(spindleIncLabel, False);
    }

    setLabel(spindleMenu, string);
    redraw = 1;

    oldSpindleDirection = emcStatus->io.spindle.direction;
  }

  if (emcStatus->io.spindle.brake != oldBrake) {
    if (emcStatus->io.spindle.brake) {
      sprintf(string, "BRAKE ON");
    }
    else {
      sprintf(string, "BRAKE OFF");
    }

    setLabel(brakeMenu, string);
    redraw = 1;

    oldBrake = emcStatus->io.spindle.brake;
  }

  if (emcStatus->io.tool.toolInSpindle != oldTool) {
    sprintf(string, "%d", emcStatus->io.tool.toolInSpindle);
    setLabel(toolNumberFormName, string);

    redraw = 1;

    oldTool = emcStatus->io.tool.toolInSpindle;
  }

  if (emcStatus->task.toolOffset.tran.z != oldToolOffset) {
    sprintf(string, "%.4f", emcStatus->task.toolOffset.tran.z);
    setLabel(toolOffsetFormName, string);

    redraw = 1;

    oldToolOffset = emcStatus->task.toolOffset.tran.z;
  }

  // redraw label for types of position displayed, if any have changed
  if (changedPosDisplayType ||
      changedCoordType ||
      changedPosFrameType) {
    sprintf(string, "%s %s %s",
            (posDisplay == POS_DISPLAY_CMD) ? "Commanded" : "Actual",
            (coords == COORD_MACHINE) ? "Machine" : "Relative",
            (posFrame == POS_FRAME_WORLD) ? "World" : "Joint");
    setLabel(positionTypeFormName, string);
    redraw = 1;
  }

  // check if we changed between machine and relative coords. If so,
  // redraw the work offset string.
  if (changedCoordType) {
    if (coords == COORD_MACHINE) {
    // switched to machine display, so blank out offsets
      string[0] = 0;
      setLabel(workOffsetFormName, string);
      redraw = 1;
    }
    else {
      // switched to relative display, so redisplay offsets
      sprintf(string, "X%.4f  Y%.4f  Z%.4f",
              emcStatus->task.origin.tran.x,
              emcStatus->task.origin.tran.y,
              emcStatus->task.origin.tran.z);
      setLabel(workOffsetFormName, string);
      redraw = 1;
    }
  }

  // check if controller offset changed
  if (emcStatus->task.origin.tran.x != oldOrigin.tran.x || 
      emcStatus->task.origin.tran.y != oldOrigin.tran.y || 
      emcStatus->task.origin.tran.z != oldOrigin.tran.z || 
      emcStatus->task.origin.a != oldOrigin.a || 
      emcStatus->task.origin.b != oldOrigin.b || 
      emcStatus->task.origin.c != oldOrigin.c
      ) {
    if (coords == COORD_MACHINE) {
      // display offsets changed, but we're not displaying them
    }
    else {
      // display offsets changed and we are displaying them
      // FIXME-- tran only
      sprintf(string, "X%.4f  Y%.4f  Z%.4f",
              emcStatus->task.origin.tran.x,
              emcStatus->task.origin.tran.y,
              emcStatus->task.origin.tran.z);
      setLabel(workOffsetFormName, string);
      redraw = 1;

      oldOrigin = emcStatus->task.origin;
    }
  }

  // compute new posLabel[] numbers
  if (posFrame == POS_FRAME_WORLD) {
    if (coords == COORD_MACHINE) {
      if (posDisplay == POS_DISPLAY_ACT) {
        mapPoseToLabels(emcStatus->motion.traj.actualPosition);
      }
      else {
        mapPoseToLabels(emcStatus->motion.traj.position);
      }
    }
    else {
      // COORD_RELATIVE-- need to subtract off offsets
      // FIXME-- this just does the tran portion, no support
      // for quaternion offsets yet
      if (posDisplay == POS_DISPLAY_ACT) {
        offsetPose.tran.x = emcStatus->motion.traj.actualPosition.tran.x -
          emcStatus->task.origin.tran.x;
        offsetPose.tran.y = emcStatus->motion.traj.actualPosition.tran.y -
          emcStatus->task.origin.tran.y;
        offsetPose.tran.z = emcStatus->motion.traj.actualPosition.tran.z -
          emcStatus->task.origin.tran.z -
          emcStatus->task.toolOffset.tran.z;
        offsetPose.a = emcStatus->motion.traj.actualPosition.a -
          emcStatus->task.origin.a;
        offsetPose.b = emcStatus->motion.traj.actualPosition.b -
          emcStatus->task.origin.b;
        offsetPose.c = emcStatus->motion.traj.actualPosition.c -
          emcStatus->task.origin.c;
        mapPoseToLabels(offsetPose);
      }
      else {
        offsetPose.tran.x = emcStatus->motion.traj.position.tran.x -
          emcStatus->task.origin.tran.x;
        offsetPose.tran.y = emcStatus->motion.traj.position.tran.y -
          emcStatus->task.origin.tran.y;
        offsetPose.tran.z = emcStatus->motion.traj.position.tran.z -
          emcStatus->task.origin.tran.z -
          emcStatus->task.toolOffset.tran.z;
        offsetPose.a = emcStatus->motion.traj.position.a -
          emcStatus->task.origin.a;
        offsetPose.b = emcStatus->motion.traj.position.b -
          emcStatus->task.origin.b;
        offsetPose.c = emcStatus->motion.traj.position.c -
          emcStatus->task.origin.c;
        mapPoseToLabels(offsetPose);
      }
    }
  }
  else {
    // joint coordinates
    if (posDisplay == POS_DISPLAY_ACT) {
      // actual joints
      for (t = 0; t < numJoints; t++) {
        newPosLabelValue[t] = emcStatus->motion.axis[t].input;
      }
    }
    else {
      // commanded joints
      for (t = 0; t < numJoints; t++) {
        newPosLabelValue[t] = emcStatus->motion.axis[t].setpoint;
      }
    }
  }

  for (t = 0; t < numPosLabels; t++) {
    if (newPosLabelValue[t] != oldPosLabelValue[t] ||
        changedPosFrameType) {
      if (posFrame == POS_FRAME_WORLD) {
        // use posLabelWorld[] array of {'X', 'Y'} etc.
        // and blank out unused coords
        if (t < numCoords) {
          sprintf(string, "%c %9.4f", posLabelWorld[t], newPosLabelValue[t]);
        }
        else {
          string[0] = 0;
        }
      }
      else {
        // use joint numbering from posLabelJoint[] array of {'1', '2'} etc.
        // and blank out unused axes
        if (t < numJoints) {
          sprintf(string, "%c %9.4f", posLabelJoint[t], newPosLabelValue[t]);
        }
        else {
          string[0] = 0;
        }
      }
      setLabel(posLabel[t], string);
      redraw = 1;

      oldPosLabelValue[t] = newPosLabelValue[t];
    }
  }

  // fill in the logging status
  if (oldLogOpen != emcStatus->logOpen) {
    strcpy(string, emcStatus->logOpen ? "Open" : "Closed");
    setLabel(loggingStatusOpenLabel, string);
    redraw = 1;

    oldLogOpen = emcStatus->logOpen;
  }

  if (oldLogStarted != emcStatus->logStarted) {
    strcpy(string, emcStatus->logStarted ? "Logging" : "Not Logging");
    setLabel(loggingStatusStartedLabel, string);
    redraw = 1;

    oldLogStarted = emcStatus->logStarted;
  }

  if (oldLogPoints != emcStatus->logPoints) {
    sprintf(string, "%d", emcStatus->logPoints);
    setLabel(loggingStatusPointsLabel, string);
    redraw = 1;

    oldLogPoints = emcStatus->logPoints;
  }

  // fill in the active G codes
  active_g_codes_string[0] = 0;
  for (t = 1; t < EMC_TASK_ACTIVE_G_CODES; t++) {
    code = emcStatus->task.activeGCodes[t];
    if (code == -1) {
      continue;
    }
    if (code % 10) {
      sprintf(string, "G%.1f ", (double) code / 10.0);
    }
    else {
      sprintf(string, "G%d ", code / 10);
    }
    strcat(active_g_codes_string, string);
  }

  // fill in the active M codes, settings too
  active_m_codes_string[0] = 0;
  for (t = 1; t < EMC_TASK_ACTIVE_M_CODES; t++) {
    code = emcStatus->task.activeMCodes[t];
    if (code == -1) {
      continue;
    }
    sprintf(string, "M%d ", code);
    strcat(active_m_codes_string, string);
  }

  sprintf(mdiCodes, "%s %s", active_g_codes_string, active_m_codes_string);

  // fill in F and S codes also
  sprintf(string, " F%.0f", emcStatus->task.activeSettings[1]);
  strcat(mdiCodes, string);
  sprintf(string, " S%.0f", emcStatus->task.activeSettings[2]);
  strcat(mdiCodes, string);

  if (0 != strcmp(oldMdiCodes, mdiCodes)) {
    XtVaSetValues(mdiCodesLabel, XtNlabel, mdiCodes, NULL);
    strcpy(oldMdiCodes, mdiCodes);
  }

  // program text updating

  if (0 != emcStatus->task.file[0] &&
      0 != strcmp(programFile, emcStatus->task.file)) {
    // new program has been opened-- open it here

    fwClose(&programFw);
    oldProgramActiveLine = -1;

    if (0 == fwOpen(&programFw, emcStatus->task.file)) {
      // opened successfully locally
      // save it to run again
      strcpy(lastProgramFile, emcStatus->task.file);
      // set string for label
      strcpy(string, emcStatus->task.file);
    }
    else {
      // couldn't open it locally
      // save it to run again, even though we can't see it
      strcpy(lastProgramFile, emcStatus->task.file);
      // set string for label
      sprintf(string, "(%s not found)", emcStatus->task.file);
    }

    // set the program label
    setLabel(programFormName, string);
    redraw = 1;

    strcpy(programFile, emcStatus->task.file);
  }

  // compose program state string
  switch (emcStatus->task.interpState) {
  case EMC_TASK_INTERP_IDLE:
    strcpy(string, "Idle");
    break;

  case EMC_TASK_INTERP_READING:
  case EMC_TASK_INTERP_WAITING:
    strcpy(string, "Running");
    break;

  case EMC_TASK_INTERP_PAUSED:
    strcpy(string, "PAUSED");
    break;

  default:
    strcpy(string, "(Idle)");   // shouldn't get here; parens for debug
    break;
  }
  // and print it, if new
  if (strcmp(string, oldProgramString)) {
    setLabel(programFormState, string);
    redraw = 1;

    strcpy(oldProgramString, string);
  }

  // print active line and next few in window

  if (programStartLineLast < 0 ||
      emcStatus->task.readLine < programStartLineLast) {
    // controller is skipping lines
    programActiveLine = emcStatus->task.readLine;
  }
  else {                        // controller is not skipping lines
    if (emcStatus->task.currentLine > 0) {
      if (emcStatus->task.motionLine > 0 &&
          emcStatus->task.motionLine < emcStatus->task.currentLine) {
        // active line is the motion line, which lags
        programActiveLine = emcStatus->task.motionLine;
      }
      else {
        // active line is the current line-- no motion lag
        programActiveLine = emcStatus->task.currentLine;
      }
    }
    else {
      // no active line at all
      programActiveLine = 0;
    }
  } // end of else controller is not skipping lines

  if (programActiveLine != oldProgramActiveLine) {
    programTopLine = programActiveLine - 2;
    if (programTopLine < 1) {
      programTopLine = 1;
    }
    fwSyncLine(&programFw, programTopLine);
    fwString(&programFw, programFwString);
    setProgramText(programFwString);
    highlightProgramText(programFwString, programActiveLine - programTopLine);
    redraw = 1;

    oldProgramActiveLine = programActiveLine;
  }

  // set label colors: do red for limit first
  // FIXME-- this should only be done for joint frame; what do
  // we do for world frame?
  for (t = 0; t < numPosLabels; t++) {
    if (emcStatus->motion.axis[t].minHardLimit ||
        emcStatus->motion.axis[t].minSoftLimit ||
        emcStatus->motion.axis[t].maxSoftLimit ||
        emcStatus->motion.axis[t].maxHardLimit) {
      if (posColor[t] != pixelRed) {
        setColor(posLabel[t], pixelRed, 1);
        posColor[t] = pixelRed;
      }
    }
    else if (emcStatus->motion.axis[t].homed &&
             posColor[t] != pixelGreen) {
      setColor(posLabel[t], pixelGreen, 1);
      posColor[t] = pixelGreen;
    }
    else if (! emcStatus->motion.axis[t].homed &&
             posColor[t] != pixelYellow) {
      setColor(posLabel[t], pixelYellow, 1);
      posColor[t] = pixelYellow;
    }
  }

  // do menu dimming

  if (emcStatus->task.state != EMC_TASK_STATE_ON) {
    // if not on, dim all menus
    enableAuxMenus(False);
    enableManualMenus(False);
    enableAutoMenus(False);
    enableMdiMenus(False);
  }
  else {
    // it's on, so only enable according to mode
    if (emcStatus->task.mode == EMC_TASK_MODE_MANUAL) {
      enableAuxMenus(True);
      enableAutoMenus(False);
      enableMdiMenus(False);
      enableManualMenus(True);
    }
    else if (emcStatus->task.mode == EMC_TASK_MODE_AUTO) {
      if (emcStatus->task.interpState == EMC_TASK_INTERP_IDLE ||
          emcStatus->task.interpState == EMC_TASK_INTERP_PAUSED) {
        enableAuxMenus(True);
      }
      else {
        enableAuxMenus(False);
      }
      enableMdiMenus(False);
      enableManualMenus(False);
      enableAutoMenus(True);
    }
    else if (emcStatus->task.mode == EMC_TASK_MODE_MDI) {
      enableAuxMenus(True);
      enableManualMenus(False);
      enableAutoMenus(False);
      enableMdiMenus(True);
    }
  }

  // flush changes now if necessary, don't wait for event
  if (redraw) {
    XFlush(XtDisplay(topForm));
    redraw = 0;
  }

  // re-register this proc for the timeout
  XtAppAddTimeOut(app_context, UPDATE_MSECS, timeoutCB, NULL);

  return;
}

  static void topLevelProtocols(Widget w, XEvent *event, String *string, Cardinal *c)
{
  quit();
}

static void fileOpenShellProtocols(Widget w, XEvent *event, String *string, Cardinal *c)
{
  XtPopdown(fileOpenShell);
}

static void fileQuitShellProtocols(Widget w, XEvent *event, String *string, Cardinal *c)
{
  XtPopdown(fileQuitShell);
}

static void fileEditShellProtocols(Widget w, XEvent *event, String *string, Cardinal *c)
{
  XtPopdown(fileEditShell);
}

static void fileEditorShellProtocols(Widget w, XEvent *event, String *string, Cardinal *c)
{
  XtPopdown(fileEditorShell);
  destroyFileEditorShell();
}

static void toolTableShellProtocols(Widget w, XEvent *event, String *string, Cardinal *c)
{
  XtPopdown(toolTableShell);
  destroyToolTableShell();
}

static void toolSetOffsetShellProtocols(Widget w, XEvent *event, String *string, Cardinal *c)
{
  XtPopdown(toolSetOffsetShell);
}

static void posOffsetShellProtocols(Widget w, XEvent *event, String *string, Cardinal *c)
{
  XtPopdown(posOffsetShell);
}

static void jogSpeedShellProtocols(Widget w, XEvent *event, String *string, Cardinal *c)
{
  XtPopdown(jogSpeedShell);
}

static void feedOverrideShellProtocols(Widget w, XEvent *event, String *string, Cardinal *c)
{
  XtPopdown(feedOverrideShell);
}

static void varFileShellProtocols(Widget w, XEvent *event, String *string, Cardinal *c)
{
  XtPopdown(varFileShell);
  destroyVarFileShell();
}

static void diagnosticsShellProtocols(Widget w, XEvent *event, String *string, Cardinal *c)
{
  diagnosticsIsPopped = 0;
  XtPopdown(diagnosticsShell);
}

static void calibShellProtocols(Widget w, XEvent *event, String *string, Cardinal *c)
{
  XtPopdown(calibShell);
}

static void loggingShellProtocols(Widget w, XEvent *event, String *string, Cardinal *c)
{
  XtPopdown(loggingShell);
}

static void helpXemcProtocols(Widget w, XEvent *event, String *string, Cardinal *c)
{
  XtPopdown(helpXemcShell);
}

static void helpAboutProtocols(Widget w, XEvent *event, String *string, Cardinal *c)
{
  XtPopdown(helpAboutShell);
}

static void errorShellProtocols(Widget w, XEvent *event, String *string, Cardinal *c)
{
  XtPopdown(errorShell);
  errorIsPopped = 0;
  destroyErrorShell();
}

static XtActionsRec actionsTable[] =
{
  {"downAction", downAction},
  {"upAction", upAction},
  {"keyAction", keyAction},
  {"fileOpenReturnAction", fileOpenReturnAction},
  {"fileOpenTabAction", fileOpenTabAction},
  {"fileEditReturnAction", fileEditReturnAction},
  {"fileEditTabAction", fileEditTabAction},
  {"fileQuitReturnAction", fileQuitReturnAction},
  {"fileQuitTabAction", fileQuitTabAction},
  {"diagnosticsReturnAction", diagnosticsReturnAction},
  {"calibReturnAction", calibReturnAction},
  {"calibTabAction", calibTabAction},
  {"loggingReturnAction", loggingReturnAction},
  {"loggingTabAction", loggingTabAction},
  {"toolSetOffsetUpAction", toolSetOffsetUpAction},
  {"toolSetOffsetReturnAction", toolSetOffsetReturnAction},
  {"toolSetOffsetTabAction", toolSetOffsetTabAction},
  {"posOffsetUpAction", posOffsetUpAction},
  {"posOffsetReturnAction", posOffsetReturnAction},
  {"jogSpeedReturnAction", jogSpeedReturnAction},
  {"feedOverrideReturnAction", feedOverrideReturnAction},
  {"mdiReturnAction", mdiReturnAction},
  {"helpXemcReturnAction", helpXemcReturnAction},
  {"helpAboutReturnAction", helpAboutReturnAction},
  {"errorReturnAction", errorReturnAction},
  {"topLevelProtocols", topLevelProtocols},
  {"fileOpenShellProtocols", fileOpenShellProtocols},
  {"fileQuitShellProtocols", fileQuitShellProtocols},
  {"fileEditShellProtocols", fileEditShellProtocols},
  {"fileEditorShellProtocols", fileEditorShellProtocols},
  {"toolTableShellProtocols", toolTableShellProtocols},
  {"toolSetOffsetShellProtocols", toolSetOffsetShellProtocols},
  {"posOffsetShellProtocols", posOffsetShellProtocols},
  {"jogSpeedShellProtocols", jogSpeedShellProtocols},
  {"feedOverrideShellProtocols", feedOverrideShellProtocols},
  {"varFileShellProtocols", varFileShellProtocols},
  {"diagnosticsShellProtocols", diagnosticsShellProtocols},
  {"calibShellProtocols", calibShellProtocols},
  {"loggingShellProtocols", loggingShellProtocols},
  {"helpXemcProtocols", helpXemcProtocols},
  {"helpAboutProtocols", helpAboutProtocols},
  {"errorShellProtocols", errorShellProtocols}
};

typedef void (MenuSelectFunc)(Widget w, XtPointer client_data, XtPointer call_data);

static int setupMenu(Widget *menu, char *label,
                     char **labels,
                     Widget which,
                     Widget horiz, Widget vert,
                     MenuSelectFunc *func)
{
  Widget *popup = new Widget;   // this will be freed automatically at exit
  int t;

  if (NULL != horiz)
    {
      if (NULL != vert)
        {
          *menu =
            XtVaCreateManagedWidget(label,
                                    menuButtonWidgetClass,
                                    which,
                                    XtNfromHoriz, horiz,
                                    XtNfromVert, vert,
                                    NULL);
        }
      else
        {
          *menu =
            XtVaCreateManagedWidget(label,
                                    menuButtonWidgetClass,
                                    which,
                                    XtNfromHoriz, horiz,
                                    NULL);
        }
    }
  else
    {
      if (NULL != vert)
        {
          *menu =
            XtVaCreateManagedWidget(label,
                                    menuButtonWidgetClass,
                                    which,
                                    XtNfromVert, vert,
                                    NULL);
        }
      else
        {
          *menu =
            XtVaCreateManagedWidget(label,
                                    menuButtonWidgetClass,
                                    which,
                                    NULL);
        }
    }

  *popup =
    XtVaCreatePopupShell("menu", // need to hard-code "menu" here
                         simpleMenuWidgetClass,
                         *menu,
                         NULL);

  // set the menu item names
  for (t = 0; labels[t] != NULL; t++)
    {
      if (labels[t][0] == '-' &&
          labels[t][1] == 0)
        {
          // it's a dash
          XtAddCallback(XtVaCreateManagedWidget(labels[t],
                                                smeLineObjectClass,
                                                *popup,
                                                NULL),
                        XtNcallback, func, (XtPointer) t);

        }
      else
        {
          XtAddCallback(XtVaCreateManagedWidget(labels[t],
                                                smeBSBObjectClass,
                                                *popup,
                                                NULL),
                        XtNcallback, func, (XtPointer) t);
        }
    }
  return(0);
}

static String fallbackResources[] =
{
  NULL
};

static void quit()
{
  // clean up NML buffers

  if (emcErrorBuffer != 0)
    {
      delete emcErrorBuffer;
      emcErrorBuffer = 0;
    }

  if (emcStatusBuffer != 0)
    {
      delete emcStatusBuffer;
      emcStatusBuffer = 0;
      emcStatus = 0;
    }

  if (emcCommandBuffer != 0)
    {
      delete emcCommandBuffer;
      emcCommandBuffer = 0;
    }

  // get rid of program file window string
  if (NULL != programFwString) {
    free(programFwString);
    programFwString = 0;
  }

  exit(0);
}

// destructively converts string to its uppercase counterpart
static char *upcase(char *string)
{
  char *ptr = string;

  while (*ptr != 0)
    {
      *ptr = toupper(*ptr);
      ptr++;
    }

  return string;
}

static int iniLoad(const char *filename)
{
  INIFILE inifile;
  const char *inistring;
  char machine[INIFILE_MAX_LINELEN] = "";
  char version[INIFILE_MAX_LINELEN] = "";
  char displayString[INIFILE_MAX_LINELEN] = "";
  int t;
  int i;
  double d;
  int len;

  // open it
  if (-1 == inifile.open(filename)) {
    return -1;
  }

  if (NULL != (inistring = inifile.find("NML_FILE", "EMC"))) {
    // copy to global
    strcpy(EMC_NMLFILE, inistring);
  }
  else {
    // not found, use default
  }

  if (NULL != (inistring = inifile.find("DEBUG", "EMC"))) {
    // copy to global
    if (1 != sscanf(inistring, "%i", &EMC_DEBUG)) {
      EMC_DEBUG = 0;
    }
  }
  else {
    // not found, use default
    EMC_DEBUG = 0;
  }


  if (NULL != (inistring = inifile.find("AXES", "TRAJ"))) {
    if (1 == sscanf(inistring, "%d", &numJoints)) {
      // compare against XEMC_NUM_AXES, if larger then clip and warn
      if (numJoints > XEMC_NUM_AXES) {
        numJoints = XEMC_NUM_AXES;
      }
    }
    else {
      // there, but invalid
      numJoints = 3;
    }
  }
  else {
    // not there, use default
    numJoints = 3;
  }

  if (NULL != (inistring = inifile.find("KINEMATICS", "TRAJ"))) {
    if (! strcmp(inistring, "IDENTITY")) {
      kinematicsType = KINEMATICS_IDENTITY;
    }
    else if (! strcmp(inistring, "SERIAL")) {
      kinematicsType = KINEMATICS_SERIAL;
    }
    else if (! strcmp(inistring, "PARALLEL")) {
      kinematicsType = KINEMATICS_SERIAL;
    }
    else {
      // there, but invalid
      kinematicsType = KINEMATICS_IDENTITY;
    }
  }
  else {
    // not there, use default
    kinematicsType = KINEMATICS_IDENTITY;
  }

  // set coordinateMark[] array with 1's for those coordinates
  // to be displayed, e.g., 1 1 0 0 0 1 for X Y W out of X Y Z R P W
  if (NULL != (inistring = inifile.find("COORDINATES", "TRAJ"))) {
    len = strlen(inistring);
    // there's an entry in ini file, so clear all the marks out first
    // so that defaults don't apply at all
    for (t = 0; t < 6; t++) {
      coordinateMark[t] = 0;
    }
    // now set actual marks
    for (t = 0; t < len; t++) {
      if (inistring[t] == 'X')
        coordinateMark[0] = 1;
      else if (inistring[t] == 'Y')
        coordinateMark[1] = 1;
      else if (inistring[t] == 'Z')
        coordinateMark[2] = 1;
      else if (inistring[t] == 'R')
        coordinateMark[3] = 1;
      else if (inistring[t] == 'P')
        coordinateMark[4] = 1;
      else if (inistring[t] == 'W')
        coordinateMark[5] = 1;
    }
  }
  else {
    // not there, use default
    // by leaving coordinateMark[] alone
  }

  // count the number of unique marks
  numCoords = 0;
  for (t = 0; t < 6; t++) {
    if (coordinateMark[t]) {
      // since t never lags numCoords, we can pack letters down
      posLabelWorld[numCoords] = posLabelWorld[t];
      coordNum[numCoords] = t;
      numCoords++;
    }
  }

  if (NULL != (inistring = inifile.find("MACHINE", "EMC"))) {
    strcpy(machine, inistring);

    if (NULL != (inistring = inifile.find("VERSION", "EMC"))) {
      sscanf(inistring, "$Revision: %s", version);

      sprintf(version_string, "%s EMC Version %s", machine, version);
    }
  }

  if (NULL != (inistring = inifile.find("TOOL_TABLE", "EMCIO"))) {
    strcpy(TOOL_TABLE_FILE, inistring);
  }
  else {
    strcpy(TOOL_TABLE_FILE, "tool.tbl"); // FIXME-- hardcoded
  }

  if (NULL != (inistring = inifile.find("PARAMETER_FILE", "RS274NGC"))) {
    strcpy(PARAMETER_FILE, inistring);
  }
  else {
    strcpy(PARAMETER_FILE, "rs274ngc.var"); // FIXME-- hardcoded
  }

  if (NULL != (inistring = inifile.find("DEFAULT_VELOCITY", "TRAJ"))) {
    if (1 != sscanf(inistring, "%lf", &TRAJ_DEFAULT_VELOCITY)) {
      TRAJ_DEFAULT_VELOCITY = DEFAULT_TRAJ_DEFAULT_VELOCITY;
    }
  }
  else {
    TRAJ_DEFAULT_VELOCITY = DEFAULT_TRAJ_DEFAULT_VELOCITY;
  }
  // round jogSpeed in display to integer, per-minute
  jogSpeed = (int) (TRAJ_DEFAULT_VELOCITY * 60.0 + 0.5);

  if (NULL != (inistring = inifile.find("MAX_VELOCITY", "TRAJ"))) {
    if (1 != sscanf(inistring, "%lf", &TRAJ_MAX_VELOCITY)) {
      TRAJ_MAX_VELOCITY = DEFAULT_TRAJ_MAX_VELOCITY;
    }
  }
  else {
    TRAJ_MAX_VELOCITY = DEFAULT_TRAJ_MAX_VELOCITY;
  }
  // round maxJogSpeed in display to integer, per-minute
  maxJogSpeed = (int) (TRAJ_MAX_VELOCITY * 60.0 + 0.5);

  if (NULL != (inistring = inifile.find("PROGRAM_PREFIX", "DISPLAY"))) {
    if (1 != sscanf(inistring, "%s", programPrefix)) {
      programPrefix[0] = 0;
    }
  }
  else if (NULL != (inistring = inifile.find("PROGRAM_PREFIX", "TASK"))) {
    if (1 != sscanf(inistring, "%s", programPrefix)) {
      programPrefix[0] = 0;
    }
  }
  else {
    programPrefix[0] = 0;
  }

  if (NULL != (inistring = inifile.find("POSITION_OFFSET", "DISPLAY"))) {
    if (1 == sscanf(inistring, "%s", displayString)) {
      if (! strcmp(upcase(displayString), "MACHINE")) {
        coords = COORD_MACHINE;
      }
      else if (1 == sscanf(inistring, "%s", displayString)) {
        if (! strcmp(upcase(displayString), "RELATIVE")) {
          coords = COORD_RELATIVE;
        }
      }
      else {
        // error-- invalid value
        // ignore
      }
    }
    else {
      // error-- no value provided
      // ignore
    }
  }
  else {
    // no line at all
    // ignore
  }

  if (NULL != (inistring = inifile.find("POSITION_FEEDBACK", "DISPLAY"))) {
    if (1 == sscanf(inistring, "%s", displayString)) {
      if (! strcmp(upcase(displayString), "ACTUAL")) {
        posDisplay = POS_DISPLAY_ACT;
      }
      else if (1 == sscanf(inistring, "%s", displayString)) {
        if (! strcmp(upcase(displayString), "COMMANDED")) {
          posDisplay = POS_DISPLAY_CMD;
        }
      }
      else {
        // error-- invalid value
        // ignore
      }
    }
    else {
      // error-- no value provided
      // ignore
    }
  }
  else {
    // no line at all
    // ignore
  }

  for (t = 0; t < XEMC_NUM_AXES; t++) {
    jogPol[t] = 1;              // set to default
    sprintf(displayString, "AXIS_%d", t);
    if (NULL != (inistring = inifile.find("JOGGING_POLARITY", displayString)) &&
        1 == sscanf(inistring, "%d", &i) &&
        i == 0) {
      // it read as 0, so override default
      jogPol[t] = 0;
    }
  }

  if (NULL != (inistring = inifile.find("MAX_FEED_OVERRIDE", "DISPLAY"))) {
    if (1 == sscanf(inistring, "%lf", &d) &&
        d > 0.0) {
      maxFeedOverride = (int) (d * 100.0 + 0.5);
    }
    else {
      // error-- no value provided
      // ignore
    }
  }
  else {
    // no line at all
    // ignore
  }

  // close it
  inifile.close();

  return 0;;
}

int main(int argc, char **argv)
{
  int t;
  double start;
  int good;
  char string[80];
  Dimension cmfbw, sdw, sw, siw, sh, bh, bw;
  Dimension stw, mw;
  Dimension posw;

  // process command line args, indexing argv[] from [1]
  for (t = 1; t < argc; t++)
    {
      // try -ini
      if (!strcmp(argv[t], "-ini"))
        {
          if (t == argc - 1)
            {
              printf("syntax: -ini <inifile\n");
              exit(1);
            }
          else
            {
              strcpy(EMC_INIFILE, argv[t+1]);
              t++;              // step over inifile
              continue;
            }
        }
    }

  // read INI file
  iniLoad(EMC_INIFILE);

  // blank out the annoying RCS version message
  rcs_version_printed = 1;

  // init NML

#define RETRY_TIME 10.0         // seconds to wait for subsystems to come up
#define RETRY_INTERVAL 1.0      // seconds between wait tries for a subsystem

  if (! (EMC_DEBUG & EMC_DEBUG_NML)) {
    set_rcs_print_destination(RCS_PRINT_TO_NULL);     // inhibit diag messages
  }
  start = etime();
  good = 0;
  do {
    if (0 == emcTaskNmlGet()) {
      good = 1;
      break;
    }
    esleep(RETRY_INTERVAL);
  } while (etime() - start < RETRY_TIME);
  if (! (EMC_DEBUG & EMC_DEBUG_NML)) {
    set_rcs_print_destination(RCS_PRINT_TO_STDOUT); // restore diag messages
  }
  if (! good) {
    rcs_print_error("can't establish communication with emc\n");
    exit(1);
  }

  if (! (EMC_DEBUG & EMC_DEBUG_NML)) {
    set_rcs_print_destination(RCS_PRINT_TO_NULL);     // inhibit diag messages
  }
  updateStatus();
  if(emcStatus->motion.traj.kinematics_type != 1)
    {   
      posFrame = POS_FRAME_JOINT;
    }
  start = etime();
  good = 0;
  do {
    if (0 == emcErrorNmlGet()) {
      good = 1;
      break;
    }
    esleep(RETRY_INTERVAL);
  } while (etime() - start < RETRY_TIME);
  if (! (EMC_DEBUG & EMC_DEBUG_NML)) {
    set_rcs_print_destination(RCS_PRINT_TO_STDOUT); // restore diag messages
  }
  if (! good) {
    rcs_print_error("can't establish communication with emc\n");
    exit(1);
  }

  // create file window for program text

  programFwString =
    (char *) malloc(PROGRAM_FW_NUM_LINES * PROGRAM_FW_LEN_LINES);

  if (0 != fwInit(&programFw, PROGRAM_FW_NUM_LINES, PROGRAM_FW_LEN_LINES)) {
    fprintf(stderr, "can't init file window\n");
    exit(1);
  }

  // get widgets

  topLevel =
    XtVaAppInitialize(&app_context, /* Application context */
                      "YEmc",   /* Application class */
                      NULL, 0,  /* command line option list */
                      &argc, argv, /* command line args */
                      fallbackResources, /* app defaults string, or NULL */
                      NULL);    /* terminate varargs list */

  topForm =
    XtVaCreateManagedWidget("topForm", /* arbitrary widget name */
                            formWidgetClass, /* widget class from Label.h */
                            topLevel, /* parent widget */
                            NULL); /* terminate varargs list */

  barMenuForm =
    XtVaCreateManagedWidget("barMenuForm",
                            formWidgetClass,
                            topForm,
                            NULL);

  setupMenu(&fileMenu, "fileMenu",
            fileMenuEntryNames,
            barMenuForm,
            NULL, NULL,
            fileMenuSelect);

  setupMenu(&viewMenu, "viewMenu",
            viewMenuEntryNames,
            barMenuForm,
            fileMenu, NULL,
            viewMenuSelect);

  setupMenu(&settingsMenu, "settingsMenu",
            settingsMenuEntryNames,
            barMenuForm,
            viewMenu, NULL,
            settingsMenuSelect);

  setupMenu(&helpMenu, "helpMenu",
            helpMenuEntryNames,
            barMenuForm,
            settingsMenu, NULL,
            helpMenuSelect);

  commandMenuForm =
    XtVaCreateManagedWidget("commandMenuForm",
                            formWidgetClass,
                            topForm,
                            XtNfromVert, barMenuForm,
                            NULL);

  setupMenu(&stateMenu, "stateMenu",
            stateMenuEntryNames,
            commandMenuForm,
            NULL, NULL,
            stateMenuSelect);

  XtVaGetValues(stateMenu,
                XtNwidth, &stw,
                NULL);

  setupMenu(&modeMenu, "modeMenu",
            modeMenuEntryNames,
            commandMenuForm,
            NULL, stateMenu,
            modeMenuSelect);

  XtVaSetValues(modeMenu,
                XtNwidth, stw,
                NULL);

  setupMenu(&mistMenu, "mistMenu",
            mistMenuEntryNames,
            commandMenuForm,
            stateMenu, NULL,
            mistMenuSelect);

  XtVaGetValues(mistMenu,
                XtNwidth, &mw,
                NULL);

  setupMenu(&floodMenu, "floodMenu",
            floodMenuEntryNames,
            commandMenuForm,
            stateMenu, mistMenu,
            floodMenuSelect);

  XtVaSetValues(floodMenu,
                XtNwidth, mw,
                NULL);

  spindleDecLabel =
    XtVaCreateManagedWidget("spindleDecLabel",
                            labelWidgetClass,
                            commandMenuForm,
                            XtNfromHoriz, mistMenu,
                            NULL);

  setupMenu(&spindleMenu, "spindleMenu",
            spindleMenuEntryNames,
            commandMenuForm,
            spindleDecLabel, NULL,
            spindleMenuSelect);

  spindleIncLabel =
    XtVaCreateManagedWidget("spindleIncLabel",
                            labelWidgetClass,
                            commandMenuForm,
                            XtNfromHoriz, spindleMenu,
                            NULL);

  XtVaGetValues(spindleMenu,
                XtNwidth, &sw,
                XtNheight, &sh,
                XtNborderWidth, &cmfbw,
                NULL);

  XtVaGetValues(spindleDecLabel,
                XtNwidth, &sdw,
                NULL);

  XtVaGetValues(spindleIncLabel,
                XtNwidth, &siw,
                NULL);

  setupMenu(&brakeMenu, "brakeMenu",
            brakeMenuEntryNames,
            commandMenuForm,
            mistMenu, spindleDecLabel,
            brakeMenuSelect);

  bw = sdw + cmfbw + cmfbw + sw + cmfbw + cmfbw + siw;
  XtVaSetValues(brakeMenu,
                XtNwidth, bw,
                NULL);

  XtVaGetValues(brakeMenu,
                XtNheight, &bh,
                NULL);

  fileOpenShell =
    XtVaCreatePopupShell("fileOpenShell",
                         transientShellWidgetClass,
                         topLevel,
                         XtNallowShellResize, True,
                         NULL);

  fileOpenDialog =
    XtVaCreateManagedWidget("fileOpenDialog",
                            dialogWidgetClass,
                            fileOpenShell,
                            XtNvalue, programPrefix,
                            NULL);

  fileOpenDone =
    XtVaCreateManagedWidget("fileOpenDone",
                            commandWidgetClass,
                            fileOpenDialog,
                            NULL);

  XtAddCallback(fileOpenDone, XtNcallback, fileOpenDoneCB, fileOpenShell);

  fileOpenCancel =
    XtVaCreateManagedWidget("fileOpenCancel",
                            commandWidgetClass,
                            fileOpenDialog,
                            NULL);

  XtAddCallback(fileOpenCancel, XtNcallback, genericDoneCB, fileOpenShell);

  fileEditShell =
    XtVaCreatePopupShell("fileEditShell",
                         transientShellWidgetClass,
                         topLevel,
                         XtNallowShellResize, True,
                         NULL);

  fileEditDialog =
    XtVaCreateManagedWidget("fileEditDialog",
                            dialogWidgetClass,
                            fileEditShell,
                            XtNvalue, programPrefix,
                            NULL);

  fileEditDone =
    XtVaCreateManagedWidget("fileEditDone",
                            commandWidgetClass,
                            fileEditDialog,
                            NULL);

  XtAddCallback(fileEditDone, XtNcallback, fileEditDoneCB, fileEditShell);

  fileEditCancel =
    XtVaCreateManagedWidget("fileEditCancel",
                            commandWidgetClass,
                            fileEditDialog,
                            NULL);

  XtAddCallback(fileEditCancel, XtNcallback, genericDoneCB, fileEditShell);

  fileQuitShell =
    XtVaCreatePopupShell("fileQuitShell",
                         transientShellWidgetClass,
                         topLevel,
                         XtNallowShellResize, True,
                         NULL);

  fileQuitDialog =
    XtVaCreateManagedWidget("fileQuitDialog",
                            dialogWidgetClass,
                            fileQuitShell,
                            NULL);

  fileQuitDone =
    XtVaCreateManagedWidget("fileQuitDone",
                            commandWidgetClass,
                            fileQuitDialog,
                            NULL);

  XtAddCallback(fileQuitDone, XtNcallback, fileQuitDoneCB, fileQuitShell);

  fileQuitCancel =
    XtVaCreateManagedWidget("fileQuitCancel",
                            commandWidgetClass,
                            fileQuitDialog,
                            NULL);

  XtAddCallback(fileQuitCancel, XtNcallback, genericDoneCB, fileQuitShell);

  // diagnostics shell

  diagnosticsShell =
    XtVaCreatePopupShell("diagnosticsShell",
                         topLevelShellWidgetClass,
                         topLevel,
                         XtNallowShellResize, True,
                         NULL);

  diagnosticsForm =
    XtVaCreateManagedWidget("diagnosticsForm",
                            formWidgetClass,
                            diagnosticsShell,
                            NULL);

  diagnosticsLabel =
    XtVaCreateManagedWidget("diagnosticsLabel",
                            labelWidgetClass,
                            diagnosticsForm,
                            XtNborderWidth, 0,
                            NULL);

  diagnosticsTaskHBLabel =
    XtVaCreateManagedWidget("diagnosticsTaskHBLabel",
                            labelWidgetClass,
                            diagnosticsForm,
                            XtNfromVert, diagnosticsLabel,
                            XtNborderWidth, 0,
                            NULL);

  diagnosticsTaskHB =
    XtVaCreateManagedWidget("diagnosticsTaskHB",
                            labelWidgetClass,
                            diagnosticsForm,
                            XtNfromVert, diagnosticsLabel,
                            XtNfromHoriz, diagnosticsTaskHBLabel,
                            NULL);

  diagnosticsIoHBLabel =
    XtVaCreateManagedWidget("diagnosticsIoHBLabel",
                            labelWidgetClass,
                            diagnosticsForm,
                            XtNfromVert, diagnosticsTaskHBLabel,
                            XtNborderWidth, 0,
                            NULL);

  diagnosticsIoHB =
    XtVaCreateManagedWidget("diagnosticsIoHB",
                            labelWidgetClass,
                            diagnosticsForm,
                            XtNfromVert, diagnosticsTaskHBLabel,
                            XtNfromHoriz, diagnosticsIoHBLabel,
                            NULL);

  diagnosticsMotionHBLabel =
    XtVaCreateManagedWidget("diagnosticsMotionHBLabel",
                            labelWidgetClass,
                            diagnosticsForm,
                            XtNfromVert, diagnosticsIoHBLabel,
                            XtNborderWidth, 0,
                            NULL);

  diagnosticsMotionHB =
    XtVaCreateManagedWidget("diagnosticsMotionHB",
                            labelWidgetClass,
                            diagnosticsForm,
                            XtNfromVert, diagnosticsIoHBLabel,
                            XtNfromHoriz, diagnosticsMotionHBLabel,
                            NULL);

  diagnosticsFerrorLabel =
    XtVaCreateManagedWidget("diagnosticsFerrorLabel",
                            labelWidgetClass,
                            diagnosticsForm,
                            XtNfromVert, diagnosticsMotionHBLabel,
                            XtNborderWidth, 0,
                            NULL);

  diagnosticsFerror =
    XtVaCreateManagedWidget("diagnosticsFerror",
                            labelWidgetClass,
                            diagnosticsForm,
                            XtNfromVert, diagnosticsMotionHBLabel,
                            XtNfromHoriz, diagnosticsFerrorLabel,
                            NULL);

  diagnosticsDone =
    XtVaCreateManagedWidget("diagnosticsDone",
                            commandWidgetClass,
                            diagnosticsForm,
                            XtNfromVert, diagnosticsFerrorLabel,
                            NULL);

  XtAddCallback(diagnosticsDone, XtNcallback, diagnosticsDoneCB, NULL);

  // calibration shell

  calibShell =
    XtVaCreatePopupShell("calibShell",
                         topLevelShellWidgetClass,
                         topLevel,
                         XtNallowShellResize, True,
                         NULL);

  calibForm =
    XtVaCreateManagedWidget("calibForm",
                            formWidgetClass,
                            calibShell,
                            NULL);

  calibLabel =
    XtVaCreateManagedWidget("calibLabel",
                            labelWidgetClass,
                            calibForm,
                            XtNborderWidth, 0,
                            NULL);

  calibCycleTimeLabel =
    XtVaCreateManagedWidget("calibCycleTimeLabel",
                            labelWidgetClass,
                            calibForm,
                            XtNfromVert, calibLabel,
                            XtNborderWidth, 0,
                            NULL);

  calibCycleTime =
    XtVaCreateManagedWidget("calibCycleTime",
                            asciiTextWidgetClass,
                            calibForm,
                            XtNeditType, XawtextEdit,
                            XtNfromVert, calibLabel,
                            XtNfromHoriz, calibCycleTimeLabel,
                            NULL);

  calibPGainLabel =
    XtVaCreateManagedWidget("calibPGainLabel",
                            labelWidgetClass,
                            calibForm,
                            XtNfromVert, calibCycleTimeLabel,
                            XtNborderWidth, 0,
                            NULL);

  calibPGain =
    XtVaCreateManagedWidget("calibPGain",
                            asciiTextWidgetClass,
                            calibForm,
                            XtNeditType, XawtextEdit,
                            XtNfromVert, calibCycleTimeLabel,
                            XtNfromHoriz, calibPGainLabel,
                            NULL);

  calibIGainLabel =
    XtVaCreateManagedWidget("calibIGainLabel",
                            labelWidgetClass,
                            calibForm,
                            XtNfromVert, calibPGainLabel,
                            XtNborderWidth, 0,
                            NULL);

  calibIGain =
    XtVaCreateManagedWidget("calibIGain",
                            asciiTextWidgetClass,
                            calibForm,
                            XtNeditType, XawtextEdit,
                            XtNfromVert, calibPGainLabel,
                            XtNfromHoriz, calibIGainLabel,
                            NULL);

  calibDGainLabel =
    XtVaCreateManagedWidget("calibDGainLabel",
                            labelWidgetClass,
                            calibForm,
                            XtNfromVert, calibIGainLabel,
                            XtNborderWidth, 0,
                            NULL);

  calibDGain =
    XtVaCreateManagedWidget("calibDGain",
                            asciiTextWidgetClass,
                            calibForm,
                            XtNeditType, XawtextEdit,
                            XtNfromVert, calibIGainLabel,
                            XtNfromHoriz, calibDGainLabel,
                            NULL);

  calibFF0GainLabel =
    XtVaCreateManagedWidget("calibFF0GainLabel",
                            labelWidgetClass,
                            calibForm,
                            XtNfromVert, calibDGainLabel,
                            XtNborderWidth, 0,
                            NULL);

  calibFF0Gain =
    XtVaCreateManagedWidget("calibFF0Gain",
                            asciiTextWidgetClass,
                            calibForm,
                            XtNeditType, XawtextEdit,
                            XtNfromVert, calibDGainLabel,
                            XtNfromHoriz, calibFF0GainLabel,
                            NULL);

  calibFF1GainLabel =
    XtVaCreateManagedWidget("calibFF1GainLabel",
                            labelWidgetClass,
                            calibForm,
                            XtNfromVert, calibFF0GainLabel,
                            XtNborderWidth, 0,
                            NULL);

  calibFF1Gain =
    XtVaCreateManagedWidget("calibFF1Gain",
                            asciiTextWidgetClass,
                            calibForm,
                            XtNeditType, XawtextEdit,
                            XtNfromVert, calibFF0GainLabel,
                            XtNfromHoriz, calibFF1GainLabel,
                            NULL);

  calibFF2GainLabel =
    XtVaCreateManagedWidget("calibFF2GainLabel",
                            labelWidgetClass,
                            calibForm,
                            XtNfromVert, calibFF1GainLabel,
                            XtNborderWidth, 0,
                            NULL);

  calibFF2Gain =
    XtVaCreateManagedWidget("calibFF2Gain",
                            asciiTextWidgetClass,
                            calibForm,
                            XtNeditType, XawtextEdit,
                            XtNfromVert, calibFF1GainLabel,
                            XtNfromHoriz, calibFF2GainLabel,
                            NULL);

  calibBacklashLabel =
    XtVaCreateManagedWidget("calibBacklashLabel",
                            labelWidgetClass,
                            calibForm,
                            XtNfromVert, calibFF2GainLabel,
                            XtNborderWidth, 0,
                            NULL);


  calibBacklash =
    XtVaCreateManagedWidget("calibBacklash",
                            asciiTextWidgetClass,
                            calibForm,
                            XtNeditType, XawtextEdit,
                            XtNstring, string,
                            XtNfromVert, calibFF2GainLabel,
                            XtNfromHoriz, calibBacklashLabel,
                            NULL);

  calibBiasLabel =
    XtVaCreateManagedWidget("calibBiasLabel",
                            labelWidgetClass,
                            calibForm,
                            XtNfromVert, calibBacklashLabel,
                            XtNborderWidth, 0,
                            NULL);


  calibBias =
    XtVaCreateManagedWidget("calibBias",
                            asciiTextWidgetClass,
                            calibForm,
                            XtNeditType, XawtextEdit,
                            XtNstring, string,
                            XtNfromVert, calibBacklashLabel,
                            XtNfromHoriz, calibBiasLabel,
                            NULL);

  calibMaxErrorLabel =
    XtVaCreateManagedWidget("calibMaxErrorLabel",
                            labelWidgetClass,
                            calibForm,
                            XtNfromVert, calibBiasLabel,
                            XtNborderWidth, 0,
                            NULL);


  calibMaxError =
    XtVaCreateManagedWidget("calibMaxError",
                            asciiTextWidgetClass,
                            calibForm,
                            XtNeditType, XawtextEdit,
                            XtNstring, string,
                            XtNfromVert, calibBiasLabel,
                            XtNfromHoriz, calibMaxErrorLabel,
                            NULL);

  calibOutputScaleLabel =
    XtVaCreateManagedWidget("calibOutputScaleLabel",
                            labelWidgetClass,
                            calibForm,
                            XtNfromVert, calibMaxErrorLabel,
                            XtNborderWidth, 0,
                            NULL);


  calibOutputScale =
    XtVaCreateManagedWidget("calibOutputScale",
                            asciiTextWidgetClass,
                            calibForm,
                            XtNeditType, XawtextEdit,
                            XtNstring, string,
                            XtNfromVert, calibMaxErrorLabel,
                            XtNfromHoriz, calibOutputScaleLabel,
                            NULL);

  calibOutputOffsetLabel =
    XtVaCreateManagedWidget("calibOutputOffsetLabel",
                            labelWidgetClass,
                            calibForm,
                            XtNfromVert, calibOutputScaleLabel,
                            XtNborderWidth, 0,
                            NULL);


  calibOutputOffset =
    XtVaCreateManagedWidget("calibOutputOffset",
                            asciiTextWidgetClass,
                            calibForm,
                            XtNeditType, XawtextEdit,
                            XtNstring, string,
                            XtNfromVert, calibOutputScaleLabel,
                            XtNfromHoriz, calibOutputOffsetLabel,
                            NULL);

  calibFerrorLabel =
    XtVaCreateManagedWidget("calibFerrorLabel",
                            labelWidgetClass,
                            calibForm,
                            XtNfromVert, calibOutputOffsetLabel,
                            XtNborderWidth, 0,
                            NULL);


  calibFerror =
    XtVaCreateManagedWidget("calibFerror",
                            asciiTextWidgetClass,
                            calibForm,
                            XtNeditType, XawtextEdit,
                            XtNstring, string,
                            XtNfromVert, calibOutputOffsetLabel,
                            XtNfromHoriz, calibFerrorLabel,
                            NULL);

  calibDone =
    XtVaCreateManagedWidget("calibDone",
                            commandWidgetClass,
                            calibForm,
                            XtNfromVert, calibFerrorLabel,
                            NULL);

  calibCancel =
    XtVaCreateManagedWidget("calibCancel",
                            commandWidgetClass,
                            calibForm,
                            XtNfromVert, calibFerrorLabel,
                            XtNfromHoriz, calibDone,
                            NULL);

  XtAddCallback(calibDone, XtNcallback, calibDoneCB, NULL);
  XtAddCallback(calibCancel, XtNcallback, calibCancelCB, NULL);

  loggingShell =
    XtVaCreatePopupShell("loggingShell",
                         topLevelShellWidgetClass,
                         topLevel,
                         XtNallowShellResize, True,
                         NULL);

  loggingForm =
    XtVaCreateManagedWidget("loggingForm",
                            formWidgetClass,
                            loggingShell,
                            NULL);

  loggingLabel =
    XtVaCreateManagedWidget("loggingLabel",
                            labelWidgetClass,
                            loggingForm,
                            XtNborderWidth, 0,
                            NULL);

  loggingFileLabel =
    XtVaCreateManagedWidget("loggingFileLabel",
                            labelWidgetClass,
                            loggingForm,
                            XtNfromVert, loggingLabel,
                            XtNborderWidth, 0,
                            NULL);

  loggingFile =
    XtVaCreateManagedWidget("loggingFile",
                            asciiTextWidgetClass,
                            loggingForm,
                            XtNeditType, XawtextEdit,
                            XtNfromVert, loggingLabel,
                            XtNfromHoriz, loggingFileLabel,
                            NULL);

  loggingTypeLabel =
    XtVaCreateManagedWidget("loggingTypeLabel",
                            labelWidgetClass,
                            loggingForm,
                            XtNfromVert, loggingFileLabel,
                            XtNborderWidth, 0,
                            NULL);

  setupMenu(&loggingTypeMenu, "loggingTypeMenu",
            loggingTypeMenuEntryNames,
            loggingForm,
            loggingTypeLabel, loggingFileLabel,
            loggingTypeMenuSelect);

  loggingSizeLabel =
    XtVaCreateManagedWidget("loggingSizeLabel",
                            labelWidgetClass,
                            loggingForm,
                            XtNfromVert, loggingTypeLabel,
                            XtNborderWidth, 0,
                            NULL);

  loggingSize =
    XtVaCreateManagedWidget("loggingSize",
                            asciiTextWidgetClass,
                            loggingForm,
                            XtNeditType, XawtextEdit,
                            XtNfromVert, loggingTypeLabel,
                            XtNfromHoriz, loggingSizeLabel,
                            NULL);

  loggingSkipLabel =
    XtVaCreateManagedWidget("loggingSkipLabel",
                            labelWidgetClass,
                            loggingForm,
                            XtNfromVert, loggingSizeLabel,
                            XtNborderWidth, 0,
                            NULL);

  loggingSkip =
    XtVaCreateManagedWidget("loggingSkip",
                            asciiTextWidgetClass,
                            loggingForm,
                            XtNeditType, XawtextEdit,
                            XtNfromVert, loggingSizeLabel,
                            XtNfromHoriz, loggingSkipLabel,
                            NULL);

  loggingStart =
    XtVaCreateManagedWidget("loggingStart",
                            commandWidgetClass,
                            loggingForm,
                            XtNfromVert, loggingSkipLabel,
                            NULL);

  loggingStop =
    XtVaCreateManagedWidget("loggingStop",
                            commandWidgetClass,
                            loggingForm,
                            XtNfromVert, loggingSkipLabel,
                            XtNfromHoriz, loggingStart,
                            NULL);

  loggingSave =
    XtVaCreateManagedWidget("loggingSave",
                            commandWidgetClass,
                            loggingForm,
                            XtNfromVert, loggingSkipLabel,
                            XtNfromHoriz, loggingStop,
                            NULL);

  loggingPlot =
    XtVaCreateManagedWidget("loggingPlot",
                            commandWidgetClass,
                            loggingForm,
                            XtNfromVert, loggingSkipLabel,
                            XtNfromHoriz, loggingSave,
                            NULL);

  loggingDone =
    XtVaCreateManagedWidget("loggingDone",
                            commandWidgetClass,
                            loggingForm,
                            XtNfromVert, loggingStart,
                            NULL);

  loggingCancel =
    XtVaCreateManagedWidget("loggingCancel",
                            commandWidgetClass,
                            loggingForm,
                            XtNfromVert, loggingStart,
                            XtNfromHoriz, loggingDone,
                            NULL);

  XtAddCallback(loggingStart, XtNcallback, loggingStartCB, NULL);
  XtAddCallback(loggingStop, XtNcallback, loggingStopCB, NULL);
  XtAddCallback(loggingSave, XtNcallback, loggingSaveCB, NULL);
  XtAddCallback(loggingPlot, XtNcallback, loggingPlotCB, NULL);
  XtAddCallback(loggingDone, XtNcallback, loggingDoneCB, NULL);
  XtAddCallback(loggingCancel, XtNcallback, loggingCancelCB, NULL);

  helpXemcShell =
    XtVaCreatePopupShell("helpXemcShell",
                         topLevelShellWidgetClass,
                         topLevel,
                         XtNallowShellResize, True,
                         NULL);

  helpXemcForm =
    XtVaCreateManagedWidget("helpXemcForm",
                            formWidgetClass,
                            helpXemcShell,
                            NULL);

  helpXemcLabel =
    XtVaCreateManagedWidget("helpXemcLabel",
                            labelWidgetClass,
                            helpXemcForm,
                            NULL);

  helpXemcText =
    XtVaCreateManagedWidget("helpXemcText",
                            asciiTextWidgetClass,
                            helpXemcForm,
                            XtNfromVert, helpXemcLabel,
                            XtNeditType, XawtextRead,
                            XtNtype, XawAsciiFile,
                            XtNstring, "doc/xemc.txt",
                            XtNscrollVertical, XawtextScrollWhenNeeded,
                            XtNscrollHorizontal, XawtextScrollWhenNeeded,
                            NULL);

  helpXemcDone =
    XtVaCreateManagedWidget("helpXemcDone",
                            commandWidgetClass,
                            helpXemcForm,
                            XtNfromVert, helpXemcText,
                            NULL);

  XtAddCallback(helpXemcDone, XtNcallback, genericDoneCB, helpXemcShell);

  helpAboutShell =
    XtVaCreatePopupShell("helpAboutShell",
                         transientShellWidgetClass,
                         topLevel,
                         NULL);

  helpAboutDialog =
    XtVaCreateManagedWidget("helpAboutDialog",
                            dialogWidgetClass,
                            helpAboutShell,
                            NULL);

  helpAboutDone =
    XtVaCreateManagedWidget("helpAboutDone",
                            commandWidgetClass,
                            helpAboutDialog,
                            NULL);

  XtAddCallback(helpAboutDone, XtNcallback, genericDoneCB, helpAboutShell);

  toolNumberForm =
    XtVaCreateManagedWidget("toolNumberForm",
                            formWidgetClass,
                            topForm,
                            XtNfromVert, commandMenuForm,
                            NULL);

  toolNumberFormTitle =
    XtVaCreateManagedWidget("toolNumberFormTitle",
                            labelWidgetClass,
                            toolNumberForm,
                            NULL);

  toolNumberFormName =
    XtVaCreateManagedWidget("toolNumberFormName",
                            labelWidgetClass,
                            toolNumberForm,
                            XtNfromHoriz, toolNumberFormTitle,
                            NULL);

  toolOffsetForm =
    XtVaCreateManagedWidget("toolOffsetForm",
                            formWidgetClass,
                            topForm,
                            XtNfromVert, toolNumberForm,
                            NULL);

  toolOffsetFormTitle =
    XtVaCreateManagedWidget("toolOffsetFormTitle",
                            labelWidgetClass,
                            toolOffsetForm,
                            NULL);

  toolOffsetFormName =
    XtVaCreateManagedWidget("toolOffsetFormName",
                            labelWidgetClass,
                            toolOffsetForm,
                            XtNfromHoriz, toolOffsetFormTitle,
                            NULL);

  toolSetOffsetShell =
    XtVaCreatePopupShell("toolSetOffsetShell",
                         transientShellWidgetClass,
                         topLevel,
                         NULL);

  toolSetOffsetForm =
    XtVaCreateManagedWidget("toolSetOffsetForm",
                            formWidgetClass,
                            toolSetOffsetShell,
                            NULL);

  toolSetOffsetToolLabel =
    XtVaCreateManagedWidget("toolSetOffsetToolLabel",
                            labelWidgetClass,
                            toolSetOffsetForm,
                            XtNborderWidth, 0,
                            NULL);

  toolSetOffsetTool =
    XtVaCreateManagedWidget("toolSetOffsetTool",
                            asciiTextWidgetClass,
                            toolSetOffsetForm,
                            XtNfromHoriz, toolSetOffsetToolLabel,
                            XtNeditType, XawtextEdit,
                            NULL);

  toolSetOffsetLengthLabel =
    XtVaCreateManagedWidget("toolSetOffsetLengthLabel",
                            labelWidgetClass,
                            toolSetOffsetForm,
                            XtNfromVert, toolSetOffsetToolLabel,
                            XtNborderWidth, 0,
                            NULL);

  toolSetOffsetLength =
    XtVaCreateManagedWidget("toolSetOffsetLength",
                            asciiTextWidgetClass,
                            toolSetOffsetForm,
                            XtNfromHoriz, toolSetOffsetLengthLabel,
                            XtNfromVert, toolSetOffsetToolLabel,
                            XtNeditType, XawtextEdit,
                            NULL);

  toolSetOffsetDiameterLabel =
    XtVaCreateManagedWidget("toolSetOffsetDiameterLabel",
                            labelWidgetClass,
                            toolSetOffsetForm,
                            XtNfromVert, toolSetOffsetLengthLabel,
                            XtNborderWidth, 0,
                            NULL);

  toolSetOffsetDiameter =
    XtVaCreateManagedWidget("toolSetOffsetDiameter",
                            asciiTextWidgetClass,
                            toolSetOffsetForm,
                            XtNfromHoriz, toolSetOffsetDiameterLabel,
                            XtNfromVert, toolSetOffsetLengthLabel,
                            XtNeditType, XawtextEdit,
                            NULL);

  toolSetOffsetDone =
    XtVaCreateManagedWidget("toolSetOffsetDone",
                            commandWidgetClass,
                            toolSetOffsetForm,
                            XtNfromVert, toolSetOffsetDiameterLabel,
                            NULL);

  toolSetOffsetCancel =
    XtVaCreateManagedWidget("toolSetOffsetCancel",
                            commandWidgetClass,
                            toolSetOffsetForm,
                            XtNfromVert, toolSetOffsetDiameterLabel,
                            XtNfromHoriz, toolSetOffsetDone,
                            NULL);

  XtAddCallback(toolSetOffsetDone, XtNcallback, toolSetOffsetDoneCB, NULL);
  XtAddCallback(toolSetOffsetCancel, XtNcallback, toolSetOffsetCancelCB, NULL);

  positionTypeForm =
    XtVaCreateManagedWidget("positionTypeForm",
                            formWidgetClass,
                            topForm,
                            XtNfromVert, commandMenuForm,
                            XtNfromHoriz, toolNumberForm,
                            NULL);

  positionTypeFormTitle =
    XtVaCreateManagedWidget("positionTypeFormTitle",
                            labelWidgetClass,
                            positionTypeForm,
                            NULL);

  positionTypeFormName =
    XtVaCreateManagedWidget("positionTypeFormName",
                            labelWidgetClass,
                            positionTypeForm,
                            XtNfromHoriz, positionTypeFormTitle,
                            NULL);

  workOffsetForm =
    XtVaCreateManagedWidget("workOffsetForm",
                            formWidgetClass,
                            topForm,
                            XtNfromVert, positionTypeForm,
                            XtNfromHoriz, toolNumberForm,
                            NULL);

  workOffsetFormTitle =
    XtVaCreateManagedWidget("workOffsetFormTitle",
                            labelWidgetClass,
                            workOffsetForm,
                            NULL);

  workOffsetFormName =
    XtVaCreateManagedWidget("workOffsetFormName",
                            labelWidgetClass,
                            workOffsetForm,
                            XtNfromHoriz, workOffsetFormTitle,
                            NULL);

  // set up position labels

  // first get the number we'll need-- must hold both joints and
  // marked Cartesian coordinates
  numPosLabels = numCoords > numJoints ? numCoords : numJoints;

  // create the first pos label manually, and set the next ones to be
  // positioned underneath the previous one
  posLabel[0] =
    XtVaCreateManagedWidget("posLabel",
                            labelWidgetClass,
                            topForm,
                            XtNfromVert, toolOffsetForm,
                            NULL);
  // get the width, for aligning the abort button
  XtVaGetValues(posLabel[0],
                XtNwidth, &posw,
                NULL);

  // do the other labels
  for (t = 1; t < numPosLabels; t++) {
    posLabel[t] =
      XtVaCreateManagedWidget("posLabel",
                              labelWidgetClass,
                              topForm,
                              XtNfromVert, posLabel[t-1],
                              NULL);
  }

  abortCommand =
    XtVaCreateManagedWidget("abortCommand",
                            commandWidgetClass,
                            commandMenuForm,
                            XtNheight, sh + cmfbw + cmfbw + bh,
                            XtNwidth, posw - (bw + mw + stw + 8 * cmfbw),
                            XtNfromHoriz, spindleIncLabel,
                            NULL);

  XtAddCallback(abortCommand, XtNcallback, abortCB, NULL);

  posOffsetShell =
    XtVaCreatePopupShell("posOffsetShell",
                         transientShellWidgetClass,
                         topLevel,
                         NULL);

  posOffsetDialog =
    XtVaCreateManagedWidget("posOffsetDialog",
                            dialogWidgetClass,
                            posOffsetShell,
                            NULL);

  jogSpeedForm =
    XtVaCreateManagedWidget("jogSpeedForm",
                            formWidgetClass,
                            topForm,
                            XtNfromVert, posLabel[numPosLabels - 1],
                            NULL);

  jogSpeedTitleLabel =
    XtVaCreateManagedWidget("jogSpeedTitleLabel",
                            labelWidgetClass,
                            jogSpeedForm,
                            NULL);

  jogSpeedDecLabel =
    XtVaCreateManagedWidget("jogSpeedDecLabel",
                            labelWidgetClass,
                            jogSpeedForm,
                            XtNfromVert, jogSpeedTitleLabel,
                            NULL);

  jogSpeedLabel =
    XtVaCreateManagedWidget("jogSpeedLabel",
                            labelWidgetClass,
                            jogSpeedForm,
                            XtNfromHoriz, jogSpeedDecLabel,
                            XtNfromVert, jogSpeedTitleLabel,
                            NULL);

  jogSpeedIncLabel =
    XtVaCreateManagedWidget("jogSpeedIncLabel",
                            labelWidgetClass,
                            jogSpeedForm,
                            XtNfromHoriz, jogSpeedLabel,
                            XtNfromVert, jogSpeedTitleLabel,
                            NULL);

  jogSpeedShell =
    XtVaCreatePopupShell("jogSpeedShell",
                         transientShellWidgetClass,
                         topLevel,
                         NULL);

  jogSpeedDialog =
    XtVaCreateManagedWidget("jogSpeedDialog",
                            dialogWidgetClass,
                            jogSpeedShell,
                            NULL);

  jogIncrementForm =
    XtVaCreateManagedWidget("jogIncrementForm",
                            formWidgetClass,
                            topForm,
                            XtNfromHoriz, jogSpeedForm,
                            XtNfromVert, posLabel[numPosLabels - 1],
                            NULL);

  jogIncrementTitleLabel =
    XtVaCreateManagedWidget("jogIncrementTitleLabel",
                            labelWidgetClass,
                            jogIncrementForm,
                            NULL);

  setupMenu(&jogIncrementMenu, "jogIncrementMenu",
            jogIncrementMenuEntryNames,
            jogIncrementForm,
            NULL, jogIncrementTitleLabel,
            jogIncrementMenuSelect);

  jogForm =
    XtVaCreateManagedWidget("jogForm",
                            formWidgetClass,
                            topForm,
                            XtNfromHoriz, jogIncrementForm,
                            XtNfromVert, posLabel[numPosLabels - 1],
                            NULL);

  jogTitleLabel =
    XtVaCreateManagedWidget("jogTitleLabel",
                            labelWidgetClass,
                            jogForm,
                            NULL);

  jogMinusLabel =
    XtVaCreateManagedWidget("jogMinusLabel",
                            labelWidgetClass,
                            jogForm,
                            XtNfromVert, jogTitleLabel,
                            NULL);

  homeCommand =
    XtVaCreateManagedWidget("homeCommand",
                            commandWidgetClass,
                            jogForm,
                            XtNfromHoriz, jogMinusLabel,
                            XtNfromVert, jogTitleLabel,
                            NULL);

  XtAddCallback(homeCommand, XtNcallback, homeCB, 0);

  jogPlusLabel =
    XtVaCreateManagedWidget("jogPlusLabel",
                            labelWidgetClass,
                            jogForm,
                            XtNfromHoriz, homeCommand,
                            XtNfromVert, jogTitleLabel,
                            NULL);

  feedOverrideForm =
    XtVaCreateManagedWidget("feedOverrideForm",
                            formWidgetClass,
                            topForm,
                            XtNfromHoriz, jogForm,
                            XtNfromVert, posLabel[numPosLabels - 1],
                            NULL);

  feedOverrideTitleLabel =
    XtVaCreateManagedWidget("feedOverrideTitleLabel",
                            labelWidgetClass,
                            feedOverrideForm,
                            NULL);

  feedOverrideDecLabel =
    XtVaCreateManagedWidget("feedOverrideDecLabel",
                            labelWidgetClass,
                            feedOverrideForm,
                            XtNfromVert, feedOverrideTitleLabel,
                            NULL);

  feedOverrideLabel =
    XtVaCreateManagedWidget("feedOverrideLabel",
                            labelWidgetClass,
                            feedOverrideForm,
                            XtNfromHoriz, feedOverrideDecLabel,
                            XtNfromVert, feedOverrideTitleLabel,
                            NULL);

  feedOverrideIncLabel =
    XtVaCreateManagedWidget("feedOverrideIncLabel",
                            labelWidgetClass,
                            feedOverrideForm,
                            XtNfromHoriz, feedOverrideLabel,
                            XtNfromVert, feedOverrideTitleLabel,
                            NULL);

  feedOverrideShell =
    XtVaCreatePopupShell("feedOverrideShell",
                         transientShellWidgetClass,
                         topLevel,
                         NULL);

  feedOverrideDialog =
    XtVaCreateManagedWidget("feedOverrideDialog",
                            dialogWidgetClass,
                            feedOverrideShell,
                            NULL);

  loggingStatusForm =
    XtVaCreateManagedWidget("loggingStatusForm",
                            formWidgetClass,
                            topForm,
                            XtNfromHoriz, feedOverrideForm,
                            XtNfromVert, posLabel[numPosLabels - 1],
                            NULL);

  loggingStatusTitleLabel =
    XtVaCreateManagedWidget("loggingStatusTitleLabel",
                            labelWidgetClass,
                            loggingStatusForm,
                            NULL);

  loggingStatusOpenLabel =
    XtVaCreateManagedWidget("loggingStatusOpenLabel",
                            labelWidgetClass,
                            loggingStatusForm,
                            XtNfromVert, loggingStatusTitleLabel,
                            NULL);

  loggingStatusStartedLabel =
    XtVaCreateManagedWidget("loggingStatusStartedLabel",
                            labelWidgetClass,
                            loggingStatusForm,
                            XtNfromHoriz, loggingStatusOpenLabel,
                            XtNfromVert, loggingStatusTitleLabel,
                            NULL);

  loggingStatusPointsLabel =
    XtVaCreateManagedWidget("loggingStatusPointsLabel",
                            labelWidgetClass,
                            loggingStatusForm,
                            XtNfromHoriz, loggingStatusStartedLabel,
                            XtNfromVert, loggingStatusTitleLabel,
                            NULL);

  mdiForm =
    XtVaCreateManagedWidget("mdiForm",
                            formWidgetClass,
                            topForm,
                            XtNfromVert, jogSpeedForm,
                            NULL);

  mdiFormTitle =
    XtVaCreateManagedWidget("mdiFormTitle",
                            labelWidgetClass,
                            mdiForm,
                            NULL);

  mdiFormText =
    XtVaCreateManagedWidget("mdiFormText",
                            asciiTextWidgetClass,
                            mdiForm,
                            XtNfromHoriz, mdiFormTitle,
                            XtNeditType, XawtextEdit,
                            NULL);

  mdiCodesLabel =
    XtVaCreateManagedWidget("mdiCodesLabel",
                            labelWidgetClass,
                            topForm,
                            XtNfromVert, mdiForm,
                            NULL);

  programForm =
    XtVaCreateManagedWidget("programForm",
                            formWidgetClass,
                            topForm,
                            XtNfromVert, mdiCodesLabel,
                            NULL);

  programFormTitle =
    XtVaCreateManagedWidget("programFormTitle",
                            labelWidgetClass,
                            programForm,
                            NULL);

  programFormName =
    XtVaCreateManagedWidget("programFormName",
                            labelWidgetClass,
                            programForm,
                            XtNfromHoriz, programFormTitle,
                            NULL);

  programFormStateTitle =
    XtVaCreateManagedWidget("programFormStateTitle",
                            labelWidgetClass,
                            programForm,
                            XtNfromHoriz, programFormName,
                            NULL);

  programFormState =
    XtVaCreateManagedWidget("programFormState",
                            labelWidgetClass,
                            programForm,
                            XtNfromHoriz, programFormStateTitle,
                            NULL);

  programOpenCommand =
    XtVaCreateManagedWidget("programOpenCommand",
                            commandWidgetClass,
                            programForm,
                            XtNfromVert, programFormTitle,
                            NULL);

  XtAddCallback(programOpenCommand, XtNcallback, dialogPopup, fileOpenShell);

  programRunCommand =
    XtVaCreateManagedWidget("programRunCommand",
                            commandWidgetClass,
                            programForm,
                            XtNfromHoriz, programOpenCommand,
                            XtNfromVert, programFormTitle,
                            NULL);

  XtAddCallback(programRunCommand, XtNcallback, programRunCB, NULL);

  programPauseCommand =
    XtVaCreateManagedWidget("programPauseCommand",
                            commandWidgetClass,
                            programForm,
                            XtNfromHoriz, programRunCommand,
                            XtNfromVert, programFormTitle,
                            NULL);

  XtAddCallback(programPauseCommand, XtNcallback, programPauseCB, NULL);

  programResumeCommand =
    XtVaCreateManagedWidget("programResumeCommand",
                            commandWidgetClass,
                            programForm,
                            XtNfromHoriz, programPauseCommand,
                            XtNfromVert, programFormTitle,
                            NULL);

  XtAddCallback(programResumeCommand, XtNcallback, programResumeCB, NULL);

  programStepCommand =
    XtVaCreateManagedWidget("programStepCommand",
                            commandWidgetClass,
                            programForm,
                            XtNfromHoriz, programResumeCommand,
                            XtNfromVert, programFormTitle,
                            NULL);

  XtAddCallback(programStepCommand, XtNcallback, programStepCB, NULL);

  programVerifyCommand =
    XtVaCreateManagedWidget("programVerifyCommand",
                            commandWidgetClass,
                            programForm,
                            XtNfromHoriz, programStepCommand,
                            XtNfromVert, programFormTitle,
                            NULL);

  XtAddCallback(programVerifyCommand, XtNcallback, programVerifyCB, NULL);

  programText =
    XtVaCreateManagedWidget("programText",
                            asciiTextWidgetClass,
                            topForm,
                            XtNfromVert, programForm,
                            NULL);

  // add actions table for all action functions
  XtAppAddActions(app_context, actionsTable, XtNumber(actionsTable));

  // create windows for widgets and map them
  XtRealizeWidget(topLevel);

  // init atom to catch window kills
  killAtom = XInternAtom(XtDisplay(topLevel), "WM_DELETE_WINDOW", False);

  // initialize hard-coded colors
  stringToPixel(topForm, "black", &pixelBlack);
  stringToPixel(topForm, "red", &pixelRed);
  stringToPixel(topForm, "yellow", &pixelYellow);
  stringToPixel(topForm, "green", &pixelGreen);

  // initialize joint frame items
  for (t = 0; t < numJoints; t++) {
    // initialize diagnostics ferrors
    oldAxisFerror[t] = -1.0;
  }

  // initialize position label items
  for (t = 0; t < numPosLabels; t++) {
    // get position label background and border colors for toggling
    getColor(posLabel[t], &posLabelBackground[t], 0);
    getBorderColor(posLabel[t], &posLabelBorderColor[t]);
    // initialize pos label colors
    posColor[t] = 0;
    // initialize label values
    newPosLabelValue[t] = 0.0;
    oldPosLabelValue[t] = DBL_MAX; // forces an update
  }

  // get border color for dialog buttons, for de-highlighting

  getBorderColor(fileOpenDialog, &fileOpenBorderColor);
  setBorderColor(fileOpenDone, pixelRed);

  getBorderColor(fileEditDialog, &fileEditBorderColor);
  setBorderColor(fileEditDone, pixelRed);

  getBorderColor(fileQuitDialog, &fileQuitBorderColor);
  setBorderColor(fileQuitDone, pixelRed);

  getBorderColor(toolSetOffsetForm, &toolSetOffsetFormBorderColor);
  setBorderColor(toolSetOffsetDone, pixelRed);

  getBorderColor(calibForm, &calibFormBorderColor);
  setBorderColor(calibDone, pixelRed);

  getBorderColor(loggingForm, &loggingFormBorderColor);
  setBorderColor(loggingDone, pixelRed);

  // set labels for dynamic labels we can't init in timeoutCB
  sprintf(string, "%d", jogSpeed);
  setLabel(jogSpeedLabel, string);

  // start X interval timer
  XtAppAddTimeOut(app_context, UPDATE_MSECS, timeoutCB, NULL);

  // trap window kill for top level
  XSetWMProtocols(XtDisplay(topLevel), XtWindow(topLevel), &killAtom, 1);

  // loop for events
  XtAppMainLoop(app_context);

  return 0;
}

---