---

/Go4FitGUI/TGo4FitPanel.ui.h

Go to the documentation of this file.

//---------------------------------------------------------------
//        Go4 Release Package v2.10-5 (build 21005) 
//                      03-Nov-2005
//---------------------------------------------------------------
//       The GSI Online Offline Object Oriented (Go4) Project
//       Experiment Data Processing at DVEE department, GSI
//---------------------------------------------------------------
//
//Copyright (C) 2000- Gesellschaft f. Schwerionenforschung, GSI
//                    Planckstr. 1, 64291 Darmstadt, Germany
//Contact:            http://go4.gsi.de
//----------------------------------------------------------------
//This software can be used under the license agreements as stated
//in Go4License.txt file which is part of the distribution.
//----------------------------------------------------------------
/****************************************************************************
** ui.h extension file, included from the uic-generated form implementation.
**
** If you wish to add, delete or rename slots use Qt Designer which will
** update this file, preserving your code. Create an init() slot in place of
** a constructor, and a destroy() slot in place of a destructor.
*****************************************************************************/

#include <iostream.h>

static const char* SelectedXPM[]={
"12 12 5 1",
"# c #000000",
"a c #ffffff",
"c c #808080",
"b c #c0c0c0",
". c None",
"############",
"#aaaaaaaaaa#",
"#aaaaaaa##a#",
"#aaaaaaa##a#",
"#aaaaaa##aa#",
"#a##aaa##aa#",
"#a##aa##aaa#",
"#aa##a##aaa#",
"#aa####aaaa#",
"#aaa##aaaaa#",
"#aaaaaaaaaa#",
"############"};

static const char* UnselectedXPM[]={
"12 12 5 1",
"# c #000000",
"a c #ffffff",
"c c #808080",
"b c #c0c0c0",
". c None",
"############",
"#aaaaaaaaaa#",
"#aaaaaaaaaa#",
"#aaaaaaaaaa#",
"#aaaaaaaaaa#",
"#aaaaaaaaaa#",
"#aaaaaaaaaa#",
"#aaaaaaaaaa#",
"#aaaaaaaaaa#",
"#aaaaaaaaaa#",
"#aaaaaaaaaa#",
"############"};


#include "Go4Fit/TGo4FitModelGauss1.h"
#include "Go4Fit/TGo4FitModelGauss2.h"
#include "Go4Fit/TGo4FitModelGaussN.h"


void TGo4FitPanel::init()
{
    TGo4LockGuard Global;

    setAcceptDrops(TRUE);
    fxRegistry = TGo4GUIRegistry::Instance();
    fxSlots = dynamic_cast<TGo4FitPanelSlots*> (fxRegistry->GetSlotClass("TGo4FitPanelSlots"));
    if(fxSlots==0) fxSlots = new TGo4FitPanelSlots ("TGo4FitPanelSlots" , "Slot Class for Qt GUI", this);
              else fxSlots->SetGUI(this);

    fxStatus = dynamic_cast <TGo4FitPanelStatus *> (fxSlots->GetStatus());

    MenuBar = new QMenuBar( this, "menubar" );
    MenuBar->setFrameShape(QFrame::NoFrame);

    FitterMenu = new QPopupMenu( this );
    MenuBar->insertItem( "&Fitter",FitterMenu);
    connect(FitterMenu, SIGNAL(aboutToShow()), this, SLOT(AboutToShowFitterMenu()) );

    ViewMenu = new QPopupMenu( this );
    MenuBar->insertItem( "&Tools",ViewMenu);
    connect(ViewMenu, SIGNAL(aboutToShow()), this, SLOT(AboutToShowViewMenu()) );

    SettMenu = new QPopupMenu( this );
    MenuBar->insertItem( "&Settings", SettMenu);
    connect(SettMenu, SIGNAL(aboutToShow()), this, SLOT(AboutToShowSettMenu()) );

    SettMenu->insertItem("&Confirmation", this, SLOT(ChangeSettings(int)), 0, 1);
    SettMenu->insertItem("&Show primitives", this, SLOT(ChangeSettings(int)), 0, 2);
    SettMenu->insertItem("&Freeze mode", this, SLOT(ChangeSettings(int)), 0, 3);
    SettMenu->insertItem("&Save with objects", this, SLOT(ChangeSettings(int)), 0, 4);

    SettMenu->insertSeparator();

    SettMenu->insertItem("&Use current range", this, SLOT(ChangeSettings(int)), 0, 10);
    SettMenu->insertItem("&Draw model", this, SLOT(ChangeSettings(int)), 0, 11);
    SettMenu->insertItem("Draw &background", this, SLOT(ChangeSettings(int)), 0, 14);
    SettMenu->insertItem("Dra&w components", this, SLOT(ChangeSettings(int)), 0, 12);
    SettMenu->insertItem("Draw on same &pad", this, SLOT(ChangeSettings(int)), 0, 13);
    SettMenu->insertItem("Draw &info on pad", this, SLOT(ChangeSettings(int)), 0, 15);
    
    SettMenu->insertSeparator();

    SettMenu->insertItem("&No &integral", this, SLOT(ChangeSettings(int)), 0, 17);
    SettMenu->insertItem("&Counts", this, SLOT(ChangeSettings(int)), 0, 18);
    SettMenu->insertItem("&Integral", this, SLOT(ChangeSettings(int)), 0, 19);
    SettMenu->insertItem("&Gauss integral", this, SLOT(ChangeSettings(int)), 0, 20);

    SettMenu->insertItem("Recalculate gauss &widths", this, SLOT(ChangeSettings(int)), 0, 16);

    SettMenu->insertSeparator();

    SettMenu->insertItem("&Do not use buffers", this, SLOT(ChangeSettings(int)), 0, 21);
    SettMenu->insertItem("&Only for data", this, SLOT(ChangeSettings(int)), 0, 22);
    SettMenu->insertItem("&For data and models", this, SLOT(ChangeSettings(int)), 0, 23);
    SettMenu->insertItem("&Individual settings", this, SLOT(ChangeSettings(int)), 0, 24);

    ItemMenu = 0;

    fxWizPars = new TObjArray();
    fxWizSlots = new TObjArray();
    fxParsTableList = new TObjArray();

    fiPaintMode = 0;

    TGo4FitPanelLayout->setMargin(3);
    TGo4FitPanelLayout->setSpacing(1);

    fxSlots->ActivateByFitter(0);
}

void TGo4FitPanel::destroy()
{
    TGo4LockGuard Global;

    TGo4MainWindow* w = dynamic_cast<TGo4MainWindow*> (fxRegistry->GetMainWindow());
    if (w) w->CloseFitPanel();

    delete fxParsTableList;
    delete fxWizSlots;
    delete fxWizPars;
    delete fxSlots;
}

// **************************** interface to MainGUI ************************

void TGo4FitPanel::ActivateByFitter( TGo4Fitter * Fitter) {
   TGo4LockGuard Global;

   if(fxSlots)
     fxSlots->ActivateByFitter(Fitter);
}

void TGo4FitPanel::DropFitterOnPanel(TGo4Fitter* Fitter, TGo4PreviewPanel* Panel)
{
   if (fxSlots)
     fxSlots->Fitter_DropToPanel(Fitter, Panel);
}


void TGo4FitPanel::SetViewPanel(TGo4PreviewPanel* Panel) {
  TGo4LockGuard Global;

  if (Panel)
    fxSlots->ActivePadSelected(Panel, Panel->GetActivePad());
}

void TGo4FitPanel::SelectedPadChange(TGo4PreviewPanel* Panel) {
   TGo4LockGuard Global;

  if (Panel==0) return;
}

void TGo4FitPanel::PanelRemoved(TGo4PreviewPanel* Panel) {
  TGo4LockGuard Global;

  if (fxSlots && Panel)
     fxSlots->ViewPanelRemoved(Panel);
}

void TGo4FitPanel::PadUpdated(TGo4PreviewPanel* Panel, TPad* Pad) {
  TGo4LockGuard Global;

  if ((Panel==0) || (Pad==0)) return;
}

// ************************ end of interface to MainGUI *****************************


void TGo4FitPanel::closeEvent( QCloseEvent *ce )
{
    TGo4LockGuard Global;

    ce->accept();
    delete this;
}

void TGo4FitPanel::FitList_contextMenuRequested( QListViewItem * item, const QPoint & pnt, int )
{
   TGo4LockGuard Global;

   QFitItem* fititem = dynamic_cast<QFitItem*> (item);
   if (fititem==0) return;

   QPopupMenu menu(0,"ListPopup");

   if (fxSlots->FillPopupForItem(fititem,&menu)) {
      int id =  menu.exec(pnt);
      fxSlots->ExecPopupForItem(fititem, id /*, menu.text(id) */);
   }
}


void TGo4FitPanel::FitList_currentChanged( QListViewItem * item)
{
   TGo4LockGuard Global;

   fxSlots->ListItemClicked(item);
}

