XGpref

//*-- Author :   Joel Snow  2001/01/31
// Extracted from XGwdgt.cxx 2001/01/31 jms 
// latest Modification: 2002/08/06 - jms

// $Author: snow $
// $Date: 2002/08/25 17:16:48 $
// $Id: XGpref.cpp.html,v 1.11 2002/08/25 17:16:48 snow Exp $

#include <iostream>
#include <TSystem.h>
#ifdef NO_SRT
#include "XGpref.hpp"
#else
#include "root_gui/XGpref.hpp"
#endif

static char *rcsid = "@(#) $Id: XGpref.cpp.html,v 1.11 2002/08/25 17:16:48 snow Exp $";

enum E_TABS {ETAB, DTAB, TTAB};
static const int nrshells = 3;
static const char *rshell[nrshells] = {"rsh", "ssh", "d0ssh"};
enum E_WIDS {OK, CAN, RSS, RSH, EXAM, SADR, SPORT, RCP,
	     HGX, HGY, CSX, CSY, PER, FBUT, AWRN, CMB,
	     STO, KTO, GTO, CTO};

ClassImpQ(PrefDialog)

//____________________________________________________________________________
//
// PrefDialog
//
// Preferences Dialog Window
//____________________________________________________________________________

PrefDialog::PrefDialog(const TGWindow *p, const TGWindow *main, prefs *prefs,
		       std::vector<Examine*> **exlist, UInt_t w, UInt_t h,
		       UInt_t options)
          : TGTransientFrame(p, main, w, h, options)
{
   // Create a dialog window. A dialog window pops up with respect to its
   // "main" window.

  parent = (XgooeyMainFrame *)main;
  lprefs = *prefs;
  Xprefs = prefs;
  int nexamine = (*exlist)->size() - 1; //last examine is registry entry
  lexlist = new std::vector<Examine*>(nexamine);
  for (int i=0; i<nexamine; i++) {
    (*lexlist)[i] = new Examine(*((**exlist)[i]));
//      cout << (*lexlist)[i]->GetName() << endl;
  }
  tabWidgets = new TList();
  Exlist = exlist;
  focus = 0;
  GCValues_t gval;
  GContext_t bold, norm;
  FontStruct_t boldfs, normfs;
  gval.fMask = kGCFont;
  boldfs = gClient->GetFontByName(xgClient->getBoldFont());
  normfs = gClient->GetFontByName(xgClient->getNormFont());
  gval.fFont = gVirtualX->GetFontHandle(boldfs);
  bold = gVirtualX->CreateGC(GetId(), &gval);
  gval.fMask = kGCFont;
  gval.fFont = gVirtualX->GetFontHandle(normfs);
  norm = gVirtualX->CreateGC(GetId(), &gval);

  ULong_t fbkgnd, fbkgnd1, fbkgnd2, fbkgnd3;
  if (!gClient->GetColorByName("#ff88ff", fbkgnd)) {
    gClient->GetColorByName("grey", fbkgnd);
  }
  if (!gClient->GetColorByName("light blue", fbkgnd1)) {
    gClient->GetColorByName("grey", fbkgnd1);
  }
  if (!gClient->GetColorByName("#ccffff", fbkgnd2)) {
    gClient->GetColorByName("grey", fbkgnd2);
  }
  if (!gClient->GetColorByName("#ccccff", fbkgnd3)) {
    gClient->GetColorByName("grey", fbkgnd3);
  }
  SetBackgroundColor(fbkgnd);
  fFrame1 = new TGHorizontalFrame(this, 60, 20, kFixedWidth);

//    fOkButton = new TGTextButton(fFrame1, "&Ok", 1);
  fOkButton = new LiveButton(fFrame1, "&Ok","light green", OK, 0, kTRUE);
  fOkButton->Associate(this);
//    fCancelButton = new TGTextButton(fFrame1, "&Cancel", 2);
  fCancelButton = new LiveButton(fFrame1, "&Cancel", "#ff6666", CAN, 0, kTRUE);
  fCancelButton->Associate(this);

  fL1 = new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX,
			  2, 2, 2, 2);
  fL2 = new TGLayoutHints(kLHintsBottom | kLHintsRight, 2, 2, 2, 1);

  fFrame1->AddFrame(fOkButton, fL1);
  fFrame1->AddFrame(fCancelButton, fL1);
  fFrame1->SetBackgroundColor(fbkgnd);

  fFrame1->Resize(150, fOkButton->GetDefaultHeight());
  AddFrame(fFrame1, fL2);

  //--------- create Tab widget and some composite frames

  fTab = new TGTab(this, 300, 300, norm, normfs);
  fTab->SetBackgroundColor(fbkgnd);
  fL3 = new TGLayoutHints(kLHintsTop | kLHintsLeft, 5, 5, 5, 5);
  fL4 = new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX, 5,5, 5,0);
  fL5 = new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX, 5,5, 0,5);
  fLgrp = new TGLayoutHints(kLHintsTop | kLHintsLeft, 0,0, 0,2);
  fLgrpx = new TGLayoutHints(kLHintsTop | kLHintsLeft |
					    kLHintsExpandX, 0,0, 0,2);
  fLlf = new TGLayoutHints(kLHintsTop | kLHintsLeft, 0,5, 5,5);
  fLto = new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX, 0,2,3,0);
  fL6 = new TGLayoutHints(kLHintsTop | kLHintsLeft, 5, 5, 5, 0);
  fL7 = new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX, 5,5, 5,5);
  fL8 = new TGLayoutHints(kLHintsTop | kLHintsLeft, 5, 5, 0, 5);

  char tmp[64];
  strncpy(tmp,rcsid,63);

  EtabList = new TList();
  //--- tab Examine
  tf = fTab->AddTab(new TGHotString("&Examine"));
  tf->SetBackgroundColor(fbkgnd2);
  TGTabElement *tabex = fTab->GetTabTab(0);
  tabex->ChangeBackground(fbkgnd2);
  rsLabel = new TGLabel(tf, new TGHotString("&Remote Start Script:"), norm, normfs);
  rsLabel->SetBackgroundColor(fbkgnd2);
  tf->AddFrame(rsLabel, fL6);
  TGTextBuffer *tbuf5 = new TGTextBuffer(128);
  tbuf5->AddText(0, lprefs.exstart.Data());
  tentrs = new XGTextEntry(tf, tbuf5, RSS, norm, normfs);
  tentrs->Resize(175, tentrs->GetDefaultHeight());
  tf->AddFrame(tentrs, fL5);
  EtabList->Add(tentrs);
  rcmdLabel = new TGLabel(tf, new TGHotString("Re&mote Shell:"), norm, normfs);
  rcmdLabel->SetBackgroundColor(fbkgnd2);
  tf->AddFrame(rcmdLabel, fL6);
  frcmdComboBox = new XGComboBox(tf, RSH);
  frcmdComboBox->Associate(this);
  EtabList->Add(frcmdComboBox);
  for (int i = 0; i<nrshells; i++) {
    frcmdComboBox->AddEntry(rshell[i], i);
    if (lprefs.Rcmd.CompareTo(rshell[i]) == 0)
      frcmdComboBox->Select(i);
  }
  frcmdComboBox->Resize(60, 20);
  tf->AddFrame(frcmdComboBox, fL8);

  fF6 = new TGGroupFrame(tf, new TGHotString("E&xamine"),
			 kVerticalFrame, norm, normfs);
  fF6->SetBackgroundColor(fbkgnd2);

  exSelected = 0;
  fexComboBox = new XGComboBox(fF6, EXAM);
  fexComboBox->Associate(this);
  EtabList->Add(fexComboBox);
  for (unsigned int i = 0; i < lexlist->size(); i++) {
    fexComboBox->AddEntry(((*lexlist)[i])->GetFName().Data(), i);
    if ((*lexlist)[i]->GetName() == lprefs.currEx->GetName()) exSelected = i;
  }
  fexComboBox->AddEntry("Registry", lexlist->size());
  fexComboBox->Select(exSelected);
  fexComboBox->Resize(100, 20);

  fF6->AddFrame(fexComboBox, fLgrp);

  saLabel = new TGLabel(fF6, new TGHotString("&Server Address:"), norm, normfs);
  saLabel->SetBackgroundColor(fbkgnd2);
  fF6->AddFrame(saLabel, fLgrp);
  TGTextBuffer *tbuf2 = new TGTextBuffer(64);
  tbuf2->AddText(0, lprefs.currEx->GetHost());
  tentsa = new XGTextEntry(fF6, tbuf2, SADR, norm, normfs);
  tentsa->Resize(150, tentsa->GetDefaultHeight());
  fF6->AddFrame(tentsa, fLgrp);
  EtabList->Add(tentsa);

  spLabel = new TGLabel(fF6, new TGHotString("Server &Port:"), norm, normfs);
  spLabel->SetBackgroundColor(fbkgnd2);
  fF6->AddFrame(spLabel, fLgrp);
  TGTextBuffer *tbuf3 = new TGTextBuffer(10);
  sprintf(tmp, "%d", lprefs.currEx->GetPort());
  tbuf3->AddText(0, tmp);
  tentsp = new XGTextEntry(fF6, tbuf3, SPORT, norm, normfs);
  tentsp->Resize(60, tentsp->GetDefaultHeight());
  fF6->AddFrame(tentsp, fLgrp);
  EtabList->Add(tentsp);

  rcpLabel = new TGLabel(fF6, new TGHotString("RCP &File:"), norm, normfs);
  rcpLabel->SetBackgroundColor(fbkgnd2);
  fF6->AddFrame(rcpLabel, fLgrp);
  TGTextBuffer *tbuf4 = new TGTextBuffer(64);
  tbuf4->AddText(0, lprefs.currEx->GetRCP());
  tentrcp = new XGTextEntry(fF6, tbuf4, RCP, norm, normfs);
  tentrcp->Resize(175, tentrcp->GetDefaultHeight());
  fF6->AddFrame(tentrcp, fLgrpx);
  EtabList->Add(tentrcp);

  fF6->Resize(fF6->GetDefaultSize());
