static char ErsGui_id[] = "$Header: /usr/tiburon/unix/gui/tmacs/RCS/ErsGui.cc,v 1.8 1997/10/03 09:30:10 oreilly Exp $";


/*
$Log: ErsGui.cc,v $
Revision 1.8  1997/10/03 09:30:10  oreilly
*** empty log message ***

Revision 1.7  97/09/10  08:50:39  08:50:39  oreilly (Thomas C. O'Reilly)
*** empty log message ***

Revision 1.6  97/05/30  15:52:08  15:52:08  oreilly (Thomas C. O'Reilly)
*** empty log message ***

Revision 1.5  97/05/12  20:37:10  20:37:10  oreilly (Thomas C. O'Reilly)
*** empty log message ***

Revision 1.4  97/03/20  12:29:21  12:29:21  oreilly (Thomas C. O'Reilly)
..

Revision 1.3  96/10/28  09:12:04  09:12:04  oreilly (Thomas C. O'Reilly)
*** empty log message ***

Revision 1.2  96/07/22  10:42:00  10:42:00  oreilly (Thomas C. O'Reilly)
First external release

*/
#include <stdlib.h>
#include <values.h>
#include <Xm/RowColumn.h>
#include <Xm/Form.h>
#include <Xm/Separator.h>
#include <Xm/Label.h>
#include <Xm/PushB.h>
#include <Xm/Frame.h>
#include "ErsGui.h"
#include "TiburonApp.h"
#include "tiburon.h"
#include "AlarmedText.h"

#define dprintf if (debug) fprintf

const char *const ErsGui::latchDisarmedMnem = "Disarmed";
const char *const ErsGui::latchArmedMnem = "Armed";
const char *const ErsGui::latchArmedNoPwrMnem = "ArmedNoPwr";
const char *const ErsGui::latchRunningMnem = "Running";

const char *const ErsGui::latchedMnem = "Latched";
const char *const ErsGui::unlatchedMnem = "Unlatched";
const char *const ErsGui::connectedMnem = "Connected";
const char *const ErsGui::unconnectedMnem = "Unconnected";

