#define EXPERT

#include "MStarguider.h"

#include <fstream.h>    // ifstream
#include <iostream.h>   // cout
#include <iomanip.h>   // cout

#include <TH2F.h>
#include <TGraph.h>
#include <TTimer.h>
#include <TSystem.h>
#include <TFile.h> // temp writeout of histos
#include "MAstro.h"
#include "MString.h"

#include <TGMenu.h>
#include <TGLabel.h>
#include <TGButton.h>
#include <TGSplitter.h>    // TGHorizontal3DLine
#include <TGTextEntry.h>
#include <TGLayout.h>
#include "MString.h"

#include "MCosy.h"
#include "MCaos.h"
// #include "MStargLeds.h"
#include "MStargHistograms.h"
#include "MDriveCom.h"

#include "MGStarg.h" 
#include "TGFrame.h"

#include "MGImage.h"
#include "MGCoordinates.h"

#include "coord.h"

#include "Camera.h"
#include "PngReader.h"

#include "Led.h"
#include "Writer.h"
#include "FilterLed.h"
#include "MStarList.h"
#include "CaosFilter.h"
#include "StarCatalog.h"
#include "MGeomCamMagic.h"
#include "MAstroCamera.h"

#include "MGMenu.h"
#include "MGCosy.h"

ClassImp(MStarguider);

enum {
    IDM_kFilter,
    IDM_kFindStar,
    IDM_kCaosFilter,
    IDM_kCatalog,
    IDM_kStarguider,
    IDM_kStart,
    IDM_kStop,
    IDM_kFileType,
    IDM_kPPM,
    IDM_kPNG,
    IDM_kOnce,
    IDM_kStretch,
    IDM_kInput,
    IDM_kChannel1,
    IDM_kChannel2,
    IDM_kContinous,
    IDM_kRate25ps,
    IDM_kRate5ps,
    IDM_kRate1s,
    IDM_kRate5s,
    IDM_kRate30s,
    IDM_kRate1m,
    IDM_kRate5m,
    IDM_kSetup,
    IDM_kLimMag3,
    IDM_kLimMag4,
    IDM_kLimMag5,
    IDM_kLimMag6,
    IDM_kLimMag7,
    IDM_kLimMag8,
    IDM_kLimMag9,
    IDM_kPixSize,
    IDM_kAngle,
    IDM_kInterpol250,
    IDM_kInterpol125,
    IDM_kInterpol50,
    IDM_kInterpol25,
    IDM_kInterpol10,
    IDM_kInterpol5,
    IDM_kInterpol2,
    IDM_kInterpol1,
    IDM_kCaosPrintRings,
    IDM_kCaosPrintLeds,
    IDM_kCaosAnalStart,
    IDM_kCaosAnalStop,
    IDM_kCaosWriteStart,
    IDM_kCaosWriteStop,
    IDM_kResetHistograms,
    IDM_kStargHistograms,
    IDM_kStargAnalysis,
    IDM_kStargCaosFilter,
    IDM_kStargLEDFilter,
    IDM_kStargFindStar

};

Bool_t MStarguider::HandleTimer(TTimer *t)
{
    if (IsMapped())
    {
        fImage->DoRedraw();
        fZoomImage->DoRedraw();
    }

    if (fCosy && fCosy->GetWin()->IsMapped())
        fCosy->GetWin()->GetImage()->DoRedraw();

    fGStarg->Update(fPos, fD);   
 
    return kTRUE;
}

#define kZOOM 96

XY MStarguider::GetCoordinates() const
{
    return fPZdAz->GetCoordinates();
}