//    tf->AddFrame(fF6, fL3);
  tf->AddFrame(fF6, fL7);
  tabWidgets->Add(EtabList);

  DtabList = new TList();
  //--- tab Display
  tf = fTab->AddTab(new TGHotString("&Display"));
  tf->SetBackgroundColor(fbkgnd1);
  TGTabElement *tabdi = fTab->GetTabTab(1);
  tabdi->ChangeBackground(fbkgnd1);
  fF4 = new TGCompositeFrame(tf, 60, 20, kVerticalFrame);
  fF4->SetBackgroundColor(fbkgnd1);
  fgridFrame = new TGGroupFrame(fF4, "Histogram Grid", kVerticalFrame,
				norm, normfs);
  fgridFrame->SetLayoutManager(new TGHorizontalLayout(fgridFrame));
  fgridFrame->SetBackgroundColor(fbkgnd1);
  fxLabel = new TGLabel(fgridFrame, new TGHotString("&X:"), norm, normfs);
  fyLabel = new TGLabel(fgridFrame, new TGHotString("&Y:"), norm, normfs);
  fxLabel->SetBackgroundColor(fbkgnd1);
  fyLabel->SetBackgroundColor(fbkgnd1);
  fgridFrame->AddFrame(fxLabel, fL6);
  fxCombo = new XGComboBox(fgridFrame, HGX);
  fxCombo->Associate(this);
  fgridFrame->AddFrame(fxCombo, fL6);
  fgridFrame->AddFrame(fyLabel, fL6);
  fyCombo = new XGComboBox(fgridFrame, HGY);
  fyCombo->Associate(this);
  fgridFrame->AddFrame(fyCombo, fL6);
  DtabList->Add(fxCombo);
  DtabList->Add(fyCombo);
  fF4->AddFrame(fgridFrame, fL4);

  fsizeFrame = new TGGroupFrame(fF4, "Canvas Size", kHorizontalFrame,
				norm, normfs);
  fsizeFrame->SetLayoutManager(new TGHorizontalLayout(fsizeFrame));
  fsizeFrame->SetBackgroundColor(fbkgnd1);
  TGTextBuffer *tbuf0 = new TGTextBuffer(10);
  sprintf(tmp, "%d", lprefs.hcx);
  tbuf0->AddText(0, tmp);
  tsizex = new XGTextEntry(fsizeFrame, tbuf0, CSX, norm, normfs);
  tsizex->Resize(60, tsizex->GetDefaultHeight());
  fsizeFrame->AddFrame(tsizex, fLto);
  DtabList->Add(tsizex);
  fsizeLabel = new TGLabel(fsizeFrame, new TGHotString("&by"), norm, normfs);
  fsizeLabel->SetBackgroundColor(fbkgnd1);
  fsizeFrame->AddFrame(fsizeLabel, fLto);
  TGTextBuffer *tbuf9 = new TGTextBuffer(10);
  sprintf(tmp, "%d", lprefs.hcy);
  tbuf9->AddText(0, tmp);
  tsizey = new XGTextEntry(fsizeFrame, tbuf9, CSY, norm, normfs);
  tsizey->Resize(60, tsizey->GetDefaultHeight());
  fsizeFrame->AddFrame(tsizey, fLto);
  DtabList->Add(tsizey);
  fpixLabel = new TGLabel(fsizeFrame, new TGHotString("pixe&ls"), norm, normfs);
  fpixLabel->SetBackgroundColor(fbkgnd1);
  fsizeFrame->AddFrame(fpixLabel, fLto);
  fF4->AddFrame(fsizeFrame, fL4);

  fdelayFrame = new TGCompositeFrame(fF4, 0, 0);
  fdelayFrame->SetLayoutManager(new TGHorizontalLayout(fdelayFrame));
  fdelayFrame->SetBackgroundColor(fbkgnd1);
  fdelayLabel = new TGLabel(fdelayFrame,
			    new TGHotString("Cycle/Update &Period (s):"),
			    norm, normfs);
  fdelayLabel->SetBackgroundColor(fbkgnd1);
  fdelayFrame->AddFrame(fdelayLabel, fLlf);
  TGTextBuffer *tbuf = new TGTextBuffer(10);
  sprintf(tmp, "%4.1f", (float)(lprefs.Delay)/1000.);
  tbuf->AddText(0, tmp);
  tent = new XGTextEntry(fdelayFrame, tbuf, PER, norm, normfs);
  tent->Resize(40, tent->GetDefaultHeight());
  fdelayFrame->AddFrame(tent, fLlf);
  DtabList->Add(tent);
  fF4->AddFrame(fdelayFrame, fL3);
  fChk1 = new TGCheckButton(fF4, "&Flashable Buttons", FBUT, norm, normfs);
  fChk1->SetBackgroundColor(fbkgnd1);
  fChk1->Associate(this);
  if (lprefs.Flashable) {
    fChk1->SetState(kButtonDown);
  } else {
    fChk1->SetState(kButtonUp);
  }
  fChk1in = fChk1->GetState();
  fF4->AddFrame(fChk1, fL1);
  DtabList->Add(fChk1);
  fChk2 = new TGCheckButton(fF4, "&Audible Warnings", AWRN, norm, normfs);
  fChk2->Associate(this);
  fChk2->SetBackgroundColor(fbkgnd1);
  if (lprefs.bellEnabled) {
    fChk2->SetState(kButtonDown);
  } else {
    fChk2->SetState(kButtonUp);
  }
  fChk2in = fChk2->GetState();
  fF4->AddFrame(fChk2, fL1);
  DtabList->Add(fChk2);
  fChk3 = new TGCheckButton(fF4, "Canvas &Menu Bar", CMB, norm, normfs);
  fChk3->Associate(this);
  fChk3->SetBackgroundColor(fbkgnd1);
  if (lprefs.mbflag > 0) {
    fChk3->SetState(kButtonDown);
  } else {
    fChk3->SetState(kButtonUp);
  }
  fChk3in = fChk3->GetState();
  fF4->AddFrame(fChk3, fL1);
  DtabList->Add(fChk3);
  tf->AddFrame(fF4, fL3);
  tabWidgets->Add(DtabList);

  fFirstEntry = 0;
  fLastEntry  = 6;
  for (int i = fFirstEntry; i < fLastEntry; ++i) {
    sprintf(tmp, "%i", i+1);
    fxCombo->AddEntry(tmp, i);
    fyCombo->AddEntry(tmp, i);
  }
  fxCombo->Select(lprefs.nXh-1);
  fxCombo->Resize(40, 20);
  fyCombo->Select(lprefs.nYh-1);
  fyCombo->Resize(40, 20);

  TtabList = new TList();
  //--- tab Time Outs
  tf = fTab->AddTab(new TGHotString("&Time Outs"));
  tf->SetBackgroundColor(fbkgnd3);
  TGTabElement *tabto = fTab->GetTabTab(2);
  tabto->ChangeBackground(fbkgnd3);
  fF2 = new TGCompositeFrame(tf, 60, 20, kVerticalFrame);
  fF2->SetBackgroundColor(fbkgnd3);
  ftoFrame = new TGGroupFrame(fF2, "Time Outs In Seconds",
			      kVerticalFrame, norm, normfs);
  ftoFrame->SetLayoutManager(new TGHorizontalLayout(ftoFrame));
  ftoFrame->SetBackgroundColor(fbkgnd3);
  ftoFrame1 = new TGCompositeFrame(fF2, 0, 0);
  ftoFrame1->SetLayoutManager(new TGVerticalLayout(ftoFrame1));
  ftoFrame1->SetBackgroundColor(fbkgnd3);
  ftoLabel1 = new TGLabel(ftoFrame1, new TGHotString("&Start Up Wait:"), norm, normfs);
  ftoLabel1->SetBackgroundColor(fbkgnd3);
  ftoFrame1->AddFrame(ftoLabel1, fLlf);
  ftoLabel2 = new TGLabel(ftoFrame1, new TGHotString("&Key Wait:"), norm, normfs);
  ftoLabel2->SetBackgroundColor(fbkgnd3);
  ftoFrame1->AddFrame(ftoLabel2, fLlf);
  ftoLabel3 = new TGLabel(ftoFrame1, new TGHotString("&Go Wait:"), norm, normfs);
  ftoLabel3->SetBackgroundColor(fbkgnd3);
  ftoFrame1->AddFrame(ftoLabel3, fLlf);
  ftoLabel4 = new TGLabel(ftoFrame1, new TGHotString("C&ategory Wait:"), norm, normfs);
  ftoLabel4->SetBackgroundColor(fbkgnd3);
  ftoFrame1->AddFrame(ftoLabel4, fLlf);
  ftoFrame->AddFrame(ftoFrame1, fL3);

  ftoFrame2 = new TGCompositeFrame(fF2, 0, 0);
  ftoFrame2->SetLayoutManager(new TGVerticalLayout(ftoFrame2));
  ftoFrame2->SetBackgroundColor(fbkgnd3);
  TGTextBuffer *tbuf1 = new TGTextBuffer(10);
  sprintf(tmp, "%3.1f", (float)(lprefs.WSstart)/1000.);
  tbuf1->AddText(0, tmp);
  tentto1 = new XGTextEntry(ftoFrame2, tbuf1, STO, norm, normfs);
  tentto1->Resize(40, tentto1->GetDefaultHeight());
  ftoFrame2->AddFrame(tentto1, fLto);
  TtabList->Add(tentto1);
  TGTextBuffer *tbuf6 = new TGTextBuffer(10);
  sprintf(tmp, "%3.1f", (float)(lprefs.WSkey)/1000.);
  tbuf6->AddText(0, tmp);
  tentto2 = new XGTextEntry(ftoFrame2, tbuf6, KTO, norm, normfs);
  tentto2->Resize(40, tentto2->GetDefaultHeight());
  ftoFrame2->AddFrame(tentto2, fLto);
  TtabList->Add(tentto2);
  TGTextBuffer *tbuf7 = new TGTextBuffer(10);
  sprintf(tmp, "%3.1f", (float)(lprefs.WSgomsg)/1000.);
  tbuf7->AddText(0, tmp);
  tentto3 = new XGTextEntry(ftoFrame2, tbuf7, GTO, norm, normfs);
  tentto3->Resize(40, tentto3->GetDefaultHeight());
  ftoFrame2->AddFrame(tentto3, fLto);
  TtabList->Add(tentto3);
  TGTextBuffer *tbuf8 = new TGTextBuffer(10);
  sprintf(tmp, "%3.1f", (float)(lprefs.WShists)/1000.);
  tbuf8->AddText(0, tmp);
  tentto4 = new XGTextEntry(ftoFrame2, tbuf8, CTO, norm, normfs);
  tentto4->Resize(40, tentto4->GetDefaultHeight());
  ftoFrame2->AddFrame(tentto4, fLto);
  TtabList->Add(tentto4);
  ftoFrame->AddFrame(ftoFrame2, fL7);
  tabWidgets->Add(TtabList);

  fF2->AddFrame(ftoFrame, fL5);
  tf->AddFrame(fF2, fL7);

  //--- end of last tab

  fL9 = new TGLayoutHints(kLHintsBottom | kLHintsExpandX |
                                          kLHintsExpandY, 2, 2, 5, 1);
  AddFrame(fTab, fL9);

  BindKey(gClient->GetRoot(), gVirtualX->KeysymToKeycode('a'), kKeyMod1Mask);
  BindKey(gClient->GetRoot(), gVirtualX->KeysymToKeycode('b'), kKeyMod1Mask);
  BindKey(gClient->GetRoot(), gVirtualX->KeysymToKeycode('d'), kKeyMod1Mask);
  BindKey(gClient->GetRoot(), gVirtualX->KeysymToKeycode('e'), kKeyMod1Mask);
  BindKey(gClient->GetRoot(), gVirtualX->KeysymToKeycode('f'), kKeyMod1Mask);
  BindKey(gClient->GetRoot(), gVirtualX->KeysymToKeycode('g'), kKeyMod1Mask);
  BindKey(gClient->GetRoot(), gVirtualX->KeysymToKeycode('k'), kKeyMod1Mask);
  BindKey(gClient->GetRoot(), gVirtualX->KeysymToKeycode('l'), kKeyMod1Mask);
  BindKey(gClient->GetRoot(), gVirtualX->KeysymToKeycode('p'), kKeyMod1Mask);
  BindKey(gClient->GetRoot(), gVirtualX->KeysymToKeycode('r'), kKeyMod1Mask);
  BindKey(gClient->GetRoot(), gVirtualX->KeysymToKeycode('s'), kKeyMod1Mask);
  BindKey(gClient->GetRoot(), gVirtualX->KeysymToKeycode('t'), kKeyMod1Mask);
  BindKey(gClient->GetRoot(), gVirtualX->KeysymToKeycode('x'), kKeyMod1Mask);
  BindKey(gClient->GetRoot(), gVirtualX->KeysymToKeycode('y'), kKeyMod1Mask);
  BindKey(gClient->GetRoot(), gVirtualX->KeysymToKeycode('i'), kKeyControlMask);  
  BindKey(gClient->GetRoot(), gVirtualX->KeysymToKeycode(kKey_Escape), 0);
  BindKey(gClient->GetRoot(), gVirtualX->KeysymToKeycode(kKey_Enter), 0);
  BindKey(gClient->GetRoot(), gVirtualX->KeysymToKeycode(kKey_Return), 0);
  BindKey(gClient->GetRoot(), gVirtualX->KeysymToKeycode(kKey_Tab), 0);
  BindKey(gClient->GetRoot(), gVirtualX->KeysymToKeycode(kKey_Up), 0);
  BindKey(gClient->GetRoot(), gVirtualX->KeysymToKeycode(kKey_Down), 0);
  BindKey(gClient->GetRoot(), gVirtualX->KeysymToKeycode(kKey_Space), 0);

  TQObject::Connect("XGTextEntry", "Clicked(Long_t)", "PrefDialog", this,
		  "setFocus(Long_t)");
  MapSubwindows();
  Resize(GetDefaultSize());

  // position relative to the parent's window
  Window_t wdum;
  int ax, ay;
  gVirtualX->TranslateCoordinates(main->GetId(), GetParent()->GetId(),
			     (((TGFrame *) main)->GetWidth() - fWidth) >> 1,
			     (((TGFrame *) main)->GetHeight() - fHeight) >> 1,
			     ax, ay, wdum);
  Move(ax, ay);

  SetWindowName("ECP Preferences");

  MapWindow();
}

