#include <Xm/RowColumn.h>
#include <Xm/Form.h>
#include <Xm/Label.h>
#include <Xm/ToggleB.h>
#include <Xm/Frame.h>
#include <Xm/ScrollBar.h>
#include <Xm/PushB.h>
#include <Vk/VkInfoDialog.h>
#include "MainCameraDialog.h"
#include "MainCamera.h"
#include "camera.h"
#include "DmErrno.h"

#define dprintf if (debug) fprintf

const int MainCameraSetup::LowGain = 0;
const int MainCameraSetup::MedGain = 1;
const int MainCameraSetup::HighGain = 2;
const int MainCameraSetup::AutoIris = 0;
const int MainCameraSetup::ManualIris = -1;
const int MainCameraSetup::ColorBarsOff = 0;
const int MainCameraSetup::ColorBarsOn = -1;

VkMenuDesc MainCameraSetup::_shutterMenuDesc[] = 
{ 
  {ACTION, "shutterOff", &MainCameraSetup::shutterCallback},
  {ACTION, "shutter100", &MainCameraSetup::shutterCallback},
  {ACTION, "shutter500", &MainCameraSetup::shutterCallback},
  {ACTION, "shutter1000", &MainCameraSetup::shutterCallback},
  {ACTION, "shutterSs", &MainCameraSetup::shutterCallback},
  {ACTION, "shutterElc", &MainCameraSetup::shutterCallback},
  {END}
};    


VkMenuDesc MainCameraSetup::_sceneMenuDesc[] = 
{ 
  {ACTION, "userSet", &MainCameraSetup::sceneCallback},
  {ACTION, "scene1", &MainCameraSetup::sceneCallback},
  {ACTION, "scene2", &MainCameraSetup::sceneCallback},
  {ACTION, "scene3", &MainCameraSetup::sceneCallback},
  {END}
};    