void MStarguider::InitGui(Int_t channel)
{
    fList = new MGList;

    const TGWindow *p=gClient->GetRoot();

    fChannel = new MGPopupMenu(p);
    fChannel->AddEntry("Starfield Camera", IDM_kChannel1);
    fChannel->AddEntry("TPoint Camera", IDM_kChannel2);
    fChannel->CheckEntry(channel==0?IDM_kChannel1:IDM_kChannel2);
    fChannel->Associate(this);
    fList->Add(fChannel);

    //
    // Create Menu for MStarguider Display
    //
    fDisplay = new MGPopupMenu(p);
    fDisplay->AddEntry("&Filter",      IDM_kFilter);
    fDisplay->AddEntry("Find &Star",   IDM_kFindStar);
    fDisplay->AddEntry("C&aos Filter",  IDM_kCaosFilter);
    fDisplay->AddEntry("SAO &Catalog", IDM_kCatalog);
    fDisplay->AddEntry("Stretch",      IDM_kStretch);
    fDisplay->AddSeparator();
    fDisplay->AddEntry("Starguider",   IDM_kStarguider);
    fDisplay->AddEntry("Starguider LED Filter",  IDM_kStargCaosFilter);
    fDisplay->AddEntry("Starguider Find Star",   IDM_kStargFindStar);
    fDisplay->AddEntry("Starguider Analysis",   IDM_kStargAnalysis);
    fDisplay->AddSeparator();    
    if (channel>=0)
        fDisplay->AddPopup("&Input",   fChannel);
    fDisplay->DisableEntry(IDM_kStargAnalysis);
    fDisplay->DisableEntry(IDM_kStargFindStar);
    fDisplay->CheckEntry(IDM_kStretch);
    fDisplay->Associate(this);
    fList->Add(fDisplay);

    fFileType = new MGPopupMenu(p);
    fFileType->AddEntry("PP&M", IDM_kPPM);
    fFileType->AddEntry("&PNG", IDM_kPNG);
    fFileType->CheckEntry(IDM_kPNG);
    fFileType->Associate(this);
    fList->Add(fFileType);

    fWriteType = new MGPopupMenu(p);
    fWriteType->AddEntry("&Once",      IDM_kOnce);
    fWriteType->AddEntry("&Continous", IDM_kContinous);
    fWriteType->CheckEntry(IDM_kOnce);
    fWriteType->Associate(this);
    fList->Add(fWriteType);

    fWriteRate = new MGPopupMenu(p);
    fWriteRate->AddEntry("25/s", IDM_kRate25ps);
    fWriteRate->AddEntry("5/s",  IDM_kRate5ps);
    fWriteRate->AddEntry("1s",   IDM_kRate1s);
    fWriteRate->AddEntry("5s",   IDM_kRate5s);
    fWriteRate->AddEntry("30s",  IDM_kRate30s);
    fWriteRate->AddEntry("1min", IDM_kRate1m);
    fWriteRate->AddEntry("5min", IDM_kRate5m);
    fWriteRate->CheckEntry(IDM_kRate1m);
    fWriteRate->Associate(this);
    fList->Add(fWriteRate);

    fWrtRate = 25*60;

    fWritePictures = new MGPopupMenu(p);
    fWritePictures->AddEntry("&Start",      IDM_kStart);
    fWritePictures->AddEntry("Sto&p",       IDM_kStop);
    fWritePictures->AddSeparator();
    fWritePictures->AddPopup("File &Type",  fFileType);
    fWritePictures->AddPopup("&Write Type", fWriteType);
    fWritePictures->AddPopup("Write &Rate", fWriteRate);
    fWritePictures->DisableEntry(IDM_kStop);
    fWritePictures->Associate(this);
    fList->Add(fWritePictures);

    fLimMag = new MGPopupMenu(p);
    fLimMag->AddEntry("3", IDM_kLimMag3);
    fLimMag->AddEntry("4", IDM_kLimMag4);
    fLimMag->AddEntry("5", IDM_kLimMag5);
    fLimMag->AddEntry("6", IDM_kLimMag6);
    fLimMag->AddEntry("7", IDM_kLimMag7);
    fLimMag->AddEntry("8", IDM_kLimMag8);
    fLimMag->AddEntry("9", IDM_kLimMag9);
    fLimMag->CheckEntry(IDM_kLimMag8);
    fLimMag->Associate(this);
    fList->Add(fLimMag);

    fSao->SetLimitMag(7.0);

    fInterpol = new MGPopupMenu(p);
    fInterpol->AddEntry("250", IDM_kInterpol250);
    fInterpol->AddEntry("125", IDM_kInterpol125);
    fInterpol->AddEntry("50",  IDM_kInterpol50);
    fInterpol->AddEntry("25",  IDM_kInterpol25);
    fInterpol->AddEntry("10",  IDM_kInterpol10);
    fInterpol->AddEntry("5",   IDM_kInterpol5);
    fInterpol->AddEntry("2",   IDM_kInterpol2);
    fInterpol->AddEntry("Off", IDM_kInterpol1);
    fInterpol->Associate(this);
    fList->Add(fInterpol);

    TString disp=gVirtualX->DisplayName();
    cout << "Display: " << disp << endl;
    if (disp.First(':')>=0)
        disp=disp(0, disp.First(':'));

    if (disp.IsNull() || disp==(TString)"localhost")
    {
        fInterpol->CheckEntry(IDM_kInterpol5);
        fIntRate = 50;
    }
    else
    {
        fInterpol->CheckEntry(IDM_kInterpol125);
        fIntRate = 125;
    }

    fSetup = new MGPopupMenu(p);
    fSetup->AddPopup("Lim. &Magnitude",      fLimMag);
    fSetup->AddPopup("Disp. &Interpolation", fInterpol);
    //fSetup->AddEntry("Use Ra/Dec from file", IDM_kUseFileRaDec);
    fSetup->Associate(this);
    fList->Add(fSetup);

    fCaosPrint = new MGPopupMenu(p);
    fCaosPrint->AddEntry("&Leds",  IDM_kCaosPrintLeds);
    fCaosPrint->AddEntry("&Rings", IDM_kCaosPrintRings);
    fCaosPrint->Associate(this);
    fList->Add(fCaosPrint);

    fCaosWrite = new MGPopupMenu(p);
    fCaosWrite->AddEntry("&Start", IDM_kCaosWriteStart);
    fCaosWrite->AddEntry("Sto&p",  IDM_kCaosWriteStop);
    fCaosWrite->DisableEntry(IDM_kCaosWriteStop);
    fCaosWrite->Associate(this);
    fList->Add(fCaosWrite);

    fCaosAnalyse = new MGPopupMenu(p);
    fCaosAnalyse->AddEntry("S&tart Analysis", IDM_kCaosAnalStart);
    fCaosAnalyse->AddEntry("St&op Analysis", IDM_kCaosAnalStop);
    fCaosAnalyse->DisableEntry(IDM_kCaosAnalStop);
    //    fCaosAnalyse->AddEntry("&Reset Histograms", IDM_kResetHistograms);
    //    fCaosAnalyse->AddEntry("Reset &Graph", IDM_kResetGraph);
    fCaosAnalyse->Associate(this);
    fList->Add(fCaosAnalyse);

    fMenu = new MGMenuBar(this, 0, 0, kHorizontalFrame);
    fMenu->AddPopup("&Display",   fDisplay,         NULL);
    fMenu->AddPopup("&WritePics", fWritePictures,   NULL);
    fMenu->AddPopup("&Setup",     fSetup,           NULL);
    fMenu->Resize(fMenu->GetDefaultSize());
    fMenu->BindKeys(this);
    AddFrame(fMenu); 
    fList->Add(fMenu);

    fCaOs = new MGPopupMenu(p);
    fCaOs->AddPopup("&Write",   fCaosWrite);
    fCaOs->AddPopup("&Print",   fCaosPrint);
    fCaOs->AddPopup("&Analyse", fCaosAnalyse);
    fCaOs->Associate(this);
    fCaOs->BindKeys(fMenu, this);
    fList->Add(fCaOs);

    TGLayoutHints *hints2a = 
	new TGLayoutHints(kLHintsCenterX|kLHintsCenterY|
			  kLHintsExpandX|kLHintsExpandY,1,1);
    fList->Add(hints2a);

    fGStarg = new MGStarg(this, 235);
    fGStarg->Move(530,596+5);
    fList->Add(fGStarg);

    fCRaDec = new MGCoordinates(this, kETypeRaDec);
    fCRaDec->Move(4, fMenu->GetDefaultHeight()+584);
    AddFrame(fCRaDec);
    fList->Add(fCRaDec);

    fCZdAz = new MGCoordinates(this, kETypeZdAz, kFALSE);
    fCZdAz->Move(240+12+28, fMenu->GetDefaultHeight()+581+12);
    AddFrame(fCZdAz);
    fList->Add(fCZdAz);

    fPZdAz = new MGCoordinates(this, kETypeZdAz, kFALSE);
    fPZdAz->Move(240+12+28, fMenu->GetDefaultHeight()+627+2*12);
    AddFrame(fPZdAz);
    fList->Add(fPZdAz);

    fDZdAz = new MGCoordinates(this, kETypeZdAz, kFALSE);
    fDZdAz->Move(240+12+28, fMenu->GetDefaultHeight()+673+3*12);
    AddFrame(fDZdAz);
    fList->Add(fDZdAz);

    fSZdAz = new MGCoordinates(this, kETypeZdAz, kFALSE);
    fSZdAz->Move(240+12+28, fMenu->GetDefaultHeight()+719+4*12);
    AddFrame(fSZdAz);
    fList->Add(fSZdAz);

    fTPoint = new TGTextButton(this, "TPoint");
    fTPoint->Move(4, fMenu->GetDefaultHeight()+722+3*12+25);
    fTPoint->AllowStayDown(kTRUE);
    AddFrame(fTPoint);
    fList->Add(fTPoint);

    fFps = new TGLabel(this, "---fps");
    fFps->SetTextJustify(kTextRight);
    fFps->Move(650-440, fMenu->GetDefaultHeight()+619+13+60+20);
    AddFrame(fFps);
    fList->Add(fFps);

    fPosZoom = new TGLabel(this, "----.--d/----.--d (----, ----)");
    fPosZoom->SetTextJustify(kTextRight);
    fPosZoom->Move(4, fMenu->GetDefaultHeight()+765);
    AddFrame(fPosZoom);
    fList->Add(fPosZoom);

    fSkyBright = new TGLabel(this, "Sky Brightness: ---         ");
    fSkyBright->SetTextJustify(kTextLeft);
    fSkyBright->Move(4, fMenu->GetDefaultHeight()+785);
    AddFrame(fSkyBright);
    fList->Add(fSkyBright);

    TGLabel *l = new TGLabel(this, "arcsec/pix");
    l->SetTextJustify(kTextLeft);
    l->Move(605-400, fMenu->GetDefaultHeight()+619+13+60);
    AddFrame(l);
    fList->Add(l);

    l = new TGLabel(this, "deg");
    l->SetTextJustify(kTextLeft);
    l->Move(605-410, fMenu->GetDefaultHeight()+619-10+60);
    AddFrame(l);
    fList->Add(l);

    l = new TGLabel(this, "Telescope pointing at");
    l->SetTextJustify(kTextLeft);
    l->Move(240+12+20, fMenu->GetDefaultHeight()+584-5);
    AddFrame(l);
    fList->Add(l);

    l = new TGLabel(this, "Starguider position");
    l->SetTextJustify(kTextLeft);
    l->Move(240+12+20, fMenu->GetDefaultHeight()+630+12-5);
    AddFrame(l);
    fList->Add(l);

    l = new TGLabel(this, "Misspointing");
    l->SetTextJustify(kTextLeft);
    l->Move(240+12+20, fMenu->GetDefaultHeight()+676+2*12-5);
    AddFrame(l);
    fList->Add(l);

#ifdef EXPERT
    l = new TGLabel(this, "Misspointing/FindStar (Experts Only!)");
    l->SetTextJustify(kTextLeft);
    l->Move(240+12+20, fMenu->GetDefaultHeight()+722+3*12-5);
    AddFrame(l);
    fList->Add(l);
#endif
    
    const Double_t pixsize = 48.8; // used to be 23.4

    fSao->SetPixSize(pixsize);
    fSao->SetRotationAngle(0);

    TString txt;
    txt += pixsize;

    fPixSize = new TGTextEntry(this, txt, IDM_kPixSize);
    fPixSize->SetAlignment(kTextCenterX);
    fPixSize->Move(547-410, fMenu->GetDefaultHeight()+617+13+60);
    AddFrame(fPixSize);
    fList->Add(fPixSize);

    fAngle = new TGTextEntry(this, "         0", IDM_kAngle);
    fAngle->SetAlignment(kTextCenterX);
    fAngle->Move(547-410, fMenu->GetDefaultHeight()+617-10+60);
    AddFrame(fAngle);
    fList->Add(fAngle);

    // TGHorizontal3DLine *fLineSep = new TGHorizontal3DLine(this);
    // AddFrame(fLineSep, new TGLayoutHints (kLHintsNormal | kLHintsExpandX));
    // fList->Add(fLineSep);

    //
    // Create Image Display
    //
    fZoomImage = new MGImage(this, kZOOM, kZOOM);
    // fZoomImage->Move(768-kZOOM-2, 700-kZOOM-2);
    fZoomImage->Move(4, 700-kZOOM-2+85);
    AddFrame(fZoomImage);
    fList->Add(fZoomImage);

    fImage = new MGImage(this, 768, 576);
    fImage->Move(0, fMenu->GetDefaultHeight());
    AddFrame(fImage);
    fList->Add(fImage);

    //
    // Make everything visible
    //
    SetWindowName("MStarguider Main Window");
    SetIconName("MStarguider");

    MapSubwindows();
    fTPoint->UnmapWindow();
    fGStarg->UnmapWindow();
    fPZdAz->UnmapWindow();
    fDZdAz->UnmapWindow();
    fSZdAz->UnmapWindow();
    fSkyBright->UnmapWindow();
    MapWindow();


    //IconifyWindow();

    //------------------------------------------------------------
    //    XY xy(3.819444, 24.05333);
    //    fCRaDec->SetCoordinates(xy);
    //    fRaDec->Set(xy.X()*360/24, xy.Y());
    //------------------------------------------------------------
}