PrefDialog::~PrefDialog()
{
//  cout << "PrefDialog::~PrefDialog" << endl;
  // Delete Pref dialog widgets etc.

  EtabList->Clear();
  DtabList->Clear();
  TtabList->Clear();
  tabWidgets->Clear();

  delete fL9; delete tentto4; delete tentto3; delete tentto2; delete tentto1;
  delete ftoFrame2; delete ftoLabel4; delete ftoLabel3; delete ftoLabel2;
  delete ftoLabel1; delete ftoFrame1; delete ftoFrame; delete fF2;
  delete TtabList; delete fChk3; delete fChk2; delete fChk1; delete tent;
  delete fdelayLabel;
  delete fdelayFrame; delete fpixLabel; delete tsizey; delete fsizeLabel;
  delete tsizex; delete fsizeFrame; delete fyCombo; delete fxCombo;
  delete fyLabel; delete fxLabel; delete fgridFrame; delete fF4;
  delete DtabList; delete tentrcp; delete rcpLabel; delete tentsp;
  delete spLabel; delete fexComboBox; delete fF6; delete frcmdComboBox;
  delete rcmdLabel; delete tentrs; delete rsLabel; delete tentsa;
  delete saLabel; delete EtabList; delete fL8; delete fL7; delete fL6;
  delete fLto; delete fLlf; delete fLgrpx; delete fLgrp; delete fL5;
  delete fL4; delete fL3; delete fTab; delete fL2; delete fL1;
  delete fCancelButton; delete fOkButton; delete fFrame1; delete tabWidgets;
  delete lexlist;

}