ErsGui::ErsGui(const char *name, Widget parent, int period) :
  DmGuiObject(name, parent)
{
  _volts = 0;
  _life = 0;
  _toolsledInterface = 0;
  _mode = 0;
  
  _baseWidget = 
    XtVaCreateWidget(name, xmRowColumnWidgetClass, parent, 
		   XmNorientation, XmVERTICAL,
		   NULL, 0);

  installDestroyHandler();
  
  char errorBuf[errorMsgSize];
  char voltAlarmName[MaxDmNameLen];
  char lifeAlarmName[MaxDmNameLen];
  
  strcpy(voltAlarmName, ERS_DCON_DM_PREFIX);
  strcat(voltAlarmName, BATTERY_VOLTAGE_ALARM_DM);
  strcpy(lifeAlarmName, ERS_DCON_DM_PREFIX);
  strcat(lifeAlarmName, BATTERY_LIFE_ALARM_DM);  

  SystemAlarms *alarms = ((TiburonApp *)theApplication)->systemAlarms;
  Alarm *voltAlarm;
  if ((voltAlarm = alarms->find(voltAlarmName)) == NULL)
  {
    sprintf(errorBuf,
	    "ErsGui::ErsGui() - Couldn't find \"%s\" in SystemAlarms",
	    voltAlarmName);

    setError(errorBuf);
    return;
  }    

  char itemName[MaxDmNameLen];
  strcpy(itemName, ERS_DCON_DM_PREFIX);
  char *namePtr = itemName + strlen(itemName);

  strcpy(namePtr, BATTERY_LIFE_DM);

  DmFlt32Object *dmLife = new DmFlt32Object(itemName);
  if (dmLife->error())
  {
    dmLife->errorMsg(errorBuf);
    setError(errorBuf);
    return;
  }

  Alarm *lifeAlarm;
  if ((lifeAlarm = alarms->find(lifeAlarmName)) == NULL)
  {
    sprintf(errorBuf,
	    "ErsGui::ErsGui() - Couldn't find \"%s\" in SystemAlarms",
	    lifeAlarmName);

    setError(errorBuf);
    return;
  }
  
  strcpy(namePtr, BATTERY_VOLTAGE_DM);

  DmNat16Object *dmVolts = new DmNat16Object(itemName);
  if (dmVolts->error())
  {
    dmVolts->errorMsg(errorBuf);
    setError(errorBuf);
    return;
  }
  
  Widget manager;
  manager = XtVaCreateWidget("modeDepthMgr", xmRowColumnWidgetClass, 
			     _baseWidget, 
			     XmNpacking, XmPACK_COLUMN,
			     XmNnumColumns, 2,
			     XmNorientation, XmVERTICAL,
			     NULL);
  
  XtVaCreateManagedWidget("modeLabel", xmLabelWidgetClass, manager, NULL);
				  
  XtVaCreateManagedWidget("depthLabel", xmLabelWidgetClass, manager, NULL);

  _mode = new ErsMode("mode", manager);
  _mode->show();
  
  _depth = new DynamicLabel("depth", manager);
  _depth->show();
  
  XtManageChild(manager);


  Widget frame;
  
  frame = XtVaCreateManagedWidget("frame", xmFrameWidgetClass, _baseWidget,
				  NULL);
  
  Widget form;
  Widget label;
  
  form = XtVaCreateWidget("batteryMgr", xmFormWidgetClass, frame, NULL);
  
  label = XtVaCreateManagedWidget("batteryLabel", xmLabelWidgetClass, form,
				  XmNtopAttachment, XmATTACH_FORM,
				  XmNleftAttachment, XmATTACH_FORM,
				  NULL);
  
  _batCurr = 
    XtVaCreateManagedWidget("current", xmLabelWidgetClass, form, 
			    XmNleftAttachment, XmATTACH_FORM,
			    XmNtopAttachment, XmATTACH_WIDGET,
			    XmNtopWidget, label,
			    NULL);

  Widget voltButton =
    XtVaCreateManagedWidget("voltButton", xmPushButtonWidgetClass, form,
			    XmNleftAttachment, XmATTACH_FORM,
			    XmNtopAttachment, XmATTACH_WIDGET,
			    XmNtopWidget, _batCurr,
			    NULL);

  XtAddCallback(voltButton, XmNactivateCallback,
		&ErsGui::voltButtonCallback, (XtPointer )this);

  _volts = 
    new AlarmedNat16Text("volts", form, "%.2f V", dmVolts, Aperiodic,
			 voltAlarm, True, 0.001);

  XtVaSetValues(_volts->baseWidget(),
		XmNleftAttachment, XmATTACH_WIDGET,
		XmNleftWidget, voltButton,
		XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
		XmNtopWidget, voltButton,
		NULL);
  
  _volts->show();

  _readVoltTime = 
    XtVaCreateManagedWidget("readVoltTime", xmLabelWidgetClass, form,
			    XmNleftAttachment, XmATTACH_WIDGET,
			    XmNleftWidget, _volts->baseWidget(),
			    XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
			    XmNtopWidget, voltButton,
			    NULL);
  _life = 
    new AlarmedFlt32Text("life", form, "Life:   %.1f hrs", dmLife, period,
			 lifeAlarm);

  XtVaSetValues(_life->baseWidget(),
		XmNleftAttachment, XmATTACH_FORM,
		XmNtopAttachment, XmATTACH_WIDGET,
		XmNtopWidget, voltButton,
		NULL);

  _life->show();
  
  XtManageChild(form);
  
  XtCreateManagedWidget("", xmSeparatorWidgetClass, _baseWidget, NULL, 0);

  XtVaCreateManagedWidget("toolsledLabel", xmLabelWidgetClass, _baseWidget,
			  NULL);

  _toolsledInterface = 
    new ToolsledInterface("toolsled", _baseWidget);

  _toolsledInterface->show();

  strcpy(itemName, ERS_DCON_DM_PREFIX);
  namePtr = itemName + strlen(itemName);
  
  strcpy(namePtr, ERS_DEPTH_METERS_DM);
  _dmDepth = new DmFlt64Object(itemName);
  if (_dmDepth->error())
  {
    _dmDepth->errorMsg(errorBuf);
    setError(errorBuf);
    return;
  }
  
  if (addDmObject(_dmDepth, DmConsumeFlag) == -1)
    return;
  
  strcpy(namePtr, BATTERY_CURRENT_DM);
  _dmBatCurr = new DmNat16Object(itemName);
  if (_dmBatCurr->error())
  {
    _dmBatCurr->errorMsg(errorBuf);
    setError(errorBuf);
    return;
  }
  
  if (addDmObject(_dmBatCurr, DmConsumeFlag) == -1)
    return;
  
  
  strcpy(namePtr, BATTERY_VOLTAGE_CMD_DM);
  _dmReadVoltCmd = new DmEmptyObject(itemName);
  if (_dmReadVoltCmd->error())
  {
    _dmReadVoltCmd->errorMsg(errorBuf);
    setError(errorBuf);
    return;
  }
  
  if (addDmObject(_dmReadVoltCmd, DmProvideFlag) == -1)
    return;
  
  strcpy(itemName, TIBURON_DM_PREFIX);
  namePtr = itemName + strlen(itemName);
  
  if (setConsumePeriod(period) == -1)
    return;
}


