/********************************************************************\

  Name:         fmidas.c
  Created by:   Stefan Ritt

  Contents:     ROOT based Midas GUI for histo display and experiment
                control

  $Id$

\*******************************************************************/

#include "TGButton.h"
#include "TRootEmbeddedCanvas.h"
#include "TGLayout.h"
#include "TH2.h"
#include "TCanvas.h"
#include "TSocket.h"
#include "TMessage.h"
#include "TGMsgBox.h"
#include "TApplication.h"
#include "TROOT.h"
#include "TGListBox.h"
#include "TObjArray.h"
#include "TObjString.h"
#include "TGMenu.h"
#include "TGTab.h"
#include "TGLabel.h"
#include "TGTextEntry.h"

#ifndef ROOT_TGFrame
#include "TGFrame.h"
#endif

/*------------------------------------------------------------------*/

class TGTextDialog:public TGTransientFrame {

 protected:
   TGCompositeFrame * fF1, *fF2;        // sub frames
   TGButton *fOkButton;         // ok button
   TGButton *fCancelButton;     // cancel button
   TGLayoutHints *fL1, *fL5, *fL6, *fL21;       // layout hints
   TGTextEntry *fText;          // text entry widget
   TGTextBuffer *fBLabel;       // text buffer
   TGLabel *fLabel;             // label
   char *fRetStr;               // return string

 public:
    TGTextDialog(const TGWindow * p, const TGWindow * main, UInt_t w, UInt_t h,
                 char *label, char *ret_str, UInt_t options = kVerticalFrame);
    virtual ~ TGTextDialog();

   virtual void CloseWindow();
   virtual Bool_t ProcessMessage(Long_t msg, Long_t parm1, Long_t parm2);

   //ClassDef(TGTextDialog, 0)
};

//ClassImp(TGTextDialog)

/*------------------------------------------------------------------*/

TGTextDialog::TGTextDialog(const TGWindow * p, const TGWindow * main,
                           UInt_t w, UInt_t h, char *label, char *ret_str,
                           UInt_t options):TGTransientFrame(p, main, w, h, options)
{
/* Create a dialog to enter a single line text entry */

   fRetStr = ret_str;

   ChangeOptions((GetOptions() & ~kVerticalFrame) | kHorizontalFrame);

   fF1 = new TGCompositeFrame(this, 60, 20, kVerticalFrame | kFixedWidth);
   fF2 = new TGCompositeFrame(this, 60, 20, kHorizontalFrame);

   fOkButton = new TGTextButton(fF1, new TGHotString("&Ok"), 1);
   fCancelButton = new TGTextButton(fF1, new TGHotString("&Cancel"), 2);
   fF1->Resize(fOkButton->GetDefaultWidth() + 40, GetDefaultHeight());

   fOkButton->Associate(this);
   fCancelButton->Associate(this);

   fL1 = new TGLayoutHints(kLHintsTop | kLHintsExpandX, 2, 2, 3, 0);
   fL21 = new TGLayoutHints(kLHintsTop | kLHintsRight, 2, 5, 10, 0);

   fF1->AddFrame(fOkButton, fL1);
   fF1->AddFrame(fCancelButton, fL1);
   AddFrame(fF1, fL21);

   fLabel = new TGLabel(fF2, new TGHotString(label));

   fBLabel = new TGTextBuffer(50);
   if (fRetStr[0])
      fBLabel->AddText(0, fRetStr);
   else
      fOkButton->SetState(kButtonDisabled);

   fText = new TGTextEntry(fF2, fBLabel);
   fText->Associate(this);
   fText->Resize(220, fText->GetDefaultHeight());
   fText->SelectAll();

   fL5 = new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 3, 5, 0, 0);
   fL6 = new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 0, 2, 0, 0);

   fF2->AddFrame(fLabel, fL5);
   fF2->AddFrame(fText, fL5);
   AddFrame(fF2, fL1);

   MapSubwindows();
   Resize(GetDefaultSize());

   // position relative to the parent's window
   Int_t ax, ay;
   if (main) {
      Window_t wdum;
      gVirtualX->TranslateCoordinates(main->GetId(), GetParent()->GetId(),
                                      (Int_t) (((TGFrame *) main)->GetWidth() -
                                               fWidth) >> 1,
                                      (Int_t) (((TGFrame *) main)->GetHeight() -
                                               fHeight) >> 1, ax, ay, wdum);
   } else {
      UInt_t root_w, root_h;
      gVirtualX->GetWindowSize(fClient->GetRoot()->GetId(), ax, ay, root_w, root_h);
      ax = (root_w - fWidth) >> 1;
      ay = (root_h - fHeight) >> 1;
   }

   Move(ax, ay);
   SetWMPosition(ax, ay);

   SetWindowName("Enter Text");

   SetMWMHints(kMWMDecorAll | kMWMDecorMaximize | kMWMDecorMenu,
               kMWMFuncAll | kMWMFuncMaximize | kMWMFuncResize, kMWMInputModeless);

   MapWindow();
   fClient->WaitFor(this);
}