void PrefDialog::CloseWindow()
{
  // Called when window is closed via the window manager.
  TQObject::Disconnect("XGTextEntry", "Clicked(Long_t)", this,
		       "setFocus(Long_t)");
  parent->pdiaDestroy();
  delete this;
}

Bool_t PrefDialog::ProcessMessage(Long_t msg, Long_t parm1, Long_t parm2)
{
  // Process messages coming from widgets associated with the dialog.

//    cout << "prefDialog::ProcessMessage: " << GET_MSG(msg) << ","
//         << GET_SUBMSG(msg) << endl;
//    cout << "parm1 = " << parm1 << "," << "parm2 = " << parm2 << endl;

  switch (GET_MSG(msg)) {
  case kC_COMMAND:

    switch (GET_SUBMSG(msg)) {
    case kCM_BUTTON:
      switch(parm1) {
      case OK: {  //OK
//  	printf("x: %d y: %d delay: %sn", fxCombo->GetSelected(), fyCombo->GetSelected(), tent->GetBuffer()->GetString());
	Bool_t good = kTRUE;
	Int_t ax,ay;
	UInt_t root_w,root_h;
	gVirtualX->GetWindowSize(gClient->GetRoot()->GetId(), ax, ay,
				 root_w, root_h);
	int w = atoi(tsizex->GetBuffer()->GetString());
	int h = atoi(tsizey->GetBuffer()->GetString());
	if (w > 0 && h > 0) {
	  if (w > (int)root_w) w = (int)root_w;
	  if (h > (int)root_h) h = (int)root_h;
	  lprefs.hcx = w;
	  lprefs.hcy = h;
	} else
	  good = kFALSE;
	float p = 1000.*atof(tent->GetBuffer()->GetString());
	if (p > 0) lprefs.Delay = int(p);
	else good = kFALSE;

	lprefs.nXh = fxCombo->GetSelected()+1;
	lprefs.nYh = fyCombo->GetSelected()+1;
	p = 1000.*atof(tentto1->GetBuffer()->GetString());
	if (p > 0) lprefs.WSstart = int(p);
	else good = kFALSE;
	p = 1000.*atof(tentto2->GetBuffer()->GetString());
	if (p > 0) lprefs.WSkey = int(p);
	else good = kFALSE;
	p = 1000.*atof(tentto3->GetBuffer()->GetString());
	if (p > 0) lprefs.WSgomsg = int(p);
	else good = kFALSE;
	p = 1000.*atof(tentto4->GetBuffer()->GetString());
	if (p > 0) lprefs.WShists = int(p);
	else good = kFALSE;

	w = atoi(tentsp->GetBuffer()->GetString());
	if (w <= 0) good = kFALSE;
	if (!good) {
	  parent->MsgOut("Bad data in numerical input field!",
			 MO_STDOUT | MO_POPUP, kTRUE);
	  break;
	}
  // change localhost to hostname
	TString sastring = TString(tentsa->GetBuffer()->GetString());
	if (sastring.CompareTo("localhost", TString::kIgnoreCase) == 0)
	  sastring = gSystem->HostName();
	if ((unsigned int)exSelected != lexlist->size()) {
	  Examine* ex = (*lexlist)[exSelected];
	  ex->SetPort(w);
	  ex->SetRCP(tentrcp->GetBuffer()->GetString());
	  ex->SetHost(sastring.Data());
        } else {
	  lprefs.Registrar = sastring;
	  lprefs.RegPort = w;
	}
	lprefs.Rcmd = rshell[frcmdComboBox->GetSelected()];
	lprefs.exstart = tentrs->GetBuffer()->GetString();
	Bool_t oldFlashState = lprefs.Flashable;
	if (fChk1->GetState() != fChk1in) {
	  oldFlashState = lprefs.Flashable;
	  if (fChk1->GetState() == kButtonUp)
	    lprefs.Flashable = kFALSE;
	  else
	    lprefs.Flashable = kTRUE;
	}
	if (fChk2->GetState() != fChk2in) {
	  if (fChk2->GetState() == kButtonUp)
	    lprefs.bellEnabled = kFALSE;
	  else
	    lprefs.bellEnabled = kTRUE;
	}
	if (fChk3->GetState() != fChk3in) {
	  if (fChk3->GetState() == kButtonUp)
	    lprefs.mbflag = -1;
	  else
	    lprefs.mbflag = 1;
	}
	*Xprefs = lprefs;
	int nexamine = lexlist->size();
	for (int i=0; i<nexamine; i++) {
	  *((**Exlist)[i]) = *((*lexlist)[i]);
	}
	parent->SetPrefs(oldFlashState);
	CloseWindow();
	break;
      }
      case CAN:  // Cancel
	printf("nTerminating dialog: %s pressedn",
	       (parm1 == 1) ? "OK" : "Cancel");
	CloseWindow();
	break;
      default:
	break;
      }
      break;
    case kCM_CHECKBUTTON: {
//        cout << " checkbutton "<< parm1 << endl;
      switch(parm1) {
      case FBUT: {
	setFocus(fChk1);
	break;
      }
      case AWRN: {
	setFocus(fChk2);
	break;
      }
      case CMB: {
	setFocus(fChk3);
	break;
      }
      default:
	break;
      }
      break;
    }
    case kCM_COMBOBOX: {
//        cout << " combobox "<< parm1 << endl;
      switch(parm1) {
      case EXAM: {
//  	printf("ComboBox item %ld activatedn", parm2);
	if (parm2 >= 0) {
	  int nexam = lexlist->size();
	  int port = atoi(tentsp->GetBuffer()->GetString());
	  TString host = tentsa->GetBuffer()->GetString();
	  TString rcp = tentrcp->GetBuffer()->GetString();
	  if (parm2 == nexam) {
	    if (exSelected != nexam) {
	      Examine* ex = (*lexlist)[exSelected];
	      ex->SetPort(port);
	      ex->SetRCP(rcp);
	      ex->SetHost(host);
	    }
	    host = lprefs.Registrar;
	    port = lprefs.RegPort;
	    rcp = "";
	    tentrcp->SetState(kFALSE);
	  } else {
	    Examine* ex = 0;
	    tentrcp->SetState(kTRUE);
	    if (exSelected == nexam) {
	      lprefs.Registrar = host;
	      lprefs.RegPort = port;
	    } else {
	      ex = (*lexlist)[exSelected];
	      ex->SetPort(port);
	      ex->SetRCP(rcp);
	      ex->SetHost(host);
	    }
	    ex = (*lexlist)[parm2];
	    port = ex->GetPort();
	    host = ex->GetHost();
	    rcp = ex->GetRCP();
	  }
	  char tmp[16];
	  sprintf(tmp,"%d",port);
	  tentsp->SetText(tmp);
	  tentsa->SetText(host);
	  tentrcp->SetText(rcp);
	  exSelected = parm2;
	}
	focus = fexComboBox; 
	gVirtualX->SetInputFocus(focus->GetId());
	break;
      }
      case RSH: {
	focus = frcmdComboBox;
	gVirtualX->SetInputFocus(focus->GetId());
	break;
      }
      case HGX: {
	focus = fxCombo;
	gVirtualX->SetInputFocus(focus->GetId());
	break;
      }
      case HGY: {
	focus = fyCombo;
	gVirtualX->SetInputFocus(focus->GetId());
	break;
      }
      default:
	break;
      }
    }
    case kCM_TAB:
//        printf("Tab item %ld activatedn", parm1);
      break;
    default:
      break;
    }
    break;

  default:
    break;
  }
  return kTRUE;
}