void TGo4FitPanel::AboutToShowViewMenu() {
  TGo4LockGuard Global;

  ViewMenu->clear();

  ViewMenu->insertItem("&Simple", this, SLOT(ChangeViewType(int)), 0, 1);
  ViewMenu->insertItem("&Wizard", this, SLOT(ChangeViewType(int)), 0, 2);
  ViewMenu->insertItem("&Expert", this, SLOT(ChangeViewType(int)), 0, 3);

  ViewMenu->setItemChecked(fxStatus->SelectedWidgetID(), TRUE);
}


void TGo4FitPanel::ChangeViewType(int id) {
  TGo4LockGuard Global;

  fxSlots->ChangeActivePage(id);
}

void TGo4FitPanel::ShowPanelPage( int id ) {
   TGo4LockGuard Global;

   QWidget* w = PageEmpty;
   switch(id) {
      case 1: w = PageSimple; break;
      case 2: w = PageWizard; break;
      case 3: w = PageExtended; break;
      case 100: w = PageParameters; break;
   }
   if (w!=WidgetStack->visibleWidget())
     WidgetStack->raiseWidget(w);
}

void TGo4FitPanel::UpdateStatusBar(const char* info) {
   TGo4LockGuard Global;

   QString status;
   TGo4Fitter* fitter = fxSlots->GetFitter();

   if (info!=0) status=info; else {
       if (fxSlots->WorkingWithPanel()) {
          status = QString("Pad ") + fxSlots->ActivePad()->GetName() +
                           " in panel " + fxSlots->ActiveViewPanel()->name();
          if (!fxSlots->WorkingWithOnlyPad())
            status += ". Muiltifit";

       } else status = "Workspace";
       if (fitter==0) status+=".  No fitter";
                 else status = status + ". Fitter: "+fitter->GetName();
   }
   MainStatusLbl->setText(status);
   MainStatusLbl->update();
   MainStatusLbl->repaint();

   MainAttachBtn->setEnabled(TRUE);

   QToolTip::remove(MainParsBtn);
   if (fxStatus->ParsWidgetShown()) {
     MainParsBtn->setText("Back");
     QToolTip::add(MainParsBtn, "Back to last selected page");
   } else {
     MainParsBtn->setText("Pars");
     QToolTip::add(MainParsBtn, "Show list of fitter parameters");
   }
   
   if (fitter==0) {
     MainFitBtn->setEnabled(FALSE);
     MainDrawBtn->setEnabled(FALSE);
     MainFindBtn->setEnabled(FALSE);
     MainParsBtn->setEnabled(FALSE);
   } else {
     MainFitBtn->setEnabled((fitter->GetNumData()>0) &&
           ((fitter->GetNumModel()>0) || fxStatus->SimpleWidgetSelected()));
     MainDrawBtn->setEnabled(fitter->GetNumData()>0);
     MainFindBtn->setEnabled((fitter->GetNumData()>0) && fxStatus->WizWidgetSelected()
                             && fxSlots->FitOptions()->GetPeakFinder(kFALSE));
     MainParsBtn->setEnabled(TRUE);
   }
}

void TGo4FitPanel::UpdateItemMenu() {
  TGo4LockGuard Global;

  bool showitem = fxStatus->ExtendedWidgetSelected();

  QString itemtext;

  if (showitem) {
    QFitItem* item = dynamic_cast<QFitItem*> (FitList->currentItem());
    if ((item==0) || (item->ObjectType()==TGo4FitPanelSlots::ot_fitter)) showitem = FALSE; else
       itemtext = item->text(0);
  }

  if (showitem) {
    if (ItemMenu==0) {
      ItemMenu = new QPopupMenu(this);
      MenuBar->insertItem( itemtext, ItemMenu, 111);
      connect(ItemMenu, SIGNAL(aboutToShow()), this, SLOT(AboutToShowItemMenu()) );
    } else MenuBar->changeItem(111, itemtext);
  } else
    if (ItemMenu!=0) {
      MenuBar->removeItem(111);
      delete ItemMenu;
      ItemMenu = 0;
    }
}

void TGo4FitPanel::AboutToShowSettMenu() {
  TGo4LockGuard Global;

  SettMenu->setItemChecked(1,fxStatus->NeedConfirmation());
  SettMenu->setItemChecked(2,fxStatus->ShowPrimitives());
  SettMenu->setItemChecked(3,fxStatus->FreezeMode());
  SettMenu->setItemChecked(4,fxStatus->SaveWithReferences());
  SettMenu->setItemVisible(4, fxStatus->ExtendedWidgetSelected());

  SettMenu->setItemChecked(10,fxStatus->UseCurrentRange());
  SettMenu->setItemChecked(11,fxStatus->DrawModels());
  SettMenu->setItemChecked(12,fxStatus->DrawComponents());
  SettMenu->setItemChecked(13,fxStatus->UseSamePanelForDraw());
  SettMenu->setItemChecked(14,fxStatus->DrawBackground());
  SettMenu->setItemChecked(15,fxStatus->DrawInfoOnPad());
  SettMenu->setItemChecked(16,fxStatus->RecalculateGaussWidth());
  
  SettMenu->setItemChecked(17,fxStatus->IntegralMode()==0);
  SettMenu->setItemChecked(18,fxStatus->IntegralMode()==1);
  SettMenu->setItemChecked(19,fxStatus->IntegralMode()==2);
  SettMenu->setItemChecked(20,fxStatus->IntegralMode()==3);

  SettMenu->setItemChecked(21,fxStatus->BuffersUsage()==0);
  SettMenu->setItemChecked(22,fxStatus->BuffersUsage()==1);
  SettMenu->setItemChecked(23,fxStatus->BuffersUsage()==2);
  SettMenu->setItemChecked(24,fxStatus->BuffersUsage()==3);

}

void TGo4FitPanel::ChangeSettings(int id) {
  TGo4LockGuard Global;

  fxSlots->ChangeSettings(id);
}

void TGo4FitPanel::AboutToShowFitterMenu() {
   TGo4LockGuard Global;

   FitterMenu->clear();

   TGo4Fitter* fitter = fxSlots->GetFitter();
   TGo4WorkSpace* space = dynamic_cast<TGo4WorkSpace*> (fxRegistry->GetCentralWindow());
   TGo4PreviewPanel* Panel = space==0 ? 0 : space->GetLastActiveViewPanel();

   bool samepad = Panel==0 ? FALSE : fxSlots->WorkingWithPanel() &&
     (Panel==fxSlots->ActiveViewPanel()) && (Panel->GetActivePad()==fxSlots->ActivePad());

   QString padname;
//   if (Panel)
//     padname = QString(Panel->GetActivePad()->GetName()) + " in panel " + Panel->name();
   if (Panel) padname = QString("panel \"") + Panel->caption() + "\""; 

   if (fxStatus->ExtendedWidgetSelected())
     FitterMenu->insertItem("&Create for workspace", this, SLOT(FitterMenuItemSelected(int)), 0, 1);
   FitterMenu->insertItem("Create &for "+padname, this, SLOT(FitterMenuItemSelected(int)), 0, 2);
   FitterMenu->insertItem("&Delete", this, SLOT(FitterMenuItemSelected(int)), 0, 3);
   FitterMenu->insertSeparator();

//   FitterMenu->insertItem("&Copy to pad "+padname, this, SLOT(FitterMenuItemSelected(int)), 0, 11);
//   FitterMenu->insertItem("&Move to pad "+padname, this, SLOT(FitterMenuItemSelected(int)), 0, 12);
//   FitterMenu->insertItem("&Copy to workspace", this, SLOT(FitterMenuItemSelected(int)), 0, 13);
//   FitterMenu->insertItem("&Move to workspace", this, SLOT(FitterMenuItemSelected(int)), 0, 14);
//   FitterMenu->insertSeparator();

   FitterMenu->insertItem("Save to &browser", this, SLOT(FitterMenuItemSelected(int)), 0, 21);
//   FitterMenu->insertItem("Save to &file", this, SLOT(FitterMenuItemSelected(int)), 0, 22);
   if (fxStatus->ExtendedWidgetSelected())
      FitterMenu->insertItem("&Workspace", this, SLOT(FitterMenuItemSelected(int)), 0, 23);
   FitterMenu->insertItem("&Update references", this, SLOT(FitterMenuItemSelected(int)), 0, 24);
   FitterMenu->insertItem("&Print parameters", this, SLOT(FitterMenuItemSelected(int)), 0, 25);
   FitterMenu->insertItem("&Rollback parameters", this, SLOT(FitterMenuItemSelected(int)), 0, 26);

   FitterMenu->insertSeparator();

   FitterMenu->insertItem("&Close", this, SLOT(FitterMenuItemSelected(int)), 0, 99);

   FitterMenu->setItemEnabled(1, TRUE);
   FitterMenu->setItemEnabled(2, (Panel!=0));
   FitterMenu->setItemEnabled(3, (fitter!=0));

   FitterMenu->setItemEnabled(11, (fitter!=0) && (Panel!=0) && !samepad);
   FitterMenu->setItemEnabled(12, (fitter!=0) && (Panel!=0) && !samepad);
   FitterMenu->setItemEnabled(13, (fitter!=0) && fxSlots->WorkingWithPanel());
   FitterMenu->setItemEnabled(14, (fitter!=0) && fxSlots->WorkingWithPanel());

   FitterMenu->setItemEnabled(21, (fitter!=0));
   FitterMenu->setItemEnabled(22, (fitter!=0));
   FitterMenu->setItemEnabled(23, fxSlots->WorkingWithPanel());
   FitterMenu->setItemEnabled(24, (fitter!=0));
   FitterMenu->setItemEnabled(25, (fitter!=0) && fxStatus->ParsWidgetShown());
   FitterMenu->setItemEnabled(26, (fitter!=0) && fitter->CanRollbackPars());

   FitterMenu->setItemEnabled(99, TRUE);
}