/*------------------------------------------------------------------*/

TGTextDialog::~TGTextDialog()
{
   // Clean up text dialog

   delete fCancelButton;
   delete fOkButton;
   delete fText;
   delete fLabel;
   delete fF1;
   delete fF2;
   delete fL1;
   delete fL5;
   delete fL6;
   delete fL21;
}

/*------------------------------------------------------------------*/

void TGTextDialog::CloseWindow()
{
   // Close the dialog. On close the dialog will be deleted and cannot be
   // re-used.

   DeleteWindow();
}

Bool_t TGTextDialog::ProcessMessage(Long_t msg, Long_t parm1, Long_t)
{
   const char *string;

   switch (GET_MSG(msg)) {
   case kC_COMMAND:
      switch (GET_SUBMSG(msg)) {
      case kCM_BUTTON:
         switch (parm1) {
         case 1:
            if (fRetStr)
               strcpy(fRetStr, fBLabel->GetString());
            CloseWindow();
            break;
         case 2:
            fRetStr[0] = 0;
            CloseWindow();
            break;
         }
         break;

      default:
         break;
      }
      break;

   case kC_TEXTENTRY:
      switch (GET_SUBMSG(msg)) {
      case kTE_TEXTCHANGED:
         string = fBLabel->GetString();
         if (strlen(string) == 0)
            fOkButton->SetState(kButtonDisabled);
         else
            fOkButton->SetState(kButtonUp);
         break;
      case kTE_ENTER:
         if (fRetStr)
            strcpy(fRetStr, fBLabel->GetString());
         CloseWindow();
         break;
      default:
         break;
      }
      break;

   default:
      break;
   }

   return kTRUE;
}

/*------------------------------------------------------------------*/

enum RMidasCommandIdentifiers {
   M_FILE_EXIT,
   M_FILE_CONNECT,
   B_UPDATE,
   B_CLEAR,
};

/*------------------------------------------------------------------*/

class RMidasFrame:public TGMainFrame {

 private:
   TGMenuBar * fMenuBar;
   TGPopupMenu *fMenuFile;

   TGTab *fTab;
   TGCompositeFrame *fTabHisto;
   TGCompositeFrame *fTabStatus;

   TGHorizontalFrame *fHorz1;
   TGHorizontalFrame *fHorz2;
   TGHorizontalFrame *fHorz3;

   TGListBox *fListBox;
   TRootEmbeddedCanvas *fCanvas;

   TGTextButton *fBUpdate;
   TGTextButton *fBClear;

   char fHost[256];             // remote host name
   TSocket *fSock;

   TObjArray *fHistoNames;
   TH1 *fHisto;

   int ConnectServer();
   void GetHistoList();
   void GetHisto(const char *name);
   void ClearHisto(const char *name);

 public:
   RMidasFrame(const TGWindow * p, UInt_t w, UInt_t h, char *host = "localhost");
   ~RMidasFrame();

   void CloseWindow();
   Bool_t ProcessMessage(Long_t msg, Long_t param1, Long_t param2);
};

/*------------------------------------------------------------------*/