MStarguider::MStarguider(MObservatory::LocationName_t obs, Int_t channel)
    : TGMainFrame(gClient->GetRoot(), 768, 840), fCosy(NULL), fOutTp(0), fDx((768-kZOOM)/2), fDy((512-kZOOM)/2), fStatus(MDriveCom::kStandby)
{
    
    cout << " #### FIXME: Make MCaos Thread safe!" << endl;

    fSao = new StarCatalog(obs);
    fRaDec = new RaDec(180, 40);

    //    fStargLeds = new MStargLeds;
    //    fStargLeds->ReadResources();

    fCaos = new MCaos;
    fCaos->ReadResources();

    fStargCaos = new MCaos;
    fStargCaos->ReadResources("stargleds.txt");
    fStargCaos->SetMinNumberRings(2);
    fStargCaos->SetRadii(158,164);

    fStargHistograms = new MStargHistograms();

    InitGui(channel);

    fTimer=new TTimer(this, 1000/25); // 40ms
    fTimer->TurnOn();

    fTime.Now();
                                             
    gVirtualX->GrabButton(fId, kButton2, 0, 0, 0, 0, kTRUE);

    if (channel<0)
        fGetter=new PngReader(*this);
    else
    {
        fGetter = new Camera(*this, channel);
        ((Camera*)fGetter)->Loop(0);
    }
}

MStarguider::~MStarguider()
{
    fGetter->ExitLoop();
    delete fGetter;

    gVirtualX->GrabButton(fId, kButton2, 0, 0, 0, 0, kFALSE);

    fTimer->TurnOff();
    delete fTimer;

    delete fList;

    delete fCaos;
    delete fStargCaos;
    //    delete fStargLeds;
    delete fStargHistograms;
    delete fSao;
    delete fRaDec;    

    if (fOutTp)
        delete fOutTp;

    cout << "Camera Display destroyed." << endl;
}

void MStarguider::Layout()
{
    // Resize(GetDefaultSize());
}

void MStarguider::CloseWindow()
{
    cout << "EventDisplay::CloseWindow: Exit Application Loop." << endl;

    //fClient.ExitLoop();
    //    cout << "FIXME: ExitLoop not called!!!!!!" << endl;
    gSystem->ExitLoop();
}

void MStarguider::Toggle(MGPopupMenu *p, UInt_t id)
{
    if (p->IsEntryChecked(id))
        p->UnCheckEntry(id);
    else
        p->CheckEntry(id);
}