Bool_t PrefDialog::HandleKey(Event_t *event)
{
   // Handle keyboard events.
//    cout << "PrefDialog::HandleKey: " << event->fCode << " " << event->fState << endl;
  if (event->fType == kGKeyPress) {
    int tab = fTab->GetCurrent();
    TList* tabList = (TList*)(tabWidgets->At(tab));
    if (!tabList) {
      parent->MsgOut("PrefDialog::HandleKey: No tabList!");
      return kTRUE;
    }
    XGComboBox *openBox = 0;
    XGComboBox *wasOpen = 0;
    TGObject *el;
    if (focus && (focus->IsA() == XGComboBox::Class())) {
      openBox = (XGComboBox*)focus;
    }

    if ((int)event->fCode == gVirtualX->KeysymToKeycode(kKey_Up)) {
      if (openBox) {
	int isel = openBox->GetSelected();
	if (isel > 0) {
	  isel--;
	} else {
	  TGListBox *elist = (TGListBox *)(openBox->GetListBox());
	  TList *el = ((TGCompositeFrame*)(elist->GetContainer()))->GetList();
	  isel = el->GetSize()-1;
	}
	openBox->Select(isel);
	openBox->GetListBox()->GetScrollBar()->SetPosition(isel);
      }
      return kFALSE;      
    } else if ((int)event->fCode == gVirtualX->KeysymToKeycode(kKey_Down)) {
      if (openBox) {
	int isel = openBox->GetSelected();
	isel++;
	openBox->Select(isel);
	isel = openBox->GetSelected();
	if (isel == -1 ) {
	  isel = 0;
	  openBox->Select(isel);
	}
	openBox->GetListBox()->GetScrollBar()->SetPosition(isel);
      }
      return kFALSE;
    } else if ((int)event->fCode == gVirtualX->KeysymToKeycode(kKey_Space)) {
      if (focus) {
	if (tab == DTAB) {
	  if (focus->IsA() == TGCheckButton::Class()) {
	    Event_t* event = new Event_t();
	    event->fType = kButtonPress;
	    ((TGCheckButton*)focus)->HandleButton(event);
	    event->fType = kButtonRelease;
	    ((TGCheckButton*)focus)->HandleButton(event);
	    delete event;
	    return kFALSE;
	  }
	}
	if (focus->IsA() == XGTextEntry::Class()) {
	  return ((XGTextEntry*)focus)->HandleKey(event);
	} else if (focus->IsA() == XGComboBox::Class()) {
	  ((XGComboBox*)focus)->OpenBox();
	  return kFALSE;
	}
      }
    }

    if (openBox) {
      wasOpen = openBox;
      openBox->CloseBox();
      openBox = 0;
    }

    if ((int)event->fCode == gVirtualX->KeysymToKeycode('e') &&
	event->fState == kKeyMod1Mask) {
      if (tab != ETAB) {
	fTab->SetTab(ETAB);
      }
      return kFALSE;
    } else if ((int)event->fCode == gVirtualX->KeysymToKeycode('d') &&
	       event->fState == kKeyMod1Mask) {
      if (tab != DTAB) {
	fTab->SetTab(DTAB);
      }
      return kFALSE;
    } else if ((int)event->fCode == gVirtualX->KeysymToKeycode('t') &&
	       event->fState == kKeyMod1Mask) {
      if (tab != TTAB) {
	fTab->SetTab(TTAB);
      }
      return kFALSE;
    } else if ((int)event->fCode == gVirtualX->KeysymToKeycode('s') &&
	       event->fState == kKeyMod1Mask) {
      if (tab == ETAB) {
	setFocus(tentsa);
      } else if (tab == TTAB) {
	setFocus(tentto1);
      }
      return kFALSE;
    } else if ((int)event->fCode == gVirtualX->KeysymToKeycode('r') &&
	       event->fState == kKeyMod1Mask) {
      setFocus(tentrs);
      return kFALSE;
    } else if ((int)event->fCode == gVirtualX->KeysymToKeycode('p') &&
	       event->fState == kKeyMod1Mask) {
      if (tab == ETAB) {
	setFocus(tentsp);
      } else if (tab == DTAB) {
	setFocus(tent);
      }
      return kFALSE;
    } else if ((int)event->fCode == gVirtualX->KeysymToKeycode('f') &&
	       event->fState == kKeyMod1Mask) {
      if (tab == ETAB) {
	setFocus(tentrcp);
	return kFALSE;
      } else if (tab == DTAB) {
	setFocus(fChk1);
      }
    } else if ((int)event->fCode == gVirtualX->KeysymToKeycode('k') &&
	       event->fState == kKeyMod1Mask) {
      setFocus(tentto2);
      return kFALSE;
    } else if ((int)event->fCode == gVirtualX->KeysymToKeycode('g') &&
	       event->fState == kKeyMod1Mask) {
      setFocus(tentto3);
      return kFALSE;
    } else if ((int)event->fCode == gVirtualX->KeysymToKeycode('b') &&
	       event->fState == kKeyMod1Mask) {
      setFocus(tsizex);
      return kFALSE;
    } else if ((int)event->fCode == gVirtualX->KeysymToKeycode('l') &&
	       event->fState == kKeyMod1Mask) {
      setFocus(tsizey);
      return kFALSE;
    } else if ((int)event->fCode == gVirtualX->KeysymToKeycode('a') &&
	       event->fState == kKeyMod1Mask) {
      if (tab == TTAB) {
	setFocus(tentto4);
	return kFALSE;
      } else if (tab == DTAB) {
	setFocus(fChk2);
      }
    } else if ((int)event->fCode == gVirtualX->KeysymToKeycode('m') &&
	       event->fState == kKeyMod1Mask) {
      if (tab == ETAB) {
	setFocus(frcmdComboBox);
	return kFALSE;
      } else if (tab == DTAB) {
	setFocus(fChk3);
      }
    } else if ((int)event->fCode == gVirtualX->KeysymToKeycode('x') &&
	       event->fState == kKeyMod1Mask) {
      if (tab == ETAB) {
	setFocus(fexComboBox);
      } else if (tab == DTAB) {
	setFocus(fxCombo);
      }
      return kFALSE;
    } else if ((int)event->fCode == gVirtualX->KeysymToKeycode('y') &&
	       event->fState == kKeyMod1Mask) {
      if (tab == DTAB) {
	setFocus(fyCombo);
      }
      return kFALSE;
    } else if ((int)event->fCode == gVirtualX->KeysymToKeycode('c') &&
	       event->fState == kKeyControlMask) {
      cout << "Control-c struck" << endl;
      return kFALSE;
    } else if ((int)event->fCode == gVirtualX->KeysymToKeycode('i') &&
	       event->fState == kKeyControlMask) {
      cout << rcsid << endl;
      return kFALSE;
    } else if ((int)event->fCode == gVirtualX->KeysymToKeycode(kKey_Escape)) {
      CloseWindow();
      return kFALSE;
    } else if ((int)event->fCode == gVirtualX->KeysymToKeycode(kKey_Enter) ||
	       (int)event->fCode == gVirtualX->KeysymToKeycode(kKey_Return)) {
      Int_t msg = MK_MSG(kC_COMMAND, kCM_COMBOBOX);
      exSelected = fexComboBox->GetSelected();
      SendMessage(this, msg, EXAM, exSelected);
      return kFALSE;
    } else if ((int)event->fCode == gVirtualX->KeysymToKeycode(kKey_Tab)) {
      int ntab = fTab->GetCurrent();
      TList* tabList = (TList*)(tabWidgets->At(ntab));
      if (!tabList) {
	parent->MsgOut("PrefDialog::HandleKey: No tabList!");
	return kTRUE;
      }
      TIter next(tabList);
      while ((el = (TGObject *) next())) {
	if (el->IsA() == XGTextEntry::Class()) {
	  if ((XGTextEntry*)el == focus) {
	    TGObject *nxtel = (TGObject *)tabList->After(el);
	    if (!nxtel) break;
	    setFocus(nxtel);
	    return kFALSE;
	  }
	} else if (el->IsA() == XGComboBox::Class()) {
	  if ((XGComboBox*)el == focus) {
	    TGObject *nxtel = (TGObject *)tabList->After(el);
	    if (!nxtel) break;
	    setFocus(nxtel);
	    return kFALSE;
	  }
	} else if (el->IsA() == TGCheckButton::Class()) {
	  if ((TGCheckButton*)el == focus) {
	    TGObject *nxtel = (TGObject *)tabList->After(el);
	    if (!nxtel) break;
	    setFocus(nxtel);
	    return kFALSE;
	  }
	} else {
	  parent->MsgOut("PrefDialog::HandleKey: got some unknown widget!");
	}
      }
      TGObject *te = (TGObject*)tabList->At(0);
      setFocus(te);
      return kFALSE;
    }
  }
  return TGTransientFrame::HandleKey(event);
}