int RMidasFrame::ConnectServer()
{
   char str[80];

   if (fSock) {
      /* disconnect first */
      fSock->Close();
      delete fSock;
      fSock = NULL;

      SetWindowName("RMidas");

      fListBox->RemoveEntries(0, 999);
   }

   if (fHost[0] == 0) {
      new TGTextDialog(gClient->GetRoot(), this, 100, 100, "&Host name:", fHost);
   }

   /* Connect to RMidasServ */
   fSock = new TSocket(fHost, 9090);

   if (!fSock->IsValid()) {
      sprintf(str, "Cannot connect to RMidas server on host %s, port 9090\n", fHost);
      new TGMsgBox(gClient->GetRoot(), this, "Error", str, kMBIconExclamation, 0, NULL);

      SetWindowName("RMidas");
      return 0;
   } else {
      fSock->Recv(str, sizeof(str));
      if (strncmp(str, "RMSERV", 6)) {
         sprintf(str, "RMidas server not found on host %s, port 9090\n", fHost);
         new TGMsgBox(gClient->GetRoot(), this, "Error", str, kMBIconExclamation, 0,
                      NULL);

         fSock->Close();
         delete fSock;
         fSock = NULL;

         SetWindowName("RMidas");
         return 0;
      } else {
         sprintf(str, "RMidas connected to %s", fHost);
         SetWindowName(str);
         GetHistoList();
         return 1;
      }
   }
}

/*------------------------------------------------------------------*/

void RMidasFrame::GetHistoList()
{
   int i;

   fSock->Send("LIST");

   TMessage *m;
   fSock->Recv(m);

   if (fHistoNames)
      delete fHistoNames;

   fHistoNames = (TObjArray *) m->ReadObject(m->GetClass());

   for (i = 0; i < fHistoNames->GetLast() + 1; i++)
      fListBox->AddEntry((const char *) ((TObjString *) (fHistoNames->At(i)))->String(),
                         i);

   fListBox->MapSubwindows();
   fListBox->Layout();
   delete m;
}

/*------------------------------------------------------------------*/

void RMidasFrame::GetHisto(const char *name)
{
   TMessage *m;
   char str[32];

   sprintf(str, "GET %s", name);
   fSock->Send(str);
   fSock->Recv(m);

   if (fHisto)
      delete fHisto;

   fHisto = (TH1 *) m->ReadObject(m->GetClass());

   if (!fHisto)
      printf("Histo \"%s\" not available\n", name);
   else
      fHisto->Draw();

   fCanvas->GetCanvas()->Modified();
   fCanvas->GetCanvas()->Update();

   delete m;
}

/*------------------------------------------------------------------*/

void RMidasFrame::ClearHisto(const char *name)
{
   char str[32];

   sprintf(str, "CLEAR %s", name);
   fSock->Send(str);
   fSock->Recv(str, sizeof(str));
}

/*------------------------------------------------------------------*/