Bool_t MStarguider::ProcessMessage(Long_t msg, Long_t mp1, Long_t mp2)
{
    switch (GET_MSG(msg))
    {
    case kC_TEXTENTRY:
        if (GET_SUBMSG(msg)==kTE_ENTER)
            switch (mp1)
            {
            case IDM_kPixSize:
                {
                    const Float_t pixsize = atof(fPixSize->GetText());
                    cout << "Pixel Size changed to " << pixsize << "\"/pix" << endl;
                    fSao->SetPixSize(pixsize);
                    return kTRUE;
                }
            case IDM_kAngle:
                {
                    const Float_t angle = atof(fAngle->GetText());
                    cout << "Rotation Angle changed to " << angle << "deg" << endl;
                    fSao->SetRotationAngle(angle);
                    return kTRUE;
                }
            }
        return kTRUE;

    case kC_COMMAND:
        switch (GET_SUBMSG(msg))
        {
        case kCM_MENU:
            switch (mp1)
            {
            case IDM_kCatalog:
                Toggle(fDisplay, IDM_kCatalog);
//              if (!fDisplay->IsEntryChecked(IDM_kCatalog))
//                 {
//                     fDisplay->UnCheckEntry(IDM_kStarguider);
//                     fDisplay->DisableEntry(IDM_kStarguider);
//                 } else {
// 		    fDisplay->EnableEntry(IDM_kStarguider);
// 		}
                return kTRUE;

           case IDM_kStargFindStar:
                Toggle(fDisplay, IDM_kStargFindStar);         
		if (fDisplay->IsEntryChecked(IDM_kStargFindStar)) {
		    fSZdAz->MapWindow();
		} else {
		    fSZdAz->UnmapWindow();
		}
                return kTRUE;

            case IDM_kStarguider:
                Toggle(fDisplay, IDM_kStarguider);

		if (fDisplay->IsEntryChecked(IDM_kStarguider)) {	

  		    fLastBright = 0xff;

		    fDisplay->DisableEntry(IDM_kFindStar);
		    fDisplay->EnableEntry(IDM_kStargAnalysis);		  
		    
		    fPZdAz->MapWindow();
		    fDZdAz->MapWindow();
		    fSkyBright->MapWindow();

		    fSao->SetLimitMag(8.3);
		    fIntRate = 125;

		    fDisplay->CheckEntry(IDM_kCatalog);
		    fGStarg->MapWindow();

		    const Int_t ch0 = 
			fChannel->IsEntryChecked(IDM_kChannel1) ? 0 : 1;
                    const Int_t ch1 = 0;

                    if (ch0!=ch1)
		    {

			delete fGetter;
			usleep(150000); // FIX: Device or resource busy.
			fGetter = new Camera(*this, ch1);
			((Camera*)fGetter)->Loop(0);
		    }

		    fChannel->CheckEntry(IDM_kChannel1);
		    fChannel->UnCheckEntry(IDM_kChannel2);
		    fChannel->DisableEntry(IDM_kChannel2);

		} else {

		    fStatus = MDriveCom::kStandby;
		
		    fPZdAz->UnmapWindow();
		    fDZdAz->UnmapWindow();
		    fSkyBright->UnmapWindow();
		    fGStarg->UnmapWindow();		
		    fChannel->EnableEntry(IDM_kChannel2);
		    fDisplay->EnableEntry(IDM_kFindStar);
		    fDisplay->DisableEntry(IDM_kStargAnalysis);		    
		}

                gSystem->Unlink("tracking_error.txt");

                return kTRUE;

            case IDM_kStargAnalysis:
                Toggle(fDisplay, IDM_kStargAnalysis);
		if (fDisplay->IsEntryChecked(IDM_kStargAnalysis)) {
		    fStargHistograms->OpenFile();
		} else {
		    fStargHistograms->CloseFile();
		}

                return kTRUE;

            case IDM_kStargHistograms:
                Toggle(fDisplay, IDM_kStargHistograms);
                return kTRUE;

            case IDM_kStargLEDFilter:
                Toggle(fDisplay, IDM_kStargLEDFilter);
                return kTRUE;

            case IDM_kFilter:
                Toggle(fDisplay, IDM_kFilter);           
                return kTRUE;

//              case IDM_kFilterStarg:
//                  Toggle(fDisplay, IDM_kFilterStarg);
//                  if (fDisplay->IsEntryChecked(IDM_kFilterStarg))
//                      fDisplay->EnableEntry(IDM_kStarguider);
//                  else
//                  {
//                      fDisplay->UnCheckEntry(IDM_kStarguider);
//                      fDisplay->DisableEntry(IDM_kStarguider);
//                  }
//                  return kTRUE;

            case IDM_kFindStar:
                Toggle(fDisplay, IDM_kFindStar);
                if (fDisplay->IsEntryChecked(IDM_kFindStar) && fCosy)
                    fTPoint->MapWindow();
                else
                {
                    fTPoint->UnmapWindow();
                    fTPoint->SetDown(kFALSE);
                }
                return kTRUE;

            case IDM_kStretch:
                Toggle(fDisplay, IDM_kStretch);
                return kTRUE;

            case IDM_kCaosFilter:
                //if (!fDisplay->IsEntryChecked(IDM_kCaosFilter))
                //    fCaos->OpenFile();
                Toggle(fDisplay, IDM_kCaosFilter);
                if (fDisplay->IsEntryChecked(IDM_kCaosFilter)) {
                    fMenu->AddPopup("&CaOs", fCaOs, NULL);
		}
                else
                {
                    if(fCaosWrite->IsEntryChecked(IDM_kCaosPrintLeds))
                        fCaosWrite->UnCheckEntry(IDM_kCaosPrintLeds);
                    if(fCaosWrite->IsEntryChecked(IDM_kCaosPrintRings))
                        fCaosWrite->UnCheckEntry(IDM_kCaosPrintRings);
                    if(fCaosAnalyse->IsEntryEnabled(IDM_kCaosAnalStop))
                    {
                        fCaosAnalyse->DisableEntry(IDM_kCaosAnalStop);
                        fCaosAnalyse->EnableEntry(IDM_kCaosAnalStart);
                        fCaos->DeleteHistograms();
                    }
                    if(fCaosWrite->IsEntryEnabled(IDM_kCaosWriteStop))
                    {
                        fCaosWrite->DisableEntry(IDM_kCaosWriteStop);
                        fCaosWrite->EnableEntry(IDM_kCaosWriteStart);
                        fCaos->CloseFile();
                    }
                    fMenu->RemovePopup("CaOs");
                }
                fMenu->Resize(fMenu->GetDefaultSize());
                MapSubwindows(); // maps everything, but we don't want that
		fTPoint->UnmapWindow(); 
		fGStarg->UnmapWindow();
		fPZdAz->UnmapWindow();
		fDZdAz->UnmapWindow();
		fSZdAz->UnmapWindow();
		fSkyBright->UnmapWindow();
                MapWindow();
                return kTRUE;

            case IDM_kStargCaosFilter:             
		Toggle(fDisplay, IDM_kStargCaosFilter);                
		if (fDisplay->IsEntryEnabled(IDM_kStargCaosFilter)) {
		    fDisplay->EnableEntry(IDM_kStargFindStar);
		} else {
		    fDisplay->DisableEntry(IDM_kStargFindStar);
		}
		return kTRUE;

            case IDM_kCaosPrintLeds:
            case IDM_kCaosPrintRings:
                Toggle(fCaosPrint, mp1);
                return kTRUE;

            case IDM_kCaosAnalStart:
                fCaosAnalyse->DisableEntry(IDM_kCaosAnalStart);
                fCaosAnalyse->EnableEntry(IDM_kCaosAnalStop);
                fCaos->InitHistograms();
                return kTRUE;

            case IDM_kCaosAnalStop:
                fCaosAnalyse->DisableEntry(IDM_kCaosAnalStop);
                fCaosAnalyse->EnableEntry(IDM_kCaosAnalStart);
                fCaos->ShowHistograms();
                fCaos->DeleteHistograms();
                return kTRUE;

            case IDM_kCaosWriteStart:
                fCaosWrite->DisableEntry(IDM_kCaosWriteStart);
                fCaosWrite->EnableEntry(IDM_kCaosWriteStop);
                fCaos->OpenFile();
                return kTRUE;

            case IDM_kCaosWriteStop:
                fCaosWrite->DisableEntry(IDM_kCaosWriteStop);
                fCaosWrite->EnableEntry(IDM_kCaosWriteStart);
                fCaos->CloseFile();
                return kTRUE;

            case IDM_kStart:
                fWritePictures->DisableEntry(IDM_kStart);
                fWritePictures->EnableEntry(IDM_kStop);
                return kTRUE;

            case IDM_kStop:
                fWritePictures->DisableEntry(IDM_kStop);
                fWritePictures->EnableEntry(IDM_kStart);
                return kTRUE;

            case IDM_kPNG:
                fFileType->CheckEntry(IDM_kPNG);
                fFileType->UnCheckEntry(IDM_kPPM);
                return kTRUE;

            case IDM_kPPM:
                fFileType->CheckEntry(IDM_kPPM);
                fFileType->UnCheckEntry(IDM_kPNG);
                return kTRUE;

            case IDM_kOnce:
                fWriteType->CheckEntry(IDM_kOnce);
                fWriteType->UnCheckEntry(IDM_kContinous);
                return kTRUE;

            case IDM_kContinous:
                fWriteType->CheckEntry(IDM_kContinous);
                fWriteType->UnCheckEntry(IDM_kOnce);
                return kTRUE;

            case IDM_kRate25ps:
            case IDM_kRate5ps:
            case IDM_kRate1s:
            case IDM_kRate5s:
            case IDM_kRate30s:
            case IDM_kRate1m:
            case IDM_kRate5m:
                for (int i=IDM_kRate25ps; i<=IDM_kRate5m; i++)
                    if (mp1==i)
                        fWriteRate->CheckEntry(i);
                    else
                        fWriteRate->UnCheckEntry(i);
                switch (mp1)
                {
                case IDM_kRate25ps:
                    fWrtRate = 1;
                    return kTRUE;
                case IDM_kRate5ps:
                    fWrtRate = 5;
                    return kTRUE;
                case IDM_kRate1s:
                    fWrtRate = 25;
                    return kTRUE;
                case IDM_kRate5s:
                    fWrtRate = 5*25;
                    return kTRUE;
                case IDM_kRate30s:
                    fWrtRate = 30*25;
                    return kTRUE;
                case IDM_kRate1m:
                    fWrtRate = 60*25;
                    return kTRUE;
                case IDM_kRate5m:
                    fWrtRate = 5*60*25;
                    return kTRUE;
                }
                return kTRUE;

            case IDM_kChannel1:
            case IDM_kChannel2:
                {
                    const Int_t ch0 = fChannel->IsEntryChecked(IDM_kChannel1) ? 0 : 1;
                    const Int_t ch1 = mp1==IDM_kChannel1                      ? 0 : 1;

		    if (ch0==ch1)
                        return kTRUE;

                    fChannel->CheckEntry  (ch1==0?IDM_kChannel1:IDM_kChannel2);
                    fChannel->UnCheckEntry(ch1==1?IDM_kChannel1:IDM_kChannel2);
                    delete fGetter;
                    usleep(150000); // FIX: Device or resource busy.
                    fGetter = new Camera(*this, ch1);
                    ((Camera*)fGetter)->Loop(0);
                }
                return kTRUE;

            case IDM_kInterpol250:
            case IDM_kInterpol125:
            case IDM_kInterpol50:
            case IDM_kInterpol25:
            case IDM_kInterpol10:
            case IDM_kInterpol5:
            case IDM_kInterpol2:
            case IDM_kInterpol1:
                for (int i=IDM_kInterpol250; i<=IDM_kInterpol1; i++)
                    if (mp1==i)
                        fInterpol->CheckEntry(i);
                    else
                        fInterpol->UnCheckEntry(i);
                switch (mp1)
                {
                case IDM_kInterpol1:
                    fIntRate = 1;
                    return kTRUE;
                case IDM_kInterpol2:
                    fIntRate = 2;
                    return kTRUE;
                case IDM_kInterpol5:
                    fIntRate = 5;
                    return kTRUE;
                case IDM_kInterpol10:
                    fIntRate = 10;
                    return kTRUE;
                case IDM_kInterpol25:
                    fIntRate = 25;
                    return kTRUE;
                case IDM_kInterpol50:
                    fIntRate = 50;
                    return kTRUE;
                case IDM_kInterpol125:
                    fIntRate = 125;
                    return kTRUE;
                case IDM_kInterpol250:
                    fIntRate = 250;
                    return kTRUE;
                }
                return kTRUE;

            case IDM_kLimMag3:
            case IDM_kLimMag4:
            case IDM_kLimMag5:
            case IDM_kLimMag6:
            case IDM_kLimMag7:
            case IDM_kLimMag8:
            case IDM_kLimMag9:
                for (int i=IDM_kLimMag3; i<=IDM_kLimMag9; i++)
                    if (mp1==i)
                        fLimMag->CheckEntry(i);
                    else
                        fLimMag->UnCheckEntry(i);

                fSao->SetLimitMag(mp1-IDM_kLimMag3+3);
                return kTRUE;
            }
            break;
        }
        break;
    }

    return kTRUE;
}