void TGo4FitPanel::FitterMenuItemSelected(int id) {
   TGo4LockGuard Global;

   switch (id) {
      case 1: fxSlots->Fitter_New(); break;
      case 2: fxSlots->Fitter_NewForActivePad(TRUE); break;
      case 3: fxSlots->Fitter_Delete(); break;
      case 11: fxSlots->Fitter_MoveCopy(FALSE, TRUE); break;
      case 12: fxSlots->Fitter_MoveCopy(TRUE, TRUE); break;
      case 13: fxSlots->Fitter_MoveCopy(FALSE, FALSE); break;
      case 14: fxSlots->Fitter_MoveCopy(TRUE, FALSE); break;
      case 21: fxSlots->Fitter_SaveToBrowser(); break;
      case 22: fxSlots->Fitter_SaveToFile(); break;
      case 23: fxSlots->Fitter_UseWorkspace(); break;
      case 24: fxSlots->Fitter_UpdateReferences(); break;
      case 25: fxSlots->Fitter_PrintParameters(); break;
      case 26: fxSlots->Fitter_RollbackParameters(); break;
      case 99: close(); break;
   }
}

void TGo4FitPanel::AboutToShowItemMenu() {
  TGo4LockGuard Global;

  if (ItemMenu==0) return;
  QFitItem* item = dynamic_cast<QFitItem*> (FitList->currentItem());
  if (item==0) return;
  ItemMenu->clear();
  if (!fxSlots->FillPopupForItem(item,ItemMenu)) return;
  for(uint n=0;n<ItemMenu->count();n++) {
     int id = ItemMenu->idAt(n);
     ItemMenu->connectItem(id, this, SLOT(ItemMenuItemSelected(int)));
  }
}

void TGo4FitPanel::ItemMenuItemSelected(int id) {
   TGo4LockGuard Global;

   QFitItem* item = dynamic_cast<QFitItem*> (FitList->currentItem());
   if (item==0) return;
   fxSlots->ExecPopupForItem(item, id /*, ItemMenu->text(id) */);
}

void TGo4FitPanel::focusInEvent( QFocusEvent* event) {
  TGo4LockGuard Global;

  UpdateStatusBar(0);
  QWidget::focusInEvent(event);
}

void TGo4FitPanel::windowActivationChange( bool OldActive) {
   TGo4LockGuard Global;

   UpdateStatusBar(0);
   QWidget::windowActivationChange(OldActive);
}

void TGo4FitPanel::dragEnterEvent( QDragEnterEvent * Event ) {
    TGo4LockGuard Global;

    fxSlots->DragEnterEvent(Event);
}

void TGo4FitPanel::dragMoveEvent(QDragMoveEvent * Event) {
  TGo4LockGuard Global;

  bool ignore = TRUE;
  if (QTextDrag::canDecode(Event)) {
    QWidget* w = childAt(Event->pos(), TRUE);

    if (w == (QWidget*)FitList->viewport()) {
      QPoint pnt = FitList->viewport()->mapFrom(this, Event->pos());
      QFitItem* item = dynamic_cast<QFitItem*> (FitList->itemAt(pnt));
      if (item) {
        fxSlots->DragMoveEvent(item->Object(), item->ObjectType(), Event);
        ignore = FALSE;
      }
    } else

    if ((w == Wiz_DataSlotsTable->viewport())) {
      QPoint pnt = Wiz_DataSlotsTable->viewport()->mapFrom(this, Event->pos());
      pnt = Wiz_DataSlotsTable->viewportToContents(pnt);
      int nrow = Wiz_DataSlotsTable->rowAt(pnt.y());

      if ((nrow>=0) && (nrow<=fxWizSlots->GetLast())) {
        TGo4FitSlot* slot = dynamic_cast<TGo4FitSlot*> (fxWizSlots->At(nrow));
        if (slot) {
          fxSlots->DragMoveEvent(slot, TGo4FitPanelSlots::ot_slot, Event);
          ignore = FALSE;
        }
       }
     } else

     if ((w==PageEmpty) || (w==PageEmptyLbl)) {
       fxSlots->DragMoveEvent(0, TGo4FitPanelSlots::ot_empty, Event);
       ignore = FALSE;
     } else

     if (w == Wiz_DataList->viewport()) {
       fxSlots->DragMoveEvent(0, TGo4FitPanelSlots::ot_wizdatalist, Event);
       ignore = FALSE;
     }
    }
  if (ignore) Event->ignore();
}

void TGo4FitPanel::dropEvent( QDropEvent * Event ) {
   TGo4LockGuard Global;

   QWidget* w = childAt(Event->pos(), TRUE);

   if(w==(QWidget*)FitList->viewport()) {
      QPoint pnt = FitList->viewport()->mapFrom(this, Event->pos());
      QFitItem* item = dynamic_cast<QFitItem*> (FitList->itemAt(pnt));
      if (item)
        fxSlots->DropEvent(item->Object(), item->ObjectType(), Event, item);
   } else
   if (w == Wiz_DataSlotsTable->viewport()) {
      QPoint pnt = Wiz_DataSlotsTable->viewport()->mapFrom(this, Event->pos());
      pnt = Wiz_DataSlotsTable->viewportToContents(pnt);
      int nrow = Wiz_DataSlotsTable->rowAt(pnt.y());

      if ((nrow>=0) && (nrow<=fxWizSlots->GetLast())) {
        TGo4FitSlot* slot = dynamic_cast<TGo4FitSlot*> (fxWizSlots->At(nrow));
        if (slot)
          fxSlots->DropEvent(slot, TGo4FitPanelSlots::ot_slot, Event);
      }
   } else
   if ((w==PageEmpty) || (w==PageEmptyLbl)) {
     fxSlots->DropEvent(0, TGo4FitPanelSlots::ot_empty, Event);
   } else
   if (w == Wiz_DataList->viewport())
     fxSlots->DropEvent(0, TGo4FitPanelSlots::ot_wizdatalist, Event);
}

void TGo4FitPanel::SetFillingWidget(bool zn) {
  fbFillingWidget = zn;
}

bool TGo4FitPanel::IsFillingWidget() {
   return fbFillingWidget;
}

void TGo4FitPanel::UpdatePFAmplLbl() {
   TGo4LockGuard Global;

   TGo4FitPeakFinder* finder = fxSlots->FitOptions() ? fxSlots->FitOptions()->GetPeakFinder() : 0;
   if (finder)
     PF_AmplLbl->setText(QString("Threshold: ")+QString::number(finder->Get0MaxAmplFactor()*100)+"%");
   else
     PF_AmplLbl->setText("Threshold:");
   PF_AmplLbl->adjustSize();
}

void TGo4FitPanel::UpdatePFRelNoiseLbl() {
   TGo4LockGuard Global;

   TGo4FitPeakFinder* finder = fxSlots->FitOptions() ? fxSlots->FitOptions()->GetPeakFinder() : 0;

   if (finder)
     PF_RelNoiseLbl->setText(QString("Noise factor: ")+QString::number(finder->Get2NoiseFactor()));
   else
     PF_RelNoiseLbl->setText("Noise factor: ");
   PF_RelNoiseLbl->adjustSize();
}

void TGo4FitPanel::PF_MinWidthEdt_textChanged( const QString & str )
{
  TGo4LockGuard Global;

  if (IsFillingWidget()) return;
  bool ok;
  double zn = str.toDouble(&ok);
  if (fxSlots->FitOptions() && ok) {
    TGo4FitPeakFinder* finder = fxSlots->FitOptions()->GetPeakFinder();
    if (finder) finder->Set0MinWidth(zn);
  }
}


void TGo4FitPanel::PF_MaxWidthEdt_textChanged( const QString & str )
{
  TGo4LockGuard Global;

  if (IsFillingWidget()) return;
  bool ok;
  double zn = str.toDouble(&ok);
  if (fxSlots->FitOptions() && ok) {
    TGo4FitPeakFinder* finder = fxSlots->FitOptions()->GetPeakFinder();
    if (finder) finder->Set0MaxWidth(zn);
  }
}


void TGo4FitPanel::PF_WidthEdit_textChanged( const QString & str)
{
  TGo4LockGuard Global;

  if (IsFillingWidget()) return;
  bool ok;
  double zn = str.toDouble(&ok);
  if (fxSlots->FitOptions() && ok) {
    TGo4FitPeakFinder* finder = fxSlots->FitOptions()->GetPeakFinder();
    if (finder) finder->Set1LineWidth(zn);
  }
}