RMidasFrame::RMidasFrame(const TGWindow * p, UInt_t w, UInt_t h,
                         char *host):TGMainFrame(p, w, h)
{
   /* save host name */
   if (host)
      strcpy(fHost, host);
   else
      fHost[0] = 0;
   fSock = NULL;

   /* Create Menus */
   fMenuFile = new TGPopupMenu(fClient->GetRoot());
   fMenuFile->AddEntry("&Connect to ...", M_FILE_CONNECT);
   fMenuFile->AddEntry("E&xit", M_FILE_EXIT);
   fMenuFile->Associate(this);

   fMenuBar = new TGMenuBar(this, 1, 1, kHorizontalFrame);
   fMenuBar->AddPopup("&File", fMenuFile,
                      new TGLayoutHints(kLHintsTop | kLHintsLeft, 0, 4, 0, 0));

   AddFrame(fMenuBar,
            new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX, 0, 0, 1, 1));

   /* Create tab widget */
   fTab = new TGTab(this, 600, 400);

  /*---- histo tab ----*/

   TGCompositeFrame *tf = fTab->AddTab("Histo");
   fTabHisto = new TGCompositeFrame(tf, 60, 20, kVerticalFrame);

   /* Create a horizonal frame containing histo selection tree and canvas */
   fHorz1 = new TGHorizontalFrame(fTabHisto, 600, 400);
   fTabHisto->AddFrame(fHorz1,
                       new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 3, 3, 3, 0));

   /* Create ListBox widget */
   fListBox = new TGListBox(fHorz1, 1);
   fListBox->Resize(100, 400);
   fListBox->Associate(this);
   fHorz1->AddFrame(fListBox, new TGLayoutHints(kLHintsExpandY, 0, 0, 0, 0));

   /* Create an embedded canvas and add to the main frame, centered in x and y */
   fCanvas = new TRootEmbeddedCanvas("Canvas", fHorz1, 400, 400);
   fHorz1->AddFrame(fCanvas,
                    new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 0, 0, 0, 0));

   /* Create a horizonal frame containing text buttons */
   fHorz2 = new TGHorizontalFrame(fTabHisto, 600, 30);
   fTabHisto->AddFrame(fHorz2, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 0));

   /* Create "Update" button */
   fBUpdate = new TGTextButton(fHorz2, "Update", B_UPDATE);
   fBUpdate->Associate(this);
   fHorz2->AddFrame(fBUpdate, new TGLayoutHints(kLHintsCenterX, 10, 10, 4, 4));

   /* Create "Clear" button */
   fBClear = new TGTextButton(fHorz2, "Clear", B_CLEAR);
   fBClear->Associate(this);
   fHorz2->AddFrame(fBClear, new TGLayoutHints(kLHintsCenterX, 10, 10, 4, 4));

   tf->AddFrame(fTabHisto, new TGLayoutHints(kLHintsTop | kLHintsLeft, 0, 0, 0, 0));

  /*---- status tab ----*/

   tf = fTab->AddTab("Status");
   fTabStatus = new TGCompositeFrame(tf, 60, 20, kVerticalFrame);
   /*
      fHorz3 = new TGHorizontalFrame(fTabStatus, 600, 400);
      fTabStatus->AddFrame(fHorz3, new TGLayoutHints(kLHintsExpandX|kLHintsExpandY, 0, 0, 0, 0));
      fHorz3->AddFrame(new TGLabel(fTabStatus, "Test"), new TGLayoutHints(kLHintsExpandX|kLHintsExpandY, 0, 0, 0, 0));
    */
   fTabStatus->
       AddFrame(new TGLabel(fTabStatus, "Here will come the experiment status display"),
                new TGLayoutHints(kLHintsTop, 100, 100, 100, 0));
   tf->AddFrame(fTabStatus, new TGLayoutHints(kLHintsTop | kLHintsLeft, 0, 0, 0, 0));

  /*--------------------*/

   AddFrame(fTab, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 0, 0, 0, 0));

   SetWindowName("RMidas");

   MapSubwindows();
   Resize(GetDefaultSize());
   MapWindow();

   fHisto = 0;
   fHistoNames = 0;

   /* connect to MRootServer */
   ConnectServer();
}

void RMidasFrame::CloseWindow()
{
   // Got close message for this MainFrame. Terminate the application
   // or returns from the TApplication event loop (depending on the
   // argument specified in TApplication::Run()).

   gApplication->Terminate(0);
}

Bool_t RMidasFrame::ProcessMessage(Long_t msg, Long_t param1, Long_t param2)
{
   // Process messages coming from widgets associated with the dialog.

   switch (GET_MSG(msg)) {
   case kC_COMMAND:

      switch (GET_SUBMSG(msg)) {
      case kCM_MENU:
         switch (param1) {
         case M_FILE_EXIT:
            CloseWindow();
            break;

         case M_FILE_CONNECT:
            fHost[0] = 0;
            ConnectServer();
            break;
         }
         break;

      case kCM_BUTTON:
         switch (param1) {
         case B_UPDATE:
            if (fHisto)
               GetHisto((char *) fHisto->GetName());
            break;

         case B_CLEAR:
            if (fHisto) {
               ClearHisto((char *) fHisto->GetName());
               GetHisto((char *) fHisto->GetName());
            }
            break;
         }
         break;

      case kCM_LISTBOX:
         GetHisto((const char *) ((TObjString *) (fHistoNames->At(param2)))->String());
         break;


      case kCM_TAB:
         //printf("Tab item %ld activated\n", param1);
         break;
      }
      break;

   }

   return kTRUE;
}

RMidasFrame::~RMidasFrame()
{
   // Clean up

   delete fMenuBar;
   delete fMenuFile;
   delete fHisto;
   delete fHistoNames;
   delete fSock;
   delete fBUpdate;
   delete fHorz1;
   delete fHorz2;
   delete fCanvas;
}

void rmidas()
{
   new RMidasFrame(gClient->GetRoot(), 200, 200, "pc2948");
}

int main(int argc, char **argv)
{
   TApplication theApp("RMidas", &argc, argv);

   if (gROOT->IsBatch()) {
      printf("%s: cannot run in batch mode\n", argv[0]);
      return 1;
   }

   new RMidasFrame(gClient->GetRoot(), 200, 200, argv[1]);

   theApp.Run();

   return 0;
}