void MStarguider::SetPointingPosition(RaDec rd)
{
    rd.Ra(rd.Ra()*24/360);
    fCRaDec->SetCoordinates(rd);
}

ZdAz MStarguider::TrackingError(TArrayF &x, TArrayF &y, TArrayF &mag) const
{
    //
    // Viewable area (FIXME: AZ)
    //
    // TH2F h("Hist", "dX/dY", 77, -768/2-.5, 768/2+.5, 58, -576/2-.5, 576/2+.5); // 3
    // chose a bit coarser binning to enhance excess 
    // important: chose binning symmetrical around (0|0)!
    TH2F h("Hist", "dX/dY", 49, -768/2-8, 768/2+8, 37, -576/2-8, 576/2+8); // 3

//     TH1F hmag("HistMag", "Mag", 19, 0, 100);
//     for (int i=0; i<mag.GetSize(); i++)
//         hmag.Fill(mag[i]);
    
    //
    // Search for matching Magnitudes
    //
    for (int i=0; i<mag.GetSize(); i++)
    {
        if (mag[i]>48-15 && mag[i]<48+15)
            h.Fill(x[i], y[i]);
    }

    //
    // Search for an excess in the histogram
    //
    Int_t mx, my, dummy;
    h.GetMaximumBin(mx, my, dummy);

    const double xmax = h.GetXaxis()->GetBinCenter(mx);
    const double dx   = h.GetXaxis()->GetBinWidth(mx);

    const double ymax = h.GetYaxis()->GetBinCenter(my);
    const double dy   = h.GetYaxis()->GetBinWidth(my);

#ifdef EXPERT
    cout << setprecision(3);
    cout << "Cut-XY:       " << xmax << " +- " << dx << " / " << ymax << " +- " << dy << endl;
#endif

    TGraph g;
    for (int i=0; i<mag.GetSize(); i++)
    {
        if (!(x[i]>xmax-dx && x[i]<xmax+dx &&
              y[i]>ymax-dy && y[i]<ymax+dy /*&&
					     mag[i]>48-15 && mag[i]<48+15*/))
            continue;

        g.SetPoint(g.GetN(), x[i], y[i]);	
    }
  
#ifdef EXPERT
    cout << "Offset-XY:    " << g.GetMean(1) << " +- " << g.GetRMS(1) << " / ";
    cout << g.GetMean(2) << " +- " << g.GetRMS(2) << endl;
#endif

    AltAz pos0 = fSao->CalcAltAzFromPix(768/2,              576/2)*kRad2Deg;
    AltAz pos1 = fSao->CalcAltAzFromPix(768/2+g.GetMean(1), 576/2+g.GetMean(2))*kRad2Deg;

    ofstream fout1("pointingpos.txt");
    fout1 << setprecision(10) << fSao->GetMjd()-52000 << " ";
    if (fCosy)
        fout1 << fCosy->GetPointingPos() << " ";
    fout1 << -pos1.Alt() << " " << pos1.Az() << endl;

    pos1 -= pos0;

    ofstream fout2("tracking_error.txt", ios::app);
    fout2 << setprecision(10) << fSao->GetMjd()-52000 << " ";
    if (fCosy)
        fout2 << fCosy->GetPointingPos() << " ";
    fout2 << -pos1.Alt() << " " << pos1.Az() << endl;

//    if (g.GetMean(1)>9 || g.GetMean(2)>9) {
//      TFile f1("sguider-highoffset.root","UPDATE");
//      h.Write();
//      hmag.Write();
//      g.Write();
//      f1.Close(); 
//    } else {
//      TFile f1("sguider-niceoffset.root","UPDATE");
//     h.Write();
//      hmag.Write();
//      g.Write();
 //     f1.Close();
	

//	}

    return ZdAz(-pos1.Alt(), pos1.Az());
}