MainCameraSetup::MainCameraSetup(const char *name, Widget parent, 
				 MainCamera *mainCamera)
  : DmGuiObject(name, parent)
{
  _baseWidget = XtVaCreateWidget(name, xmRowColumnWidgetClass, parent, 
				 NULL);
  installDestroyHandler();
  Widget mgr, mgr2;
  Widget frame;
  
  _mainCamera = mainCamera;
  
  mgr = 
    XtVaCreateWidget("mgr", xmRowColumnWidgetClass, _baseWidget,
		     XmNorientation, XmHORIZONTAL,
		     NULL);

  mgr2 = 
    XtVaCreateWidget("mgr2", xmRowColumnWidgetClass, mgr,
		     XmNorientation, XmVERTICAL,
		     NULL);

  _colorBars = 
    XtVaCreateManagedWidget("colorBars", xmToggleButtonWidgetClass,
			    mgr2, NULL);

  XtAddCallback(_colorBars, XmNvalueChangedCallback, 
		&MainCameraSetup::valueChangedCallback, (XtPointer )this);

  _autoIris = 
    XtVaCreateManagedWidget("autoIris", xmToggleButtonWidgetClass,
			    mgr2, NULL);
  
  XtAddCallback(_autoIris, XmNvalueChangedCallback, 
		&MainCameraSetup::valueChangedCallback, (XtPointer )this);

  XtManageChild(mgr2);

  frame = 
    XtVaCreateManagedWidget("frame", xmFrameWidgetClass, mgr, NULL);

  Widget gainMgr = 
    XtVaCreateWidget("gainMgr", xmRowColumnWidgetClass, frame,
		     XmNorientation, XmHORIZONTAL,
		     NULL);

  _gainMode = new VkRadioBox("gainMode", gainMgr);
  _manualGainMode = 
    _gainMode->addItem("manual", False, &MainCameraSetup::gainModeCallback,
		       this);

  _gainMode->addItem("lowAuto",  False, &MainCameraSetup::gainModeCallback,
		     this);

  _gainMode->addItem("highAuto",  False, &MainCameraSetup::gainModeCallback,
		     this);

  _gainMode->show();


  _gain = new VkRadioBox("gain", gainMgr);
  XtVaSetValues(_gain->baseWidget(),
		XmNorientation, XmHORIZONTAL,
		NULL);
  
  _gain->addItem("lowGain", False, &MainCameraSetup::gainSelectCallback,
		 this);

  _gain->addItem("medGain", False, &MainCameraSetup::gainSelectCallback,
		 this);

  _gain->addItem("highGain", False, &MainCameraSetup::gainSelectCallback,
		 this);

  _gain->show();

  XtManageChild(gainMgr);
  
  _sharpness = new VkRadioBox("sharpness", mgr);
  XtVaSetValues(_sharpness->baseWidget(),
		XmNorientation, XmHORIZONTAL,
		NULL);
  
  _sharpness->addItem("highSharp", False, 
		      &MainCameraSetup::sharpSelectCallback,
		      this);

  _sharpness->addItem("lowSharp", False, 
		      &MainCameraSetup::sharpSelectCallback,
		      this);

  _sharpness->addItem("sharpOff", False, &MainCameraSetup::sharpSelectCallback,
		      this);

  _sharpness->show();

  mgr2 = 
    XtVaCreateWidget("mgr2", xmRowColumnWidgetClass, mgr,
		     XmNorientation, XmVERTICAL,
		     NULL);

  _shutter = new VkOptionMenu(mgr2, "shutter", _shutterMenuDesc,
			      (XtPointer )this);

  _scene = new VkOptionMenu(mgr2, "scene", _sceneMenuDesc,
			    (XtPointer )this);
  
  XtManageChild(mgr2);
  XtManageChild(mgr);

  mgr = 
    XtVaCreateWidget("mgr", xmRowColumnWidgetClass, _baseWidget,
		     XmNorientation, XmHORIZONTAL,
		     NULL);

  _balanceMode = new VkRadioBox("balanceMode", mgr);
  XtVaSetValues(_balanceMode->baseWidget(),
		XmNorientation, XmHORIZONTAL,
		NULL);
  
  _manualBalanceMode = 
    _balanceMode->addItem("manual", False, 
			  &MainCameraSetup::balanceModeSelectCallback,
			  this);

  _balanceMode->addItem("autoA", False, 
			&MainCameraSetup::balanceModeSelectCallback,
			this);

  _balanceMode->addItem("autoB", False, 
			&MainCameraSetup::balanceModeSelectCallback,
			this);

  _balanceMode->show();

  Widget balanceMgr = 
    XtVaCreateWidget("balanceMgr", xmRowColumnWidgetClass, mgr,
		     XmNorientation, XmVERTICAL, NULL);

  frame = 
    XtVaCreateManagedWidget("frame", xmFrameWidgetClass, balanceMgr, NULL);
  
  _manualBalanceMgr = 
    XtVaCreateWidget("manualBalanceMgr", xmFormWidgetClass, frame,
		     NULL);
  
  const int sliderSize = 400;
  const int colorGainMin = 0;
  const int colorGainMax = 100;
  const int scrollBarLeftEdge = 25;
  
  Widget label;
  Widget mainLabel;
  
  mainLabel = 
    XtVaCreateManagedWidget("manualBalanceLabel", xmLabelWidgetClass, 
			    _manualBalanceMgr, 
			    XmNleftAttachment, XmATTACH_FORM,
			    XmNtopAttachment,  XmATTACH_FORM,
			    NULL);

  label = 
    XtVaCreateManagedWidget("redGainLabel", xmLabelWidgetClass, 
			    _manualBalanceMgr, 
			    XmNleftAttachment, XmATTACH_FORM,
			    XmNtopAttachment,  XmATTACH_WIDGET,
			    XmNtopWidget, mainLabel,
			    NULL);

  _redGain = 
    XtVaCreateManagedWidget("redGain", xmScrollBarWidgetClass, 
			    _manualBalanceMgr,
			    XmNorientation, XmHORIZONTAL,
//			    XmNsliderSize, sliderSize,
			    XmNminimum, colorGainMin,
			    XmNmaximum, colorGainMax + sliderSize,
			    XmNleftAttachment, XmATTACH_POSITION,
			    XmNleftPosition, scrollBarLeftEdge,
			    XmNtopAttachment,  XmATTACH_WIDGET,
			    XmNtopWidget, mainLabel,
			    NULL);

  XtAddCallback(_redGain, XmNvalueChangedCallback, 
		&MainCameraSetup::balanceAdjustCallback,
		(XtPointer )this);

  label = 
    XtVaCreateManagedWidget("blueGainLabel", xmLabelWidgetClass, 
			    _manualBalanceMgr, 
			    XmNleftAttachment, XmATTACH_FORM,
			    XmNtopAttachment,  XmATTACH_WIDGET,
			    XmNtopWidget, _redGain,
			    NULL);
  _blueGain = 
    XtVaCreateManagedWidget("blueGain", xmScrollBarWidgetClass, 
			    _manualBalanceMgr,
			    XmNorientation, XmHORIZONTAL,
//			    XmNsliderSize, sliderSize,
			    XmNminimum, colorGainMin,
			    XmNmaximum, colorGainMax + sliderSize,
			    XmNleftAttachment, XmATTACH_POSITION,
			    XmNleftPosition, scrollBarLeftEdge,
			    XmNtopAttachment,  XmATTACH_WIDGET,
			    XmNtopWidget, _redGain,
			    NULL);
  
  XtAddCallback(_blueGain, XmNvalueChangedCallback, 
		&MainCameraSetup::balanceAdjustCallback,
		(XtPointer )this);

  label = 
    XtVaCreateManagedWidget("redPedestalLabel", xmLabelWidgetClass, 
			    _manualBalanceMgr, 
			    XmNleftAttachment, XmATTACH_FORM,
			    XmNtopAttachment,  XmATTACH_WIDGET,
			    XmNtopWidget, _blueGain,
			    NULL);

  _redPedestal =
    XtVaCreateManagedWidget("redPedestal", xmScrollBarWidgetClass, 
			    _manualBalanceMgr,
			    XmNorientation, XmHORIZONTAL,
//			    XmNsliderSize, sliderSize,
			    XmNminimum, colorGainMin,
			    XmNmaximum, colorGainMax + sliderSize,
			    XmNleftAttachment, XmATTACH_POSITION,
			    XmNleftPosition, scrollBarLeftEdge,
			    XmNtopAttachment,  XmATTACH_WIDGET,
			    XmNtopWidget, _blueGain,
			    NULL);

  XtAddCallback(_redPedestal, XmNvalueChangedCallback, 
		&MainCameraSetup::balanceAdjustCallback,
		(XtPointer )this);

  label = 
    XtVaCreateManagedWidget("bluePedestalLabel", xmLabelWidgetClass, 
			    _manualBalanceMgr, 
			    XmNleftAttachment, XmATTACH_FORM,
			    XmNtopAttachment,  XmATTACH_WIDGET,
			    XmNtopWidget, _redPedestal,
			    NULL);
  _bluePedestal =
    XtVaCreateManagedWidget("bluePedestal", xmScrollBarWidgetClass, 
			    _manualBalanceMgr,
			    XmNorientation, XmHORIZONTAL,
//			    XmNsliderSize, sliderSize,
			    XmNminimum, colorGainMin,
			    XmNmaximum, colorGainMax + sliderSize,
			    XmNleftAttachment, XmATTACH_POSITION,
			    XmNleftPosition, scrollBarLeftEdge,
			    XmNtopAttachment,  XmATTACH_WIDGET,
			    XmNtopWidget, _redPedestal,
			    NULL);

  XtAddCallback(_bluePedestal, XmNvalueChangedCallback, 
		&MainCameraSetup::balanceAdjustCallback,
		(XtPointer )this);


  label = 
    XtVaCreateManagedWidget("totalPedestalLabel", xmLabelWidgetClass, 
			    _manualBalanceMgr, 
			    XmNleftAttachment, XmATTACH_FORM,
			    XmNtopAttachment,  XmATTACH_WIDGET,
			    XmNtopWidget, _bluePedestal,
			    NULL);
  _totalPedestal =
    XtVaCreateManagedWidget("totalPedestal", xmScrollBarWidgetClass, 
			    _manualBalanceMgr,
			    XmNorientation, XmHORIZONTAL,
//			    XmNsliderSize, sliderSize,
			    XmNminimum, colorGainMin,
			    XmNmaximum, colorGainMax + sliderSize,
			    XmNleftAttachment, XmATTACH_POSITION,
			    XmNleftPosition, scrollBarLeftEdge,
			    XmNtopAttachment,  XmATTACH_WIDGET,
			    XmNtopWidget, _bluePedestal,
			    NULL);
  
  XtAddCallback(_totalPedestal, XmNvalueChangedCallback, 
		&MainCameraSetup::balanceAdjustCallback,
		(XtPointer )this);

  XtManageChild(_manualBalanceMgr);

  frame = 
    XtVaCreateManagedWidget("frame", xmFrameWidgetClass, balanceMgr, NULL);

  _autoBalanceMgr = 
    XtVaCreateWidget("autoBalanceMgr", xmRowColumnWidgetClass, frame,
		     XmNorientation, XmHORIZONTAL, 
		     XmNpacking, XmPACK_COLUMN,
		     NULL);
  
  label = 
    XtVaCreateManagedWidget("autoBalanceLabel", xmLabelWidgetClass, 
			    _autoBalanceMgr, 
			    NULL);

  _autoWhite = 
    XtVaCreateManagedWidget("autoWhite", xmPushButtonWidgetClass, 
			    _autoBalanceMgr, NULL);
  
  XtAddCallback(_autoWhite, XmNactivateCallback,
		&MainCameraSetup::autoCallback,
		(XtPointer )this);

  _autoBlack = 
    XtVaCreateManagedWidget("autoBlack", xmPushButtonWidgetClass, 
			    _autoBalanceMgr, NULL);
  
  XtAddCallback(_autoBlack, XmNactivateCallback,
		&MainCameraSetup::autoCallback,
		(XtPointer )this);
		

  _holdAuto = 
    XtVaCreateManagedWidget("holdAuto", xmPushButtonWidgetClass, 
			    _autoBalanceMgr, NULL);
  
  XtAddCallback(_holdAuto, XmNactivateCallback,
		&MainCameraSetup::autoCallback,
		(XtPointer )this);

  XtManageChild(_autoBalanceMgr);
  
  XtManageChild(balanceMgr);
			    
  XtManageChild(mgr);

  char itemName[MaxDmNameLen];
  strcpy(itemName, _mainCamera->dmPrefix());
  char *namePtr = itemName + strlen(itemName);
  
  strcpy(namePtr, GAIN_VALUE_DM);
  _dmGain = new DmInt16Object(itemName);
  if (addDmObject(_dmGain, DmConsumeFlag | DmProvideFlag) == -1)
    return;
  
  strcpy(namePtr, GAIN_MODE_DM);
  _dmGainMode = new DmInt16Object(itemName);
  if (addDmObject(_dmGainMode, DmConsumeFlag | DmProvideFlag) == -1)
    return;  

  strcpy(namePtr, IRIS_MODE_DM);
  _dmIrisMode = new DmInt16Object(itemName);
  if (addDmObject(_dmIrisMode, DmConsumeFlag | DmProvideFlag) == -1)
    return;    

  strcpy(namePtr, COLOR_BARS_MODE_DM);
  _dmColorBars = new DmBooleanObject(itemName);
  if (addDmObject(_dmColorBars, DmConsumeFlag | DmProvideFlag) == -1)
    return;
  
  if (setConsumePeriod(Aperiodic) == -1)
    return;

  _externalChange = False;

  updateGui();
}