void TGo4FitPanel::PF_AmplSlider_valueChanged( int zn )
{
  TGo4LockGuard Global;

  if (!IsFillingWidget() && fxSlots->FitOptions()) {
     TGo4FitPeakFinder* finder = fxSlots->FitOptions()->GetPeakFinder();
     if (finder) finder->Set0MaxAmplFactor(1.-zn/100.);
     UpdatePFAmplLbl();
  }
}

void TGo4FitPanel::PF_AmplSlider_sliderReleased()
{
  TGo4LockGuard Global;

  if (!IsFillingWidget() && fxSlots)
    fxSlots->Button_PeakFinder();
}

void TGo4FitPanel::PF_RelNoiseSlider_valueChanged( int zn )
{
  TGo4LockGuard Global;

  if (!IsFillingWidget() && fxSlots->FitOptions()) {
     TGo4FitPeakFinder* finder = fxSlots->FitOptions()->GetPeakFinder();
     if (finder) finder->Set2NoiseFactor((101-zn)/10.);
     UpdatePFRelNoiseLbl();
  }
}

void TGo4FitPanel::PF_RelNoiseSlider_sliderReleased()
{
  TGo4LockGuard Global;

  if (!IsFillingWidget() && fxSlots)
    fxSlots->Button_PeakFinder();
}

void TGo4FitPanel::PF_MinNoiseEdit_textChanged( const QString & str)
{
  TGo4LockGuard Global;

  if (IsFillingWidget()) return;
  bool ok;
  double zn = str.toDouble(&ok);
  if (fxSlots->FitOptions() && ok) {
    TGo4FitPeakFinder* finder = fxSlots->FitOptions()->GetPeakFinder();
    if (finder) finder->Set2NoiseMinimum(zn);
  }
}


void TGo4FitPanel::PF_SumUpSpin_valueChanged( int num)
{
  TGo4LockGuard Global;

  if (!IsFillingWidget() && fxSlots->FitOptions()) {
    TGo4FitPeakFinder* finder = fxSlots->FitOptions()->GetPeakFinder();
    if (finder) {
       finder->Set2ChannelSum(num);
       fxSlots->Button_PeakFinder();
    }
  }
}


void TGo4FitPanel::UpdateWizDataList() {
  TGo4LockGuard Global;

   if (fxSlots->FitOptions()==0) return;

   TGo4Fitter* fitter = fxSlots->GetFitter();

   SetFillingWidget(TRUE);

   bool updatestack = FALSE, updatepaint = FALSE;

   Wiz_DataList->clear();
   if (fitter==0) fxSlots->FitOptions()->SetWizDataName("");
   else {
     if ((fxSlots->FitOptions()->GetWizData()==0) && (fitter->GetNumData()>0)) {
       fxSlots->FitOptions()->SetWizDataName(fitter->GetDataName(0));
       if (fxSlots->FitOptions()->WizPageIndex()<1) updatestack = TRUE;
       if (fiPaintMode==0) updatepaint = TRUE;
     }

     int selindx = -1;
     for(Int_t n=0;n<fitter->GetNumData();n++) {
       TGo4FitData* data = fitter->GetData(n);
       Wiz_DataList->insertItem(data->GetName());
       if (strcmp(data->GetName(), fxSlots->FitOptions()->GetWizDataName())==0) selindx = n;
     }
     Wiz_DataList->setSelected(selindx, TRUE);
     if (selindx<0) fxSlots->FitOptions()->SetWizDataName("");
               else Wiz_DataList->setSelected(selindx, TRUE);
   }
   UpdateWizDataBtns();
   SetFillingWidget(FALSE);

   if (updatestack) {
      fxSlots->FitOptions()->WizPageIndex() = 2;
      UpdateWizStackWidget();
   }
   if (updatepaint)
     UpdateWizPaint(1);

}

void TGo4FitPanel::UpdateWizDataBtns() {
  TGo4LockGuard Global;

   TGo4Fitter* fitter = fxSlots->GetFitter();
   if ((fitter==0) || (fxSlots->FitOptions()==0)) return;
   TGo4FitData* data = fxSlots->FitOptions()->GetWizData();

   Wiz_PFSetupBtn->setEnabled(data!=0);

   if (!fxSlots->WorkingWithPanel()) {
     Wiz_RebuildDataBtn->setShown(FALSE);
     Wiz_AddDataBtn->setShown(TRUE);
     Wiz_DelDataBtn->setShown(TRUE);
     Wiz_AddDataBtn->setEnabled(fitter!=0);
     Wiz_DelDataBtn->setEnabled(data!=0);
   } else {
     Wiz_RebuildDataBtn->setShown(TRUE);
     Wiz_RebuildDataBtn->setEnabled(fitter!=0);
     Wiz_AddDataBtn->setShown(FALSE);
     Wiz_DelDataBtn->setShown(FALSE);
   }
}

void TGo4FitPanel::UpdateWizModelsList(bool changestack) {
  TGo4LockGuard Global;

    SetFillingWidget(TRUE);

    Wiz_ModelList->clear();
    if (fxSlots->FitOptions()) {

        TGo4Fitter* fitter = fxSlots->GetFitter();

        Wiz_ShowAllMod->setChecked(fxSlots->FitOptions()->WizShowAllModels());
        int selindx = -1;
        if(fitter) {
           TGo4FitData* data = fxSlots->FitOptions()->GetWizData();
           int indx = 0;
           for(Int_t n=0;n<fitter->GetNumModel();n++) {
              TGo4FitModel* model = fitter->GetModel(n);
              if (data && !fxSlots->FitOptions()->WizShowAllModels())
                if (!model->IsAssignTo(data->GetName())) continue;

              bool assign = FALSE;
              if (data && model->IsAssignTo(data->GetName())) assign = TRUE;
              if (assign) Wiz_ModelList->insertItem(QPixmap(SelectedXPM), model->GetName());
                     else Wiz_ModelList->insertItem(QPixmap(UnselectedXPM), model->GetName());

              if (strcmp(model->GetName(), fxSlots->FitOptions()->GetWizModelName())==0) selindx = indx;
              indx++;
           }
           Wiz_ModelList->setSelected(selindx, TRUE);

           if (selindx<0) fxSlots->FitOptions()->SetWizModelName("");
                     else Wiz_ModelList->ensureCurrentVisible();

        } else fxSlots->FitOptions()->SetWizModelName("");
       if (changestack)
         if (selindx>=0) fxSlots->FitOptions()->WizPageIndex() = 1; else
          if (fxSlots->FitOptions()->WizPageIndex()==1) fxSlots->FitOptions()->WizPageIndex() = 0;
    }

    UpdateWizModelsBtns();
    SetFillingWidget(FALSE);
    if(changestack)
      UpdateWizStackWidget();
}

void TGo4FitPanel::UpdateWizModelsBtns() {
  TGo4LockGuard Global;

   Wiz_AddModelBtn->setEnabled(FALSE);
   Wiz_DelModelBtn->setEnabled(FALSE);
   Wiz_ShowAllMod->setEnabled(FALSE);

   if (fxSlots->FitOptions()==0) return;

   TGo4Fitter* fitter = fxSlots->GetFitter();
   TGo4FitModel* model = fxSlots->FitOptions()->GetWizModel();
//   TGo4FitData* data = fxSlots->FitOptions()->GetWizData();

   Wiz_ShowAllMod->setShown(!fxSlots->WorkingWithOnlyPad());

   if (fitter) {
      Wiz_AddModelBtn->setEnabled(TRUE);
      Wiz_DelModelBtn->setEnabled(model!=0);
      Wiz_ShowAllMod->setEnabled(TRUE);

   } else {
      Wiz_AddModelBtn->setEnabled(FALSE);
      Wiz_DelModelBtn->setEnabled(FALSE);
      Wiz_ShowAllMod->setEnabled(FALSE);
   }
}