bool MStarguider::CalcTrackingError(Leds &leds, MStarList &stars, ZdAz &d, MTime &t)
{
    const Int_t max = leds.GetEntries();
      if (stars.GetRealEntries() < 3)
      {
          cout << "Sorry, less than 3 stars in FOV!" << endl;
          return kFALSE;
      }
      if (max < 3) //was 1
      {
          cout << "Sorry, less than 3 detected spot in FOV!" << endl;	 
          return kFALSE;	 
      }

    stars.Sort(); // Sort by magnitude

#ifdef EXPERT
    TString str = "data/tracking_";
    str += fSao->GetMjd();
    str += ".txt";

    ofstream fout(str);
#endif

    TArrayF x, y, mag;

    Int_t num = 0;

    // FIXME: Is predefined value 3 a good idea?

    MStar *star;
    MStarListIter NextStar(&stars);
    while ((star=NextStar()) && num++<max+3) 
    {
        TIter NextSp(&leds);
        Led *spot=NULL;
        while ((spot=(Led*)NextSp())) 
	{
            const XY dpos(spot->GetX()-(768-star->GetX()), spot->GetY()-star->GetY());
	    
            const Int_t idx = x.GetSize();
	    
            x.Set(idx+1);
            y.Set(idx+1);
            mag.Set(idx+1);
	    
            x.AddAt(dpos.X(), idx);
            y.AddAt(dpos.Y(), idx);
            mag.AddAt(spot->GetMag()/star->GetMag(), idx);
#ifdef EXPERT
            if (fout) {
		fout << spot->GetX() << " " 
		     << spot->GetY()  << " " 
		     << spot->GetMag()  << " " 
		     << star->GetX() << " " 
		     << star->GetY()  << " " 
		     << star->GetMag()  << " ";
                fout << x[idx] << " " << y[idx] << " " << mag[idx] << endl;
	    }
#endif
        }
    }  

    d = TrackingError(x, y, mag);
    fDZdAz->SetCoordinates(d);
    
    //
    // Calculated offsets
    //

#ifdef EXPERT
    // round= floor(x+.5)
    cout << "Offset-ZdAz: " << d.Zd()*60 << "' / " << d.Az()*60 << "'" << endl;
    cout << "Offset-ZdAz: " << d.Zd()/360*16384 << " / " << d.Az()/360*16384 << " (SE) " << endl;
#endif

    //
    // Current Pointing position
    //
    ZdAz cpos = fSao->GetZdAz()-d;
    fPZdAz->SetCoordinates(cpos);

    return kTRUE; 

}

ZdAz MStarguider::FindStar(FilterLed &f, FilterLed &f2, Ring &center, MTime &t, Double_t cut, Double_t box, Double_t scalefactor = 1.0)
{
    // Set search Paremeters (FIXME: Get them from user input!)
    f.SetCut(cut);  // 3.5
    f.SetBox(box);  // 70

    // Try to find Led in this area
    Leds leds;
    f.FindStar(leds, (Int_t)center.GetX(), (Int_t)center.GetY());

    // Check whether star found
    Led *star = (Led*)leds.At(0);
    if (!star || leds.GetEntries()<1)
        return ZdAz(.0,.0);

    cout << "Found star @ " << flush;
    star->Print();
    f2.MarkPoint(star->GetX(), star->GetY(), 2<<2);

    // Initialize Star Catalog on th camera plane
    MGeomCamMagic geom;
    MAstroCamera ac;
    ac.SetGeom(geom);
    ac.SetRadiusFOV(3);
    ac.SetObservatory(*fSao);
    ac.SetTime(t);

    // Get tracking coordinates
    const XY    xy = fCRaDec->GetCoordinates();
    const RaDec rd(xy.X()*TMath::DegToRad()*15, xy.Y()*TMath::DegToRad());

    ac.SetRaDec(rd.Ra(), rd.Dec());

    // Adapt coordinate system (GUIs and humans are counting Y in different directions)
    Double_t x = star->GetX()-center.GetX();
    Double_t y = center.GetY()-star->GetY();

    cout << "STAR-Offset: " << MTime(-1) << " dx=" << x << "pix  dy=" << y << "pix" << endl;

    // Convert from Pixel to millimeter (1pix=2.9mm)
    x *= (2.58427 * scalefactor);
    y *= (2.58427 * scalefactor);

    // Correct for abberation.
    x /= 1.0713;
    y /= 1.0713;

    // Calculate Offset
    Double_t dzd, daz;
    ac.GetDiffZdAz(x, y, dzd, daz);

    cout << "STAR-Offset: " << MTime(-1) << " dZd=" << dzd << "d  dAz=" << daz << "d" << endl;

    ZdAz zdaz(dzd,daz);

    // Check TPoint data set request
    if (!fTPoint->IsDown())
        return zdaz;
    fTPoint->SetDown(kFALSE);

    // If no file open: open new file
    if (!fOutTp)
    {
        //
        // open tpoint file
        //
        const TString name = MCosy::GetFileName("tpoint/starg_%s.txt");
        cout << "TPoint-Starg File ********* " << name << " ********** " << endl;

        fOutTp = new ofstream(name);
        *fOutTp << "Magic Model  TPOINT data file" << endl;
        *fOutTp << ": ALTAZ" << endl;
        *fOutTp << "49 48 0 ";
        *fOutTp << t << endl;
        // temp(°C) pressure(mB) height(m) humidity(1) wavelength(microm) troplapserate(K/m)
    }

    // Output Ra/Dec the drive system thinks that it is currently tracking
    cout << "TPoint Star: " << xy.X() << "h " << xy.Y() << "°" << endl;

    // From the star position in the camera we calculate the Alt/Az
    // position we are currently tracking (real pointing position)
    fSao->SetMjd(t.GetMjd());
    AltAz za0 = fSao->CalcAltAz(rd)*kRad2Deg;

    //ZdAz za0 = fSao->GetZdAz();
    za0 -= AltAz(-dzd, daz);

    // From the Shaftencoders we get the current 'pointing' position
    // as it is seen by the drive system (system pointing position)
    const ZdAz za1 = fCosy->GetTrackingPosRaw();

    // Write real pointing position
    cout << "     Alt/Az: " << za0.Alt() << "° " << za0.Az() << "°" << endl;
    *fOutTp << setprecision(7) << za0.Az() << " " << za0.Alt() << " ";

    // Write system pointing position
    cout << "     SE-Pos: " << 90-za1.Zd() << "° " << za1.Az() << "°" << endl;
    *fOutTp << fmod(za1.Az()+360, 360) << " " << 90-za1.Zd();

    *fOutTp << " " << xy.X() << " " << xy.Y();
    *fOutTp << " " << -dzd << " " << -daz;
    *fOutTp << " " << setprecision(11) << t.GetMjd();
    *fOutTp << " " << setprecision(4) << center.GetMag();
    *fOutTp << " " << star->GetMag();
    *fOutTp << endl;

    MLog &outrep = *fCosy->GetOutRep();
    if (outrep.Lock("MStarguider::FindStar"))
    {
        outrep << "FINDSTAR-REPORT " << MTime(-1) << " " << setprecision(7);
        outrep << 90-za0.Alt() << " " << za0.Az() << " ";
        outrep << za1.Zd() << " " << za1.Az() << " ";
        outrep << xy.X() << " " << xy.Y() << " ";
        outrep << -dzd << " " << -daz << " ";
        outrep << star->GetX() << " " << star->GetY() << " ";
        outrep << center.GetX() << " " << center.GetY() << " ";
        outrep << x*1.0713/2.58427 << " " << y*1.0713/2.58427 << " " << star->GetMag();
        outrep << setprecision(11) << t.GetMjd() << endl;
        outrep.UnLock("MStarguider::FindStar");
    }
    
    return zdaz;
}