MainCameraSetup::~MainCameraSetup()
{
}


void MainCameraSetup::updateGui(DM_Item handle)
{
  Boolean debug = True;
  
  dprintf(stderr, "MainCameraSetup::updateGui()\n");
  
  Int16 value;
  DM_Time t;
  Errno errno;
  char errorBuf[errorMsgSize];

  /* Set flag which tells widget callbacks not to fire. This is necessary
     because the ViewKit VkRadioBox::setValue() function *always* invokes
     the associated callbacks (dumb!). So we check the value of this flag
     in the callbacks themselves. */
  _externalChange = True;

  int index;
  
  if ((errno = _dmGainMode->read(&value, &t)) != SUCCESS)
  {
    sprintDmError(errno, "MainCameraSetup::updateGui() - reading gain mode",
		  errorBuf);
    setError(errorBuf);
  }
  else
  {
    index = -1;  
    switch (value)
    {
      case ManualGain:
      index = 0;
      break;
      
      case LowAutoGain:
      index = 1;
      break;
      
      case HighAutoGain:
      index = 2;
      break;

      default:
      sprintf(errorBuf, 
	      "MainCameraSetup::updateGui() - %d: invalid gain mode",
	      value);

      setError(errorBuf);
    }
    if (index != -1)
    {
      _gainMode->setValue(index, True);
    }

    if (value == ManualGain)
    {
      // Manual mode; sensitize gain value buttons
      XtSetSensitive(_gain->baseWidget(), True);
    }
    else
    {
      // Auto mode; de-sensitize gain value buttons
      XtSetSensitive(_gain->baseWidget(), False);
    }
  }

  if ((errno = _dmGain->read(&value, &t)) != SUCCESS)
  {
    sprintDmError(errno, "MainCameraSetup::updateGui() - reading gain",
		  errorBuf);
    setError(errorBuf);
  }
  else
  {
    index = -1;
  
    switch (value)
    {
      case LowGain:
      index = 0;
      break;
    
      case MedGain:
      index = 1;
      break;
    
      case HighGain:
      index = 2;
      break;
    
      default:
      sprintf(errorBuf, "MainCameraSetup::updateGui() - %d: invalid gain",
	      value);

      setError(errorBuf);
    }
    if (index != -1)
      _gain->setValue(index, True);
  }
  
  if ((errno = _dmIrisMode->read(&value, &t)) != SUCCESS)
  {
    sprintDmError(errno, "MainCameraSetup::updateGui() - reading iris mode",
		  errorBuf);

    setError(errorBuf);
  }  
  else
  {
    switch (value)
    {
      case AutoIris:
      XtVaSetValues(_autoIris, XmNset, True, NULL);
      break;
      
      case ManualIris:
      XtVaSetValues(_autoIris, XmNset, False, NULL);
      break;
      
      default:
      sprintf(errorBuf, 
	      "MainCameraSetup::updateGui() - %d: invalid auto iris",
	      value);

      setError(errorBuf);
    }
  }

  MBool showColorBars;
  if ((errno = _dmColorBars->read(&showColorBars, &t)) != SUCCESS)
  {
    sprintDmError(errno, 
		  "MainCameraSetup::updateGui() - reading color bar mode",
		  errorBuf);

    setError(errorBuf);
  }  
  else
  {
    Boolean set;
    if (showColorBars)
      set = True;
    else
      set = False;
    
    XtVaSetValues(_colorBars, XmNset, set, NULL);
  }

  _externalChange = False;
}