void TGo4FitPanel::UpdateWizStackWidget() {
    TGo4LockGuard Global;

    SetFillingWidget(TRUE);
    TGo4Fitter* fitter = fxSlots->GetFitter();

    int indx = -1;
    if (fxSlots->FitOptions())
      if (fitter==0) fxSlots->FitOptions()->WizPageIndex() = -1;
                else indx = fxSlots->FitOptions()->WizPageIndex();

    QWidget* target = 0;

    switch (indx) {
       case -1:
          target = Wiz_EmptyPage;
          break;
       case 0: {
          target = Wiz_FitterPage;

          int typ = fitter->GetFitFunctionType();
          if (typ==TGo4Fitter::ff_user) typ = TGo4Fitter::ff_least_squares;
          Wiz_FitFuncCmb->setCurrentItem(typ);

          Wiz_UseAmplEstimChk->setChecked(fxSlots->FitOptions()->UseAmplEstim());
          Wiz_MigradIterSpin->setValue(fxSlots->FitOptions()->NumMigradIter());

          break; 
       }
       
       case 1: {
          TGo4FitModel* model = fxSlots->FitOptions()->GetWizModel();
          if (model==0) break;

          target = Wiz_ModelPage;

          QString modelinfo;
          fxSlots->Wiz_GetModelInfo(model, &modelinfo);
          Wiz_ModelInfoLbl->setText(modelinfo);

          Wiz_BackgroundChk->setChecked(model->GetGroupIndex()==0);

          Wiz_ModelBufChk->setChecked(model->GetUseBuffers());
          Wiz_ModelBufChk->setEnabled(fxStatus->BuffersUsage()==3);

          FillParsTable(Wiz_ParTable, fitter, model, FALSE, fxWizPars);

          break; 
       }

       case 2: {
         TGo4FitData* data = fxSlots->FitOptions()->GetWizData();
         if (data==0) break;

         target = Wiz_DataPage;

         QString datainfo("Data: ");
         datainfo += data->GetName();
         datainfo += "  of class: ";
         datainfo += data->ClassName();
         if (fxStatus->IntegralMode()==1) {
            datainfo += "\nCounts=";
            double v = fitter->CalculatesIntegral(data->GetName(),0,kTRUE);
            datainfo += QString::number(v);  
         }
         if (fxStatus->IntegralMode()==2) {
            datainfo += "\nIntegral=";
            double v = fitter->CalculatesIntegral(data->GetName(),0,kFALSE);
            datainfo += QString::number(v);  
         }
         Wiz_DataInfoLbl->setText(datainfo);

         QString models("Models:");
         for(int n=0;n<fitter->GetNumModel();n++) {
            TGo4FitModel* model = fitter->GetModel(n);
            if (model->IsAssignTo(data->GetName())) {
               if (models.length()>45) {
                  models += " ...";
                  break; 
               }
               models += " ";
               models += model->GetName();
            }
         }
         Wiz_DataModelsLbl->setText(models);

         Wiz_DataBufChk->setChecked(
           (fxStatus->BuffersUsage()==1) || (fxStatus->BuffersUsage()==2) ||
           ((fxStatus->BuffersUsage()==3) && data->GetUseBuffers()));
         Wiz_DataBufChk->setEnabled(fxStatus->BuffersUsage()==3);

         fxWizSlots->Clear();
         data->FillSlotList(fxWizSlots);

         Wiz_DataSlotsTable->setNumRows(fxWizSlots->GetLast()+1);

         for(int n=0;n<=fxWizSlots->GetLast();n++) {
           TGo4FitSlot* slot = dynamic_cast<TGo4FitSlot*> (fxWizSlots->At(n));
           if (slot==0) continue;

           Wiz_DataSlotsTable->verticalHeader()->setLabel(n, slot->GetName());
           TObject* obj = slot->GetObject();

           if (obj==0) {
              Wiz_DataSlotsTable->setText(n, 0, " --- ");
              Wiz_DataSlotsTable->setText(n, 1, slot->GetClass()->GetName());
              Wiz_DataSlotsTable->setText(n, 2, "false");
           } else {
              Wiz_DataSlotsTable->setText(n, 0, obj->GetName());
              Wiz_DataSlotsTable->setText(n, 1, obj->ClassName());
              if (slot->GetOwned()) Wiz_DataSlotsTable->setText(n, 2, "true");
                               else Wiz_DataSlotsTable->setText(n, 2, "false");
           }

           QString info;
           fxSlots->Wiz_GetSlotSourceInfo(slot, &info);
           Wiz_DataSlotsTable->setText(n, 3, info);
         }

         for(int n=0;n<=3;n++)
           Wiz_DataSlotsTable->adjustColumn(n);

         Wiz_DataUseRangeBtn->setEnabled(fxSlots->Wiz_DataHasPad());
         if (data)
           Wiz_DataClearRangesBtn->setEnabled(data->IsAnyRangeLimits());
         Wiz_DrawDataBtn->setEnabled(data!=0);

         break; 
      }
      case 3: {
         target = Wiz_PFPage;

         TGo4FitPeakFinder* finder = fxSlots->FitOptions()->GetPeakFinder();
         if (finder==0) break;
         
         UpdateStatusBar(0);

         FindersTab->setCurrentPage(finder->GetPeakFinderType());

         Wiz_PFUsePolynChk->setChecked(finder->GetUsePolynom());
         Wiz_PFPolynSpin->setEnabled(finder->GetUsePolynom());
         Wiz_PFPolynSpin->setValue(finder->GetPolynomOrder());

         PF_MinWidthEdt->setText(QString::number(finder->Get0MinWidth()));
         PF_MaxWidthEdt->setText(QString::number(finder->Get0MaxWidth()));
         PF_AmplSlider->setValue(int(100*(1.-finder->Get0MaxAmplFactor())));
         UpdatePFAmplLbl();

         PF_WidthEdit->setText(QString::number(finder->Get1LineWidth()));

         int zn = int(10*finder->Get2NoiseFactor());  // from 1..100
         PF_RelNoiseSlider->setValue(101 - zn);
         UpdatePFRelNoiseLbl();
         PF_MinNoiseEdit->setText(QString::number(finder->Get2NoiseMinimum()));
         PF_SumUpSpin->setValue(finder->Get2ChannelSum());

         break; 
      }
    }

    if (target) Wiz_Stack->raiseWidget(target);
           else Wiz_Stack->raiseWidget(Wiz_EmptyPage);

    SetFillingWidget(FALSE);
}

void TGo4FitPanel::SetWizPaint(int mode) {
  TGo4LockGuard Global;
  if (mode>=0) fiPaintMode = mode;
}

void TGo4FitPanel::UpdateWizPaint(int mode) {
    TGo4LockGuard Global;

    fxSlots->Wiz_ClearPaint();

    if (fxSlots->FitOptions()==0) return;

    if (mode>=0) fiPaintMode = mode;

    TGo4FitModel* model = fxSlots->FitOptions()->GetWizModel();
    TGo4FitData* data = fxSlots->FitOptions()->GetWizData();

    if (data && (fiPaintMode==1)) fxSlots->Wiz_PaintData();
    if (model && (fiPaintMode==2)) fxSlots->Wiz_PaintModel();
}

void TGo4FitPanel::Wiz_DataListSelect(int indx)
{
  TGo4LockGuard Global;

  if (IsFillingWidget() || (fxSlots->FitOptions()==0)) return;
  QString name = Wiz_DataList->text(indx);

  if ( (name==fxSlots->FitOptions()->GetWizDataName()) &&
       (fxSlots->FitOptions()->WizPageIndex() == 2) ) return;
  fxSlots->FitOptions()->SetWizDataName(name);
  fxSlots->FitOptions()->WizPageIndex() = 2;
  UpdateWizDataBtns();
  UpdateWizModelsList(FALSE);
  UpdateWizStackWidget();
  UpdateWizPaint(1);

}

void TGo4FitPanel::Wiz_DataList_highlighted( int indx)
{
  TGo4LockGuard Global;

  Wiz_DataListSelect(indx);
}

void TGo4FitPanel::Wiz_ModelListSelect(int indx, bool ontext)
{
  TGo4LockGuard Global;

  if (IsFillingWidget() || (fxSlots->FitOptions()==0)) return;

  QString name = Wiz_ModelList->text(indx);

  bool needupdate = ( (name != fxSlots->FitOptions()->GetWizModelName()) ||
                      (fxSlots->FitOptions()->WizPageIndex() != 1) );

  fxSlots->FitOptions()->SetWizModelName(name);
  fxSlots->FitOptions()->WizPageIndex() = 1;

  if (!ontext) {

    TGo4Fitter* fitter = fxSlots->GetFitter();
    TGo4FitModel* model = fxSlots->FitOptions()->GetWizModel();
    TGo4FitData* data = fxSlots->FitOptions()->GetWizData();
    if ((fitter!=0) && (data!=0) && (model!=0)) {
       bool wasassigned = model->IsAssignTo(data->GetName());
       if (wasassigned) model->ClearAssignmentTo(data->GetName());
                   else model->AssignToData(data->GetName());

      SetFillingWidget(TRUE);
      if (!wasassigned) Wiz_ModelList->changeItem(QPixmap(SelectedXPM), model->GetName(), indx);
                   else Wiz_ModelList->changeItem(QPixmap(UnselectedXPM), model->GetName(), indx);
      Wiz_ModelList->setSelected(indx, TRUE);
      SetFillingWidget(FALSE);
      needupdate = TRUE;
    }
  }

  if (needupdate) {
    UpdateWizModelsBtns();
    UpdateWizStackWidget();
    UpdateWizPaint(2);
  }
}

void TGo4FitPanel::Wiz_ModelList_highlighted(int indx)
{
  TGo4LockGuard Global;

  Wiz_ModelListSelect(indx, TRUE);
}


void TGo4FitPanel::Wiz_AddDataBtn_clicked()
{
  TGo4LockGuard Global;

   if (IsFillingWidget() || (fxSlots->FitOptions()==0)) return;
   QPopupMenu menu(0,"WizPopup");

   fxSlots->Wiz_PrepareDataTypeList(&menu);
   int id =  menu.exec(Wiz_AddDataBtn->mapToGlobal(QPoint(5,5)));
   TGo4FitData* data = fxSlots->Wiz_CreateNewData(id);
   if (data) {
     fxSlots->FitOptions()->SetWizDataName(data->GetName());
     fxSlots->FitOptions()->WizPageIndex() = 2;
     UpdateWizDataList();
     UpdateWizModelsList(FALSE);
     UpdateWizStackWidget();
     UpdateWizPaint(1);
     UpdateStatusBar(0);
   }
}