bool MStarguider::Interpolate(const unsigned long n, byte *img) const
{
    if (fIntRate<=1)
        return true;

    static unsigned short myimg[768*576];

    unsigned short *f = myimg;
    byte *i = img;
    byte *e = img+768*576;

    while (i<e)
        *f++ += *i++;

    if (n%fIntRate)
        return false;

    f = myimg;
    i = img;
    e = img+768*576;

    while (i<e)
        *i++ = (byte)(*f++/fIntRate);

    memset(myimg, 0, sizeof(myimg));

    return true;
}

void MStarguider::ProcessFrame(const unsigned long n, byte *img, 
			       struct timeval *tm)
{
    static unsigned long n0 = n;

    MTime t(*tm);

    const Double_t d = t-fTime;
    if (d>1)
    {
        MString txt;
        txt.Print("%dfps", (int)((n-n0)/d+.5));
        fFps->SetText(txt);
        fTime = t;
        n0 = n;
    }

    if (!Interpolate(n, img))
        return;

    byte cimg[768*576];
    memset(cimg, 0, 768*576);

    FilterLed f(img,   768, 576, 2.5); // 2.5
    FilterLed f2(cimg, 768, 576); // former color 0xb0
    
    if (fDisplay->IsEntryChecked(IDM_kStretch))
        f.Stretch();
    
    if (!fWritePictures->IsEntryEnabled(IDM_kStart) &&
        (!(n%fWrtRate) || fWriteType->IsEntryChecked(IDM_kOnce)))
    {     
 
        if (fFileType->IsEntryChecked(IDM_kPNG))
            Writer::Png("pix/file", img, tm, fCRaDec->GetCoordinates());
	
        if (fFileType->IsEntryChecked(IDM_kPPM))
            Writer::Ppm("pix/file", img, tm, fCRaDec->GetCoordinates());
	
        if (fWriteType->IsEntryChecked(IDM_kOnce))
            ProcessMessage(MK_MSG(kC_COMMAND, kCM_MENU), IDM_kStop, 0);
    }
    
    // Visual Filter, whole FOV
    if (fDisplay->IsEntryChecked(IDM_kFilter))
        f.Execute();
   
    /* ---------------------------------- 
    // Visual StarFilter for Starguider
    if (fDisplay->IsEntryChecked(IDM_kFilterStarg) && !fDisplay->IsEntryChecked(IDM_kStarguider)) {
      f.SetBox(230);
      f.AddIgnoreRegion(295,112,384,204);
      f.Execute(530, 292);
    }
    ------------------------------------- */

    // Find Center of Camera for Caos and Tpoints
    Ring center(768/2, 576/2);
    if (fDisplay->IsEntryChecked(IDM_kCaosFilter))
    {
        const bool printl = fCaosPrint->IsEntryChecked(IDM_kCaosPrintLeds);
        const bool printr = fCaosPrint->IsEntryChecked(IDM_kCaosPrintRings);
        ZdAz pos;
        if (fCosy)
            pos = fCosy->GetPointingPos();
        center = fCaos->Run(img, printl, printr, pos, t, 50, 3.0);
    }

    // Find Star at Center---for Tpoint Procedure
    if (fDisplay->IsEntryChecked(IDM_kFindStar))
        ZdAz zdaz = FindStar(f, f2, center, t, 3.5, 70);

    byte zimg[kZOOM*kZOOM];
    for (int y=0; y<kZOOM; y++)
        for (int x=0; x<kZOOM; x++)
            zimg[x+y*kZOOM] = img[(fDx+(x-kZOOM/2)/2)+(fDy+(y-kZOOM/2)/2)*768];

    fZoomImage->DrawImg(zimg);

    if (fCosy)
    {
	byte simg[(768/2-1)*(576/2-1)];
	for (int y=0; y<576/2-1; y++)
	    for (int x=0; x<768/2-1; x++)
		simg[x+y*(768/2-1)] = ((unsigned int)img[2*x+2*y*768]+img[2*x+2*y*768+1]+img[2*x+2*(y+1)*768]+img[2*x+2*(y+1)*768+1])/4;	
	
	fCosy->GetWin()->GetImage()->DrawImg(simg);
    }

    // Find Center of Camera in Starfield Camera picture 

    Ring sgcenter(53.2, 293.6); // Center of camera in SG picture [px]
    ZdAz sgcenterzdaz(0, 0);    // Center of camera in SG picture [deg] 
                                // (0,0)_deg is at (53.2, 293.6)_px
    ZdAz star(0, 0);            // Star on curtain in [deg]

    if (fDisplay->IsEntryChecked(IDM_kStargCaosFilter))
    {    
        ZdAz pos;
        if (fCosy)
            pos = fCosy->GetPointingPos();
        sgcenter = 
	    fStargCaos->Run(img, kFALSE, kFALSE, pos, t, 30, 3.0); // [px]
	const Float_t pixsize = atof(fPixSize->GetText()); // [arcsec/px]
	sgcenterzdaz.Zd((sgcenter.GetY()-293.6) * pixsize /3600 );
	sgcenterzdaz.Az((sgcenter.GetX()-53.2) * pixsize /3600 ); 
#ifdef EXPERT
	cout << "- LEDs imply offset of Zd=" 
	     << sgcenter.GetX()-53.2 << "pix Az=" 
	     << sgcenter.GetY()-293.6<< "pix" << endl; 	
#endif
	if (fDisplay->IsEntryChecked(IDM_kStargFindStar)) {
	    star = FindStar(f, f2, sgcenter, t, 4.5, 30, 267/161.9); // [deg]
#ifdef EXPERT
	    cout << "- Star is found to be off Zd=" << star.Zd()*60 << "' Az=" 
		 << star.Az()*60 << "'" << endl;	    
#endif
	    fSZdAz->SetCoordinates(star); // Misspointing found from Camera
	}
    }

    // we calculate the offset given by the three ETH Leds visible to
    // the guide camera
    // This is an (inferior, obsolete) alternative to the StarCaosFilter
    // Led offset;
    // if (fDisplay->IsEntryChecked(IDM_kStargLEDFilter))	
    //	fStargLeds->Run(img,offset);