void MainCameraSetup::gainModeCallback(Widget w, XtPointer clientData,
				       XtPointer callData)
{
  XmToggleButtonCallbackStruct *cb = 
    (XmToggleButtonCallbackStruct *)callData;
  
  if (!cb->set)
    return;

  Boolean debug = False;
  dprintf(stderr, "MainCameraSetup::gainModeCallback()\n");
  
  MainCameraSetup *obj = (MainCameraSetup *)clientData;
  dprintf(stderr, "_externalChange = %d\n", obj->_externalChange);

  if (obj->_externalChange)
    return;
  
  if (w == obj->_manualGainMode)
  {
    // Manual mode; sensitize gain value buttons
    XtSetSensitive(obj->_gain->baseWidget(), True);
  }
  else
  {
    // Auto mode; de-sensitize gain value buttons
    XtSetSensitive(obj->_gain->baseWidget(), False);
  }

  obj->writeValues();
}


void MainCameraSetup::valueChangedCallback(Widget w,
					   XtPointer clientData,
					   XtPointer callData)
{
  Boolean debug = False;
  dprintf(stderr, "MainCameraSetup::valueChangedCallback()\n");
  
  MainCameraSetup *obj = (MainCameraSetup *)clientData;
  obj->writeValues();
}


void MainCameraSetup::notImplemented()
{
  theInfoDialog->postAndWait("Not implemented");
}