void TGo4FitPanel::Wiz_DelDataBtn_clicked()
{
  TGo4LockGuard Global;

  if (IsFillingWidget() || (fxSlots->FitOptions()==0)) return;

  if (fxSlots->Wiz_RemoveData()) {
    UpdateWizDataList();
    UpdateWizModelsList(FALSE);
    fxSlots->FitOptions()->WizPageIndex() = 0;
    UpdateWizStackWidget();
    UpdateWizPaint(0);
    UpdateStatusBar(0);
  }
}


void TGo4FitPanel::Wiz_AddModelBtn_clicked()
{
  TGo4LockGuard Global;

   if (IsFillingWidget() || (fxSlots->FitOptions()==0)) return;
   QPopupMenu menu(0,"WizPopup");

   fxSlots->Wiz_PrepareModelTypeList(&menu);
   int id =  menu.exec(Wiz_AddModelBtn->mapToGlobal(QPoint(5,5)));
   TGo4FitModel* model = fxSlots->Wiz_CreateNewModel(id);
   if (model) fxSlots->FitOptions()->SetWizModelName(model->GetName());
   UpdateWizModelsList(TRUE);
   if(fxSlots->FitOptions()->GetWizModel())  UpdateWizPaint(2);
   UpdateStatusBar(0);
}


void TGo4FitPanel::Wiz_DelModelBtn_clicked()
{
  TGo4LockGuard Global;

  if (IsFillingWidget() || (fxSlots->FitOptions()==0)) return;

  TGo4Fitter* fitter = fxSlots->GetFitter();
  if (fitter==0) return;

  if(fxStatus->NeedConfirmation())
    if ( QMessageBox::information(0,"Delete models",
       QString("Are you sure to delete selected models"),
       QMessageBox::Yes, QMessageBox::No) == QMessageBox::No ) return;

  for(uint n=0; n<Wiz_ModelList->count();n++) {
     if (!Wiz_ModelList->isSelected(n)) continue;
     QString name = Wiz_ModelList->text(n);
     fitter->RemoveModel(name, kTRUE);
  }

  fxSlots->FitOptions()->SetWizModelName("");
  UpdateWizModelsList(TRUE);
  UpdateWizPaint(0);
  UpdateStatusBar(0);
}

void TGo4FitPanel::Wiz_ShowAllMod_toggled(bool zn)
{
  TGo4LockGuard Global;

  if (IsFillingWidget() || (fxSlots->FitOptions()==0)) return;
  fxSlots->FitOptions()->WizShowAllModels() = zn;
  UpdateWizModelsList(TRUE);
  UpdateWizPaint(2);
}


void TGo4FitPanel::Wiz_FitFuncCmb_activated( int typ)
{
  TGo4LockGuard Global;

  if (!IsFillingWidget() && fxSlots->GetFitter())
    fxSlots->GetFitter()->SetFitFunctionType(typ);
}


void TGo4FitPanel::Wiz_FitNameEdt_textChanged( const QString & name)
{
  TGo4LockGuard Global;

  TGo4Fitter* fitter = fxSlots->GetFitter();
  if(IsFillingWidget() || (fitter==0) || (name.length()==0) || (fxSlots->FitOptions()==0)) return;
  fitter->SetName(name);

  fxSlots->FitOptions()->WizPageIndex() = 0;
  UpdateWizStackWidget();
  UpdateWizPaint(0);

  UpdateStatusBar(0);
}


void TGo4FitPanel::Wiz_ParTable_valueChanged( int nrow, int ncol)
{
  TGo4LockGuard Global;

  ParsTableChanged(Wiz_ParTable, nrow, ncol, FALSE, fxWizPars, TRUE);
}


void TGo4FitPanel::Wiz_DataList_doubleClicked( QListBoxItem * )
{
  TGo4LockGuard Global;

  if (fxSlots->FitOptions()==0) return;
  TGo4Fitter* fitter = fxSlots->GetFitter();
  TGo4FitData* data = fxSlots->FitOptions()->GetWizData();
  if ((data==0) || (fitter==0)) return;
  bool ok;
  QString newname = QInputDialog::getText("Change data name", "Input new name", QLineEdit::Normal, data->GetName(), &ok, this);
  if (ok && (newname.length()>0) && (newname!=data->GetName())) {
     if (fitter->FindData(newname)) {
       QMessageBox::information(this, "Fit panel", "Unable to rename data.\n Name " +
                                newname + " already exists","return");
       return;
     }
     fitter->ChangeDataNameInAssignments(data->GetName(), newname);
     data->SetName(newname);
     fxSlots->FitOptions()->SetWizDataName(newname);
     UpdateWizDataList();
     UpdateWizPaint(1);
  }
}


void TGo4FitPanel::Wiz_ModelList_doubleClicked( QListBoxItem * )
{
  TGo4LockGuard Global;

  if (fxSlots->FitOptions()==0) return;
  TGo4Fitter* fitter = fxSlots->GetFitter();
  TGo4FitModel* model = fxSlots->FitOptions()->GetWizModel();
  if ((model==0) || (fitter==0)) return;
  bool ok;
  QString newname = QInputDialog::getText("Change model name", "Input new name", QLineEdit::Normal, model->GetName(), &ok, this);
  if (ok && (newname.length()>0) && (newname!=model->GetName())) {
     if (fitter->FindModel(newname)) {
       QMessageBox::information(this, "Fit panel", QString("Unable to rename model.\n Name ")+
                                newname + " already exists\n", "Return");
       return;
     }
     model->SetName(newname);
     fxSlots->FitOptions()->SetWizModelName(newname);
//     Wiz_ModelList->changeItem(newname, Wiz_ModelList->index(item));

     UpdateWizModelsList(TRUE);
     UpdateWizPaint(2);
   }
}

void TGo4FitPanel::Wiz_RebuildDataBtn_clicked()
{
  TGo4LockGuard Global;

  fxSlots->Wiz_RebuildDataList();
}

void TGo4FitPanel::Wiz_DataBufChk_toggled( bool zn)
{
  TGo4LockGuard Global;

  if (IsFillingWidget() || (fxSlots->FitOptions()==0)) return;
  TGo4FitData* data = fxSlots->FitOptions()->GetWizData();
  if (data) data->SetUseBuffers(zn);
}


void TGo4FitPanel::Wiz_UseAmplEstimChk_toggled( bool chk)
{
  TGo4LockGuard Global;

   if (IsFillingWidget() || (fxSlots->FitOptions()==0)) return;
   fxSlots->FitOptions()->UseAmplEstim() = chk;
}


void TGo4FitPanel::Wiz_MigradIterSpin_valueChanged( int num)
{
  TGo4LockGuard Global;

   if (IsFillingWidget() || (fxSlots->FitOptions()==0)) return;
   fxSlots->FitOptions()->NumMigradIter() = num;
}


void TGo4FitPanel::Wiz_DataSlotsTable_contextMenuRequested( int nrow, int ncol, const QPoint& pnt )
{
  TGo4LockGuard Global;

  if (IsFillingWidget() || (fxWizSlots==0)) return;

  if ((nrow<0) || (ncol<0) || (nrow>fxWizSlots->GetLast())) return;

  TGo4FitSlot* slot = dynamic_cast<TGo4FitSlot*> (fxWizSlots->At(nrow));
  if (slot==0) return;

  QPopupMenu menu(0,"SlotPopup");

  if (fxSlots->FillPopupForSlot(slot,&menu)) {
    int id =  menu.exec(pnt);
    fxSlots->ExecutePopupForSlot(0, slot, id /*, menu.text(id) */);
  }
}

void TGo4FitPanel::Wiz_DataUseRangeBtn_clicked()
{
  TGo4LockGuard Global;

  if (IsFillingWidget() || (fxSlots->FitOptions()==0)) return;

  fxSlots->Wiz_UseSelectedRange();
}


void TGo4FitPanel::Wiz_DataClearRangesBtn_clicked()
{
  TGo4LockGuard Global;

  if (IsFillingWidget() || (fxSlots->FitOptions()==0)) return;
  TGo4FitData* data = fxSlots->FitOptions()->GetWizData();
  if (data) {
     data->ClearRanges();
     fxSlots->UpdateActivePage();
  }
}


void TGo4FitPanel::Wiz_DrawDataBtn_clicked()
{
  TGo4LockGuard Global;

  if (IsFillingWidget() || (fxSlots->FitOptions()==0)) return;
  if (fxSlots->FitOptions()->GetWizData())
    fxSlots->Button_FitterDraw(fxSlots->FitOptions()->GetWizData());
}

void TGo4FitPanel::MainAttachBtn_clicked()
{
  TGo4LockGuard Global;

  UpdateStatusBar(0);

  fxSlots->Button_WorkWithPanel();
}

void TGo4FitPanel::MainFitBtn_clicked()
{
   TGo4LockGuard Global;

   QApplication::setOverrideCursor( Qt::WaitCursor );
   
   fxSlots->Button_PerformFit();
   
   QApplication::restoreOverrideCursor();
}