    // Position corresponding to the camera center (53.2, 293.6)
    Ring skycenter(392, 318);
    // MStarList spots;

    // we obtain a list of stars in the FOV from the SAO catalog
    if (fDisplay->IsEntryChecked(IDM_kCatalog))
    {
	MTime time(*tm);
	  
	XY xy = fCRaDec->GetCoordinates();
	fRaDec->Set(xy.X()*360/24, xy.Y());

	UpdatePosZoom();

	// Always call SetMjd first!
  	fSao->SetPointing(time.GetMjd(), *fRaDec);
  	fCZdAz->SetCoordinates(fSao->GetZdAz());

  	MStarList stars;
    	fSao->SetBox(230); // Region of interest around center

  	// very careful: If center of camera cannot be determined
	// sgcenter jumps to (0,0)  
	double sgcenteroffsetX = 0.0;
	double sgcenteroffsetY = 0.0;
	if ((double)sgcenter.GetX() > 0.0 && (double)sgcenter.GetY() > 0.0) {
	    sgcenteroffsetX = sgcenter.GetX()-53.2;
	    sgcenteroffsetY = sgcenter.GetY()-293.6;
	}

    	// we obtain stars in the effective star FOV and draw them.
    	// coordinates are video frame coords.
	// We determine the ideal starfield using camera sagging info
	// from the LEDs

	//cout << sgcenteroffsetX << " " << sgcenteroffsetY << endl;

        fSao->CalcStars(stars, 530, 292, 
    			-8+2-3+sgcenteroffsetX,  //x: star<spot =>subs
			31.5-3+sgcenteroffsetY);   //y: star<spot =>subs?

	fSao->DrawStars(stars, cimg);

	// There are two corrections to the misspointing
	// - Sagging of the camera as measured with the LEDs
	// - Star not ideally centered on MAGIC Camera

	// Next we evaluate the offset given by the LEDs. This we obtain
	// in Zd/Az and add it to the tracking error.
       
	if (fDisplay->IsEntryChecked(IDM_kStarguider))
	{
  	    Leds spots;
  	    f.SetBox(230);
	    double bright;
  	    f.ExecuteAndMark(spots, 530, 292, bright);
 	    MString txt;
 	    txt.Print("Sky Brightness: %.1f", bright);
 	    fSkyBright->SetText(txt);

            ULong_t color;
	    gClient->GetColorByName("Green", color);    
	    if (bright> 60) gClient->GetColorByName("Yellow", color);    
	    if (bright> 85) gClient->GetColorByName("Orange", color);    
	    if (bright> 95) gClient->GetColorByName("Red", color);    
            fSkyBright->SetBackgroundColor(color);
	   
  	    bool rc = CalcTrackingError(spots, stars, fD, t);

	    if (rc && (bright <= 1.75* fLastBright) && (bright < 110)) {
	      fStatus = MDriveCom::kMonitoring;
	    } else {
	      fStatus = MDriveCom::kError;
	    }
            
	    if (fCosy)
		fPos = fCosy->GetPointingPos();   
	 
  	    if (fDisplay->IsEntryChecked(IDM_kStargAnalysis)) 
    		fStargHistograms->Fill(spots, stars, fD, 
		   fSao->GetZdAz(), sgcenter, sgcenterzdaz,
		   star, bright, fPos, t);

	    fLastBright = bright;

	} //kStarguider

	f2.DrawCircle(skycenter, 2.0, 0x0a);
	
	f2.DrawCircle(skycenter, 7.4, 0x0a); //0.1deg

	f2.DrawCircle(skycenter, 2.06*.5*74.0, 0x0a);
	f2.DrawCircle(skycenter, 2.32*.5*74.0, 0x0a);
        f2.DrawCircle(skycenter, 3.50*.5*74.0, 0x0a);
        f2.DrawCircle(skycenter, 3.84*.5*74.0, 0x0a);

    } //CalcStars

    if (fCosy) {
        MDriveCom &com = *fCosy->GetDriveCom();
        com.SendStargReport(fStatus, fD);    // Report
    }

    // Draw Circles around center of Camera
    if (fDisplay->IsEntryChecked(IDM_kCaosFilter))
    {
        f2.DrawCircle(center, 0x0a);
        f2.DrawCircle(center,   5.0, 
		      fDisplay->IsEntryChecked(IDM_kFindStar)?3:0xb0);
        f2.DrawCircle(center, 115.0, 0x0a);
        f2.DrawCircle(center, 230.0, 0x0a);
        f2.DrawCircle(center, 245.0, 0x0a);
    }

    if (fDisplay->IsEntryChecked(IDM_kStargCaosFilter))
    {
        f2.DrawCircle(sgcenter, 0x0a);
        f2.DrawCircle(sgcenter,   5.0, 
		      fDisplay->IsEntryChecked(IDM_kFindStar)?3:0xb0);
    }

//      if (fDisplay->IsEntryChecked(IDM_kCatalog))
//      {
//          fSao->PaintImg(cimg, 768, 576);
//          const float r = 60*60/fSao->GetPixSize();
//  	f2.DrawCircle(0.5*r, 0x0a);
//  	f2.DrawCircle(1.0*r, 0x0a);
//  	f2.DrawCircle(1.5*r, 0x0a);
//      }

    if (fDisplay->IsEntryChecked(IDM_kCaosFilter) ||
        fDisplay->IsEntryChecked(IDM_kCatalog)    ||
        fDisplay->IsEntryChecked(IDM_kFindStar))
        fImage->DrawColImg(img, cimg);
    else
        fImage->DrawImg(img);
}

void MStarguider::UpdatePosZoom()
{
    MString txt;
    if (fDisplay->IsEntryChecked(IDM_kCatalog))
    {
        // FIXME: Necessary?
	fSao->Now();
        AltAz aa = fSao->CalcAltAzFromPix(fDx, fDy)*kRad2Deg;
        if (aa.Az()<0)
            aa.Az(aa.Az()+360);
        txt.Print("%.1fd/%.1fd (%d, %d)", -aa.Alt(), aa.Az()-180, fDx, fDy);
    }
    else
        txt.Print("(%d, %d)", fDx, fDy);
    fPosZoom->SetText(txt);
}

Bool_t MStarguider::HandleDoubleClick(Event_t *event)
{
    const Int_t w = fImage->GetWidth();
    const Int_t h = fImage->GetHeight();
    const Int_t x = fImage->GetX();
    const Int_t y = fImage->GetY();

    if (!(event->fX>x && event->fX<x+w && event->fY>y && event->fY<y+h))
        return kTRUE;

    Int_t dx = event->fX-x;
    Int_t dy = event->fY-y;

    if (dx<kZOOM/4) dx=kZOOM/4;
    if (dy<kZOOM/4) dy=kZOOM/4;
    if (dx>766-kZOOM/4) dx=766-kZOOM/4;
    if (dy>574-kZOOM/4) dy=574-kZOOM/4;

    fDx = dx;
    fDy = dy;

    UpdatePosZoom();
    return kTRUE;
}

void MStarguider::Print(TString &str, Double_t deg) const
{
    Char_t sgn;
    UShort_t d, m, s;

    MAstro::Deg2Dms(deg, sgn, d, m, s);

    MString txt;
    str += txt.Print("%c %03d %02d %03d ", sgn, d, m, s);
}