void MainCameraSetup::sharpSelectCallback(Widget w,
					  XtPointer clientData,
					  XtPointer callData)
{
  XmToggleButtonCallbackStruct *cb = 
    (XmToggleButtonCallbackStruct *)callData;
  
  if (!cb->set)
    return;

  MainCameraSetup *obj = (MainCameraSetup *)clientData;
  obj->notImplemented();
}


void MainCameraSetup::shutterCallback(Widget w,
				      XtPointer clientData,
				      XtPointer callData)
{
  MainCameraSetup *obj = (MainCameraSetup *)clientData;
  obj->notImplemented();
}


void MainCameraSetup::sceneCallback(Widget w,
				      XtPointer clientData,
				      XtPointer callData)
{
  MainCameraSetup *obj = (MainCameraSetup *)clientData;
  obj->notImplemented();
}


void MainCameraSetup::balanceAdjustCallback(Widget w,
					    XtPointer clientData,
					    XtPointer callData)
{
  MainCameraSetup *obj = (MainCameraSetup *)clientData;
  obj->notImplemented();
}


void MainCameraSetup::autoCallback(Widget w,
				   XtPointer clientData,
				   XtPointer callData)
{
  MainCameraSetup *obj = (MainCameraSetup *)clientData;
  obj->notImplemented();
}