void TGo4FitPanel::MainDrawBtn_clicked()
{
  TGo4LockGuard Global;

  fxSlots->Button_FitterDraw();
}


void TGo4FitPanel::MainFindBtn_clicked()
{
  TGo4LockGuard Global;

   if (fxSlots->GetFitter()==0) return;
   fxSlots->Button_PeakFinder();
}


void TGo4FitPanel::Wiz_DataList_clicked( QListBoxItem * )
{
  TGo4LockGuard Global;

  Wiz_DataListSelect(Wiz_DataList->currentItem());
}


void TGo4FitPanel::Wiz_DataList_pressed( QListBoxItem * )
{
  TGo4LockGuard Global;

  Wiz_DataListSelect(Wiz_DataList->currentItem());
}


void TGo4FitPanel::Wiz_DataList_selected( int indx)
{
  TGo4LockGuard Global;

  Wiz_DataListSelect(indx);
}


void TGo4FitPanel::Wiz_ModelList_selected( int indx)
{
  TGo4LockGuard Global;

  Wiz_ModelListSelect(indx, TRUE);
}


void TGo4FitPanel::MainParsBtn_clicked()
{
  TGo4LockGuard Global;

  fxStatus->ParsWidgetShown() = !fxStatus->ParsWidgetShown();

  fxSlots->UpdateActivePage();
}

void TGo4FitPanel::FillParsWidget() {
  TGo4Fitter* fitter = fxSlots->GetFitter();
  if (fitter==0) return;
  SetFillingWidget(TRUE);

  Double_t FF = fitter->GetResultFF();
  Int_t NDF = fitter->GetResultNDF();
  if ((FF==0) && (NDF==0)) Par_FitterResLbl->hide();
  else {
    Par_FitterResLbl->setText("Result: Fit func = " + QString::number(FF) +
                                    "  NDF = " + QString::number(NDF));
    Par_FitterResLbl->show();
  }

  FillParsTable(ParsTable, fitter, 0, LineParsChk->isChecked(), fxParsTableList);
  SetFillingWidget(FALSE);
}

void TGo4FitPanel::LineParsChk_toggled(bool)
{
  TGo4LockGuard Global;

  if (IsFillingWidget()) return;

  TGo4Fitter* fitter = fxSlots->GetFitter();
  if (fitter==0) return;
  SetFillingWidget(TRUE);
  FillParsTable(ParsTable, fitter, 0, LineParsChk->isChecked(), fxParsTableList);
  WidgetStack->raiseWidget(PageParameters);
  SetFillingWidget(FALSE);
}


void TGo4FitPanel::ParsTable_valueChanged( int nrow, int ncol)
{
  TGo4LockGuard Global;

  if (IsFillingWidget()) return;

  ParsTableChanged(ParsTable, nrow, ncol, LineParsChk->isChecked(), fxParsTableList, FALSE);
}


void TGo4FitPanel::FillParsTable(QTable* table, TGo4Fitter* fitter, TGo4FitModel* model, bool LinesView, TObjArray* TableList) {
   if ((table==0) || (fitter==0) || (TableList==0)) return;

   if (model && LinesView) return;
   TableList->Clear();

   for (int n=0;n<table->numRows();n++) table->clearCell(n, 0);

   for (int nr=0;nr<table->numRows();nr++)
     for (int nc=0;nc<table->numCols();nc++)
       if (table->item(nr,nc))
          table->item(nr,nc)->setEnabled(TRUE);

   if (LinesView) {
     int MaxAxis = 0;
     for (Int_t n=0; n<fitter->GetNumModel();n++) {
        TGo4FitModel* m = fitter->GetModel(n);
        if (m==0) continue;
        Double_t zn;
        for (int naxis=0;naxis<10;naxis++)
          if (m->GetPosition(naxis,zn) || m->GetWidth(naxis,zn)) MaxAxis = naxis;
     }

     int nfcol = (fxStatus->IntegralMode()>0) ? 2 : 1;
     table->setNumCols(nfcol+(MaxAxis+1)*2);
     table->horizontalHeader()->setLabel(0,"Amplitude");
     if (fxStatus->IntegralMode()==1)
        table->horizontalHeader()->setLabel(1,"Counts");
     else if (fxStatus->IntegralMode()==2)   
        table->horizontalHeader()->setLabel(1,"Integral");
     else if (fxStatus->IntegralMode()==3)   
        table->horizontalHeader()->setLabel(1,"Gauss Int");

     for (int naxis=0;naxis<=MaxAxis;naxis++) {
        QString capt = QString("Position ") + QString::number(naxis);
        table->horizontalHeader()->setLabel(nfcol + naxis*2, capt);
        if (fxStatus->RecalculateGaussWidth())
          capt = QString("FWHM ");
        else
          capt = QString("Sigma ");
        capt += QString::number(naxis);
        table->horizontalHeader()->setLabel(nfcol+1 + naxis*2, capt);
     }

     table->setNumRows(fitter->GetNumModel());

     for (Int_t n=0; n<fitter->GetNumModel();n++) {
        TGo4FitModel* m = fitter->GetModel(n);
        TableList->Add(m);

        bool recalculatew = (m->InheritsFrom(TGo4FitModelGauss1::Class()) ||
                             m->InheritsFrom(TGo4FitModelGauss2::Class()) ||
                             m->InheritsFrom(TGo4FitModelGaussN::Class())) &&
                             fxStatus->RecalculateGaussWidth();
        double widthk = recalculatew ? 2.3548 : 1.0;

        table->verticalHeader()->setLabel(n, m->GetName());
        table->setText(n, 0, QString::number(m->GetAmplValue()));
        table->item(n,0)->setEnabled(m->GetAmplPar());

        if (fxStatus->IntegralMode()>0) {
           Double_t v = 0.;
           TGo4FitData* data = fxSlots->FitOptions() ? fxSlots->FitOptions()->GetWizData() : 0;
           switch (fxStatus->IntegralMode()) {
              case 1: 
                 if (data!=0)
                   v = fitter->CalculatesIntegral(data->GetName(), m->GetName(), kTRUE); 
                 else
                   v = fitter->CalculatesModelIntegral(m->GetName(), kTRUE); 
                 break;
              case 2: 
                 if (data!=0)
                   v = fitter->CalculatesIntegral(data->GetName(), m->GetName(), kFALSE); 
                 else
                   v = fitter->CalculatesModelIntegral(m->GetName(), kFALSE); 
                 break;
              case 3: v = m->Integral(); break;
              default: v = 0;
           } 
           if ((v<=0.) && (fxStatus->IntegralMode()==3)) 
             table->setText(n, 1, "---");
           else 
             table->setText(n, 1, QString::number(v));
           table->item(n,1)->setEnabled(FALSE);
        }

        for (int naxis=0;naxis<=MaxAxis;naxis++) {

            Double_t pos, width;

            if (m->GetPosition(naxis,pos)) {
              table->setText(n, nfcol+naxis*2, QString::number(pos));
              table->item(n, nfcol+naxis*2)->setEnabled(TRUE);
            } else {
              table->setText(n, nfcol+naxis*2, "---");
              table->item(n, nfcol+naxis*2)->setEnabled(FALSE);
            }

            if (m->GetWidth(naxis,width)) {
               table->setText(n, nfcol+1+naxis*2, QString::number(width*widthk));
               table->item(n, nfcol+1+naxis*2)->setEnabled(TRUE);
            } else {
              table->setText(n, nfcol+1+naxis*2, "---");
              table->item(n, nfcol+1+naxis*2)->setEnabled(FALSE);
            }
        }
     }

   } else {

     TGo4FitParsList* pars = (model==0) ? dynamic_cast<TGo4FitParsList*> (fitter) :
                                          dynamic_cast<TGo4FitParsList*> (model);
     if (pars==0) return;

     for(Int_t n=0; n<pars->NumPars();n++)
       TableList->Add(pars->GetPar(n));

     table->setNumCols(6);
     table->horizontalHeader()->setLabel(0,"Fixed");
     table->horizontalHeader()->setLabel(1,"Value");
     table->horizontalHeader()->setLabel(2,"Error");
     table->horizontalHeader()->setLabel(3,"Epsilon");
     table->horizontalHeader()->setLabel(4,"Min");
     table->horizontalHeader()->setLabel(5,"Max");

     table->setNumRows(TableList->GetLast()+1);

     for(Int_t n=0;n<=TableList->GetLast();n++) {
       TGo4FitParameter* par = dynamic_cast<TGo4FitParameter*> (TableList->At(n));
       if (par==0) continue;

       if (model) table->verticalHeader()->setLabel(n, par->GetName());
             else table->verticalHeader()->setLabel(n, par->GetFullName());

       QCheckTableItem* checkitem = new QCheckTableItem(table, "fix");
       checkitem->setChecked(par->GetFixed());
       table->setItem(n, 0, checkitem);

       table->setText(n, 1, QString::number(par->GetValue()));
       table->item(n,1)->setEnabled(!par->GetFixed());

       table->setText(n, 2, QString::number(par->GetError()));

       Double_t eps, min, max;
       if (par->GetEpsilon(eps)) table->setText(n, 3, QString::number(eps));
                            else table->setText(n, 3, "");


       if (par->GetRange(min,max)) {
         table->setText(n, 4, QString::number(min));
         table->setText(n, 5, QString::number(max));
       } else {
         table->setText(n, 4, "");
         table->setText(n, 5, "");
       }
     }
   }

   for(int n=0;n<table->numCols();n++)
     table->adjustColumn(n);

   table->verticalHeader()->adjustHeaderSize();
   table->horizontalHeader()->adjustHeaderSize();
}