void PrefDialog::resetFocus()
{
  if (!focus) return;
  if ((focus->IsA() == XGTextEntry::Class())) {
    Event_t* event = new Event_t();
    event->fCode = kNotifyNormal;
    event->fState = kNotifyNormal;
    event->fType = kFocusOut;
    ((XGTextEntry*)focus)->HandleFocusChange(event);
//      } else if (el->IsA() == XGComboBox::Class()) {
  } else if ((focus->IsA() == TGCheckButton::Class())) {
    ((TGCheckButton*)focus)->ChangeOptions(0);
    ((TGCheckButton*)focus)->DrawBorder();
    fClient->NeedRedraw((TGCheckButton*)focus);
  }
  focus = 0;
}

void PrefDialog::setFocus(TGObject* el)
{
  resetFocus();
  if (el->IsA() == XGTextEntry::Class()) {
    Event_t* event = new Event_t();
    event->fCode = kButton1;
    event->fType = kButtonPress ;
    event->fX = 0;
    ((XGTextEntry*)el)->HandleButton(event);
    event->fCode = kNotifyNormal;
    event->fState = kNotifyNormal;
    event->fType = kFocusIn;
    ((XGTextEntry*)el)->HandleFocusChange(event);
    delete event;
    focus = (XGTextEntry*)el;
  } else if (el->IsA() == XGComboBox::Class()) {
    ((XGComboBox*)el)->OpenBox();
    gVirtualX->SetInputFocus(((XGComboBox*)el)->GetId());
    focus = (XGComboBox*)el;
  } else if (el->IsA() == TGCheckButton::Class()) {
    gVirtualX->SetInputFocus(((TGCheckButton*)el)->GetId());
    ((TGCheckButton*)el)->ChangeOptions(kRaisedFrame);
    ((TGCheckButton*)el)->DrawBorder();
    focus = (TGCheckButton*)el;
  } else {
    parent->MsgOut("PrefDialog::setFocus: got some unknown widget!");
  }
}

void PrefDialog::setFocus(Long_t gid)
{
//    cout << "PrefDialog::setFocus(Long_t gid): " << gid << endl;
  resetFocus();
  focus = fClient->GetWindowById((Handle_t)gid);
  if (!focus)
    parent->MsgOut("PrefDialog::setFocus: got some unknown window id!");
}