void MainCameraSetup::balanceModeSelectCallback(Widget w,
						XtPointer clientData,
						XtPointer callData)
{
  XmToggleButtonCallbackStruct *cb = 
    (XmToggleButtonCallbackStruct *)callData;
  
  if (!cb->set)
    return;

  MainCameraSetup *obj = (MainCameraSetup *)clientData;

  if (w == obj->_manualBalanceMode)
  {
    XtSetSensitive(obj->_manualBalanceMgr, True);
    XtSetSensitive(obj->_autoBalanceMgr, False);
  }
  else
  {
    XtSetSensitive(obj->_manualBalanceMgr, False);
    XtSetSensitive(obj->_autoBalanceMgr, True);
  }
  
  obj->notImplemented();
}


void MainCameraSetup::gainSelectCallback(Widget w,
					 XtPointer clientData,
					 XtPointer callData)
{
  XmToggleButtonCallbackStruct *cb = 
    (XmToggleButtonCallbackStruct *)callData;
  
  if (!cb->set)
    return;
  
  Boolean debug = False;
  dprintf(stderr, "MainCameraSetup::valueChangedCallback()\n");
  
  MainCameraSetup *obj = (MainCameraSetup *)clientData;
  if (obj->_externalChange)
    return;
  
  obj->writeValues();
}


void MainCameraSetup::writeValues()
{
  Int16 value;
  DM_Time t;
  Errno errno;
  char errorBuf[errorMsgSize];
  t.tv_sec = time(NULL);
  t.tv_usec = 0;

  int i;
  for (i = 0; i <= 2; i++)
  {
    if (_gainMode->getValue(i))
      break;
  }

  switch (i)
  {
    case 0:
    value = ManualGain;
    break;
    
    case 1:
    value = LowAutoGain;
    break;
    
    case 2:
    value = HighAutoGain;
    break;
    
  }
  
  if ((errno = _dmGainMode->write(value, &t)) != SUCCESS)
  {
    sprintDmError(errno, 
		  "MainCameraSetup::writeValues() - writing gain mode",
		  errorBuf);

    setError(errorBuf);
  }

  if (value == ManualGain)
  {
    for (i = 0; i < 3; i++)
    {
      if (_gain->getValue(i))
      {
	switch (i)
	{
	  case 0:
	  value = (Int16 )LowGain; 
	  break;
	
	  case 1:
	  value = (Int16 )MedGain;
	  break;
	
	  case 2:
	  value = (Int16 )HighGain; 
	  break;
	}
	break;
      }
    }
    if ((errno = _dmGain->write(value, &t)) != SUCCESS)
    {
      sprintDmError(errno, "MainCameraSetup::writeValues() - writing gain",
		    errorBuf);

      setError(errorBuf);
    }

    // Must reassert Manual gain
    value = ManualGain;
    
    if ((errno = _dmGainMode->write(value, &t)) != SUCCESS)
    {
      sprintDmError(errno, 
		    "MainCameraSetup::writeValues() - writing gain mode",
		    errorBuf);

      setError(errorBuf);
    }
  }

  Boolean set;
  XtVaGetValues(_autoIris, XmNset, &set, NULL);
  if (set)
    value = AutoIris;
  else
    value = ManualIris;
  
  if ((errno = _dmIrisMode->write(value, &t)) != SUCCESS)
  {
    sprintDmError(errno, "MainCameraSetup::writeValues() - writing iris mode",
		  errorBuf);

    setError(errorBuf);
  }  

  XtVaGetValues(_colorBars, XmNset, &set, NULL);
  MBool colorBars;
  if (set)
    colorBars = ColorBarsOn;
  else
    colorBars = ColorBarsOff;
  
  if ((errno = _dmColorBars->write(colorBars, &t)) != SUCCESS)
  {
    sprintDmError(errno, 
		  "MainCameraSetup::writeValues() - writing color bar mode",
		  errorBuf);

    setError(errorBuf);
  }  
}


Widget MainCameraDialog::createDialog(Widget parent)
{
  Widget base = VkGenericDialog::createDialog(parent);

  setup = new MainCameraSetup("mainCameraSetup", base, _mainCamera);
  setup->show();
  
  _showOK = False;
  _showApply = False;
  _showCancel = True;
  
  return base;
}