ErsGui::~ErsGui()
{
  delete _volts;
  delete _life;
  delete _toolsledInterface;
  delete _mode;
}


void ErsGui::updateGui(DM_Item handle)
{
  char errorBuf[errorMsgSize];
  Errno errno;
  DM_Time t;
  XmString xmstr;
  MBool debug = FALSE;
  Pixel foreground, background;
  
  TiburonApp *app = (TiburonApp *)theApplication;

  char buf[512];
  
  Flt64 depth;
  
  if ((errno = _dmDepth->read(&depth, &t)) != SUCCESS)
  { 
    _dmDepth->errorMsg(errorBuf);
    setError(errorBuf);
  }

  static Flt64 prevDepth = -10000.;
  if (depth != prevDepth)
  {
    sprintf(buf, "%.1f m", depth);
    _depth->setText(buf);
  }
  prevDepth = depth;
  
  Nat16 current;
  if ((errno = _dmBatCurr->read(&current, &t)) != SUCCESS)
  {
    _dmBatCurr->errorMsg(errorBuf);
    setError(errorBuf);
  }
  
  static Nat16 prevCurrent = MAXSHORT;

  if (current != prevCurrent)
  {
    sprintf(buf, "Current:   %d mA", current);
    xmstr = XmStringCreateSimple(buf);
    XtVaSetValues(_batCurr, XmNlabelString, xmstr, NULL);
    XmStringFree(xmstr);    
  }
  prevCurrent = current;
}


void ErsGui::readVoltCmd()
{
  DM_Time t;
  char errorBuf[errorMsgSize];
  t.tv_sec = time(NULL);
  t.tv_usec = 0;
  Errno errno;
  if ((errno = _dmReadVoltCmd->write(&t)) != SUCCESS)
  {
    _dmReadVoltCmd->errorMsg(errorBuf);
    setError(errorBuf);
  }
  char buf[100];
  struct tm *timePtr = gmtime((const time_t *)&t.tv_sec);
  strftime(buf, sizeof(buf), "at %H:%M:%S UTC", timePtr); 
  XmString xmstr = XmStringCreateSimple(buf);
  XtVaSetValues(_readVoltTime, XmNlabelString, xmstr, NULL);
  XmStringFree(xmstr);
  
}


void ErsGui::voltButtonCallback(Widget w, XtPointer clientData,
				XtPointer callData)
{
  ErsGui *obj = (ErsGui *)clientData;
  obj->readVoltCmd();
}


void ErsGui::thresholdButtonCallback(Widget w, XtPointer clientData,
				     XtPointer callData)
{
  fprintf(stderr, "Popup alarm threshold window...\n");
}


void ErsGui::updateFromPeer(DmGuiObject *peer, void *clientData)
{
}