void TGo4FitPanel::ParsTableChanged(QTable* table, int nrow, int ncol, bool LinesView, TObjArray* TableList, bool updatepaint) {
   if (IsFillingWidget() || (table==0) || (TableList==0)) return;

   if ((nrow<0) || (nrow>TableList->GetLast())) return;

   if (LinesView) {
      TGo4FitModel* model = dynamic_cast<TGo4FitModel*> (TableList->At(nrow));
      if (model==0) return;

      bool recalculatew = (model->InheritsFrom(TGo4FitModelGauss1::Class()) ||
                           model->InheritsFrom(TGo4FitModelGauss2::Class()) ||
                           model->InheritsFrom(TGo4FitModelGaussN::Class())) &&
                           fxStatus->RecalculateGaussWidth();
      double widthk = recalculatew ? 2.3548 : 1.0;

      bool ok = FALSE;
      double zn = table->text(nrow, ncol).toDouble(&ok);
      if (!ok) return;

      if (ncol==0) model->SetAmplValue(zn); else {
         int nfcol = (fxStatus->IntegralMode()>0) ? 2 : 1;
         int naxis = (ncol-nfcol) /2;
         if ((ncol-nfcol) % 2 == 0) model->SetPosition(naxis, zn);
                               else model->SetWidth(naxis, zn/widthk);
      }

   } else {

       TGo4FitParameter* par = dynamic_cast<TGo4FitParameter*> (TableList->At(nrow));
       if (par==0) return;

       switch (ncol) {
         case 0: {
           QCheckTableItem* checkitem = dynamic_cast<QCheckTableItem*> ( table->item(nrow,0));
           if (checkitem) par->SetFixed(checkitem->isChecked());
           table->item(nrow,1)->setEnabled(!par->GetFixed());
           break; }
         case 1: {
           if (par->GetFixed()) break;
           bool ok = FALSE;
           double zn = table->text(nrow,1).toDouble(&ok);
           if (ok) {
             par->SetValue(zn);
             if (updatepaint) UpdateWizPaint(2);
           }
           break; }
         case 2: {
           if (par->GetFixed()) break;
           bool ok = FALSE;
           double zn = table->text(nrow,2).toDouble(&ok);
           if (ok) par->SetError(zn);
           break; }
         case 3: {
           bool ok = FALSE;
           double zn = table->text(nrow,3).toDouble(&ok);
           if (ok) par->SetEpsilon(zn);
           break; }
         case 4:
         case 5: {
           bool ok = FALSE;
           double zn = table->text(nrow, ncol).toDouble(&ok);
           if(ok) {
             Double_t min, max;
             bool changemin = false;
             bool changemax = false;
             if (!par->GetRange(min,max)) {
                max = zn; changemin = (ncol!=4);
                min = zn; changemax = (ncol!=5);
             } else
             if (ncol==4) { 
               min = zn; 
               if (max<min) { max = min; changemax = true; }
             } else
             if (ncol==5) { 
               max = zn; 
               if (min>max) { min = max; changemin = true; }
             }
             cout << "Set range " << min << "  " << max << endl;
             par->SetRange(min,max);
             SetFillingWidget(TRUE);
             if (changemin)
               table->setText(nrow, 4, QString::number(min));
             if (changemax)
               table->setText(nrow, 5, QString::number(max));
             SetFillingWidget(FALSE);
           } else {
             if ((table->text(nrow, ncol).length()==0) && 
                 (table->text(nrow, 9-ncol).length()==0)) {
                    par->ClearRange();
                    cout << "Clear range for " << par->GetName() << endl; 
                 }
                 
           }
           break; }
       }
   }
}


void TGo4FitPanel::Wiz_ModelBufChk_toggled( bool zn)
{
  TGo4LockGuard Global;

  if (IsFillingWidget() || (fxSlots->FitOptions()==0)) return;
  TGo4FitModel* model = fxSlots->FitOptions()->GetWizModel();
  if (model) model->SetUseBuffers(zn);
}


void TGo4FitPanel::Wiz_PFSetupBtn_clicked()
{
  TGo4LockGuard Global;

  if (IsFillingWidget() || (fxSlots->FitOptions()==0)) return;

  if (fxSlots->FitOptions()->GetWizData()==0) return;
  fxSlots->FitOptions()->WizPageIndex() = 3;
  UpdateWizStackWidget();
  UpdateWizPaint(1);
}


void TGo4FitPanel::Wiz_PFUsePolynChk_toggled( bool zn )
{
  TGo4LockGuard Global;

  if (IsFillingWidget() || (fxSlots->FitOptions()==0)) return;

  TGo4FitPeakFinder* finder = fxSlots->FitOptions()->GetPeakFinder();
  if (finder) finder->SetUsePolynom(zn);

  Wiz_PFPolynSpin->setEnabled(zn);
}


void TGo4FitPanel::Wiz_PFPolynSpin_valueChanged( int zn )
{
  TGo4LockGuard Global;

  if (IsFillingWidget() || (fxSlots->FitOptions()==0)) return;

  TGo4FitPeakFinder* finder = fxSlots->FitOptions()->GetPeakFinder();
  if (finder) finder->SetPolynomOrder(zn);
}



void TGo4FitPanel::Smp_PolynomBtn_clicked()
{
  TGo4LockGuard Global;

  fxSlots->Button_SimpleFit(0);
}


void TGo4FitPanel::Smp_GaussianBtn_clicked()
{
  TGo4LockGuard Global;

  fxSlots->Button_SimpleFit(1);
}


void TGo4FitPanel::Smp_LorenzBtn_clicked()
{
  TGo4LockGuard Global;

  fxSlots->Button_SimpleFit(2);
}


void TGo4FitPanel::Smp_ExponentBtn_clicked()
{
  TGo4LockGuard Global;

  fxSlots->Button_SimpleFit(3);
}


void TGo4FitPanel::Smp_ClearBtn_clicked()
{
  TGo4LockGuard Global;

  fxSlots->Button_SimpleClear();
}


void TGo4FitPanel::Wiz_MinSetupBtn_clicked()
{
  TGo4LockGuard Global;

  if (IsFillingWidget() || (fxSlots->FitOptions()==0)) return;

  fxSlots->FitOptions()->WizPageIndex() = 0;
  UpdateWizStackWidget();
  UpdateWizPaint(0);
}


void TGo4FitPanel::FindersTab_currentChanged( QWidget * )
{
  TGo4LockGuard Global;

  if (IsFillingWidget() || (fxSlots->FitOptions()==0)) return;

  TGo4FitPeakFinder* finder = fxSlots->FitOptions()->GetPeakFinder();
  if (finder)
    finder->SetPeakFinderType(FindersTab->currentPageIndex());

}


void TGo4FitPanel::Wiz_ModelList_clicked( QListBoxItem * item, const QPoint & pnt)
{
  TGo4LockGuard Global;

  if (item==0) return;

  QRect rect = Wiz_ModelList->itemRect(item);
  QPoint pnt2 = Wiz_ModelList->viewport()->mapFromGlobal(pnt);

  Wiz_ModelListSelect(Wiz_ModelList->currentItem(), (pnt2.x() - rect.left()) >=15 );
}


void TGo4FitPanel::Wiz_BackgroundChk_toggled( bool chk)
{
  TGo4LockGuard Global;

  if (IsFillingWidget() || (fxSlots->FitOptions()==0)) return;

  TGo4FitModel* model = fxSlots->FitOptions()->GetWizModel();
  if (model)
    if (chk) model->SetBackgroundGroupIndex();
        else model->SetGroupIndex(-1);
}


void TGo4FitPanel::PF_MinWidthEdt_returnPressed()
{
  TGo4LockGuard Global;

  if (!IsFillingWidget() && fxSlots)
    fxSlots->Button_PeakFinder();
}


void TGo4FitPanel::PF_MaxWidthEdt_returnPressed()
{
  TGo4LockGuard Global;

  if (!IsFillingWidget() && fxSlots)
    fxSlots->Button_PeakFinder();
}


void TGo4FitPanel::PF_WidthEdit_returnPressed()
{
  TGo4LockGuard Global;

  if (!IsFillingWidget() && fxSlots)
    fxSlots->Button_PeakFinder();
}


void TGo4FitPanel::PF_MinNoiseEdit_returnPressed()
{
  TGo4LockGuard Global;

  if (!IsFillingWidget() && fxSlots)
    fxSlots->Button_PeakFinder();
}

void TGo4FitPanel::ParsTable_contextMenuRequested(int nrow, int ncol, const QPoint &)
{
}

//----------------------------END OF GO4 SOURCE FILE ---------------------

---