~ajf/root/TStyleManager_8cxx_source.html

 // @(#)root/ged:$Id$

 // Author: Denis Favre-Miville   08/09/05


 /*************************************************************************

  * Copyright (C) 1995-2004, Rene Brun and Fons Rademakers.               *

  * All rights reserved.                                                  *

  *                                                                       *

  * For the licensing terms see $ROOTSYS/LICENSE.                         *

  * For the list of contributors see $ROOTSYS/README/CREDITS.             *

  *************************************************************************/


 //////////////////////////////////////////////////////////////////////////

 //                                                                      //

 //  TStyleManager                                                       //

 //                                                                      //

 //  This class provides a Graphical User Interface to manage styles     //

 //       in ROOT. It allows the user to edit styles, import / export    //

 //       them to macros, apply a style on the selected object or on     //

 //       all canvases, change gStyle.                                   //

 //                                                                      //

 //  Activate the style manager by selecting Edit menu / Style...        //

 //      in the canvas window.                                           //

 //                                                                      //

 //  The Style Manager interface is composed of two parts:               //

 //  - the top level interface that manages a list of styles;            //

 //  - the style editor, which deals with the current style settings.    //

 //                                                                      //

 //Begin_Html

 /*

 <img src="gif/StyleManager.gif">

 */

 //End_Html

 //                                                                      //

 // The combo box 'Available Styles' contains the list of available      //

 // styles for the current ROOT session and shows the currently          //

 // selected one. The field on the right shows the setting of the gStyle.//

 // You can set the global variable gStyle to the selected style by      //

 // clicking on the button in the middle.                                //

 // The group frame 'Apply on' displays information for the currently    //

 // selected canvas and object in the ROOT session. This selection might //

 // be changed by clicking on another object with the middle mouse       //

 // button. You have a choice to apply a style on the selected object or //

 // on all available canvases.                                           //

 // WARNING: You cannot undo the changes after applying the style! If    //

 // you are not sure of that action, it may be better to see a preview   //

 // of what you are going to apply.                                      //

 // If the check button 'Preview' is selected, a preview of the selected //

 // canvas according to the selected style will be shown. The selection  //

 // of the next check button 'Run Time Preview' will apply updates of    //

 // the preview any time a value of the selected style is changed. For   //

 // drawings that take a time it is better to disable this option.       //

 //                                                                      //

 // Create a new style:                                                  //

 // A new style can be created via the Style menu/New... or the toolbar. //

 // A clone of the selected style will be used as a base of the new      //

 // style. All its values can be modified via the style editor later.    //

 // The dialog that appears will ask for the name and description of the //

 // new style.                                                           //

 //                                                                      //

 // Import a style (from a macro):                                       //

 // A style macro can be imported at any time. The new imported style in //

 // the ROOT session will become the selected one.                       //

 //                                                                      //

 // Import a style (from a canvas):                                      //

 // You can do that selecting the Style menu/Import from.../Canvas or    //

 // the corresponding Tool bar button. A new style will be created in the//

 // ROOT session and will become the selected one. This style is a clone //

 // of the gStyle with modified values as they are set in the currently  //

 // selected canvas. You can import a style from any canvas and apply it //

 // later on some objects.                                               //

 //                                                                      //

 // Export a style (in a C++ macro file):                                //

 // To store a style longer than for the current ROOT session you can    //

 // save it in a C++ macro file. This can be done via the menu or the    //

 // tool bar button. There is a naming convention for the style macros:  //

 // the name must be 'Style_*.C', where * can be replaced by anything    //

 // you want.                                                            //

 //                                                                      //

 // Delete a style:                                                      //

 // The selected style can be deleted from the list when you use the     //

 // Style menu/Delete or the corresponding tool bar button. The selected //

 // style is removed from the list of all available styles for the       //

 // current ROOT session. WARRNING: it will be lost if you didn't saved  //

 // it in a C++ macro file before its deletion. Also, you cannot delete  //

 // the selected style if it is set to gStyle. A message 'Can not delete //

 // gStyle' will be displayed on the CINT prompt.                        //

 //                                                                      //

 //Begin_Html

 /*

 <img src="gif/StyleEditor.gif">

 */

 //End_Html

 //                                                                      //

 // Editor's buttons:                                                    //

 // Open / close the style editor:                                       //

 // The button 'Edit >>' opens the style editor and its label changes to //

 // 'Close <<'. For all details of what can be changed and how please see//

 // the provided Help.                                                   //

 //                                                                      //

 // Reset a style (to a previously saved state):                         //

 // When the editor is opened, the 'Reset' button allows you to reset    //

 // the values of the selected style for editing. Doing that you cancel  //

 // all changes made since the last time you saved that style in a macro.//

 // If the selected style is one of the five ROOT styles (Plain, Bold,   //

 // Video, Pub or  Default), it will be recreated.                       //

 //                                                                      //

 // Update the preview:                                                  //

 // The button 'Update Preview' is available when a preview is shown and //

 // the run time option is not selected. This button allows you to       //

 // refresh the preview any time you want to see how the style you edit  //

 // looks like.                                                          //

 //                                                                      //

 // Help button:                                                         //

 // Provides a help of the currently selected tab.                       //

 //                                                                      //

 //////////////////////////////////////////////////////////////////////////


 #include "TStyleManager.h"

 #include "TStyleDialog.h"

 #include "TStylePreview.h"

 #include "HelpSMText.h"


 #include <TCanvas.h>

 #include <TColor.h>

 #include <TG3DLine.h>

 #include <TGButton.h>

 #include <TGButtonGroup.h>

 #include <TGColorSelect.h>

 #include <TGComboBox.h>

 #include <TGedMarkerSelect.h>

 #include <TGedPatternSelect.h>

 #include <TGFileDialog.h>

 #include <TGFrame.h>

 #include <TGLabel.h>

 #include <TGLayout.h>

 #include <TGMenu.h>

 #include <TGMsgBox.h>

 #include <TGNumberEntry.h>

 #include <TGResourcePool.h>

 #include <TGStatusBar.h>

 #include <TGTab.h>

 #include <TGToolBar.h>

 #include <TROOT.h>

 #include <TRootHelpDialog.h>

 #include <TStyle.h>

 #include <TSystem.h>

 #include <TVirtualPad.h>


 TStyleManager *TStyleManager::fgStyleManager = 0;


 ClassImp(TStyleManager);


 enum EStyleManagerWid {

    kMenuNew,

    kMenuDelete,

    kMenuRename,

    kMenuImportCanvas,

    kMenuImportMacro,

    kMenuExport,

    kMenuExit,

    kMenuHelp,

    kMenuHelpEditor,

    kMenuHelpGeneral,

    kMenuHelpCanvas,

    kMenuHelpPad,

    kMenuHelpHistos,

    kMenuHelpAxis,

    kMenuHelpTitle,

    kMenuHelpStats,

    kMenuHelpPSPDF,


    kToolbarNew,

    kToolbarDelete,

    kToolbarImportCanvas,

    kToolbarImportMacro,

    kToolbarExport,

    kToolbarHelp,


    kTopStylesList,

    kTopPreview,

    kTopPreviewRealTime,

    kTopMakeDefault,

    kTopCurStyle,

    kTopCurPad,

    kTopCurObj,

    kTopApplyOnAll,

    kTopApplyOnSel,

    kTopApplyOnBut,

    kTopMoreLess,


    kEditButHelp,

    kEditButUpPrev,

    kEditButReset,


    kGeneralFillColor,

    kGeneralFillStyle,

    kGeneralHatchesLineWidth,

    kGeneralHatchesSpacing,

    kGeneralTextColor,

    kGeneralTextSize,

    kGeneralTextSizeInPixels,

    kGeneralTextFont,

    kGeneralTextAlign,

    kGeneralTextAngle,

    kGeneralLineColor,

    kGeneralLineWidth,

    kGeneralLineStyle,

    kGeneralLineStyleEdit,

    kGeneralMarkerColor,

    kGeneralMarkerStyle,

    kGeneralMarkerSize,

    kGeneralScreenFactor,


    kCanvasColor,

    kCanvasDefX,

    kCanvasDefY,

    kCanvasDefW,

    kCanvasDefH,

    kCanvasBorderModeSunken,

    kCanvasBorderModeNone,

    kCanvasBorderModeRaised,

    kCanvasBorderSize,

    kCanvasOptDateBool,

    kCanvasAttDateTextColor,

    kCanvasAttDateTextSize,

    kCanvasAttDateTextSizeInPixels,

    kCanvasOptDateFormat,

    kCanvasAttDateTextFont,

    kCanvasAttDateTextAngle,

    kCanvasAttDateTextAlign,

    kCanvasDateX,

    kCanvasDateY,


    kPadLeftMargin,

    kPadRightMargin,

    kPadTopMargin,

    kPadBottomMargin,

    kPadBorderModeSunken,

    kPadBorderModeNone,

    kPadBorderModeRaised,

    kPadBorderSize,

    kPadColor,

    kPadTickX,

    kPadTickY,

    kPadGridX,

    kPadGridY,

    kPadGridColor,

    kPadGridWidth,

    kPadGridStyle,


    kHistFillColor,

    kHistFillStyle,

    kHistLineColor,

    kHistLineWidth,

    kHistLineStyle,

    kHistBarWidth,

    kHistBarOffset,

    kHistMinimumZero,

    kHistPaintTextFormat,

    kHistNumberContours,

    kHistLegoInnerR,


    kFrameFillColor,

    kFrameFillStyle,

    kFrameLineColor,

    kFrameLineWidth,

    kFrameLineStyle,

    kFramePaletteEdit,

    kFrameBorderModeSunken,

    kFrameBorderModeNone,

    kFrameBorderModeRaised,

    kFrameBorderSize,


    kGraphsFuncColor,

    kGraphsFuncWidth,

    kGraphsFuncStyle,

    kGraphsDrawBorder,

    kGraphsEndErrorSize,

    kGraphsErrorX,


    kAxisTimeOffsetDate,

    kAxisTimeOffsetTime,

    kAxisStripDecimals,

    kAxisApplyOnXYZ,


    kAxisXTitleSize,

    kAxisXTitleSizeInPixels,

    kAxisXTitleColor,

    kAxisXTitleOffset,

    kAxisXTitleFont,

    kAxisXLabelSize,

    kAxisXLabelSizeInPixels,

    kAxisXLabelColor,

    kAxisXLabelOffset,

    kAxisXLabelFont,

    kAxisXAxisColor,

    kAxisXTickLength,

    kAxisOptLogx,

    kAxisXNdivMain,

    kAxisXNdivSub,

    kAxisXNdivSubSub,

    kAxisXNdivisionsOptimize,


    kAxisYTitleSize,

    kAxisYTitleSizeInPixels,

    kAxisYTitleColor,

    kAxisYTitleOffset,

    kAxisYTitleFont,

    kAxisYLabelSize,

    kAxisYLabelSizeInPixels,

    kAxisYLabelColor,

    kAxisYLabelOffset,

    kAxisYLabelFont,

    kAxisYAxisColor,

    kAxisYTickLength,

    kAxisOptLogy,

    kAxisYNdivMain,

    kAxisYNdivSub,

    kAxisYNdivSubSub,

    kAxisYNdivisionsOptimize,


    kAxisZTitleSize,

    kAxisZTitleSizeInPixels,

    kAxisZTitleColor,

    kAxisZTitleOffset,

    kAxisZTitleFont,

    kAxisZLabelSize,

    kAxisZLabelSizeInPixels,

    kAxisZLabelColor,

    kAxisZLabelOffset,

    kAxisZLabelFont,

    kAxisZAxisColor,

    kAxisZTickLength,

    kAxisOptLogz,

    kAxisZNdivMain,

    kAxisZNdivSub,

    kAxisZNdivSubSub,

    kAxisZNdivisionsOptimize,


    kTitleOptTitle,

    kTitleFillColor,

    kTitleStyle,

    kTitleTextColor,

    kTitleFontSize,

    kTitleFontSizeInPixels,

    kTitleFont,

    kTitleAlign,

    kTitleBorderSize,

    kTitleX,

    kTitleY,

    kTitleW,

    kTitleH,

    kTitleLegendBorderSize,


    kStatColor,

    kStatStyle,

    kStatTextColor,

    kStatFontSize,

    kStatFontSizeInPixels,

    kStatFont,

    kStatX,

    kStatY,

    kStatW,

    kStatH,

    kStatBorderSize,

    kStatOptStatName,

    kStatOptStatEntries,

    kStatOptStatOverflow,

    kStatOptStatMean,

    kStatOptStatUnderflow,

    kStatOptStatRMS,

    kStatOptStatSkewness,

    kStatOptStatIntegral,

    kStatOptStatKurtosis,

    kStatOptStatErrors,

    kStatFormat,

    kStatOptFitValues,

    kStatOptFitErrors,

    kStatOptFitProbability,

    kStatOptFitChi,

    kStatFitFormat,


    kPSPDFHeaderPS,

    kPSPDFTitlePS,

    kPSPDFColorModelPS,

    kPSPDFColorModelPSRGB,

    kPSPDFColorModelPSCMYK,

    kPSPDFLineScalePS,

    kPSPDFPaperSizePredef,

    kPSPDFPaperSizeX,

    kPSPDFPaperSizeY

 };


 const char *kFiletypes[] = { "ROOT macros", "Style_*.C",

                                0,             0 };


 ////////////////////////////////////////////////////////////////////////////////

 /// Constructor. Create the main window of the style manager.


 TStyleManager::TStyleManager(const TGWindow *p) : TGMainFrame(p)

 {

    SetWindowName("Style Manager");

    SetCleanup(kNoCleanup);


    // Initialization: no selected style, no preview, no signal/slots,

    //                 no selected object, no current macro file.

    fCurSelStyle = 0;

    fCurMacro = 0;

    fCurPad = 0;

    fCurObj = 0;

    fPreviewWindow = 0;

    fRealTimePreview = kFALSE;

    fCurTabNum = 0;

    fCurTabAxisNum = 0;

    fMoreAndNotLess = kTRUE;

    fSigSlotConnected = kFALSE;

    fStyleChanged = kFALSE;


    // Create the trash lists to have an effective deletion of every object.

    fTrashListLayout = new TList();

    fTrashListFrame = new TList();


    // To avoid to create a lot a copies of the often used layouts.

    fLayoutExpandX = new TGLayoutHints(kLHintsExpandX);

    fTrashListLayout->Add(fLayoutExpandX);

    fLayoutExpandXMargin = new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5);

    fTrashListLayout->Add(fLayoutExpandXMargin);

    fLayoutExpandXY = new TGLayoutHints(kLHintsExpandX | kLHintsExpandY);

    fTrashListLayout->Add(fLayoutExpandXY);

    fLayoutExpandXYMargin = new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 5, 5, 5, 5);

    fTrashListLayout->Add(fLayoutExpandXYMargin);

    fLayoutExpandXCenterYMargin = new TGLayoutHints(kLHintsExpandX | kLHintsCenterY, 0, 0, 3, 3);

    fTrashListLayout->Add(fLayoutExpandXCenterYMargin);


    // Build the graphical interface.

    AddMenus(this);

    AddToolbar(this);

    AddTopLevelInterface(this);

    AddEdition(this);


    // Add status bar.

    fStatusBar = new TGStatusBar(this, 50, 10, kVerticalFrame);

    Int_t parts[] = { 20, 30, 50 };

    fStatusBar->SetParts(parts, 3);

    fStatusBar->Draw3DCorner(kFALSE);

    AddFrame(fStatusBar, fLayoutExpandX);


    // Initialize the layout algorithm and map the main frame.

    MapSubwindows();

    Resize(GetDefaultSize());

    MapWindow();


    //  Ensure the editor will be visible (not out of the screen's range) when

    // the user will press the 'More' button, if they didn't move the window.

    Int_t x, y;

    UInt_t w, h;

    gVirtualX->GetWindowSize(GetId(), x, y, w, h);

    fSMWidth = w;

    fSMHeight = h;

    if (fSMWidth < 467) fSMWidth = 467;

    if (fSMHeight < 708) fSMHeight = 708;

    Window_t win;

    gVirtualX->TranslateCoordinates(GetId(), GetParent()->GetId(), 0, 0, x, y, win);

    x -= 6;

    y -= 21;

    MoveResize(x, TMath::Max(TMath::Min(y, (Int_t) (gClient->GetDisplayHeight() - h)), 0), w, h);


    // Only the top level interface is shown, at the begining.

    DoMoreLess();


    // Connect all widgets (excluding editor).

    ConnectAll();


    Init();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Destructor.


 TStyleManager::~TStyleManager()

 {

    // Disconnect all widgets

    DisconnectAll();

    DisconnectEditor(fCurTabNum);


    if (fPreviewWindow) {

       DoPreviewClosed();

       delete fPreviewWindow;

    }


    //  Delete every graphical data member,

    // excluding fPreviewWindow and fLayout[..].

    gClient->FreePicture(fToolBarNewPic);

    gClient->FreePicture(fToolBarDeletePic);

    gClient->FreePicture(fToolBarImportCanvasPic);

    gClient->FreePicture(fToolBarImportMacroPic);

    gClient->FreePicture(fToolBarExportPic);

    gClient->FreePicture(fToolBarHelpPic);

    gClient->FreePicture(fMakeDefaultPic);


    delete fImportCascade;

    delete fMenuStyle;

    delete fMenuHelp;

    delete fMenuBar;


    delete fToolBar;

    delete fToolBarNew;

    delete fToolBarDelete;

    delete fToolBarImportCanvas;

    delete fToolBarImportMacro;

    delete fToolBarExport;

    delete fToolBarHelp;

    delete fHorizontal3DLine;


    delete fListLabel;

    delete fListComboBox;

    delete fCurMacro;

    delete fCurStylabel;

    delete fCurStyle;

    delete fCurPadLabel;

    delete fCurPadTextEntry;

    delete fCurObjLabel;

    delete fCurObjTextEntry;

    delete fPreviewButton;

    delete fPreviewRealTime;

    delete fMakeDefault;


    delete fApplyOnGroup;

    delete fApplyOnAll;

    delete fApplyOnSel;

    delete fApplyOnButton;

    delete fMoreLess;


    delete fFillColor;

    delete fFillStyle;

    delete fHatchesLineWidth;

    delete fHatchesSpacing;

    delete fTextColor;

    delete fTextSize;

    delete fTextSizeInPixels;

    delete fTextFont;

    delete fTextAlign;

    delete fTextAngle;

    delete fLineColor;

    delete fLineWidth;

    delete fLineStyle;

    delete fLineStyleEdit;

    delete fMarkerColor;

    delete fMarkerStyle;

    delete fMarkerSize;

    delete fScreenFactor;

    delete fCanvasColor;

    delete fCanvasDefX;

    delete fCanvasDefY;

    delete fCanvasDefW;

    delete fCanvasDefH;

    delete fCanvasBorderMode;

    delete fCanvasBorderSize;

    delete fOptDateBool;

    delete fAttDateTextColor;

    delete fAttDateTextSize;

    delete fAttDateTextSizeInPixels;

    delete fOptDateFormat;

    delete fAttDateTextFont;

    delete fAttDateTextAngle;

    delete fAttDateTextAlign;

    delete fDateX;

    delete fDateY;

    delete fPadLeftMargin;

    delete fPadRightMargin;

    delete fPadTopMargin;

    delete fPadBottomMargin;

    delete fPadBorderMode;

    delete fPadBorderSize;

    delete fPadColor;

    delete fPadTickX;

    delete fPadTickY;

    delete fPadGridX;

    delete fPadGridY;

    delete fGridColor;

    delete fGridWidth;

    delete fGridStyle;

    delete fHistFillColor;

    delete fHistFillStyle;

    delete fHistLineColor;

    delete fHistLineWidth;

    delete fHistLineStyle;

    delete fBarWidth;

    delete fBarOffset;

    delete fHistMinimumZero;

    delete fPaintTextFormat;

    delete fNumberContours;

    delete fLegoInnerR;

    delete fFrameFillColor;

    delete fFrameFillStyle;

    delete fFrameLineColor;

    delete fFrameLineWidth;

    delete fFrameLineStyle;

    delete fPaletteEdit;

    delete fFrameBorderMode;

    delete fFrameBorderSize;

    delete fFuncColor;

    delete fFuncWidth;

    delete fFuncStyle;

    delete fDrawBorder;

    delete fEndErrorSize;

    delete fErrorX;

    delete fTimeOffsetDate;

    delete fTimeOffsetTime;

    delete fStripDecimals;

    delete fApplyOnXYZ;

    delete fXTitleSize;

    delete fXTitleSizeInPixels;

    delete fXTitleColor;

    delete fXTitleOffset;

    delete fXTitleFont;

    delete fXLabelSize;

    delete fXLabelSizeInPixels;

    delete fXLabelColor;

    delete fXLabelOffset;

    delete fXLabelFont;

    delete fXAxisColor;

    delete fXTickLength;

    delete fOptLogx;

    delete fXNdivMain;

    delete fXNdivSub;

    delete fXNdivSubSub;

    delete fXNdivisionsOptimize;

    delete fYTitleSize;

    delete fYTitleSizeInPixels;

    delete fYTitleColor;

    delete fYTitleOffset;

    delete fYTitleFont;

    delete fYLabelSize;

    delete fYLabelSizeInPixels;

    delete fYLabelColor;

    delete fYLabelOffset;

    delete fYLabelFont;

    delete fYAxisColor;

    delete fYTickLength;

    delete fOptLogy;

    delete fYNdivMain;

    delete fYNdivSub;

    delete fYNdivSubSub;

    delete fYNdivisionsOptimize;

    delete fZTitleSize;

    delete fZTitleSizeInPixels;

    delete fZTitleColor;

    delete fZTitleOffset;

    delete fZTitleFont;

    delete fZLabelSize;

    delete fZLabelSizeInPixels;

    delete fZLabelColor;

    delete fZLabelOffset;

    delete fZLabelFont;

    delete fZAxisColor;

    delete fZTickLength;

    delete fOptLogz;

    delete fZNdivMain;

    delete fZNdivSub;

    delete fZNdivSubSub;

    delete fZNdivisionsOptimize;

    delete fOptTitle;

    delete fTitleColor;

    delete fTitleStyle;

    delete fTitleTextColor;

    delete fTitleFontSize;

    delete fTitleFontSizeInPixels;

    delete fTitleFont;

    delete fTitleAlign;

    delete fTitleBorderSizeLabel;

    delete fTitleBorderSize;

    delete fTitleX;

    delete fTitleY;

    delete fTitleW;

    delete fTitleH;

    delete fLegendBorderSizeLabel;

    delete fLegendBorderSize;

    delete fStatColor;

    delete fStatStyle;

    delete fStatTextColor;

    delete fStatFontSize;

    delete fStatFontSizeInPixels;

    delete fStatFont;

    delete fStatX;

    delete fStatY;

    delete fStatW;

    delete fStatH;

    delete fStatBorderSizeLabel;

    delete fStatBorderSize;

    delete fOptStatName;

    delete fOptStatEntries;

    delete fOptStatOverflow;

    delete fOptStatMean;

    delete fOptStatUnderflow;

    delete fOptStatRMS;

    delete fOptStatSkewness;

    delete fOptStatIntegral;

    delete fOptStatKurtosis;

    delete fOptStatErrors;

    delete fStatFormatLabel;

    delete fStatFormat;

    delete fOptFitValues;

    delete fOptFitErrors;

    delete fOptFitProbability;

    delete fOptFitChi;

    delete fFitFormatLabel;

    delete fFitFormat;

    delete fHeaderPS;

    delete fTitlePS;

    delete fColorModelPS;

    delete fColorModelPSRGB;

    delete fColorModelPSCMYK;

    delete fLineScalePS;

    delete fPaperSizePredef;

    delete fPaperSizeX;

    delete fPaperSizeY;

    delete fEditionHelp;

    delete fEditionUpdatePreview;

    delete fEditionReset;

    delete fEditionButtonFrame;

    delete fHistosTab;

    delete fAxisTab;

    delete fEditionTab;

    delete fEditionFrame;


    delete fStatusBar;


    // Delete the temporary frames and layout.

    TObject *obj1;

    TObject *obj2;


    obj1 = fTrashListFrame->First();

    while (obj1) {

       obj2 = fTrashListFrame->After(obj1);

       fTrashListFrame->Remove(obj1);

       delete obj1;

       obj1 = obj2;

    }

    delete fTrashListFrame;


    obj1 = fTrashListLayout->First();

    while (obj1) {

       obj2 = fTrashListLayout->After(obj1);

       fTrashListLayout->Remove(obj1);

       delete obj1;

       obj1 = obj2;

    }

    delete fTrashListLayout;


    fgStyleManager = 0;

 }


 ////////////////////////////////////////////////////////////////////////////////

 ///static: return style manager


 TStyleManager *&TStyleManager::GetSM()

 {

    return fgStyleManager;

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Set up the interface. Called by the ctor or by the 'Show' method.


 void TStyleManager::Init()

 {

    // Build the list of available styles and select gStyle.

    BuildList(gStyle);


    // Show the current object.

    if ((gROOT->GetSelectedPad()) && (gROOT->GetSelectedPad()->GetCanvas())) {

       DoSelectCanvas(gROOT->GetSelectedPad()->GetCanvas(),

                      gROOT->GetSelectedPad()->GetCanvas(), kButton2Down);

    } else {

       DoSelectNoCanvas();

    }

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Called to hide the style manager.


 void TStyleManager::Hide()

 {

    if (fgStyleManager) {

       fgStyleManager->UnmapWindow();

    }

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Called to show the style manager. Static method.


 void TStyleManager::Show()

 {

    if (fgStyleManager) {

       fgStyleManager->Init();

       if (!fgStyleManager->IsMapped()) {

          fgStyleManager->MapWindow();

       }

    } else {

       TStyleManager::GetSM() = new TStyleManager(gClient->GetRoot());

    }

 }


 ////////////////////////////////////////////////////////////////////////////////

 ///  Called to delete the style manager. Called when the ROOT session is

 /// closed via a canvas' menu.


 void TStyleManager::Terminate()

 {

    delete fgStyleManager;

    fgStyleManager = 0;

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the menu bar to the frame 'p'.


 void TStyleManager::AddMenus(TGCompositeFrame *p)

 {

    fMenuBar = new TGMenuBar(p);


    fMenuStyle = new TGPopupMenu(gClient->GetRoot());

    fMenuStyle->Associate(this);

    fMenuStyle->AddEntry("&New...", kMenuNew);

    fMenuStyle->AddEntry("&Delete", kMenuDelete);

    fMenuStyle->AddSeparator();

    fMenuStyle->AddEntry("&Rename...", kMenuRename);

    fMenuStyle->AddSeparator();

    fImportCascade = new TGPopupMenu(gClient->GetRoot());

    fImportCascade->Associate(this);

    fImportCascade->AddEntry("&Macro...", kMenuImportMacro);

    fImportCascade->AddEntry("&Canvas...", kMenuImportCanvas);

    fMenuStyle->AddPopup("&Import From...", fImportCascade);


    fMenuStyle->AddEntry("&Export...", kMenuExport);

    fMenuStyle->AddSeparator();

    fMenuStyle->AddEntry("&Close", kMenuExit);

    TGLayoutHints *layout1 = new TGLayoutHints(kLHintsNormal);

    fTrashListLayout->Add(layout1);

    fMenuBar->AddPopup("&Style", fMenuStyle, layout1);


    fMenuHelp = new TGPopupMenu(gClient->GetRoot());

    fMenuHelp->Associate(this);

    fMenuHelp->AddEntry("Top &level", kMenuHelp);

    fMenuHelp->AddSeparator();

    fMenuHelp->AddEntry("&General", kMenuHelpGeneral);

    fMenuHelp->AddEntry("&Canvas", kMenuHelpCanvas);

    fMenuHelp->AddEntry("Pa&d", kMenuHelpPad);

    fMenuHelp->AddEntry("&Histograms", kMenuHelpHistos);

    fMenuHelp->AddEntry("&Axis", kMenuHelpAxis);

    fMenuHelp->AddEntry("&Title", kMenuHelpTitle);

    fMenuHelp->AddEntry("&Stats", kMenuHelpStats);

    fMenuHelp->AddEntry("&PS / PDF", kMenuHelpPSPDF);

    TGLayoutHints *layout2 = new TGLayoutHints(kLHintsRight);

    fTrashListLayout->Add(layout2);

    fMenuBar->AddPopup("&Help", fMenuHelp, layout2);


    p->AddFrame(fMenuBar, fLayoutExpandX);

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Create a new style. Called via the menu bar or the tool bar.


 void TStyleManager::DoNew()

 {

    // Open a message box to allow the user to create a new style.

    new TStyleDialog(this, fCurSelStyle, 1, 0);


    // Create the list of available styles, and select:

    //    - the new style, if it has been created (Ok).

    //    - the previous selected style, if no style has been created (Cancel).

    if (fLastChoice) BuildList();

                else BuildList(fCurSelStyle);

 }


 ////////////////////////////////////////////////////////////////////////////////

 ///  Delete the current selected style from the ROOT session.

 /// Called via the menu or the tool bar.


 void TStyleManager::DoDelete()

 {

    // Protection: the user is NOT allowed to delete gStyle.

    // As a consequence, there is always at least one style in the ROOT session.

    if (fCurSelStyle == gStyle) {

       printf("Can not delete gStyle.\n");

       return;

    }


    delete fCurSelStyle;

    fCurSelStyle = 0;


    BuildList(gStyle);

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Rename the current selected style. Called via the menu bar.


 void TStyleManager::DoRename()

 {

    new TStyleDialog(this, fCurSelStyle, 2, 0);


    // Create the list of styles and select the previous selected style.

    BuildList(fCurSelStyle);

 }


 ////////////////////////////////////////////////////////////////////////////////

 ///  Save the current selected style in a C++ macro file. Called via the menu

 /// or the tool bar.


 void TStyleManager::DoExport()

 {

    // Create an associated macro and propose a pertinent name to the user.

    CreateMacro();

    TString newName;

    newName.Form("Style_%s.C", fCurSelStyle->GetName());


    //  Protection: The user isn't allowed to export a style if the output

    // file name isn't based on the "Style_*.C" mask, without spaces.

    char* tmpFileName;

    const char* tmpBaseName;

    do {

       fCurMacro->fFilename = StrDup(newName.Data());


       // Open a dialog to ask the user to choose an output file.

       new TGFileDialog(gClient->GetRoot(), this, kFDSave, fCurMacro);

       tmpFileName = fCurMacro->fFilename;

       if (tmpFileName) tmpBaseName = gSystem->BaseName(tmpFileName);

                   else tmpBaseName = 0;

    } while (tmpBaseName && (strstr(tmpBaseName, "Style_") != tmpBaseName)

                         && (strstr(tmpBaseName, " ") != 0));


    if (tmpBaseName != 0) {

       // Export the style.

       fCurSelStyle->SaveSource(gSystem->UnixPathName(tmpFileName));

       fCurMacro->fFilename = StrDup(tmpBaseName);

       fStyleChanged = kFALSE;

    }


    UpdateStatusBar();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Close the style manager. Called via the menu bar.


 void TStyleManager::DoExit()

 {

 //   SendCloseMessage();   // Doesn't delete the StyleManager. Hides it.

    delete this;

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Open an help window. Called via the menu bar or the tool bar.


 void TStyleManager::DoHelp(Int_t i)

 {

    TRootHelpDialog *hd;

    switch (i) {

       case 0:

          hd = new TRootHelpDialog(this, "Help on General Tab", 600, 400);

          hd->SetText(gHelpSMGeneral);

          break;

       case 1:

          hd = new TRootHelpDialog(this, "Help on Canvas Tab", 600, 400);

          hd->SetText(gHelpSMCanvas);

          break;

       case 2:

          hd = new TRootHelpDialog(this, "Help on Pad Tab", 600, 400);

          hd->SetText(gHelpSMPad);

          break;

       case 3:

          hd = new TRootHelpDialog(this, "Help on Histograms Tab", 600, 400);

          hd->SetText(gHelpSMHistos);

          break;

       case 4:

          hd = new TRootHelpDialog(this, "Help on Axis Tab", 600, 400);

          hd->SetText(gHelpSMAxis);

          break;

       case 5:

          hd = new TRootHelpDialog(this, "Help on Title Tab", 600, 400);

          hd->SetText(gHelpSMTitle);

          break;

       case 6:

          hd = new TRootHelpDialog(this, "Help on Stats Tab", 600, 400);

          hd->SetText(gHelpSMStats);

          break;

       case 7:

          hd = new TRootHelpDialog(this, "Help on PS / PDF Tab", 600, 400);

          hd->SetText(gHelpSMPSPDF);

          break;

       default:

          hd = new TRootHelpDialog(this, "Help on Top Level", 600, 400);

          hd->SetText(gHelpSMTopLevel);

    }

    hd->Popup();

 }


 ////////////////////////////////////////////////////////////////////////////////

 ///  Create a new style (a copy of gStyle) and import the properties of the

 /// current canvas inside.


 void TStyleManager::DoImportCanvas()

 {

    if ((!fCurPad) || (!fCurObj)) return;


    new TStyleDialog(this, gStyle, 3, fCurPad);


    // Create the list of available style, and select:

    //    - the new style, if it has been created

    //    - the previous selected style, if no style has been created (Cancel)

    if (fLastChoice) {

       BuildList();


       // Auto export of the canvas' style.

       CreateMacro();

       TString newName;

       newName.Form("Style_%s.C", fCurSelStyle->GetName());

       fCurMacro->fFilename = StrDup(newName.Data());

       fCurSelStyle->SaveSource(gSystem->UnixPathName(fCurMacro->fFilename));

    } else {

       BuildList(fCurSelStyle);

    }

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Create a TGFileInfo concerning a macro, if it doesn't exist already.


 void TStyleManager::CreateMacro()

 {

    if (fCurMacro) delete fCurMacro;

    fCurMacro = new TGFileInfo();

    TString dir(".");

    fCurMacro->fFileTypes = kFiletypes;

    fCurMacro->fIniDir    = StrDup(dir);

    fCurMacro->fFilename  = 0;

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the tool bar to the frame 'p'.


 void TStyleManager::AddToolbar(TGCompositeFrame *p)

 {

    TGLayoutHints *layout1 = new TGLayoutHints(kLHintsNormal, 3);

    fTrashListLayout->Add(layout1);

    TGLayoutHints *layout2 = new TGLayoutHints(kLHintsNormal, 6);

    fTrashListLayout->Add(layout2);


    fToolBar = new TGToolBar(p);

    fToolBarNewPic = gClient->GetPicture("sm_new.xpm");

    fToolBarNew = new TGPictureButton(fToolBar, fToolBarNewPic, kToolbarNew);

    fToolBarNew->SetStyle(gClient->GetStyle());

    fToolBarNew->Associate(this);

    fToolBar->AddFrame(fToolBarNew);


    fToolBarImportCanvasPic = gClient->GetPicture("sm_import_canvas.xpm");

    fToolBarImportCanvas = new TGPictureButton(fToolBar, fToolBarImportCanvasPic, kToolbarImportCanvas);

    fToolBarImportCanvas->SetStyle(gClient->GetStyle());

    fToolBarImportCanvas->Associate(this);

    fToolBar->AddFrame(fToolBarImportCanvas, layout2);


    fToolBarImportMacroPic = gClient->GetPicture("sm_import_macro.xpm");

    fToolBarImportMacro = new TGPictureButton(fToolBar, fToolBarImportMacroPic, kToolbarImportMacro);

    fToolBarImportMacro->SetStyle(gClient->GetStyle());

    fToolBarImportMacro->Associate(this);

    fToolBar->AddFrame(fToolBarImportMacro);


    fToolBarExportPic = gClient->GetPicture("sm_export.xpm");

    fToolBarExport = new TGPictureButton(fToolBar, fToolBarExportPic, kToolbarExport);

    fToolBarExport->SetStyle(gClient->GetStyle());

    fToolBarExport->Associate(this);

    fToolBar->AddFrame(fToolBarExport, layout1);


    fToolBarDeletePic = gClient->GetPicture("sm_delete.xpm");

    fToolBarDelete = new TGPictureButton(fToolBar, fToolBarDeletePic, kToolbarDelete);

    fToolBarDelete->SetStyle(gClient->GetStyle());

    fToolBarDelete->Associate(this);

    fToolBar->AddFrame(fToolBarDelete, layout2);


    fToolBarHelpPic = gClient->GetPicture("sm_help.xpm");

    fToolBarHelp = new TGPictureButton(fToolBar, fToolBarHelpPic, kToolbarHelp);

    fToolBarHelp->SetStyle(gClient->GetStyle());

    fToolBarHelp->Associate(this);

    fToolBar->AddFrame(fToolBarHelp, layout2);


    p->AddFrame(fToolBar, fLayoutExpandX);

    fHorizontal3DLine = new TGHorizontal3DLine(p);

    p->AddFrame(fHorizontal3DLine, fLayoutExpandX);


    fToolBarNew->SetToolTipText("Create a new style");

    fToolBarDelete->SetToolTipText("Delete the selected style");

    fToolBarImportCanvas->SetToolTipText("Import a style from selected canvas");

    fToolBarImportMacro->SetToolTipText("Import a style from a macro");

    fToolBarExport->SetToolTipText("Export the selected style into a macro");

    fToolBarHelp->SetToolTipText("Help about the top level interface");

 }


 ////////////////////////////////////////////////////////////////////////////////

 ///  Add the top level interface to the frame 'cf'. This part of the

 /// interface will provide all enable functionalities, excluding the

 /// edition of styles.


 void TStyleManager::AddTopLevelInterface(TGCompositeFrame *cf)

 {

    TGLayoutHints *layout1 = new TGLayoutHints(kLHintsExpandX, 0, 0, 2, 2);

    fTrashListLayout->Add(layout1);

    TGLayoutHints *layout2 = new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 10, 10, 10, 15);

    fTrashListLayout->Add(layout2);

    TGLayoutHints *layout3 = new TGLayoutHints(kLHintsNormal, 0, 0, 18);

    fTrashListLayout->Add(layout3);

    TGLayoutHints *layout4 = new TGLayoutHints(kLHintsNormal, 10, 10);

    fTrashListLayout->Add(layout4);

    TGLayoutHints *layout5 = new TGLayoutHints(kLHintsExpandX, 125);

    fTrashListLayout->Add(layout5);

    TGLayoutHints *layout6 = new TGLayoutHints(kLHintsNormal, 0, 10, 3);

    fTrashListLayout->Add(layout6);

    TGLayoutHints *layout7 = new TGLayoutHints(kLHintsNormal, 0, 16, 3);

    fTrashListLayout->Add(layout7);

    TGLayoutHints *layout8 = new TGLayoutHints(kLHintsExpandX, 0, 0, 10);

    fTrashListLayout->Add(layout8);

    TGLayoutHints *layout9 = new TGLayoutHints(kLHintsNormal, -15, 0, -5, -10);

    fTrashListLayout->Add(layout9);

    TGLayoutHints *layout10 = new TGLayoutHints(kLHintsNormal, 15, 0, -5, -10);

    fTrashListLayout->Add(layout10);

    TGLayoutHints *layout11 = new TGLayoutHints(kLHintsExpandX, 0, 0, 15);

    fTrashListLayout->Add(layout11);

    TGLayoutHints *layout12 = new TGLayoutHints(kLHintsExpandX, 0, 0, 10, 5);

    fTrashListLayout->Add(layout12);

    TGLayoutHints *layout13 = new TGLayoutHints(kLHintsExpandX, 20, 0, 7);

    fTrashListLayout->Add(layout13);


    TGVerticalFrame *topLevel = new TGVerticalFrame(cf);

    fTrashListFrame->AddFirst(topLevel);

    TGHorizontalFrame *h1 = new TGHorizontalFrame(topLevel);

    fTrashListFrame->AddFirst(h1);

    TGVerticalFrame *v11 = new TGVerticalFrame(h1);

    fTrashListFrame->AddFirst(v11);

    fListLabel = new TGLabel(v11, "Available Styles:");

    v11->AddFrame(fListLabel);

    fListComboBox = new TGComboBox(v11, kTopStylesList);

    fListComboBox->Associate(this);

    fListComboBox->Resize(200, 22);

    v11->AddFrame(fListComboBox, layout1);

    h1->AddFrame(v11, fLayoutExpandX);

    TGVerticalFrame *v12 = new TGVerticalFrame(h1);

    fTrashListFrame->AddFirst(v12);

    fMakeDefaultPic = gClient->GetPicture("arrow_right2.xpm");

    fMakeDefault = new TGPictureButton(v12, fMakeDefaultPic, kTopMakeDefault);

    fMakeDefault->SetStyle(gClient->GetStyle());

    fMakeDefault->Associate(this);

    fMakeDefault->Resize(40, 22);

    v12->AddFrame(fMakeDefault, layout3);

    h1->AddFrame(v12, layout4);

    TGVerticalFrame *v13 = new TGVerticalFrame(h1);

    fTrashListFrame->AddFirst(v13);

    fCurStylabel = new TGLabel(v13, "gStyle is set to:");

    v13->AddFrame(fCurStylabel);

    fCurStyle = new TGTextEntry(v13, "", kTopCurStyle);

    fCurStyle->Associate(this);

    fCurStyle->SetEnabled(kFALSE);

    v13->AddFrame(fCurStyle, layout1);

    h1->AddFrame(v13, fLayoutExpandX);

    topLevel->AddFrame(h1, fLayoutExpandX);


    TGHorizontalFrame *h2 = new TGHorizontalFrame(topLevel);

    fTrashListFrame->AddFirst(h2);

    TGGroupFrame *gf = new TGGroupFrame(h2, "Apply on");

    fTrashListFrame->AddFirst(gf);

    TGVerticalFrame *vf = new TGVerticalFrame(gf);

    fTrashListFrame->AddFirst(vf);

    Pixel_t red;

    gClient->GetColorByName("#FF0000", red);

    TGHorizontalFrame *selCanvas = new TGHorizontalFrame(vf);

    fTrashListFrame->AddFirst(selCanvas);

    fCurPadLabel = new TGLabel(selCanvas, "Canvas:");

    selCanvas->AddFrame(fCurPadLabel, layout6);

    fCurPadTextEntry = new TGTextEntry(selCanvas, "", kTopCurPad);

    fCurPadTextEntry->SetEnabled(kFALSE);

    fCurPadTextEntry->SetTextColor(red, kFALSE);

    selCanvas->AddFrame(fCurPadTextEntry, fLayoutExpandX);

    vf->AddFrame(selCanvas, fLayoutExpandX);

    TGHorizontalFrame *selObject = new TGHorizontalFrame(vf);

    fTrashListFrame->AddFirst(selObject);

    fCurObjLabel = new TGLabel(selObject, "Object:");

    selObject->AddFrame(fCurObjLabel, layout7);

    fCurObjTextEntry = new TGTextEntry(selObject, "", kTopCurObj);

    fCurObjTextEntry->Associate(this);

    fCurObjTextEntry->SetEnabled(kFALSE);

    fCurObjTextEntry->SetTextColor(red, kFALSE);

    selObject->AddFrame(fCurObjTextEntry, fLayoutExpandX);

    vf->AddFrame(selObject, layout8);

    TGHorizontalFrame *h4 = new TGHorizontalFrame(vf);

    fTrashListFrame->AddFirst(h4);

    fApplyOnGroup = new TGHButtonGroup(h4);

    fApplyOnAll = new TGRadioButton(fApplyOnGroup, "All canvases",    kTopApplyOnAll);

    fApplyOnAll->Associate(this);

    fApplyOnSel = new TGRadioButton(fApplyOnGroup, "Selected object", kTopApplyOnSel);

    fApplyOnSel->Associate(this);

    fAllAndNotCurrent = kFALSE;

    fApplyOnGroup->SetButton(kTopApplyOnSel);

    fApplyOnGroup->Show();

    fApplyOnGroup->SetLayoutHints(layout9, fApplyOnAll);

    fApplyOnGroup->SetLayoutHints(layout10, fApplyOnSel);

    h4->AddFrame(fApplyOnGroup);

    fApplyOnButton = new TGTextButton(h4, "&Apply", kTopApplyOnBut);

    fApplyOnButton->Associate(this);

    fApplyOnButton->Resize(100, 22);

    h4->AddFrame(fApplyOnButton, layout13);

    vf->AddFrame(h4, fLayoutExpandX);

    gf->AddFrame(vf, layout11);

    h2->AddFrame(gf, layout12);

    topLevel->AddFrame(h2, fLayoutExpandX);


    TGHorizontalFrame *h3 = new TGHorizontalFrame(topLevel);

    fTrashListFrame->AddFirst(h3);

    fPreviewButton = new TGCheckButton(h3, "&Preview", kTopPreview);

    fPreviewButton->Associate(this);

    h3->AddFrame(fPreviewButton, layout6);

    fPreviewRealTime = new TGCheckButton(h3, "Run &Time Preview", kTopPreviewRealTime);

    fPreviewRealTime->Associate(this);

    fPreviewRealTime->SetEnabled(kFALSE);

    h3->AddFrame(fPreviewRealTime, layout6);

    fMoreLess = new TGTextButton(h3, "&Close <<", kTopMoreLess);

    fMoreLess->Associate(this);

    h3->AddFrame(fMoreLess, layout5);

    topLevel->AddFrame(h3, fLayoutExpandX);


    cf->AddFrame(topLevel, layout2);


    fApplyOnButton->SetToolTipText("Apply the selected style on the selected object");

    fPreviewButton->SetToolTipText("Show / Hide the preview window");

    fPreviewRealTime->SetToolTipText("Continuous / Asynchronous update of the preview");

 }


 ////////////////////////////////////////////////////////////////////////////////

 ///  Build the list of styles which will appear in the available styles

 /// combo box. The new style to select is mentioned. If no style has

 /// been specified, the last entry of the list is selected.


 void TStyleManager::BuildList(TStyle *style)

 {

    // Empty the list.

    fListComboBox->RemoveEntries(1, fListComboBox->GetNumberOfEntries());


    // Build the list of all styles already created in the ROOT session.

    Int_t i = 1;

    Int_t styleID = 0;

    TStyle *tmpStyle = (TStyle *) (gROOT->GetListOfStyles()->First());

    while (tmpStyle) {

       if (tmpStyle == style) styleID = i;

       fListComboBox->AddEntry(tmpStyle->GetName(), i++);

       tmpStyle = (TStyle *) (gROOT->GetListOfStyles()->After(tmpStyle));

    }


    // Select 'style' in the list of available styles.

    if (styleID == 0) styleID = i - 1;

    fListComboBox->Select(styleID);

    DoListSelect();

    fCurStyle->SetText(gStyle->GetName());

 }


 ////////////////////////////////////////////////////////////////////////////////

 ///  Update the content of the status bar: show the name of the current

 /// selected style, its title and the macro from which it has been imported.


 void TStyleManager::UpdateStatusBar()

 {

    fStatusBar->SetText(fCurSelStyle->GetName(), 0);

    fStatusBar->SetText(fCurSelStyle->GetTitle(), 2);


    if ((!strcmp(fCurSelStyle->GetName(), "Default"))

     || (!strcmp(fCurSelStyle->GetName(), "Plain"  ))

     || (!strcmp(fCurSelStyle->GetName(), "Bold"   ))

     || (!strcmp(fCurSelStyle->GetName(), "Video"  ))

     || (!strcmp(fCurSelStyle->GetName(), "Pub"    ))) {

       fStatusBar->SetText("ROOT style", 1);

    } else if (fStyleChanged) {

       fStatusBar->SetText("User Style _ Not Saved", 1);

    } else {

       fStatusBar->SetText("User Style", 1);

    }

 }


 ////////////////////////////////////////////////////////////////////////////////

 ///  Update the values of every widget entry in the editor. The new values

 /// are loaded from the current selected style.


 void TStyleManager::UpdateEditor(Int_t tabNum)

 {

    Double_t delta;

    Int_t year;

    Int_t month;

    Int_t day;

    Int_t oneYearInSecs;

    Int_t oneMonthInSecs;

    Int_t tmp;

    Int_t tmp2;

    switch (tabNum) {

       case 0: // GENERAL

          fFillColor->SetColor(TColor::Number2Pixel(fCurSelStyle->GetFillColor()));

          fFillStyle->SetPattern(fCurSelStyle->GetFillStyle());

          fHatchesLineWidth->Select(fCurSelStyle->GetHatchesLineWidth());

          fHatchesSpacing->SetNumber(fCurSelStyle->GetHatchesSpacing());

          fMarkerColor->SetColor(TColor::Number2Pixel(fCurSelStyle->GetMarkerColor()));

          fMarkerStyle->SetMarkerStyle(fCurSelStyle->GetMarkerStyle());

          fMarkerSize->Select((Int_t) fCurSelStyle->GetMarkerSize() * 5);

          fScreenFactor->SetNumber(fCurSelStyle->GetScreenFactor());

          fLineColor->SetColor(TColor::Number2Pixel(fCurSelStyle->GetLineColor()));

          fLineWidth->Select(fCurSelStyle->GetLineWidth());

          fLineStyle->Select(fCurSelStyle->GetLineStyle());

          // Nothing to do with fLineStyleEdit.

          fTextColor->SetColor(TColor::Number2Pixel(fCurSelStyle->GetTextColor()));

          if (fCurSelStyle->GetTextFont()%10 > 2) {

             fTextSizeInPixels->SetState(kButtonDown, kFALSE);

             ModTextSizeInPixels(kTRUE);

          } else {

             fTextSizeInPixels->SetState(kButtonUp, kFALSE);

             ModTextSizeInPixels(kFALSE);

          }

          fTextFont->Select(fCurSelStyle->GetTextFont()/10);

          fTextAlign->Select(fCurSelStyle->GetTextAlign());

          fTextAngle->SetNumber(fCurSelStyle->GetTextAngle());

          break;

       case 1: // CANVAS

          fCanvasColor->SetColor(TColor::Number2Pixel(fCurSelStyle->GetCanvasColor()));

          fCanvasDefX->SetIntNumber(fCurSelStyle->GetCanvasDefX());

          fCanvasDefY->SetIntNumber(fCurSelStyle->GetCanvasDefY());

          fCanvasDefW->SetIntNumber(fCurSelStyle->GetCanvasDefW());

          fCanvasDefH->SetIntNumber(fCurSelStyle->GetCanvasDefH());

          fCanvasBorderMode->SetButton(fCurSelStyle->GetCanvasBorderMode() + 1 + kCanvasBorderModeSunken);

          fCanvasBorderSize->Select(fCurSelStyle->GetCanvasBorderSize());

          fAttDateTextColor->SetColor(TColor::Number2Pixel(fCurSelStyle->GetAttDate()->GetTextColor()));

          if (fCurSelStyle->GetAttDate()->GetTextFont()%10 > 2) {

             fAttDateTextSizeInPixels->SetState(kButtonDown, kFALSE);

             ModAttDateTextSizeInPixels(kTRUE);

          } else {

             fAttDateTextSizeInPixels->SetState(kButtonUp, kFALSE);

             ModAttDateTextSizeInPixels(kFALSE);

          }

          fOptDateFormat->Select(fCurSelStyle->GetOptDate()/10 + 1);

          fAttDateTextFont->Select(fCurSelStyle->GetAttDate()->GetTextFont()/10);

          fAttDateTextAlign->Select(fCurSelStyle->GetAttDate()->GetTextAlign());

          fAttDateTextAngle->SetNumber(fCurSelStyle->GetAttDate()->GetTextAngle());

          fDateX->SetIntNumber((Int_t) (fCurSelStyle->GetDateX()*100 + 0.5));

          fDateY->SetIntNumber((Int_t) (fCurSelStyle->GetDateY()*100 + 0.5));


          if (fCurSelStyle->GetOptDate()) {

             fOptDateBool->SetState(kButtonDown, kFALSE);

             fAttDateTextColor->Enable();

             fAttDateTextSize->SetState(kTRUE);

             if (!fAttDateTextSizeInPixels->IsDown())

                fAttDateTextSizeInPixels->SetEnabled(kTRUE);

 // TODO Just delete when ComboBox can be grayed

             //fOptDateFormat->SetState(kTRUE);

             //ModAttDateTextFont->SetState(kTRUE);

             //ModAttDateTextAlign->SetState(kTRUE);

             fAttDateTextAngle->SetState(kTRUE);

             fDateX->SetState(kTRUE);

             fDateY->SetState(kTRUE);

          } else {

             fOptDateBool->SetState(kButtonUp, kFALSE);

             fAttDateTextColor->Disable();

             fAttDateTextSize->SetState(kFALSE);

             fAttDateTextSizeInPixels->SetEnabled(kFALSE);

 // TODO Just delete when ComboBox can be grayed

             //fOptDateFormat->SetState(kFALSE);

             //ModAttDateTextFont->SetState(kFALSE);

             //ModAttDateTextAlign->SetState(kFALSE);

             fAttDateTextAngle->SetState(kFALSE);

             fDateX->SetState(kFALSE);

             fDateY->SetState(kFALSE);

          }

          break;

       case 2: // PAD

          fPadTopMargin->SetIntNumber((Int_t) (fCurSelStyle->GetPadTopMargin() * 100 + 0.5));

          fPadBottomMargin->SetIntNumber((Int_t) (fCurSelStyle->GetPadBottomMargin() * 100 + 0.5));

          fPadLeftMargin->SetIntNumber((Int_t) (fCurSelStyle->GetPadLeftMargin() * 100 + 0.5));

          fPadRightMargin->SetIntNumber((Int_t) (fCurSelStyle->GetPadRightMargin() * 100 + 0.5));

          fPadBorderMode->SetButton(fCurSelStyle->GetPadBorderMode() + 1 + kPadBorderModeSunken);

          fPadBorderSize->Select(fCurSelStyle->GetPadBorderSize());

          fPadColor->SetColor(TColor::Number2Pixel(fCurSelStyle->GetPadColor()));

          if (fCurSelStyle->GetPadTickX())

             fPadTickX->SetState(kButtonDown, kFALSE);

          else

             fPadTickX->SetState(kButtonUp, kFALSE);

          if (fCurSelStyle->GetPadTickY())

             fPadTickY->SetState(kButtonDown, kFALSE);

          else

             fPadTickY->SetState(kButtonUp, kFALSE);

          if (fCurSelStyle->GetPadGridX())

             fPadGridX->SetState(kButtonDown, kFALSE);

          else

             fPadGridX->SetState(kButtonUp, kFALSE);

          if (fCurSelStyle->GetPadGridY())

             fPadGridY->SetState(kButtonDown, kFALSE);

          else

             fPadGridY->SetState(kButtonUp, kFALSE);

          fGridColor->SetColor(TColor::Number2Pixel(fCurSelStyle->GetGridColor()));

          fGridWidth->Select(fCurSelStyle->GetGridWidth());

          fGridStyle->Select(fCurSelStyle->GetGridStyle());

          break;

       case 3: // HISTOS

          fHistFillColor->SetColor(TColor::Number2Pixel(fCurSelStyle->GetHistFillColor()));

          fHistFillStyle->SetPattern(fCurSelStyle->GetHistFillStyle());

          fHistLineColor->SetColor(TColor::Number2Pixel(fCurSelStyle->GetHistLineColor()));

          fHistLineWidth->Select(fCurSelStyle->GetHistLineWidth());

          fHistLineStyle->Select(fCurSelStyle->GetHistLineStyle());

          fBarWidth->SetNumber(fCurSelStyle->GetBarWidth());

          fBarOffset->SetNumber(fCurSelStyle->GetBarOffset());

          if (fCurSelStyle->GetHistMinimumZero())

             fHistMinimumZero->SetState(kButtonDown, kFALSE);

          else

             fHistMinimumZero->SetState(kButtonUp, kFALSE);

          fPaintTextFormat->SetText(fCurSelStyle->GetPaintTextFormat());

          fNumberContours->SetIntNumber(fCurSelStyle->GetNumberContours());

          fLegoInnerR->SetIntNumber((Int_t) (fCurSelStyle->GetLegoInnerR() * 100 + 0.5));

          fFrameFillColor->SetColor(TColor::Number2Pixel(fCurSelStyle->GetFrameFillColor()));

          fFrameFillStyle->SetPattern(fCurSelStyle->GetFrameFillStyle());

          fFrameLineColor->SetColor(TColor::Number2Pixel(fCurSelStyle->GetFrameLineColor()));

          fFrameLineWidth->Select(fCurSelStyle->GetFrameLineWidth());

          fFrameLineStyle->Select(fCurSelStyle->GetFrameLineStyle());

          // Nothing to do with fPaletteEdit;

          fFrameBorderMode->SetButton(fCurSelStyle->GetFrameBorderMode() + 1 + kFrameBorderModeSunken);

          fFrameBorderSize->Select(fCurSelStyle->GetFrameBorderSize());

          fFuncColor->SetColor(TColor::Number2Pixel(fCurSelStyle->GetFuncColor()));

          fFuncWidth->Select(fCurSelStyle->GetFuncWidth());

          fFuncStyle->Select(fCurSelStyle->GetFuncStyle());

          if (fCurSelStyle->GetDrawBorder())

             fDrawBorder->SetState(kButtonDown, kFALSE);

          else

             fDrawBorder->SetState(kButtonUp, kFALSE);

          fEndErrorSize->SetNumber(fCurSelStyle->GetEndErrorSize());

          fErrorX->SetIntNumber((Int_t) (fCurSelStyle->GetErrorX() * 100 + 0.5));

          break;

       case 4: // AXIS

          delta = fCurSelStyle->GetTimeOffset() - 788918400;

          year = 1995;

          month = 1;

          day = 1;

          while (delta < 0) {

             year--;

             if (year % 4) oneYearInSecs = 3600 * 24 * 365;

             else oneYearInSecs = 3600 * 24 * 366;

             delta += oneYearInSecs;

          }

          oneYearInSecs = 3600 * 24 * 365;             // because 365 days in 1995.

          while (delta >= oneYearInSecs) {

             if (year % 4) oneYearInSecs = 3600 * 24 * 365;

             else oneYearInSecs = 3600 * 24 * 366;

             delta -= oneYearInSecs;

             year++;

          }

          oneMonthInSecs = 3600 * 24 * 31;       // because 31 days in January.

          while (delta >= oneMonthInSecs) {

             month++;

             delta -= oneMonthInSecs;

             switch (month) {

                case 2:

                   if (year % 4) oneMonthInSecs = 3600 * 24 * 28;

                   else oneMonthInSecs = 3600 * 24 * 29;

                   break;

                case 3: case 5: case 7: case 8: case 10: case 12:

                   oneMonthInSecs = 3600 * 24 * 31;

                   break;

                default:

                   oneMonthInSecs = 3600 * 24 * 30;

             }

          }

          day = (Int_t) delta / (3600 * 24) + 1;

          delta = ((Int_t) delta) % (3600 * 24);

          fTimeOffsetDate->SetNumber(year*10000 + month*100 + day);

          fTimeOffsetTime->SetNumber(delta);


          if (fCurSelStyle->GetStripDecimals())

             fStripDecimals->SetState(kButtonUp, kFALSE);

          else

             fStripDecimals->SetState(kButtonDown, kFALSE);

          fXTitleSize->SetNumber(fCurSelStyle->GetTitleSize("X"));

          if (fCurSelStyle->GetTitleFont("X")%10 > 2) {

             fXTitleSizeInPixels->SetState(kButtonDown, kFALSE);

             ModXTitleSizeInPixels(kTRUE);

          } else {

             fXTitleSizeInPixels->SetState(kButtonUp, kFALSE);

             ModXTitleSizeInPixels(kFALSE);

          }

          fXTitleColor->SetColor(TColor::Number2Pixel(fCurSelStyle->GetTitleColor("X")));

          fXTitleOffset->SetNumber(fCurSelStyle->GetTitleOffset("X"));

          fXTitleFont->Select(fCurSelStyle->GetTitleFont("X")/10);

          fXLabelSize->SetNumber(fCurSelStyle->GetLabelSize("X"));

          if (fCurSelStyle->GetLabelFont("X")%10 > 2) {

             fXLabelSizeInPixels->SetState(kButtonDown, kFALSE);

             ModXLabelSizeInPixels(kTRUE);

          } else {

             fXLabelSizeInPixels->SetState(kButtonUp, kFALSE);

             ModXLabelSizeInPixels(kFALSE);

          }

          fXLabelColor->SetColor(TColor::Number2Pixel(fCurSelStyle->GetLabelColor("X")));

          fXLabelOffset->SetNumber(fCurSelStyle->GetLabelOffset("X"));

          fXLabelFont->Select(fCurSelStyle->GetLabelFont("X")/10);

          fXAxisColor->SetColor(TColor::Number2Pixel(fCurSelStyle->GetAxisColor("X")));

          fXTickLength->SetNumber(fCurSelStyle->GetTickLength("X"));

          if (fCurSelStyle->GetOptLogx())

             fOptLogx->SetState(kButtonDown, kFALSE);

          else

             fOptLogx->SetState(kButtonUp, kFALSE);

          fXNdivMain->SetIntNumber(TMath::Abs(fCurSelStyle->GetNdivisions("X")) % 100);

          fXNdivSub->SetIntNumber((TMath::Abs(fCurSelStyle->GetNdivisions("X")) % 10000)/100);

          fXNdivSubSub->SetIntNumber((TMath::Abs(fCurSelStyle->GetNdivisions("X")) % 1000000)/10000);

          if (fCurSelStyle->GetNdivisions("X") > 0)

             fXNdivisionsOptimize->SetState(kButtonDown, kFALSE);

          else

             fXNdivisionsOptimize->SetState(kButtonUp, kFALSE);

          fYTitleSize->SetNumber(fCurSelStyle->GetTitleSize("Y"));

          if (fCurSelStyle->GetTitleFont("Y")%10 > 2) {

             fYTitleSizeInPixels->SetState(kButtonDown, kFALSE);

             ModYTitleSizeInPixels(kTRUE);

          } else {

             fYTitleSizeInPixels->SetState(kButtonUp, kFALSE);

             ModYTitleSizeInPixels(kFALSE);

          }

          fYTitleColor->SetColor(TColor::Number2Pixel(fCurSelStyle->GetTitleColor("Y")));

          fYTitleOffset->SetNumber(fCurSelStyle->GetTitleOffset("Y"));

          fYTitleFont->Select(fCurSelStyle->GetTitleFont("Y")/10);

          fYLabelSize->SetNumber(fCurSelStyle->GetLabelSize("Y"));

          if (fCurSelStyle->GetLabelFont("Y")%10 > 2) {

             fYLabelSizeInPixels->SetState(kButtonDown, kFALSE);

             ModYLabelSizeInPixels(kTRUE);

          } else {

             fYLabelSizeInPixels->SetState(kButtonUp, kFALSE);

             ModYLabelSizeInPixels(kFALSE);

          }

          fYLabelColor->SetColor(TColor::Number2Pixel(fCurSelStyle->GetLabelColor("Y")));

          fYLabelOffset->SetNumber(fCurSelStyle->GetLabelOffset("Y"));

          fYLabelFont->Select(fCurSelStyle->GetLabelFont("Y")/10);

          fYAxisColor->SetColor(TColor::Number2Pixel(fCurSelStyle->GetAxisColor("Y")));

          fYTickLength->SetNumber(fCurSelStyle->GetTickLength("Y"));

          if (fCurSelStyle->GetOptLogy())

             fOptLogy->SetState(kButtonDown, kFALSE);

          else

             fOptLogy->SetState(kButtonUp, kFALSE);

          fYNdivMain->SetIntNumber(TMath::Abs(fCurSelStyle->GetNdivisions("Y")) % 100);

          fYNdivSub->SetIntNumber((TMath::Abs(fCurSelStyle->GetNdivisions("Y")) % 10000)/100);

          fYNdivSubSub->SetIntNumber((TMath::Abs(fCurSelStyle->GetNdivisions("Y")) % 1000000)/10000);

          if (fCurSelStyle->GetNdivisions("Y") > 0)

             fYNdivisionsOptimize->SetState(kButtonDown, kFALSE);

          else

             fYNdivisionsOptimize->SetState(kButtonUp, kFALSE);

          fZTitleSize->SetNumber(fCurSelStyle->GetTitleSize("Z"));

          if (fCurSelStyle->GetTitleFont("Z")%10 > 2) {

             fZTitleSizeInPixels->SetState(kButtonDown, kFALSE);

             ModZTitleSizeInPixels(kTRUE);

          } else {

             fZTitleSizeInPixels->SetState(kButtonUp, kFALSE);

             ModZTitleSizeInPixels(kFALSE);

          }

          fZTitleColor->SetColor(TColor::Number2Pixel(fCurSelStyle->GetTitleColor("Z")));

          fZTitleOffset->SetNumber(fCurSelStyle->GetTitleOffset("Z"));

          fZTitleFont->Select(fCurSelStyle->GetTitleFont("Z")/10);

          fZLabelSize->SetNumber(fCurSelStyle->GetLabelSize("Z"));

          if (fCurSelStyle->GetLabelFont("Z")%10 > 2) {

             fZLabelSizeInPixels->SetState(kButtonDown, kFALSE);

             ModZLabelSizeInPixels(kTRUE);

          } else {

             fZLabelSizeInPixels->SetState(kButtonUp, kFALSE);

             ModZLabelSizeInPixels(kFALSE);

          }

          fZLabelColor->SetColor(TColor::Number2Pixel(fCurSelStyle->GetLabelColor("Z")));

          fZLabelOffset->SetNumber(fCurSelStyle->GetLabelOffset("Z"));

          fZLabelFont->Select(fCurSelStyle->GetLabelFont("Z")/10);

          fZAxisColor->SetColor(TColor::Number2Pixel(fCurSelStyle->GetAxisColor("Z")));

          fZTickLength->SetNumber(fCurSelStyle->GetTickLength("Z"));


          if (fCurSelStyle->GetOptLogz())

             fOptLogz->SetState(kButtonDown, kFALSE);

          else

             fOptLogz->SetState(kButtonUp, kFALSE);


          fZNdivMain->SetIntNumber(TMath::Abs(fCurSelStyle->GetNdivisions("Z")) % 100);

          fZNdivSub->SetIntNumber((TMath::Abs(fCurSelStyle->GetNdivisions("Z")) % 10000)/100);

          fZNdivSubSub->SetIntNumber((TMath::Abs(fCurSelStyle->GetNdivisions("Z")) % 1000000)/10000);

          if (fCurSelStyle->GetNdivisions("Z") > 0)

             fZNdivisionsOptimize->SetState(kButtonDown, kFALSE);

          else

             fZNdivisionsOptimize->SetState(kButtonUp, kFALSE);

          break;

       case 5: // TITLES

          fTitleColor->SetColor(TColor::Number2Pixel(fCurSelStyle->GetTitleFillColor()));

          fTitleStyle->SetPattern(fCurSelStyle->GetTitleStyle());

          fTitleTextColor->SetColor(TColor::Number2Pixel(fCurSelStyle->GetTitleTextColor()));

          fTitleFontSize->SetNumber(fCurSelStyle->GetTitleFontSize());

          if (fCurSelStyle->GetTitleFont()%10 > 2) {

             fTitleFontSizeInPixels->SetState(kButtonDown, kFALSE);

             ModTitleFontSizeInPixels(kTRUE);

          } else {

             fTitleFontSizeInPixels->SetState(kButtonUp, kFALSE);

             ModTitleFontSizeInPixels(kFALSE);

          }

          fTitleFont->Select(fCurSelStyle->GetTitleFont()/10);

          fTitleAlign->Select(fCurSelStyle->GetTitleAlign());

          fTitleBorderSize->Select(fCurSelStyle->GetTitleBorderSize());

          fLegendBorderSize->Select(fCurSelStyle->GetLegendBorderSize());

          fTitleX->SetIntNumber((Int_t) (fCurSelStyle->GetTitleX() * 100 + 0.5));

          fTitleY->SetIntNumber((Int_t) (fCurSelStyle->GetTitleY() * 100 + 0.5));

          fTitleW->SetIntNumber((Int_t) (fCurSelStyle->GetTitleW() * 100 + 0.5));

          fTitleH->SetIntNumber((Int_t) (fCurSelStyle->GetTitleH() * 100 + 0.5));


          if (fCurSelStyle->GetOptTitle()) {

             fOptTitle->SetState(kButtonDown, kFALSE);

             fTitleColor->Enable();

             fTitleStyle->Enable();

             fTitleTextColor->Enable();

             fTitleFontSize->SetState(kTRUE);

             if (!fTitleFontSizeInPixels->IsDown())

                fTitleFontSizeInPixels->SetEnabled(kTRUE);

 // TODO Just delete when ComboBox can be grayed

             //fTitleFont->SetState(kTRUE);

             //fTitleAlign->SetState(kTRUE);

             //fTitleBorderSize->SetState(kTRUE);

             //fLegendBorderSize->SetState(kTRUE);

             fTitleX->SetState(kTRUE);

             fTitleY->SetState(kTRUE);

             fTitleW->SetState(kTRUE);

             fTitleH->SetState(kTRUE);

          } else {

             fOptTitle->SetState(kButtonUp, kFALSE);

             fTitleColor->Disable();

             fTitleStyle->Disable();

             fTitleTextColor->Disable();

             fTitleFontSize->SetState(kFALSE);

             fTitleFontSizeInPixels->SetEnabled(kFALSE);

 // TODO Just delete when ComboBox can be grayed

             //fTitleFont->SetState(kFALSE);

             //fTitleAlign->SetState(kFALSE);

             //fTitleBorderSize->SetState(kFALSE);

             //fLegendBorderSize->SetState(kFALSE);

             fTitleX->SetState(kFALSE);

             fTitleY->SetState(kFALSE);

             fTitleW->SetState(kFALSE);

             fTitleH->SetState(kFALSE);

          }

          break;

       case 6: // STATS

          fStatColor->SetColor(TColor::Number2Pixel(fCurSelStyle->GetStatColor()));

          fStatStyle->SetPattern(fCurSelStyle->GetStatStyle());

          fStatTextColor->SetColor(TColor::Number2Pixel(fCurSelStyle->GetStatTextColor()));

          fStatFont->Select(fCurSelStyle->GetStatFont()/10);

          if (fCurSelStyle->GetStatFont()%10 > 2) {

             fStatFontSizeInPixels->SetState(kButtonDown, kFALSE);

             ModStatFontSizeInPixels(kTRUE);

          } else {

             fStatFontSizeInPixels->SetState(kButtonUp, kFALSE);

             ModStatFontSizeInPixels(kFALSE);

          }

          fStatFontSize->SetNumber(fCurSelStyle->GetStatFontSize());


          fStatX->SetNumber(fCurSelStyle->GetStatX());

          fStatY->SetNumber(fCurSelStyle->GetStatY());

          fStatW->SetNumber(fCurSelStyle->GetStatW());

          fStatH->SetNumber(fCurSelStyle->GetStatH());

          fStatBorderSize->Select(fCurSelStyle->GetStatBorderSize());

          tmp = fCurSelStyle->GetOptStat();


          if (tmp % 10) fOptStatName->SetState(kButtonDown, kFALSE);

          else fOptStatName->SetState(kButtonUp, kFALSE);


          if ((tmp/10) % 10) fOptStatEntries->SetState(kButtonDown, kFALSE);

          else fOptStatEntries->SetState(kButtonUp, kFALSE);


          if ((tmp/100) % 10) fOptStatMean->SetState(kButtonDown, kFALSE);

          else fOptStatMean->SetState(kButtonUp, kFALSE);


          if ((tmp/1000) % 10) fOptStatRMS->SetState(kButtonDown, kFALSE);

          else fOptStatRMS->SetState(kButtonUp, kFALSE);


          if ((tmp/10000) % 10) fOptStatUnderflow->SetState(kButtonDown, kFALSE);

          else fOptStatUnderflow->SetState(kButtonUp, kFALSE);


          if ((tmp/100000) % 10) fOptStatOverflow->SetState(kButtonDown, kFALSE);

          else fOptStatOverflow->SetState(kButtonUp, kFALSE);


          if ((tmp/1000000) % 10) fOptStatIntegral->SetState(kButtonDown, kFALSE);

          else fOptStatIntegral->SetState(kButtonUp, kFALSE);


          if ((tmp/10000000) % 10) fOptStatSkewness->SetState(kButtonDown, kFALSE);

          else fOptStatSkewness->SetState(kButtonUp, kFALSE);


          if ((tmp/100000000) % 10) fOptStatKurtosis->SetState(kButtonDown, kFALSE);

          else fOptStatKurtosis->SetState(kButtonUp, kFALSE);


          if ((((tmp/100) % 10) == 2) || (((tmp/1000) % 10) == 2) ||

              (((tmp/10000000) % 10) == 2) || (((tmp/100000000) % 10) == 2))

             fOptStatErrors->SetState(kButtonDown, kFALSE);

          else  fOptStatErrors->SetState(kButtonUp, kFALSE);


          fStatFormat->SetText(fCurSelStyle->GetStatFormat());

          tmp2 = fCurSelStyle->GetOptFit();


          if (tmp2 % 10) fOptFitValues->SetState(kButtonDown, kFALSE);

          else fOptFitValues->SetState(kButtonUp, kFALSE);


          if ((tmp2/10) % 10) {

             fOptFitErrors->SetState(kButtonDown, kFALSE);

             fOptFitValues->SetState(kButtonDown, kFALSE);

          } else

             fOptFitErrors->SetState(kButtonUp, kFALSE);


          if ((tmp2/100) % 10) fOptFitChi->SetState(kButtonDown, kFALSE);

          else fOptFitChi->SetState(kButtonUp, kFALSE);


          if ((tmp2/1000) % 10) fOptFitProbability->SetState(kButtonDown, kFALSE);

          else fOptFitProbability->SetState(kButtonUp, kFALSE);


          fFitFormat->SetText(fCurSelStyle->GetFitFormat());

          break;


       case 7: // PS / PDF

          fHeaderPS->SetText(fCurSelStyle->GetHeaderPS());

          fTitlePS->SetText(fCurSelStyle->GetTitlePS());

          fColorModelPS->SetButton(fCurSelStyle->GetColorModelPS() + kPSPDFColorModelPSRGB);

          fLineScalePS->SetNumber(fCurSelStyle->GetLineScalePS());

          Float_t papSizeX;

          Float_t papSizeY;

          fCurSelStyle->GetPaperSize(papSizeX, papSizeY);

          if ((papSizeX == 20) && (papSizeY == 26)) {

             fPaperSizePredef->Select(3);

             fPaperSizeEnCm = kTRUE;

             fPaperSizeX->SetNumber(papSizeX);

             fPaperSizeY->SetNumber(papSizeY);

          } else if ((papSizeX == 20) && (papSizeY == 24)) {

             fPaperSizePredef->Select(4);

             fPaperSizeEnCm = kFALSE;

             fPaperSizeX->SetNumber(papSizeX * 0.394);

             fPaperSizeY->SetNumber(papSizeY * 0.394);

          } else {

             fPaperSizePredef->Select(1);

             fPaperSizeEnCm = kTRUE;

             fPaperSizeX->SetNumber(papSizeX);

             fPaperSizeY->SetNumber(papSizeY);

          }

          break;

    }

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Connect every entry in the top level interface to the slot.


 void TStyleManager::ConnectAll()

 {

    Connect("CloseWindow()", "TStyleManager", this, "CloseWindow()");

    fMenuStyle->Connect("Activated(Int_t)", "TStyleManager", this, "DoMenu(Int_t)");

    fMenuHelp->Connect("Activated(Int_t)", "TStyleManager", this, "DoMenu(Int_t)");

    fToolBarNew->Connect("Clicked()", "TStyleManager", this, TString::Format("DoMenu(Int_t=%d)", kMenuNew));

    fToolBarDelete->Connect("Clicked()", "TStyleManager", this, TString::Format("DoMenu(Int_t=%d)", kMenuDelete));

    fToolBarImportCanvas->Connect("Clicked()", "TStyleManager", this, TString::Format("DoMenu(Int_t=%d)", kMenuImportCanvas));

    fToolBarImportMacro->Connect("Clicked()", "TStyleManager", this, TString::Format("DoMenu(Int_t=%d)", kMenuImportMacro));

    fToolBarExport->Connect("Clicked()", "TStyleManager", this, TString::Format("DoMenu(Int_t=%d)", kMenuExport));

    fToolBarHelp->Connect("Clicked()", "TStyleManager", this, TString::Format("DoMenu(Int_t=%d)", kMenuHelp));

    fListComboBox->Connect("Selected(Int_t)", "TStyleManager", this, "DoListSelect()");

    fPreviewButton->Connect("Toggled(Bool_t)", "TStyleManager", this, "DoPreview(Bool_t)");

    fPreviewRealTime->Connect("Toggled(Bool_t)", "TStyleManager", this, "DoRealTime(Bool_t)");

    fMakeDefault->Connect("Clicked()", "TStyleManager", this, "DoMakeDefault()");

    fApplyOnGroup->Connect("Clicked(Int_t)", "TStyleManager", this, "DoApplyOnSelect(Int_t)");

    fApplyOnButton->Connect("Clicked()", "TStyleManager", this, "DoApplyOn()");

    fMoreLess->Connect("Clicked()", "TStyleManager", this, "DoMoreLess()");


    fEditionHelp->Connect("Clicked()", "TStyleManager", this, TString::Format("DoMenu(Int_t=%d)", kMenuHelpEditor));

    fEditionUpdatePreview->Connect("Clicked()", "TStyleManager", this, "DoEditionUpdatePreview()");

    fEditionReset->Connect("Clicked()", "TStyleManager", this, "DoImportMacro(Int_t=kFALSE)");

    fEditionTab->Connect("Selected(Int_t)", "TStyleManager", this, "DoChangeTab(Int_t)");

    fAxisTab->Connect("Selected(Int_t)", "TStyleManager", this, "DoChangeAxisTab(Int_t)");


    // Connect signals emited when the current pad changed.

    TQObject::Connect("TCanvas", "Selected(TVirtualPad *, TObject *, Int_t)", "TStyleManager",

       this, "DoSelectCanvas(TVirtualPad *, TObject *, Int_t)");

    TQObject::Connect("TCanvas", "Closed()", "TStyleManager", this, "DoSelectNoCanvas()");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Disconnect every entry in the top level interface of the slot.


 void TStyleManager::DisconnectAll()

 {

    Disconnect("CloseWindow()");

    fMenuStyle->Disconnect("Activated(Int_t)");

    fMenuHelp->Disconnect("Activated(Int_t)");

    fToolBarNew->Disconnect("Clicked()");

    fToolBarDelete->Disconnect("Clicked()");

    fToolBarImportCanvas->Disconnect("Clicked()");

    fToolBarImportMacro->Disconnect("Clicked()");

    fToolBarExport->Disconnect("Clicked()");

    fToolBarHelp->Disconnect("Clicked()");

    fListComboBox->Disconnect("Selected(Int_t)");

    fPreviewButton->Disconnect("Toggled(Bool_t)");

    fMakeDefault->Disconnect("Clicked()");

    fApplyOnGroup->Disconnect("Clicked(Int_t)");

    fApplyOnButton->Disconnect("Clicked()");

    fMoreLess->Disconnect("Clicked()");


    fEditionHelp->Disconnect("Clicked()");

    fEditionUpdatePreview->Disconnect("Clicked()");

    fEditionReset->Disconnect("Clicked()");

    fEditionTab->Disconnect("Selected(Int_t)");


    TQObject::Disconnect("TCanvas", "Selected(TVirtualPad *, TObject *, Int_t)");

    TQObject::Disconnect("TCanvas", "Closed()");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Connect every widget entry of the editor to its specific slot.


 void TStyleManager::ConnectEditor(Int_t tabNum)

 {

    if (fSigSlotConnected) return;

    fSigSlotConnected = kTRUE;


    switch (tabNum) {

       case 0: // GENERAL

          fFillColor->Connect("ColorSelected(Pixel_t)", "TStyleManager", this, "ModFillColor()");

          fFillStyle->Connect("PatternSelected(Style_t)", "TStyleManager", this, "ModFillStyle()");

          fHatchesLineWidth->Connect("Selected(Int_t)", "TStyleManager", this, "ModHatchesLineWidth()");

          fHatchesSpacing->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModHatchesSpacing()");

          fMarkerColor->Connect("ColorSelected(Pixel_t)", "TStyleManager", this, "ModMarkerColor()");

          fMarkerStyle->Connect("MarkerSelected(Style_t)", "TStyleManager", this, "ModMarkerStyle()");

          fMarkerSize->Connect("Selected(Int_t)", "TStyleManager", this, "ModMarkerSize()");

          fScreenFactor->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModScreenFactor()");

          fLineColor->Connect("ColorSelected(Pixel_t)", "TStyleManager", this, "ModLineColor()");

          fLineWidth->Connect("Selected(Int_t)", "TStyleManager", this, "ModLineWidth()");

          fLineStyle->Connect("Selected(Int_t)", "TStyleManager", this, "ModLineStyle()");

          fLineStyleEdit->Connect("Clicked()", "TStyleManager", this, "ModLineStyleEdit()");

          fTextColor->Connect("ColorSelected(Pixel_t)", "TStyleManager", this, "ModTextColor()");

          fTextSize->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModTextSize()");

          fTextSizeInPixels->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModTextSizeInPixels(Bool_t)");

          fTextFont->Connect("Selected(Int_t)", "TStyleManager", this, "ModTextFont()");

          fTextAlign->Connect("Selected(Int_t)", "TStyleManager", this, "ModTextAlign()");

          fTextAngle->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModTextAngle()");

          break;

       case 1: // CANVAS

          fCanvasColor->Connect("ColorSelected(Pixel_t)", "TStyleManager", this, "ModCanvasColor()");

          fCanvasDefX->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModCanvasDefX()");

          fCanvasDefY->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModCanvasDefY()");

          fCanvasDefW->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModCanvasDefW()");

          fCanvasDefH->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModCanvasDefH()");

          fCanvasBorderMode->Connect("Clicked(Int_t)", "TStyleManager", this, "ModCanvasBorderMode()");

          fCanvasBorderSize->Connect("Selected(Int_t)", "TStyleManager", this, "ModCanvasBorderSize()");

          fOptDateBool->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModOptDateBool()");

          fAttDateTextColor->Connect("ColorSelected(Pixel_t)", "TStyleManager", this, "ModAttDateTextColor()");

          fAttDateTextSize->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModAttDateTextSize()");

          fAttDateTextSizeInPixels->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModAttDateTextSizeInPixels(Bool_t)");

          fOptDateFormat->Connect("Selected(Int_t)", "TStyleManager", this, "ModOptDateFormat()");

          fAttDateTextFont->Connect("Selected(Int_t)", "TStyleManager", this, "ModAttDateTextFont()");

          fAttDateTextAngle->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModAttDateTextAngle()");

          fAttDateTextAlign->Connect("Selected(Int_t)", "TStyleManager", this, "ModAttDateTextAlign()");

          fDateX->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModDateX()");

          fDateY->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModDateY()");

          break;

       case 2: // PAD

          fPadTopMargin->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModPadTopMargin()");

          fPadBottomMargin->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModPadBottomMargin()");

          fPadLeftMargin->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModPadLeftMargin()");

          fPadRightMargin->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModPadRightMargin()");

          fPadBorderMode->Connect("Clicked(Int_t)", "TStyleManager", this, "ModPadBorderMode()");

          fPadBorderSize->Connect("Selected(Int_t)", "TStyleManager", this, "ModPadBorderSize()");

          fPadColor->Connect("ColorSelected(Pixel_t)", "TStyleManager", this, "ModPadColor()");

          fPadTickX->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModPadTickX()");

          fPadTickY->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModPadTickY()");

          fPadGridX->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModPadGridX()");

          fPadGridY->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModPadGridY()");

          fGridColor->Connect("ColorSelected(Pixel_t)", "TStyleManager", this, "ModGridColor()");

          fGridWidth->Connect("Selected(Int_t)", "TStyleManager", this, "ModGridWidth()");

          fGridStyle->Connect("Selected(Int_t)", "TStyleManager", this, "ModGridStyle()");

          break;

       case 3: // HISTOS

          fHistFillColor->Connect("ColorSelected(Pixel_t)", "TStyleManager", this, "ModHistFillColor()");

          fHistFillStyle->Connect("PatternSelected(Style_t)", "TStyleManager", this, "ModHistFillStyle()");

          fHistLineColor->Connect("ColorSelected(Pixel_t)", "TStyleManager", this, "ModHistLineColor()");

          fHistLineWidth->Connect("Selected(Int_t)", "TStyleManager", this, "ModHistLineWidth()");

          fHistLineStyle->Connect("Selected(Int_t)", "TStyleManager", this, "ModHistLineStyle()");

          fBarWidth->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModBarWidth()");

          fBarOffset->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModBarOffset()");

          fHistMinimumZero->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModHistMinimumZero()");

          fPaintTextFormat->Connect("TextChanged(const char *)", "TStyleManager", this, "ModPaintTextFormat()");

          fNumberContours->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModNumberContours()");

          fLegoInnerR->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModLegoInnerR()");

          fFrameFillColor->Connect("ColorSelected(Pixel_t)", "TStyleManager", this, "ModFrameFillColor()");

          fFrameFillStyle->Connect("PatternSelected(Style_t)", "TStyleManager", this, "ModFrameFillStyle()");

          fFrameLineColor->Connect("ColorSelected(Pixel_t)", "TStyleManager", this, "ModFrameLineColor()");

          fFrameLineWidth->Connect("Selected(Int_t)", "TStyleManager", this, "ModFrameLineWidth()");

          fFrameLineStyle->Connect("Selected(Int_t)", "TStyleManager", this, "ModFrameLineStyle()");

          fPaletteEdit->Connect("Clicked()", "TStyleManager", this, "ModPaletteEdit()");

          fFrameBorderMode->Connect("Clicked(Int_t)", "TStyleManager", this, "ModFrameBorderMode()");

          fFrameBorderSize->Connect("Selected(Int_t)", "TStyleManager", this, "ModFrameBorderSize()");

          fFuncColor->Connect("ColorSelected(Pixel_t)", "TStyleManager", this, "ModFuncColor()");

          fFuncWidth->Connect("Selected(Int_t)", "TStyleManager", this, "ModFuncWidth()");

          fFuncStyle->Connect("Selected(Int_t)", "TStyleManager", this, "ModFuncStyle()");

          fDrawBorder->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModDrawBorder()");

          fEndErrorSize->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModEndErrorSize()");

          fErrorX->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModErrorX()");

          break;

       case 4: // AXIS

          fTimeOffsetDate->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModTimeOffset()");

          fTimeOffsetTime->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModTimeOffset()");

          fStripDecimals->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModStripDecimals()");

          fApplyOnXYZ->Connect("Clicked()", "TStyleManager", this, "ModApplyOnXYZ()");

          fXTitleSize->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModXTitleSize()");

          fXTitleSizeInPixels->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModXTitleSizeInPixels(Bool_t)");

          fXTitleColor->Connect("ColorSelected(Pixel_t)", "TStyleManager", this, "ModXTitleColor()");

          fXTitleOffset->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModXTitleOffset()");

          fXTitleFont->Connect("Selected(Int_t)", "TStyleManager", this, "ModXTitleFont()");

          fXLabelSize->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModXLabelSize()");

          fXLabelSizeInPixels->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModXLabelSizeInPixels(Bool_t)");

          fXLabelColor->Connect("ColorSelected(Pixel_t)", "TStyleManager", this, "ModXLabelColor()");

          fXLabelOffset->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModXLabelOffset()");

          fXLabelFont->Connect("Selected(Int_t)", "TStyleManager", this, "ModXLabelFont()");

          fXAxisColor->Connect("ColorSelected(Pixel_t)", "TStyleManager", this, "ModXAxisColor()");

          fXTickLength->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModXTickLength()");

          fOptLogx->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModOptLogx()");

          fXNdivMain->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModXNdivisions()");

          fXNdivSub->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModXNdivisions()");

          fXNdivSubSub->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModXNdivisions()");

          fXNdivisionsOptimize->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModXNdivisions()");

          fYTitleSize->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModYTitleSize()");

          fYTitleSizeInPixels->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModYTitleSizeInPixels(Bool_t)");

          fYTitleColor->Connect("ColorSelected(Pixel_t)", "TStyleManager", this, "ModYTitleColor()");

          fYTitleOffset->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModYTitleOffset()");

          fYTitleFont->Connect("Selected(Int_t)", "TStyleManager", this, "ModYTitleFont()");

          fYLabelSize->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModYLabelSize()");

          fYLabelSizeInPixels->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModYLabelSizeInPixels(Bool_t)");

          fYLabelColor->Connect("ColorSelected(Pixel_t)", "TStyleManager", this, "ModYLabelColor()");

          fYLabelOffset->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModYLabelOffset()");

          fYLabelFont->Connect("Selected(Int_t)", "TStyleManager", this, "ModYLabelFont()");

          fYAxisColor->Connect("ColorSelected(Pixel_t)", "TStyleManager", this, "ModYAxisColor()");

          fYTickLength->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModYTickLength()");

          fOptLogy->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModOptLogy()");

          fYNdivMain->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModYNdivisions()");

          fYNdivSub->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModYNdivisions()");

          fYNdivSubSub->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModYNdivisions()");

          fYNdivisionsOptimize->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModYNdivisions()");

          fZTitleSize->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModZTitleSize()");

          fZTitleSizeInPixels->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModZTitleSizeInPixels(Bool_t)");

          fZTitleColor->Connect("ColorSelected(Pixel_t)", "TStyleManager", this, "ModZTitleColor()");

          fZTitleOffset->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModZTitleOffset()");

          fZTitleFont->Connect("Selected(Int_t)", "TStyleManager", this, "ModZTitleFont()");

          fZLabelSize->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModZLabelSize()");

          fZLabelSizeInPixels->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModZLabelSizeInPixels(Bool_t)");

          fZLabelColor->Connect("ColorSelected(Pixel_t)", "TStyleManager", this, "ModZLabelColor()");

          fZLabelOffset->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModZLabelOffset()");

          fZLabelFont->Connect("Selected(Int_t)", "TStyleManager", this, "ModZLabelFont()");

          fZAxisColor->Connect("ColorSelected(Pixel_t)", "TStyleManager", this, "ModZAxisColor()");

          fZTickLength->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModZTickLength()");

          fOptLogz->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModOptLogz()");

          fZNdivMain->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModZNdivisions()");

          fZNdivSub->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModZNdivisions()");

          fZNdivSubSub->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModZNdivisions()");

          fZNdivisionsOptimize->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModZNdivisions()");

          break;

       case 5: // TITLES

          fOptTitle->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModOptTitle()");

          fTitleColor->Connect("ColorSelected(Pixel_t)", "TStyleManager", this, "ModTitleFillColor()");

          fTitleStyle->Connect("PatternSelected(Style_t)", "TStyleManager", this, "ModTitleStyle()");

          fTitleTextColor->Connect("ColorSelected(Pixel_t)", "TStyleManager", this, "ModTitleTextColor()");

          fTitleFontSize->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModTitleFontSize()");

          fTitleFontSizeInPixels->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModTitleFontSizeInPixels(Bool_t)");

          fTitleFont->Connect("Selected(Int_t)", "TStyleManager", this, "ModTitleFont()");

          fTitleAlign->Connect("Selected(Int_t)", "TStyleManager", this, "ModTitleAlign()");

          fTitleBorderSize->Connect("Selected(Int_t)", "TStyleManager", this, "ModTitleBorderSize()");

          fTitleX->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModTitleX()");

          fTitleY->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModTitleY()");

          fTitleW->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModTitleW()");

          fTitleH->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModTitleH()");

          fLegendBorderSize->Connect("Selected(Int_t)", "TStyleManager", this, "ModLegendBorderSize()");

          break;

       case 6: // STATS

          fStatColor->Connect("ColorSelected(Pixel_t)", "TStyleManager", this, "ModStatColor(Pixel_t)");

          fStatStyle->Connect("PatternSelected(Style_t)", "TStyleManager", this, "ModStatStyle(Style_t)");

          fStatTextColor->Connect("ColorSelected(Pixel_t)", "TStyleManager", this, "ModStatTextColor(Pixel_t)");

          fStatFontSize->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModStatFontSize()");

          fStatFontSizeInPixels->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModStatFontSizeInPixels(Bool_t)");

          fStatFont->Connect("Selected(Int_t)", "TStyleManager", this, "ModStatFont()");

          fStatX->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModStatX()");

          fStatY->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModStatY()");

          fStatW->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModStatW()");

          fStatH->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModStatH()");

          fStatBorderSize->Connect("Selected(Int_t)", "TStyleManager", this, "ModStatBorderSize()");

          fOptStatName->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModOptStat()");

          fOptStatEntries->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModOptStat()");

          fOptStatOverflow->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModOptStat()");

          fOptStatMean->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModOptStat()");

          fOptStatUnderflow->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModOptStat()");

          fOptStatRMS->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModOptStat()");

          fOptStatSkewness->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModOptStat()");

          fOptStatIntegral->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModOptStat()");

          fOptStatKurtosis->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModOptStat()");

          fOptStatErrors->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModOptStat()");

          fStatFormat->Connect("TextChanged(const char *)", "TStyleManager", this, "ModStatFormat(const char *)");

          fOptFitValues->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModOptFit()");

          fOptFitErrors->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModOptFit()");

          fOptFitProbability->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModOptFit()");

          fOptFitChi->Connect("Toggled(Bool_t)", "TStyleManager", this, "ModOptFit()");

          fFitFormat->Connect("TextChanged(const char *)", "TStyleManager", this, "ModFitFormat(const char *)");

          break;

       case 7: // PS / PDF

          fHeaderPS->Connect("TextChanged(const char *)", "TStyleManager", this, "ModHeaderPS()");

          fTitlePS->Connect("TextChanged(const char *)", "TStyleManager", this, "ModTitlePS()");

          fColorModelPS->Connect("Clicked(Int_t)", "TStyleManager", this, "ModColorModelPS()");

          fLineScalePS->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModLineScalePS()");

          fPaperSizePredef->Connect("Selected(Int_t)", "TStyleManager", this, "ModPaperSizePredef()");

          fPaperSizeX->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModPaperSizeXY()");

          fPaperSizeY->Connect("ValueSet(Long_t)", "TStyleManager", this, "ModPaperSizeXY()");

          break;

    }

 }


 ////////////////////////////////////////////////////////////////////////////////

 ///  Disconnect every widget entry of the editor from its slot. Must be

 /// called before UpdateEditor() to avoid recursive calls.


 void TStyleManager::DisconnectEditor(Int_t tabNum)

 {

    if (!fSigSlotConnected) return;

    fSigSlotConnected = kFALSE;


    switch (tabNum) {

       case 0: // GENERAL

          fFillColor->Disconnect("ColorSelected(Pixel_t)");

          fFillStyle->Disconnect("PatternSelected(Style_t)");

          fHatchesLineWidth->Disconnect("Selected(Int_t)");

          fHatchesSpacing->Disconnect("ValueSet(Long_t)");

          fMarkerColor->Disconnect("ColorSelected(Pixel_t)");

          fMarkerStyle->Disconnect("MarkerSelected(Style_t)");

          fMarkerSize->Disconnect("Selected(Int_t)");

          fScreenFactor->Disconnect("ValueSet(Long_t)");

          fLineColor->Disconnect("ColorSelected(Pixel_t)");

          fLineWidth->Disconnect("Selected(Int_t)");

          fLineStyle->Disconnect("Selected(Int_t)");

          fLineStyleEdit->Disconnect("Clicked()");

          fTextColor->Disconnect("ColorSelected(Pixel_t)");

          fTextSize->Disconnect("ValueSet(Long_t)");

          fTextFont->Disconnect("Selected(Int_t)");

          fTextAlign->Disconnect("Selected(Int_t)");

          fTextAngle->Disconnect("ValueSet(Long_t)");

          break;

       case 1: // CANVAS

          fCanvasColor->Disconnect("ColorSelected(Pixel_t)");

          fCanvasDefX->Disconnect("ValueSet(Long_t)");

          fCanvasDefY->Disconnect("ValueSet(Long_t)");

          fCanvasDefW->Disconnect("ValueSet(Long_t)");

          fCanvasDefH->Disconnect("ValueSet(Long_t)");

          fCanvasBorderMode->Disconnect("Clicked(Int_t)");

          fCanvasBorderSize->Disconnect("Selected(Int_t)");

          fOptDateBool->Disconnect("Toggled(Bool_t)");

          fAttDateTextColor->Disconnect("ColorSelected(Pixel_t)");

          fAttDateTextSize->Disconnect("ValueSet(Long_t)");

          fOptDateFormat->Disconnect("Selected(Int_t)");

          fAttDateTextFont->Disconnect("Selected(Int_t)");

          fAttDateTextAngle->Disconnect("ValueSet(Long_t)");

          fAttDateTextAlign->Disconnect("Selected(Int_t)");

          fDateX->Disconnect("ValueSet(Long_t)");

          fDateY->Disconnect("ValueSet(Long_t)");

          break;

       case 2: // PAD

          fPadTopMargin->Disconnect("ValueSet(Long_t)");

          fPadBottomMargin->Disconnect("ValueSet(Long_t)");

          fPadLeftMargin->Disconnect("ValueSet(Long_t)");

          fPadRightMargin->Disconnect("ValueSet(Long_t)");

          fPadBorderMode->Disconnect("Clicked(Int_t)");

          fPadBorderSize->Disconnect("Selected(Int_t)");

          fPadColor->Disconnect("ColorSelected(Pixel_t)");

          fPadTickX->Disconnect("Toggled(Bool_t)");

          fPadTickY->Disconnect("Toggled(Bool_t)");

          fPadGridX->Disconnect("Toggled(Bool_t)");

          fPadGridY->Disconnect("Toggled(Bool_t)");

          fGridColor->Disconnect("ColorSelected(Pixel_t)");

          fGridWidth->Disconnect("Selected(Int_t)");

          fGridStyle->Disconnect("Selected(Int_t)");

          break;

       case 3: // HISTOS

          fHistFillColor->Disconnect("ColorSelected(Pixel_t)");

          fHistFillStyle->Disconnect("PatternSelected(Style_t)");

          fHistLineColor->Disconnect("ColorSelected(Pixel_t)");

          fHistLineWidth->Disconnect("Selected(Int_t)");

          fHistLineStyle->Disconnect("Selected(Int_t)");

          fBarWidth->Disconnect("ValueSet(Long_t)");

          fBarOffset->Disconnect("ValueSet(Long_t)");

          fHistMinimumZero->Disconnect("Toggled(Bool_t)");

          fPaintTextFormat->Disconnect("TextChanged(const char *)");

          fNumberContours->Disconnect("ValueSet(Long_t)");

          fLegoInnerR->Disconnect("ValueSet(Long_t)");

          fFrameFillColor->Disconnect("ColorSelected(Pixel_t)");

          fFrameFillStyle->Disconnect("PatternSelected(Style_t)");

          fFrameLineColor->Disconnect("ColorSelected(Pixel_t)");

          fFrameLineWidth->Disconnect("Selected(Int_t)");

          fFrameLineStyle->Disconnect("Selected(Int_t)");

          fPaletteEdit->Disconnect("Clicked()");

          fFrameBorderMode->Disconnect("Clicked(Int_t)");

          fFrameBorderSize->Disconnect("Selected(Int_t)");

          fFuncColor->Disconnect("ColorSelected(Pixel_t)");

          fFuncWidth->Disconnect("Selected(Int_t)");

          fFuncStyle->Disconnect("Selected(Int_t)");

          fDrawBorder->Disconnect("Toggled(Bool_t)");

          fEndErrorSize->Disconnect("ValueSet(Long_t)");

          fErrorX->Disconnect("ValueSet(Long_t)");

          break;

       case 4: // AXIS

          fTimeOffsetDate->Disconnect("ValueSet(Long_t)");

          fTimeOffsetTime->Disconnect("ValueSet(Long_t)");

          fStripDecimals->Disconnect("Toggled(Bool_t)");

          fApplyOnXYZ->Disconnect("Clicked()");

          fXTitleSize->Disconnect("ValueSet(Long_t)");

          fXTitleColor->Disconnect("ColorSelected(Pixel_t)");

          fXTitleOffset->Disconnect("ValueSet(Long_t)");

          fXTitleFont->Disconnect("Selected(Int_t)");

          fXLabelSize->Disconnect("ValueSet(Long_t)");

          fXLabelColor->Disconnect("ColorSelected(Pixel_t)");

          fXLabelOffset->Disconnect("ValueSet(Long_t)");

          fXLabelFont->Disconnect("Selected(Int_t)");

          fXAxisColor->Disconnect("ColorSelected(Pixel_t)");

          fXTickLength->Disconnect("ValueSet(Long_t)");

          fOptLogx->Disconnect("Toggled(Bool_t)");

          fXNdivMain->Disconnect("ValueSet(Long_t)");

          fXNdivSub->Disconnect("ValueSet(Long_t)");

          fXNdivSubSub->Disconnect("ValueSet(Long_t)");

          fXNdivisionsOptimize->Disconnect("Toggled(Bool_t)");

          fYTitleSize->Disconnect("ValueSet(Long_t)");

          fYTitleColor->Disconnect("ColorSelected(Pixel_t)");

          fYTitleOffset->Disconnect("ValueSet(Long_t)");

          fYTitleFont->Disconnect("Selected(Int_t)");

          fYLabelSize->Disconnect("ValueSet(Long_t)");

          fYLabelColor->Disconnect("ColorSelected(Pixel_t)");

          fYLabelOffset->Disconnect("ValueSet(Long_t)");

          fYLabelFont->Disconnect("Selected(Int_t)");

          fYAxisColor->Disconnect("ColorSelected(Pixel_t)");

          fYTickLength->Disconnect("ValueSet(Long_t)");

          fOptLogy->Disconnect("Toggled(Bool_t)");

          fYNdivMain->Disconnect("ValueSet(Long_t)");

          fYNdivSub->Disconnect("ValueSet(Long_t)");

          fYNdivSubSub->Disconnect("ValueSet(Long_t)");

          fYNdivisionsOptimize->Disconnect("Toggled(Bool_t)");

          fZTitleSize->Disconnect("ValueSet(Long_t)");

          fZTitleColor->Disconnect("ColorSelected(Pixel_t)");

          fZTitleOffset->Disconnect("ValueSet(Long_t)");

          fZTitleFont->Disconnect("Selected(Int_t)");

          fZLabelSize->Disconnect("ValueSet(Long_t)");

          fZLabelColor->Disconnect("ColorSelected(Pixel_t)");

          fZLabelOffset->Disconnect("ValueSet(Long_t)");

          fZLabelFont->Disconnect("Selected(Int_t)");

          fZAxisColor->Disconnect("ColorSelected(Pixel_t)");

          fZTickLength->Disconnect("ValueSet(Long_t)");

          fOptLogz->Disconnect("Toggled(Bool_t)");

          fZNdivMain->Disconnect("ValueSet(Long_t)");

          fZNdivSub->Disconnect("ValueSet(Long_t)");

          fZNdivSubSub->Disconnect("ValueSet(Long_t)");

          fZNdivisionsOptimize->Disconnect("Toggled(Bool_t)");

          break;

       case 5: // TITLES

          fOptTitle->Disconnect("Toggled(Bool_t)");

          fTitleColor->Disconnect("ColorSelected(Pixel_t)");

          fTitleStyle->Disconnect("PatternSelected(Style_t)");

          fTitleTextColor->Disconnect("ColorSelected(Pixel_t)");

          fTitleFontSize->Disconnect("ValueSet(Long_t)");

          fTitleFont->Disconnect("Selected(Int_t)");

          fTitleAlign->Disconnect("Selected(Int_t)");

          fTitleBorderSize->Disconnect("Selected(Int_t)");

          fTitleX->Disconnect("ValueSet(Long_t)");

          fTitleY->Disconnect("ValueSet(Long_t)");

          fTitleW->Disconnect("ValueSet(Long_t)");

          fTitleH->Disconnect("ValueSet(Long_t)");

          fLegendBorderSize->Disconnect("Selected(Int_t)");

          break;

       case 6: // STATS

          fStatColor->Disconnect("ColorSelected(Pixel_t)");

          fStatStyle->Disconnect("PatternSelected(Style_t)");

          fStatTextColor->Disconnect("ColorSelected(Pixel_t)");

          fStatFontSize->Disconnect("ValueSet(Long_t)");

          fStatFont->Disconnect("Selected(Int_t)");

          fStatX->Disconnect("ValueSet(Long_t)");

          fStatY->Disconnect("ValueSet(Long_t)");

          fStatW->Disconnect("ValueSet(Long_t)");

          fStatH->Disconnect("ValueSet(Long_t)");

          fStatBorderSize->Disconnect("Selected(Int_t)");

          fOptStatName->Disconnect("Toggled(Bool_t)");

          fOptStatEntries->Disconnect("Toggled(Bool_t)");

          fOptStatOverflow->Disconnect("Toggled(Bool_t)");

          fOptStatMean->Disconnect("Toggled(Bool_t)");

          fOptStatUnderflow->Disconnect("Toggled(Bool_t)");

          fOptStatRMS->Disconnect("Toggled(Bool_t)");

          fOptStatSkewness->Disconnect("Toggled(Bool_t)");

          fOptStatIntegral->Disconnect("Toggled(Bool_t)");

          fOptStatKurtosis->Disconnect("Toggled(Bool_t)");

          fOptStatErrors->Disconnect("Toggled(Bool_t)");

          fStatFormat->Disconnect("TextChanged(const char *)");

          fOptFitValues->Disconnect("Toggled(Bool_t)");

          fOptFitErrors->Disconnect("Toggled(Bool_t)");

          fOptFitProbability->Disconnect("Toggled(Bool_t)");

          fOptFitChi->Disconnect("Toggled(Bool_t)");

          fFitFormat->Disconnect("TextChanged(const char *)");

          break;

       case 7: // PS / PDF

          fHeaderPS->Disconnect("TextChanged(const char *)");

          fTitlePS->Disconnect("TextChanged(const char *)");

          fColorModelPS->Disconnect("Clicked(Int_t)");

          fLineScalePS->Disconnect("ValueSet(Long_t)");

          fPaperSizePredef->Disconnect("Selected(Int_t)");

          fPaperSizeX->Disconnect("ValueSet(Long_t)");

          fPaperSizeY->Disconnect("ValueSet(Long_t)");

          break;

    }

 }


 ////////////////////////////////////////////////////////////////////////////////

 ///  Called each time something is changed in the style editor. Thanks to

 /// this method, we can know if the style differs from the original style.


 void TStyleManager::DoEditor()

 {

    fStyleChanged = kTRUE;


    // Update the status bar.

    UpdateStatusBar();


    // Update the preview if the real time mode is selected.

    if (fRealTimePreview)

       DoEditionUpdatePreview();

 }


 ////////////////////////////////////////////////////////////////////////////////

 ///  Add the editor to the frame 'p'. It contains the tabs allowing the user

 /// to modify every data member of the current TStyle object.


 void TStyleManager::AddEdition(TGCompositeFrame *p)

 {

    TGLayoutHints *layout1 = new TGLayoutHints(kLHintsExpandX, 8, 8, 5, 5);

    fTrashListLayout->Add(layout1);

    TGLayoutHints *layout2 = new TGLayoutHints(kLHintsExpandX, 10, 10);

    fTrashListLayout->Add(layout2);


    fEditionFrame = new TGVerticalFrame(p);

    fEditionFrame->ChangeOptions(kRaisedFrame);


    fEditionTab = new TGTab(fEditionFrame, 200, 150);

    fEditionTab->Associate(this);

    CreateTabGeneral(fEditionTab->AddTab("General"));

    CreateTabCanvas(fEditionTab->AddTab("Canvas"));

    CreateTabPad(fEditionTab->AddTab("Pad"));

    CreateTabHistos(fEditionTab->AddTab("Histograms"));

    CreateTabAxis(fEditionTab->AddTab("Axis"));

    CreateTabTitle(fEditionTab->AddTab("Title"));

    CreateTabStats(fEditionTab->AddTab("Stats"));

    CreateTabPsPdf(fEditionTab->AddTab("PS / PDF"));

    fEditionFrame->AddFrame(fEditionTab, layout1);


    fEditionButtonFrame = new TGHorizontalFrame(fEditionFrame);

    fEditionHelp = new TGTextButton(fEditionButtonFrame, "He&lp", kEditButHelp);

    fEditionHelp->Associate(this);

    fEditionButtonFrame->AddFrame(fEditionHelp, layout1);

    fEditionUpdatePreview = new TGTextButton(fEditionButtonFrame, "&Update Preview", kEditButUpPrev);

    fEditionUpdatePreview->Associate(this);

    fEditionUpdatePreview->SetEnabled(kFALSE);

    fEditionButtonFrame->AddFrame(fEditionUpdatePreview, layout1);

    fEditionReset = new TGTextButton(fEditionButtonFrame, "&Reset", kEditButReset);

    fEditionReset->Associate(this);

    fEditionButtonFrame->AddFrame(fEditionReset, layout1);

    fEditionFrame->AddFrame(fEditionButtonFrame, layout1);


    p->AddFrame(fEditionFrame, layout1);


    fEditionHelp->SetToolTipText("Help about the current tab");

    fEditionUpdatePreview->SetToolTipText("Force the refresh of the preview window");

    fEditionReset->SetToolTipText("Reset the selected style");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the tab 'General' to the editor.


 void TStyleManager::CreateTabGeneral(TGCompositeFrame *tab)

 {

    TGLayoutHints *layout = new TGLayoutHints(kLHintsExpandX, 10, 21, 5, 5);

    fTrashListLayout->Add(layout);


    TGHorizontalFrame *h1 = new TGHorizontalFrame(tab);

    fTrashListFrame->AddFirst(h1);

    AddGeneralFill(h1);

    AddGeneralLine(h1);

    tab->AddFrame(h1, fLayoutExpandX);


    TGHorizontalFrame *h2 = new TGHorizontalFrame(tab);

    fTrashListFrame->AddFirst(h2);

    AddGeneralText(h2);

    TGVerticalFrame *v = new TGVerticalFrame(h2);

    fTrashListFrame->AddFirst(v);

    AddGeneralMarker(v);

    TGHorizontalFrame *h3 = new TGHorizontalFrame(v);

    fTrashListFrame->AddFirst(h3);

    fScreenFactor = AddNumberEntry(h3, 0, 0, 0, kGeneralScreenFactor,

                         "Screen factor:", 0, 6, TGNumberFormat::kNESRealOne,

                         TGNumberFormat::kNEAPositive,

                         TGNumberFormat::kNELLimitMinMax, 0.2, 5);

    v->AddFrame(h3, layout);

    h2->AddFrame(v, fLayoutExpandXY);

    tab->AddFrame(h2, fLayoutExpandX);


    fScreenFactor->GetNumberEntry()->SetToolTipText("Coefficient for different screen's resolutions");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Fill' group frame to the 'General' tab.


 void TStyleManager::AddGeneralFill(TGCompositeFrame *f)

 {

    TGLayoutHints *layout2 = new TGLayoutHints(kLHintsExpandX, 5, 0, 5, 5);

    fTrashListLayout->Add(layout2);


    TGGroupFrame *gf = new TGGroupFrame(f, "Fill");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h1 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h1);

    fFillColor = AddColorEntry(h1, kGeneralFillColor);

    fFillStyle = AddFillStyleEntry(h1, kGeneralFillStyle);

    gf->AddFrame(h1, fLayoutExpandX);

    AddTitle(gf, "Hatchings");

    TGHorizontalFrame *h2 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h2);

    fHatchesLineWidth = AddLineWidthEntry(h2, kGeneralHatchesLineWidth);

    fHatchesSpacing = AddNumberEntry(h2, 0, 5, 0, kGeneralHatchesSpacing,

                         "", 0, 5, TGNumberFormat::kNESRealOne,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0.1, 5);

    gf->AddFrame(h2, layout2);

    f->AddFrame(gf, fLayoutExpandXYMargin);


 // TODO Delete the // when the selectColor and selectPattern tooltips are OK.

 //   fFillColor->SetToolTipText("General fill color");

 //   fFillStyle->SetToolTipText("General fill pattern");

    fHatchesSpacing->GetNumberEntry()->SetToolTipText("Spacing between the hatching's lines");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Line' group frame to the 'General' tab.


 void TStyleManager::AddGeneralLine(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Line");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h);

    fLineColor = AddColorEntry(h, kGeneralLineColor);

    fLineWidth = AddLineWidthEntry(h, kGeneralLineWidth);

    gf->AddFrame(h, fLayoutExpandX);

    fLineStyle = AddLineStyleEntry(gf, kGeneralLineStyle);

    fLineStyleEdit = AddTextButton(gf, "Lines' Style Editor...", kGeneralLineStyleEdit);

    fLineStyleEdit->SetEnabled(kFALSE);

    f->AddFrame(gf, fLayoutExpandXYMargin);


 // TODO Delete the // when the selectColor and selectPattern tooltips are OK.

 //   fLineColor->SetToolTipText("General line color");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Text' group frame to the 'General' tab.


 void TStyleManager::AddGeneralText(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Text");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h1 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h1);

    fTextColor = AddColorEntry(h1, kGeneralTextColor);

    fTextFont = AddFontTypeEntry(h1, kGeneralTextFont);

    gf->AddFrame(h1, fLayoutExpandX);

    fTextAlign = AddTextAlignEntry(gf, kGeneralTextAlign);

    TGHorizontalFrame *h2 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h2);

    fTextSizeInPixels = AddCheckButton(h2, "Pixels", kGeneralTextSizeInPixels);

    fTextSize = AddNumberEntry(h2, 21, 10, 0, kGeneralTextSize, "Size:", 0, 5,

                         TGNumberFormat::kNESRealThree,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 0.3);

    gf->AddFrame(h2, fLayoutExpandX);

    fTextAngle = AddNumberEntry(gf, 0, 0, 0, kGeneralTextAngle, "Angle:",

                         0, 5, TGNumberFormat::kNESInteger,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, -180, 180);

    f->AddFrame(gf, fLayoutExpandXYMargin);


 // TODO Delete the // when the selectColor and selectPattern tooltips are OK.

 //   fTextColor->SetToolTipText("General text color");

    fTextSizeInPixels->SetToolTipText("Set the text size in pixels if selected, otherwise - in % of pad.");

    fTextSize->GetNumberEntry()->SetToolTipText("General text size (in pixels or in % of pad)");

    fTextAngle->GetNumberEntry()->SetToolTipText("General text angle");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Marker' group frame to the 'General' tab.


 void TStyleManager::AddGeneralMarker(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Marker");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h);

    fMarkerColor = AddColorEntry(h, kGeneralMarkerColor);

    fMarkerStyle = AddMarkerStyleEntry(h, kGeneralMarkerStyle);

    fMarkerSize = AddMarkerSizeEntry(h, kGeneralMarkerSize);

    gf->AddFrame(h, fLayoutExpandX);

    f->AddFrame(gf, fLayoutExpandXMargin);


 // TODO Delete the // when the selectColor and selectPattern tooltips are OK.

 //   fMarkerColor->SetToolTipText("Marker color");

 //   fMarkerStyle->SetToolTipText("Marker shape");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the tab 'Canvas' to the editor.


 void TStyleManager::CreateTabCanvas(TGCompositeFrame *tab)

 {

    TGHorizontalFrame *h = new TGHorizontalFrame(tab);

    fTrashListFrame->AddFirst(h);

    TGVerticalFrame *v1 = new TGVerticalFrame(h);

    fTrashListFrame->AddFirst(v1);

    AddCanvasFill(v1);

    AddCanvasGeometry(v1);

    AddCanvasBorder(v1);

    h->AddFrame(v1, fLayoutExpandXY);

    TGVerticalFrame *v2 = new TGVerticalFrame(h);

    fTrashListFrame->AddFirst(v2);

    AddCanvasDate(v2);

    h->AddFrame(v2, fLayoutExpandXY);

    tab->AddFrame(h, fLayoutExpandX);

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Fill' group frame to the 'Canvas' tab.


 void TStyleManager::AddCanvasFill(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Fill");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h);

    fCanvasColor = AddColorEntry(h, kCanvasColor);

    gf->AddFrame(h, fLayoutExpandX);

    f->AddFrame(gf, fLayoutExpandXMargin);


 // TODO Delete the // when the selectColor and selectPattern tooltips are OK.

 //   fCanvasColor->SetToolTipText("Color used to fill canvases");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Geometry' group frame to the 'Canvas' tab.


 void TStyleManager::AddCanvasGeometry(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Geometry");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h1 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h1);

    fCanvasDefX = AddNumberEntry(h1, 0, 9, 0, kCanvasDefX, "X:",

                         0, 5, TGNumberFormat::kNESInteger,

                         TGNumberFormat::kNEAPositive,

                         TGNumberFormat::kNELLimitMinMax, 0, 5000);

    fCanvasDefY = AddNumberEntry(h1, 7, 8, 0, kCanvasDefY, "Y:",

                         0, 5, TGNumberFormat::kNESInteger,

                         TGNumberFormat::kNEAPositive,

                         TGNumberFormat::kNELLimitMinMax, 0, 5000);

    gf->AddFrame(h1, fLayoutExpandX);


    TGHorizontalFrame *h2 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h2);

    fCanvasDefW = AddNumberEntry(h2, 0, 7, 0, kCanvasDefW, "W:",

                         0, 5, TGNumberFormat::kNESInteger,

                         TGNumberFormat::kNEAPositive,

                         TGNumberFormat::kNELLimitMinMax, 0, 5000);

    fCanvasDefH = AddNumberEntry(h2, 7, 8, 0, kCanvasDefH, "H:",

                         0, 5, TGNumberFormat::kNESInteger,

                         TGNumberFormat::kNEAPositive,

                         TGNumberFormat::kNELLimitMinMax, 0, 5000);

    gf->AddFrame(h2, fLayoutExpandX);

    f->AddFrame(gf, fLayoutExpandXMargin);


    fCanvasDefX->GetNumberEntry()->SetToolTipText("Canvases' default abscissa");

    fCanvasDefY->GetNumberEntry()->SetToolTipText("Canvases' default ordinate");

    fCanvasDefW->GetNumberEntry()->SetToolTipText("Canvases' default width");

    fCanvasDefH->GetNumberEntry()->SetToolTipText("Canvases' default height");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Border' group frame to the 'Canvas' tab.


 void TStyleManager::AddCanvasBorder(TGCompositeFrame *f)

 {

    fCanvasBorderMode = AddBorderModeEntry(f, kCanvasBorderModeSunken, kCanvasBorderModeNone, kCanvasBorderModeRaised);

    fCanvasBorderSize = AddLineWidthEntry(fCanvasBorderMode, kCanvasBorderSize);

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Date' group frame to the 'Canvas' tab.


 void TStyleManager::AddCanvasDate(TGCompositeFrame *f)

 {

    TGLayoutHints *layout2 = new TGLayoutHints(kLHintsExpandX, 10);

    fTrashListLayout->Add(layout2);


    TGGroupFrame *gf = new TGGroupFrame(f, "Date");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h1 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h1);

    fOptDateBool = AddCheckButton(h1, "Show", kCanvasOptDateBool, 23);

    fAttDateTextColor = AddColorEntry(h1, kCanvasAttDateTextColor);

    gf->AddFrame(h1, fLayoutExpandX);

    TGHorizontalFrame *h2 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h2);

    fAttDateTextSizeInPixels = AddCheckButton(h2, "Pixels", kCanvasAttDateTextSizeInPixels);

    fAttDateTextSize = AddNumberEntry(h2, 22, 10, 0, kCanvasAttDateTextSize, "Size:", 0, 5,

                         TGNumberFormat::kNESRealThree,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 0.3);

    gf->AddFrame(h2, fLayoutExpandX);

    fOptDateFormat = AddDateFormatEntry(gf, kCanvasOptDateFormat);

    fAttDateTextFont = AddFontTypeEntry(gf, kCanvasAttDateTextFont);

    fAttDateTextAlign = AddTextAlignEntry(gf, kCanvasAttDateTextAlign);

    fAttDateTextAngle = AddNumberEntry(gf, 0, 0, 0, kCanvasAttDateTextAngle,

                         "Angle:", 0, 6, TGNumberFormat::kNESInteger,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, -180, 180);

    AddTitle(gf, "Position");

    TGVerticalFrame *h3 = new TGVerticalFrame(gf);

    fTrashListFrame->AddFirst(h3);

    fDateX = AddNumberEntry(h3, 0, 0, 0, kCanvasDateX, "X (% of Pad):",

                         0, 6, TGNumberFormat::kNESInteger,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 100);

    fDateY = AddNumberEntry(h3, 0, 0, 0, kCanvasDateY, "Y (% of Pad):",

                         0, 6, TGNumberFormat::kNESInteger,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 100);

    gf->AddFrame(h3, layout2);

    f->AddFrame(gf, fLayoutExpandXYMargin);


    fOptDateBool->SetToolTipText("Show / Hide the date in canvases");

 // TODO Delete the // when the selectColor and selectPattern tooltips are OK.

 //   fAttDateTextColor->SetToolTipText("Color of the date text");

    fAttDateTextSizeInPixels->SetToolTipText("Set the date text size in pixels if selected, otherwise - in % of pad");

    fAttDateTextSize->GetNumberEntry()->SetToolTipText("Date text size (in pixels or in % of pad)");

    fAttDateTextAngle->GetNumberEntry()->SetToolTipText("Date text angle");

    fDateX->GetNumberEntry()->SetToolTipText("Date abscissa in percent of pad");

    fDateY->GetNumberEntry()->SetToolTipText("Date ordinate in percent of pad");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the tab 'Pad' to the editor.


 void TStyleManager::CreateTabPad(TGCompositeFrame *tab)

 {

    TGHorizontalFrame *h1 = new TGHorizontalFrame(tab);

    fTrashListFrame->AddFirst(h1);

    AddPadMargin(h1);

    TGVerticalFrame *v = new TGVerticalFrame(h1);

    fTrashListFrame->AddFirst(v);

    AddPadFill(v);

    AddPadTicks(v);

    h1->AddFrame(v, fLayoutExpandXY);

    tab->AddFrame(h1, fLayoutExpandX);

    TGHorizontalFrame *h2 = new TGHorizontalFrame(tab);

    fTrashListFrame->AddFirst(h2);

    AddPadBorder(h2);

    AddPadGrid(h2);

    tab->AddFrame(h2, fLayoutExpandX);

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Margin' group frame to the 'Pad' tab.


 void TStyleManager::AddPadMargin(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Margin (% of Pad)");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h1 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h1);

    fPadLeftMargin = AddNumberEntry(h1, 0, 5, 0, kPadLeftMargin, "Left:",

                         0, 3, TGNumberFormat::kNESInteger,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 99);

    fPadRightMargin = AddNumberEntry(h1, 0, 0, 0, kPadRightMargin, "Right:",

                         0, 3, TGNumberFormat::kNESInteger,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 99);

    gf->AddFrame(h1, fLayoutExpandXY);

    TGHorizontalFrame *h2 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h2);

    fPadTopMargin = AddNumberEntry(h2, 0, 5, 0, kPadTopMargin, "Top:",

                         0, 3, TGNumberFormat::kNESInteger,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 99);

    fPadBottomMargin = AddNumberEntry(h2, 0, 0, 0, kPadBottomMargin, "Bottom:",

                         0, 3, TGNumberFormat::kNESInteger,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 99);

    gf->AddFrame(h2, fLayoutExpandXY);

    f->AddFrame(gf, fLayoutExpandXYMargin);


    fPadLeftMargin->GetNumberEntry()->SetToolTipText("Pads' left margin");

    fPadRightMargin->GetNumberEntry()->SetToolTipText("Pads' right margin");

    fPadTopMargin->GetNumberEntry()->SetToolTipText("Pads' top margin");

    fPadBottomMargin->GetNumberEntry()->SetToolTipText("Pads' bottom margin");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Border' group frame to the 'Pad' tab.


 void TStyleManager::AddPadBorder(TGCompositeFrame *f)

 {

    fPadBorderMode = AddBorderModeEntry(f, kPadBorderModeSunken, kPadBorderModeNone, kPadBorderModeRaised);

    fPadBorderSize = AddLineWidthEntry(fPadBorderMode, kPadBorderSize);

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Fill' group frame to the 'Pad' tab.


 void TStyleManager::AddPadFill(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Fill");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h);

    fPadColor = AddColorEntry(h, kPadColor);

    gf->AddFrame(h, fLayoutExpandX);

    f->AddFrame(gf, fLayoutExpandXYMargin);


 // TODO Delete the // when the selectColor and selectPattern tooltips are OK.

 //   fPadColor->SetToolTipText("Color used to fill pads");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Ticks' group frame to the 'Pad' tab.


 void TStyleManager::AddPadTicks(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Ticks");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h);

    TGHorizontalFrame *h1 = new TGHorizontalFrame(h);

    fTrashListFrame->AddFirst(h1);

    fPadTickX = AddCheckButton(h1, "Along X", kPadTickX);

    h->AddFrame(h1, fLayoutExpandX);

    TGHorizontalFrame *h2 = new TGHorizontalFrame(h);

    fTrashListFrame->AddFirst(h2);

    fPadTickY = AddCheckButton(h2, "Along Y", kPadTickY);

    h->AddFrame(h2, fLayoutExpandX);

    gf->AddFrame(h, fLayoutExpandX);

    f->AddFrame(gf, fLayoutExpandXYMargin);


    fPadTickX->SetToolTipText("Show / Hide the ticks along X");

    fPadTickY->SetToolTipText("Show / Hide the ticks along Y");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Grid' group frame to the 'Pad' tab.


 void TStyleManager::AddPadGrid(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Grid");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h1 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h1);

    TGHorizontalFrame *h10 = new TGHorizontalFrame(h1);

    fTrashListFrame->AddFirst(h10);

    fPadGridX = AddCheckButton(h10, "Along X", kPadGridX);

    h1->AddFrame(h10, fLayoutExpandX);

    TGHorizontalFrame *h20 = new TGHorizontalFrame(h1);

    fTrashListFrame->AddFirst(h20);

    fPadGridY = AddCheckButton(h20, "Along Y", kPadGridY);

    h1->AddFrame(h20, fLayoutExpandX);

    gf->AddFrame(h1, fLayoutExpandX);

    TGHorizontalFrame *h2 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h2);

    fGridColor = AddColorEntry(h2, kPadGridColor);

    fGridWidth = AddLineWidthEntry(h2, kPadGridWidth);

    gf->AddFrame(h2, fLayoutExpandX);

    fGridStyle = AddLineStyleEntry(gf, kPadGridStyle);

    f->AddFrame(gf, fLayoutExpandXYMargin);


 // TODO Delete the // when the selectColor and selectPattern tooltips are OK.

 //   fGridColor->SetToolTipText("Line color for the grid");

    fPadGridX->SetToolTipText("Show / Hide the grid along X");

    fPadGridY->SetToolTipText("Show / Hide the grid along Y");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the tab 'Histos' to the editor.


 void TStyleManager::CreateTabHistos(TGCompositeFrame *tab)

 {

    fHistosTab = new TGTab(tab, 1, 1);

    fHistosTab->Associate(this);

    CreateTabHistosHistos(fHistosTab->AddTab("Histos"));

    CreateTabHistosFrames(fHistosTab->AddTab("Frames"));

    CreateTabHistosGraphs(fHistosTab->AddTab("Graphs"));

    tab->AddFrame(fHistosTab, fLayoutExpandXY);

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the sub-tab 'Histos' to the tab 'Histos'.


 void TStyleManager::CreateTabHistosHistos(TGCompositeFrame *tab)

 {

    TGHorizontalFrame *h1 = new TGHorizontalFrame(tab);

    fTrashListFrame->AddFirst(h1);

    AddHistosHistosFill(h1);

    AddHistosHistosContours(h1);

    tab->AddFrame(h1, fLayoutExpandX);


    TGHorizontalFrame *h2 = new TGHorizontalFrame(tab);

    fTrashListFrame->AddFirst(h2);

    AddHistosHistosLine(h2);

    AddHistosHistosAxis(h2);

    tab->AddFrame(h2, fLayoutExpandX);


    TGHorizontalFrame *h3 = new TGHorizontalFrame(tab);

    fTrashListFrame->AddFirst(h3);

    AddHistosHistosBar(h3);

    AddHistosHistosLegoInnerR(h3);

    tab->AddFrame(h3, fLayoutExpandX);

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Fill' group frame to the 'Histos - Histos' tab.


 void TStyleManager::AddHistosHistosFill(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Fill");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h1 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h1);

    fHistFillColor = AddColorEntry(h1, kHistFillColor);

    fHistFillStyle = AddFillStyleEntry(h1, kHistFillStyle);

    gf->AddFrame(h1, fLayoutExpandX);

    f->AddFrame(gf, fLayoutExpandXYMargin);


 // TODO Delete the // when the selectColor and selectPattern tooltips are OK.

 //   fHistFillColor->SetToolTipText("Color used to fill histograms");

 //   fHistFillStyle->SetToolTipText("Pattern used to fill histograms");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Line' group frame to the 'Histos - Histos' tab.


 void TStyleManager::AddHistosHistosLine(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Line");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h);

    fHistLineColor = AddColorEntry(h, kHistLineColor);

    fHistLineWidth = AddLineWidthEntry(h, kHistLineWidth);

    gf->AddFrame(h, fLayoutExpandX);

    fHistLineStyle = AddLineStyleEntry(gf, kHistLineStyle);

    f->AddFrame(gf, fLayoutExpandXYMargin);


 // TODO Delete the // when the selectColor and selectPattern tooltips are OK.

 //   fHistLineColor->SetToolTipText("Color used for histograms' lines");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Bar' group frame to the 'Histos - Histos' tab.


 void TStyleManager::AddHistosHistosBar(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Bar");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h);

    fBarWidth = AddNumberEntry(h, 0, 5, 0, kHistBarWidth, "W:",

                         0, 5, TGNumberFormat::kNESRealTwo,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 5);

    fBarOffset = AddNumberEntry(h, 8, 5, 0, kHistBarOffset, "O:",

                         0, 5, TGNumberFormat::kNESRealTwo,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 5);

    gf->AddFrame(h, fLayoutExpandX);

    f->AddFrame(gf, fLayoutExpandXYMargin);


    fBarWidth->GetNumberEntry()->SetToolTipText("Width of bars");

    fBarOffset->GetNumberEntry()->SetToolTipText("Offset of bars");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Contours' group frame to the 'Histos - Histos' tab.


 void TStyleManager::AddHistosHistosContours(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Contours");

    fTrashListFrame->AddFirst(gf);

    fNumberContours = AddNumberEntry(gf, 0, 0, 0, kHistNumberContours, "Number:",

                         0, 5, TGNumberFormat::kNESInteger,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 99);

    f->AddFrame(gf, fLayoutExpandXYMargin);


    fNumberContours->GetNumberEntry()->SetToolTipText("Number of level lines to draw");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Axis' group frame to the 'Histos - Histos' tab.


 void TStyleManager::AddHistosHistosAxis(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Axis");

    fTrashListFrame->AddFirst(gf);

    fHistMinimumZero = AddCheckButton(gf, "Minimum zero", kHistMinimumZero);

    fPaintTextFormat = AddTextEntry(gf, "Paint format:", kHistPaintTextFormat);

    f->AddFrame(gf, fLayoutExpandXYMargin);


    fHistMinimumZero->SetToolTipText("Set to zero / Compute the minimum of axis range");

    fPaintTextFormat->SetToolTipText("Paint format of the axis labels in histograms");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the '3D Cylindrical' group frame to the 'Histos - Histos' tab.


 void TStyleManager::AddHistosHistosLegoInnerR(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "3D Cylindrical (%)");

    fTrashListFrame->AddFirst(gf);

    fLegoInnerR = AddNumberEntry(gf, 0, 0, 0, kHistLegoInnerR, "Inner radius:",

                         0, 5, TGNumberFormat::kNESInteger,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 100);

    f->AddFrame(gf, fLayoutExpandXYMargin);


    fLegoInnerR->GetNumberEntry()->SetToolTipText("Percent of radius allocated to the tube");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the sub-tab 'Frames' to the tab 'Histos'.


 void TStyleManager::CreateTabHistosFrames(TGCompositeFrame *tab)

 {

    TGLayoutHints *layout = new TGLayoutHints(kLHintsExpandX, 10, 10, 0, 13);

    fTrashListLayout->Add(layout);


    TGHorizontalFrame *h1 = new TGHorizontalFrame(tab);

    fTrashListFrame->AddFirst(h1);


    TGVerticalFrame *v1 = new TGVerticalFrame(h1);

    fTrashListFrame->AddFirst(v1);

    AddHistosFramesFill(v1);

    AddHistosFramesLine(v1);

    h1->AddFrame(v1, fLayoutExpandXY);


    TGVerticalFrame *v2 = new TGVerticalFrame(h1);

    fTrashListFrame->AddFirst(v2);

    AddHistosFramesBorder(v2);

    TGHorizontalFrame *h2 = new TGHorizontalFrame(v2);

    fTrashListFrame->AddFirst(h2);

    fPaletteEdit = AddTextButton(h2, "Palette Editor...", kFramePaletteEdit);

    fPaletteEdit->SetEnabled(kFALSE);

    v2->AddFrame(h2, layout);

    h1->AddFrame(v2, fLayoutExpandXY);


    tab->AddFrame(h1, fLayoutExpandX);

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Fill' group frame to the 'Histos - Frames' tab.


 void TStyleManager::AddHistosFramesFill(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Fill");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h1 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h1);

    fFrameFillColor = AddColorEntry(h1, kFrameFillColor);

    fFrameFillStyle = AddFillStyleEntry(h1, kFrameFillStyle);

    gf->AddFrame(h1, fLayoutExpandX);

    f->AddFrame(gf, fLayoutExpandXMargin);


 // TODO Delete the // when the selectColor and selectPattern tooltips are OK.

 //   fFrameFillColor->SetToolTipText("Color used to fill frames");

 //   fFrameFillStyle->SetToolTipText("Pattern used to fill frames");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Line' group frame to the 'Histos - Frames' tab.


 void TStyleManager::AddHistosFramesLine(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Line");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h);

    fFrameLineColor = AddColorEntry(h, kFrameLineColor);

    fFrameLineWidth = AddLineWidthEntry(h, kFrameLineWidth);

    gf->AddFrame(h, fLayoutExpandX);

    fFrameLineStyle = AddLineStyleEntry(gf, kFrameLineStyle);

    f->AddFrame(gf, fLayoutExpandXYMargin);


 // TODO Delete the // when the selectColor and selectPattern tooltips are OK.

 //   fFrameLineColor->SetToolTipText("Color of lines in frames");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Border' group frame to the 'Histos - Frames' tab.


 void TStyleManager::AddHistosFramesBorder(TGCompositeFrame *f)

 {

    fFrameBorderMode = AddBorderModeEntry(f, kFrameBorderModeSunken, kFrameBorderModeNone, kFrameBorderModeRaised);

    fFrameBorderSize = AddLineWidthEntry(fFrameBorderMode, kFrameBorderSize);

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the sub-tab 'Graphs' to the tab 'Histos'.


 void TStyleManager::CreateTabHistosGraphs(TGCompositeFrame *tab)

 {

    TGHorizontalFrame *h = new TGHorizontalFrame(tab);

    fTrashListFrame->AddFirst(h);

    AddHistosGraphsLine(h);

    AddHistosGraphsErrors(h);

    tab->AddFrame(h, fLayoutExpandX);

    AddHistosGraphsBorder(tab);

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Line' group frame to the 'Histos - Graphs' tab.


 void TStyleManager::AddHistosGraphsLine(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Line");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h);

    fFuncColor = AddColorEntry(h, kGraphsFuncColor);

    fFuncWidth = AddLineWidthEntry(h, kGraphsFuncWidth);

    gf->AddFrame(h, fLayoutExpandX);

    fFuncStyle = AddLineStyleEntry(gf, kGraphsFuncStyle);

    f->AddFrame(gf, fLayoutExpandXMargin);


 // TODO Delete the // when the selectColor and selectPattern tooltips are OK.

 //   fFuncColor->SetToolTipText("Color of curves in graphs");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Draw Border' check button to the 'Histos - Graphs' tab.


 void TStyleManager::AddHistosGraphsBorder(TGCompositeFrame *f)

 {

    TGLayoutHints *layout = new TGLayoutHints(kLHintsExpandX, 10, 21, 5, 5);

    fTrashListLayout->Add(layout);


    TGHorizontalFrame *h = new TGHorizontalFrame(f);

    fTrashListFrame->AddFirst(h);

    fDrawBorder = AddCheckButton(h, "Draw Border (for Filled Function)", kGraphsDrawBorder);

    f->AddFrame(h, layout);


    fDrawBorder->SetToolTipText("Show / Hide the border of filled functions");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Errors' group frame to the 'Histos - Graphs' tab.


 void TStyleManager::AddHistosGraphsErrors(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Errors");

    fTrashListFrame->AddFirst(gf);

    fEndErrorSize = AddNumberEntry(gf, 0, 0, 0, kGraphsEndErrorSize,

                         "End error size:", 0, 4, TGNumberFormat::kNESRealOne,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 5);

    fErrorX = AddNumberEntry(gf, 0, 0, 0, kGraphsErrorX, "Error X (% of bin):",

                         0, 4, TGNumberFormat::kNESInteger,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 100);

    f->AddFrame(gf, fLayoutExpandXMargin);


    fEndErrorSize->GetNumberEntry()->SetToolTipText("Size of lines drawn at the end of error bars");

    fErrorX->GetNumberEntry()->SetToolTipText("Percent of the bin width to use for errors along X");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the tab 'Axis' to the editor.


 void TStyleManager::CreateTabAxis(TGCompositeFrame *tab)

 {

    TGLayoutHints *layout =

                   new TGLayoutHints(kLHintsNormal, 10, 13, 3);

    fTrashListLayout->Add(layout);


    TGHorizontalFrame *h = new TGHorizontalFrame(tab);

    fTrashListFrame->AddFirst(h);


    TGVerticalFrame *h3 = new TGVerticalFrame(h);

    fTrashListFrame->AddFirst(h3);

    fStripDecimals = AddCheckButton(h3, "Decimal labels' part", kAxisStripDecimals, 0, 8);

    TGVerticalFrame *space = new TGVerticalFrame(h3);

    fTrashListFrame->AddFirst(space);

    h3->AddFrame(space, fLayoutExpandXY);

    fApplyOnXYZ = AddTextButton(h3, "Apply on XYZ", kAxisApplyOnXYZ);

    h->AddFrame(h3, layout);


    TGGroupFrame *gf = new TGGroupFrame(h, "Date/Time Offset");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h2 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h2);

    fTimeOffsetDate = AddNumberEntry(h2, 0, 13, 10, kAxisTimeOffsetDate, "",

                         0, 10, TGNumberFormat::kNESDayMYear,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELNoLimits, 0, 0);

    fTimeOffsetTime = AddNumberEntry(h2, 0, 15, 0, kAxisTimeOffsetTime, "",

                         0, 8, TGNumberFormat::kNESHourMinSec,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELNoLimits, 0, 0);

    gf->AddFrame(h2, fLayoutExpandX);

    h->AddFrame(gf, fLayoutExpandXMargin);

    tab->AddFrame(h, fLayoutExpandX);


    fAxisTab = new TGTab(tab);

    fAxisTab->Associate(this);

    CreateTabAxisX(fAxisTab->AddTab("X axis"));

    CreateTabAxisY(fAxisTab->AddTab("Y axis"));

    CreateTabAxisZ(fAxisTab->AddTab("Z axis"));

    tab->AddFrame(fAxisTab, fLayoutExpandXY);


    fStripDecimals->SetToolTipText("Draw / Hide the decimal part of labels");

    fApplyOnXYZ->SetToolTipText("Apply settings of the currently selected axis on XYZ");

    fTimeOffsetDate->GetNumberEntry()->SetToolTipText("Date offset for axis (dd/mm/yyyy)");

    fTimeOffsetTime->GetNumberEntry()->SetToolTipText("Time offset for axis (hh/mm/ss)");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the sub-tab 'X Axis' to the tab 'Axis'.


 void TStyleManager::CreateTabAxisX(TGCompositeFrame *tab)

 {

    TGHorizontalFrame *h1 = new TGHorizontalFrame(tab);

    fTrashListFrame->AddFirst(h1);

    AddAxisXLine(h1);

    AddAxisXDivisions(h1);

    tab->AddFrame(h1, fLayoutExpandX);


    TGHorizontalFrame *h2 = new TGHorizontalFrame(tab);

    fTrashListFrame->AddFirst(h2);

    AddAxisXTitle(h2);

    AddAxisXLabels(h2);

    tab->AddFrame(h2, fLayoutExpandX);

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Line' group frame to the 'Axis - X Axis' tab.


 void TStyleManager::AddAxisXLine(TGCompositeFrame *f)

 {

    TGLayoutHints *layout = new TGLayoutHints(kLHintsExpandX, 20);

    fTrashListLayout->Add(layout);


    TGGroupFrame *gf = new TGGroupFrame(f, "Line");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h);

    fXAxisColor = AddColorEntry(h, kAxisXAxisColor);

    TGHorizontalFrame *h2 = new TGHorizontalFrame(h);

    fTrashListFrame->AddFirst(h2);

    fXTickLength = AddNumberEntry(h2, 3, 8, 0, kAxisXTickLength, "Ticks:",

                         0, 5, TGNumberFormat::kNESRealThree,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 5);

    h->AddFrame(h2, layout);

    gf->AddFrame(h, fLayoutExpandX);

    fOptLogx = AddCheckButton(gf, "Logarithmic scale", kAxisOptLogx);

    f->AddFrame(gf, fLayoutExpandXYMargin);


 // TODO Delete the // when the selectColor and selectPattern tooltips are OK.

 //   fXAxisColor->SetToolTipText("Color of axis' line");

    fXTickLength->GetNumberEntry()->SetToolTipText("Set the ticks' length");

    fOptLogx->SetToolTipText("Draw logarithmic scale");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Title' group frame to the 'Axis - X Axis' tab.


 void TStyleManager::AddAxisXTitle(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Title");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h1 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h1);

    fXTitleColor = AddColorEntry(h1, kAxisXTitleColor);

    fXTitleFont = AddFontTypeEntry(h1, kAxisXTitleFont);

    gf->AddFrame(h1, fLayoutExpandX);

    TGHorizontalFrame *h2 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h2);

    fXTitleSizeInPixels = AddCheckButton(h2, "Pixels", kAxisXTitleSizeInPixels);

    fXTitleSize = AddNumberEntry(h2, 21, 8, 0, kAxisXTitleSize, "Size:", 0, 5,

                         TGNumberFormat::kNESRealThree,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 0.3);

    gf->AddFrame(h2, fLayoutExpandX);

    fXTitleOffset = AddNumberEntry(gf, 68, 8, 0, kAxisXTitleOffset, "Offset:",

                         0, 5, TGNumberFormat::kNESRealTwo,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 1);

    f->AddFrame(gf, fLayoutExpandXMargin);


 // TODO Delete the // when the selectColor and selectPattern tooltips are OK.

 //   fXTitleColor->SetToolTipText("Color of axis' title");

    fXTitleSizeInPixels->SetToolTipText("Set the title size in pixels if selected, otherwise - in % of pad");

    fXTitleSize->GetNumberEntry()->SetToolTipText("Title size (in pixels or in % of pad)");

    fXTitleOffset->GetNumberEntry()->SetToolTipText("Offset between axis and title");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Divisions' group frame to the 'Axis - X Axis' tab.


 void TStyleManager::AddAxisXDivisions(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Divisions");

    fTrashListFrame->AddFirst(gf);


    TGHorizontalFrame *h1 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h1);

    fXNdivSubSub = AddNumberEntry(h1, 0, 0, 0, kAxisXNdivSubSub, "",

                         0, 3, TGNumberFormat::kNESInteger,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 99);

    fXNdivSub = AddNumberEntry(h1, 0, 18, 0, kAxisXNdivSub, "",

                         0, 3, TGNumberFormat::kNESInteger,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 99);

    fXNdivMain = AddNumberEntry(h1, 0, 18, 0, kAxisXNdivMain, "",

                         0, 3, TGNumberFormat::kNESInteger,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 99);

    gf->AddFrame(h1, fLayoutExpandX);


    TGHorizontalFrame *h2 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h2);

    fXNdivisionsOptimize = AddCheckButton(h2, "Optimize", kAxisXNdivisionsOptimize);

    gf->AddFrame(h2, fLayoutExpandX);

    f->AddFrame(gf, fLayoutExpandXMargin);


    fXNdivMain->GetNumberEntry()->SetToolTipText("Primary axis divisions");

    fXNdivSub->GetNumberEntry()->SetToolTipText("Secondary axis divisions");

    fXNdivSubSub->GetNumberEntry()->SetToolTipText("Tertiary axis divisions");

    fXNdivisionsOptimize->SetToolTipText("Optimize the number of axis divisions if selected");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Labels' group frame to the 'Axis - X Axis' tab.


 void TStyleManager::AddAxisXLabels(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Labels");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h1 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h1);

    fXLabelColor = AddColorEntry(h1, kAxisXLabelColor);

    fXLabelFont = AddFontTypeEntry(h1, kAxisXLabelFont);

    gf->AddFrame(h1, fLayoutExpandX);

    TGHorizontalFrame *h2 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h2);

    fXLabelSizeInPixels = AddCheckButton(h2, "Pixels", kAxisXLabelSizeInPixels);

    fXLabelSize = AddNumberEntry(h2, 22, 8, 0, kAxisXLabelSize, "Size:", 0, 5,

                         TGNumberFormat::kNESRealThree,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 0.3);

    gf->AddFrame(h2, fLayoutExpandX);

    fXLabelOffset = AddNumberEntry(gf, 69, 8, 0, kAxisXTitleOffset, "Offset:",

                         0, 5, TGNumberFormat::kNESRealTwo,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 1);

    f->AddFrame(gf, fLayoutExpandXMargin);


 // TODO Delete the // when the selectColor and selectPattern tooltips are OK.

 //   fXLabelColor->SetToolTipText("Color of axis' labels");

    fXLabelSizeInPixels->SetToolTipText("Set the labels size in pixels if selected, otherwise - in % of pad");

    fXLabelSize->GetNumberEntry()->SetToolTipText("Label size (in pixels or in % of pad)");

    fXLabelOffset->GetNumberEntry()->SetToolTipText("Offset between axis and labels");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the sub-tab 'Y Axis' to the tab 'Axis'.


 void TStyleManager::CreateTabAxisY(TGCompositeFrame *tab)

 {

    TGHorizontalFrame *h1 = new TGHorizontalFrame(tab);

    fTrashListFrame->AddFirst(h1);

    AddAxisYLine(h1);

    AddAxisYDivisions(h1);

    tab->AddFrame(h1, fLayoutExpandX);


    TGHorizontalFrame *h2 = new TGHorizontalFrame(tab);

    fTrashListFrame->AddFirst(h2);

    AddAxisYTitle(h2);

    AddAxisYLabels(h2);

    tab->AddFrame(h2, fLayoutExpandX);

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Line' group frame to the 'Axis - Y Axis' tab.


 void TStyleManager::AddAxisYLine(TGCompositeFrame *f)

 {

    TGLayoutHints *layout = new TGLayoutHints(kLHintsExpandX, 20);

    fTrashListLayout->Add(layout);


    TGGroupFrame *gf = new TGGroupFrame(f, "Line");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h);

    fYAxisColor = AddColorEntry(h, kAxisYAxisColor);

    TGHorizontalFrame *h2 = new TGHorizontalFrame(h);

    fTrashListFrame->AddFirst(h2);

    fYTickLength = AddNumberEntry(h2, 3, 8, 0, kAxisYTickLength, "Ticks:",

                         0, 5, TGNumberFormat::kNESRealThree,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 5);

    h->AddFrame(h2, layout);

    gf->AddFrame(h, fLayoutExpandX);

    fOptLogy = AddCheckButton(gf, "Logarithmic scale", kAxisOptLogy);

    f->AddFrame(gf, fLayoutExpandXYMargin);


 // TODO Delete the // when the selectColor and selectPattern tooltips are OK.

 //   fYAxisColor->SetToolTipText("Color of axis' line");

    fYTickLength->GetNumberEntry()->SetToolTipText("Set the ticks' length");

    fOptLogy->SetToolTipText("Draw logarithmic scale");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Title' group frame to the 'Axis - Y Axis' tab.


 void TStyleManager::AddAxisYTitle(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Title");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h1 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h1);

    fYTitleColor = AddColorEntry(h1, kAxisYTitleColor);

    fYTitleFont = AddFontTypeEntry(h1, kAxisYTitleFont);

    gf->AddFrame(h1, fLayoutExpandX);

    TGHorizontalFrame *h2 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h2);

    fYTitleSizeInPixels = AddCheckButton(h2, "Pixels", kAxisYTitleSizeInPixels);

    fYTitleSize = AddNumberEntry(h2, 21, 8, 0, kAxisYTitleSize, "Size:", 0, 5,

                         TGNumberFormat::kNESRealThree,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 0.3);

    gf->AddFrame(h2, fLayoutExpandX);

    fYTitleOffset = AddNumberEntry(gf, 68, 8, 0, kAxisYTitleOffset, "Offset:",

                         0, 5, TGNumberFormat::kNESRealTwo,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 1);

    f->AddFrame(gf, fLayoutExpandXMargin);


 // TODO Delete the // when the selectColor and selectPattern tooltips are OK.

 //   fYTitleColor->SetToolTipText("Color of axis' title");

    fYTitleSizeInPixels->SetToolTipText("Set the title size in pixels if selected, otherwise - in % of pad");

    fYTitleSize->GetNumberEntry()->SetToolTipText("Title size (in pixels or in % of pad)");

    fYTitleOffset->GetNumberEntry()->SetToolTipText("Offset between axis and title");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Divisions' group frame to the 'Axis - Y Axis' tab.


 void TStyleManager::AddAxisYDivisions(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Divisions");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h1 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h1);

    fYNdivSubSub = AddNumberEntry(h1, 0, 0, 0, kAxisYNdivSubSub, "",

                         0, 3, TGNumberFormat::kNESInteger,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 99);

    fYNdivSub = AddNumberEntry(h1, 0, 18, 0, kAxisYNdivSub, "",

                         0, 3, TGNumberFormat::kNESInteger,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 99);

    fYNdivMain = AddNumberEntry(h1, 0, 18, 0, kAxisYNdivMain, "",

                         0, 3, TGNumberFormat::kNESInteger,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 99);

    gf->AddFrame(h1, fLayoutExpandX);


    TGHorizontalFrame *h2 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h2);

    fYNdivisionsOptimize = AddCheckButton(h2, "Optimize", kAxisYNdivisionsOptimize);

    gf->AddFrame(h2, fLayoutExpandX);

    f->AddFrame(gf, fLayoutExpandXMargin);


    fYNdivMain->GetNumberEntry()->SetToolTipText("Primary axis divisions");

    fYNdivSub->GetNumberEntry()->SetToolTipText("Secondary axis divisions");

    fYNdivSubSub->GetNumberEntry()->SetToolTipText("Tertiary axis divisions");

    fYNdivisionsOptimize->SetToolTipText("Optimize the number of axis divisions");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Labels' group frame to the 'Axis - Y Axis' tab.


 void TStyleManager::AddAxisYLabels(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Labels");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h1 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h1);

    fYLabelColor = AddColorEntry(h1, kAxisYLabelColor);

    fYLabelFont = AddFontTypeEntry(h1, kAxisYLabelFont);

    gf->AddFrame(h1, fLayoutExpandX);


    TGHorizontalFrame *h2 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h2);

    fYLabelSizeInPixels = AddCheckButton(h2, "Pixels", kAxisYLabelSizeInPixels);

    fYLabelSize = AddNumberEntry(h2, 22, 8, 0, kAxisYLabelSize, "Size:", 0, 5,

                         TGNumberFormat::kNESRealThree,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 0.3);

    gf->AddFrame(h2, fLayoutExpandX);

    fYLabelOffset = AddNumberEntry(gf, 69, 8, 0, kAxisYTitleOffset, "Offset:",

                         0, 5, TGNumberFormat::kNESRealTwo,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 1);

    f->AddFrame(gf, fLayoutExpandXMargin);


 // TODO Delete the // when the selectColor and selectPattern tooltips are OK.

 //   fYLabelColor->SetToolTipText("Color of axis' labels");

    fYLabelSizeInPixels->SetToolTipText("Set the labels size in pixels if selected, otherwise - in % of pad");

    fYLabelSize->GetNumberEntry()->SetToolTipText("Label size (in pixels or in % of pad)");

    fYLabelOffset->GetNumberEntry()->SetToolTipText("Offset between axis and labels");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the sub-tab 'Z Axis' to the tab 'Axis'.


 void TStyleManager::CreateTabAxisZ(TGCompositeFrame *tab)

 {

    TGHorizontalFrame *h1 = new TGHorizontalFrame(tab);

    fTrashListFrame->AddFirst(h1);

    AddAxisZLine(h1);

    AddAxisZDivisions(h1);

    tab->AddFrame(h1, fLayoutExpandX);


    TGHorizontalFrame *h2 = new TGHorizontalFrame(tab);

    fTrashListFrame->AddFirst(h2);

    AddAxisZTitle(h2);

    AddAxisZLabels(h2);

    tab->AddFrame(h2, fLayoutExpandX);

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Line' group frame to the 'Axis - Z Axis' tab.


 void TStyleManager::AddAxisZLine(TGCompositeFrame *f)

 {

    TGLayoutHints *layout = new TGLayoutHints(kLHintsExpandX, 20);

    fTrashListLayout->Add(layout);


    TGGroupFrame *gf = new TGGroupFrame(f, "Line");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h);

    fZAxisColor = AddColorEntry(h, kAxisZAxisColor);

    TGHorizontalFrame *h2 = new TGHorizontalFrame(h);

    fTrashListFrame->AddFirst(h2);

    fZTickLength = AddNumberEntry(h2, 3, 8, 0, kAxisZTickLength, "Ticks:",

                         0, 5, TGNumberFormat::kNESRealThree,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 5);

    h->AddFrame(h2, layout);

    gf->AddFrame(h, fLayoutExpandX);

    fOptLogz = AddCheckButton(gf, "Logarithmic scale", kAxisOptLogz);

    f->AddFrame(gf, fLayoutExpandXYMargin);


 // TODO Delete the // when the selectColor and selectPattern tooltips are OK.

 //   fZAxisColor->SetToolTipText("Color of axis' line");

    fZTickLength->GetNumberEntry()->SetToolTipText("Set the ticks' length");

    fOptLogz->SetToolTipText("Draw logarithmic scale");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Title' group frame to the 'Axis - Z Axis' tab.


 void TStyleManager::AddAxisZTitle(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Title");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h1 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h1);

    fZTitleColor = AddColorEntry(h1, kAxisZTitleColor);

    fZTitleFont = AddFontTypeEntry(h1, kAxisZTitleFont);

    gf->AddFrame(h1, fLayoutExpandX);


    TGHorizontalFrame *h2 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h2);

    fZTitleSizeInPixels = AddCheckButton(h2, "Pixels", kAxisZTitleSizeInPixels);

    fZTitleSize = AddNumberEntry(h2, 21, 8, 0, kAxisZTitleSize, "Size:", 0, 5,

                         TGNumberFormat::kNESRealThree,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 0.3);

    gf->AddFrame(h2, fLayoutExpandX);

    fZTitleOffset = AddNumberEntry(gf, 68, 8, 0, kAxisZTitleOffset, "Offset:",

                         0, 5, TGNumberFormat::kNESRealTwo,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 1);

    f->AddFrame(gf, fLayoutExpandXMargin);


 // TODO Delete the // when the selectColor and selectPattern tooltips are OK.

 //   fZTitleColor->SetToolTipText("Color of axis' title");

    fZTitleSizeInPixels->SetToolTipText("Set the title size in pixels if selected, otherwise - in % of pad");

    fZTitleSize->GetNumberEntry()->SetToolTipText("Title size (in pixels or in % of pad)");

    fZTitleOffset->GetNumberEntry()->SetToolTipText("Offset between axis and title");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Divisions' group frame to the 'Axis - Z Axis' tab.


 void TStyleManager::AddAxisZDivisions(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Divisions");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h1 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h1);

    fZNdivSubSub = AddNumberEntry(h1, 0, 0, 0, kAxisZNdivSubSub, "",

                         0, 3, TGNumberFormat::kNESInteger,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 99);

    fZNdivSub = AddNumberEntry(h1, 0, 18, 0, kAxisZNdivSub, "",

                         0, 3, TGNumberFormat::kNESInteger,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 99);

    fZNdivMain = AddNumberEntry(h1, 0, 18, 0, kAxisZNdivMain, "",

                         0, 3, TGNumberFormat::kNESInteger,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 99);

    gf->AddFrame(h1, fLayoutExpandX);


    TGHorizontalFrame *h2 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h2);

    fZNdivisionsOptimize = AddCheckButton(h2, "Optimize", kAxisZNdivisionsOptimize);

    gf->AddFrame(h2, fLayoutExpandX);

    f->AddFrame(gf, fLayoutExpandXMargin);


    fZNdivMain->GetNumberEntry()->SetToolTipText("Primary axis divisions");

    fZNdivSub->GetNumberEntry()->SetToolTipText("Secondary axis divisions");

    fZNdivSubSub->GetNumberEntry()->SetToolTipText("Tertiary axis divisions");

    fZNdivisionsOptimize->SetToolTipText("Optimize the number of axis divisions");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Labels' group frame to the 'Axis - Z Axis' tab.


 void TStyleManager::AddAxisZLabels(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Labels");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h1 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h1);

    fZLabelColor = AddColorEntry(h1, kAxisZLabelColor);

    fZLabelFont = AddFontTypeEntry(h1, kAxisZLabelFont);

    gf->AddFrame(h1, fLayoutExpandX);


    TGHorizontalFrame *h2 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h2);

    fZLabelSizeInPixels = AddCheckButton(h2, "Pixels", kAxisZLabelSizeInPixels);

    fZLabelSize = AddNumberEntry(h2, 22, 8, 0, kAxisZLabelSize, "Size:", 0, 5,

                         TGNumberFormat::kNESRealThree,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 0.3);

    gf->AddFrame(h2, fLayoutExpandX);

    fZLabelOffset = AddNumberEntry(gf, 69, 8, 0, kAxisZTitleOffset, "Offset:",

                         0, 5, TGNumberFormat::kNESRealTwo,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 1);

    f->AddFrame(gf, fLayoutExpandXMargin);


 // TODO Delete the // when the selectColor and selectPattern tooltips are OK.

 //   fZLabelColor->SetToolTipText("Color of axis' labels");

    fZLabelSizeInPixels->SetToolTipText("Set the labels size in pixels if selected, otherwise - in % of pad");

    fZLabelSize->GetNumberEntry()->SetToolTipText("Label size (in pixels or in % of pad)");

    fZLabelOffset->GetNumberEntry()->SetToolTipText("Offset between axis and labels");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the tab 'Title' to the editor.


 void TStyleManager::CreateTabTitle(TGCompositeFrame *tab)

 {

    TGLayoutHints *layout = new TGLayoutHints(kLHintsExpandX, 10, 20, 5, 5);

    fTrashListLayout->Add(layout);


    TGHorizontalFrame *h1 = new TGHorizontalFrame(tab);

    fTrashListFrame->AddFirst(h1);

    fOptTitle = AddCheckButton(h1, "Show title", kTitleOptTitle);

    tab->AddFrame(h1, layout);


    TGHorizontalFrame *h2 = new TGHorizontalFrame(tab);

    fTrashListFrame->AddFirst(h2);

    TGVerticalFrame *v1 = new TGVerticalFrame(h2);

    fTrashListFrame->AddFirst(v1);

    AddTitleFill(v1);

    AddTitleText(v1);

    h2->AddFrame(v1, fLayoutExpandXY);

    TGVerticalFrame *v2 = new TGVerticalFrame(h2);

    fTrashListFrame->AddFirst(v2);

    AddTitleBorderSize(v2);

    AddTitleGeometry(v2);

    h2->AddFrame(v2, fLayoutExpandXY);

    tab->AddFrame(h2, fLayoutExpandX);


    fOptTitle->SetToolTipText("Show / Hide the title pave");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Fill' group frame to the 'Title' tab.


 void TStyleManager::AddTitleFill(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Fill");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h1 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h1);

    fTitleColor = AddColorEntry(h1, kTitleFillColor);

    fTitleStyle = AddFillStyleEntry(h1, kTitleStyle);

    gf->AddFrame(h1, fLayoutExpandX);

    f->AddFrame(gf, fLayoutExpandXMargin);


 // TODO Delete the // when the selectColor and selectPattern tooltips are OK.

 //   fTitleColor->SetToolTipText("Color used to fill the title pave");

 //   fTitleStyle->SetToolTipText("Pattern used to fill the title pave");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Shadow' group frame to the 'Title' tab.


 void TStyleManager::AddTitleBorderSize(TGCompositeFrame *f)

 {

    TGLayoutHints *layout1 = new TGLayoutHints(kLHintsNormal, 0, 24, 6);

    fTrashListLayout->Add(layout1);

    TGLayoutHints *layout2 = new TGLayoutHints(kLHintsNormal, 0, 5, 6);

    fTrashListLayout->Add(layout2);

    TGLayoutHints *layout3 = new TGLayoutHints(kLHintsExpandX, 0, 0, 3, 3);

    fTrashListLayout->Add(layout3);


    TGGroupFrame *gf = new TGGroupFrame(f, "Shadow");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h1 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h1);

    fTitleBorderSizeLabel = new TGLabel(h1, "Title's:");

    h1->AddFrame(fTitleBorderSizeLabel, layout1);

    fTitleBorderSize = AddLineWidthEntry(h1, kTitleBorderSize);

    gf->AddFrame(h1, layout3);


    TGHorizontalFrame *h2 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h2);

    fLegendBorderSizeLabel = new TGLabel(h2, "Legend's:");

    h2->AddFrame(fLegendBorderSizeLabel, layout2);

    fLegendBorderSize = AddLineWidthEntry(h2, kTitleLegendBorderSize);

    gf->AddFrame(h2, layout3);

    f->AddFrame(gf, fLayoutExpandXMargin);

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Text' group frame to the 'Title' tab.


 void TStyleManager::AddTitleText(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Text");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h1 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h1);

    fTitleTextColor = AddColorEntry(h1, kTitleTextColor);

    fTitleFont = AddFontTypeEntry(h1, kTitleFont);

    gf->AddFrame(h1, fLayoutExpandX);

    fTitleAlign = AddTextAlignEntry(gf, kTitleAlign);

    TGHorizontalFrame *h2 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h2);

    fTitleFontSizeInPixels = AddCheckButton(h2, "Pixels", kTitleFontSizeInPixels);

    fTitleFontSize = AddNumberEntry(h2, 21, 10, 0, kTitleFontSize, "Size:", 0, 5,

                         TGNumberFormat::kNESRealThree,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 0.3);

    gf->AddFrame(h2, fLayoutExpandX);

    f->AddFrame(gf, fLayoutExpandXYMargin);


 // TODO Delete the // when the selectColor and selectPattern tooltips are OK.

 //   fTitleTextColor->SetToolTipText("Color of the title's text");

    fTitleFontSizeInPixels->SetToolTipText("Set the title's text size in pixels if selected, otherwise - in % of pad");

    fTitleFontSize->GetNumberEntry()->SetToolTipText("Title's text size (in pixels or in % of pad)");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Geometry' group frame to the 'Title' tab.


 void TStyleManager::AddTitleGeometry(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Geometry (% of Pad)");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h1 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h1);

    fTitleX = AddNumberEntry(h1, 0, 8, 0, kTitleX, "X:",

                         0, 4, TGNumberFormat::kNESInteger,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 100);

    fTitleY = AddNumberEntry(h1, 8, 8, 0, kTitleY, "Y:",

                            0, 4, TGNumberFormat::kNESInteger,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 100);

    gf->AddFrame(h1, fLayoutExpandXY);

    TGHorizontalFrame *h2 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h2);

    fTitleW = AddNumberEntry(h2, 0, 6, 0, kTitleW, "W:",

                         0, 4, TGNumberFormat::kNESInteger,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 100);

    fTitleH = AddNumberEntry(h2, 8, 8, 0, kTitleH, "H:",

                         0, 4, TGNumberFormat::kNESInteger,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 100);

    gf->AddFrame(h2, fLayoutExpandXY);

    f->AddFrame(gf, fLayoutExpandXYMargin);


    fTitleX->GetNumberEntry()->SetToolTipText("Title' default abscissa");

    fTitleY->GetNumberEntry()->SetToolTipText("Title' default ordinate");

    fTitleW->GetNumberEntry()->SetToolTipText("Title' default width");

    fTitleH->GetNumberEntry()->SetToolTipText("Title' default height");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the tab 'Stats' to the editor.


 void TStyleManager::CreateTabStats(TGCompositeFrame *tab)

 {

    TGLayoutHints *layout1 = new TGLayoutHints(kLHintsNormal, 0, 5, 6);

    fTrashListLayout->Add(layout1);

    TGLayoutHints *layout2 = new TGLayoutHints(kLHintsExpandX, 10, 21, 5, 5);

    fTrashListLayout->Add(layout2);


    TGHorizontalFrame *h1 = new TGHorizontalFrame(tab);

    fTrashListFrame->AddFirst(h1);


    TGVerticalFrame *v1 = new TGVerticalFrame(h1);

    fTrashListFrame->AddFirst(v1);

    AddStatsFill(v1);

    TGHorizontalFrame *h2 = new TGHorizontalFrame(v1);

    fTrashListFrame->AddFirst(h2);

    fStatBorderSizeLabel = new TGLabel(h2, "Stats' shadow:");

    h2->AddFrame(fStatBorderSizeLabel, layout1);

    fStatBorderSize = AddLineWidthEntry(h2, kStatBorderSize);

    v1->AddFrame(h2, layout2);

    AddStatsText(v1);

    AddStatsGeometry(v1);

    h1->AddFrame(v1, fLayoutExpandXY);


    TGVerticalFrame *v2 = new TGVerticalFrame(h1);

    fTrashListFrame->AddFirst(v2);

    AddStatsStats(v2);

    AddStatsFit(v2);

    h1->AddFrame(v2, fLayoutExpandXY);


    tab->AddFrame(h1, fLayoutExpandX);

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Fill' group frame to the 'Stats' tab.


 void TStyleManager::AddStatsFill(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Fill");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h);

    fStatColor = AddColorEntry(h, kStatColor);

    fStatStyle = AddFillStyleEntry(h, kStatStyle);

    gf->AddFrame(h, fLayoutExpandX);

    f->AddFrame(gf, fLayoutExpandXMargin);


 // TODO Delete the // when the selectColor and selectPattern tooltips are OK.

 //   fStatColor->SetToolTipText("Color used to fill the stats pave");

 //   fStatStyle->SetToolTipText("Pattern used to fill the stats pave");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Text' group frame to the 'Stats' tab.


 void TStyleManager::AddStatsText(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Text");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h1 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h1);

    fStatTextColor = AddColorEntry(h1, kStatTextColor);

    fStatFont = AddFontTypeEntry(h1, kStatFont);

    gf->AddFrame(h1, fLayoutExpandX);

    TGHorizontalFrame *h2 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h2);

    fStatFontSizeInPixels = AddCheckButton(h2, "Pixels", kStatFontSizeInPixels);

    fStatFontSize = AddNumberEntry(h2, 21, 10, 0, kStatFontSize, "Size:", 0, 5,

                         TGNumberFormat::kNESRealThree,

                         TGNumberFormat::kNEAAnyNumber,

                         TGNumberFormat::kNELLimitMinMax, 0, 0.3);

    gf->AddFrame(h2, fLayoutExpandX);

    f->AddFrame(gf, fLayoutExpandXYMargin);


 // TODO Delete the // when the selectColor and selectPattern tooltips are OK.

 //   fStatTextColor->SetToolTipText("Color of the stats's text");

    fStatFontSizeInPixels->SetToolTipText("Set the stats's text size in pixels if selected, otherwise - in % of pad");

    fStatFontSize->GetNumberEntry()->SetToolTipText("Stats's text size (in pixels or in % of pad)");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Geometry' group frame to the 'Stats' tab.


 void TStyleManager::AddStatsGeometry(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Geometry");

    fTrashListFrame->AddFirst(gf);


    TGHorizontalFrame *h1 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h1);

    fStatX = AddNumberEntry(h1, 0, 7, 0, kStatX, "X:",

                         0., 4, TGNumberFormat::kNESRealTwo,

                         TGNumberFormat::kNEANonNegative,

                         TGNumberFormat::kNELLimitMinMax, 0., 1.);

    fStatY = AddNumberEntry(h1, 8, 7, 0, kStatY, "Y:",

                         0., 4, TGNumberFormat::kNESRealTwo,

                         TGNumberFormat::kNEANonNegative,

                         TGNumberFormat::kNELLimitMinMax, 0., 1.);

    gf->AddFrame(h1, fLayoutExpandXY);


    TGHorizontalFrame *h2 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h2);

    fStatW = AddNumberEntry(h2, 0, 5, 0, kStatW, "W:",

                         0., 4, TGNumberFormat::kNESRealTwo,

                         TGNumberFormat::kNEANonNegative,

                         TGNumberFormat::kNELLimitMinMax, 0., 1.);

    fStatH = AddNumberEntry(h2, 8, 7, 0, kStatH, "H:",

                         0., 4, TGNumberFormat::kNESRealTwo,

                         TGNumberFormat::kNEANonNegative,

                         TGNumberFormat::kNELLimitMinMax, 0., 1.);

    gf->AddFrame(h2, fLayoutExpandXY);

    f->AddFrame(gf, fLayoutExpandXYMargin);


    fStatX->GetNumberEntry()->SetToolTipText("X position of top right corner of stat box.");

    fStatY->GetNumberEntry()->SetToolTipText("Y position of top right corner of stat box.");

    fStatW->GetNumberEntry()->SetToolTipText("Width of stat box.");

    fStatH->GetNumberEntry()->SetToolTipText("Height of stat box.");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Stat Options' group frame to the 'Stats' tab.


 void TStyleManager::AddStatsStats(TGCompositeFrame *f)

 {

    TGLayoutHints *layout = new TGLayoutHints(kLHintsNormal, 0, 0, 5);

    fTrashListLayout->Add(layout);


    TGGroupFrame *gf = new TGGroupFrame(f, "Stat Options");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h);

    TGVerticalFrame *v1 = new TGVerticalFrame(h);

    fTrashListFrame->AddFirst(v1);

    fOptStatName = AddCheckButton(v1, "Name", kStatOptStatName);

    fOptStatOverflow = AddCheckButton(v1, "Overflow", kStatOptStatOverflow);

    fOptStatUnderflow = AddCheckButton(v1, "Underflow", kStatOptStatUnderflow);

    fOptStatSkewness = AddCheckButton(v1, "Skewness", kStatOptStatSkewness);

    fOptStatKurtosis = AddCheckButton(v1, "Kurtosis", kStatOptStatKurtosis);

    h->AddFrame(v1, fLayoutExpandXY);

    TGVerticalFrame *v2 = new TGVerticalFrame(h);

    fTrashListFrame->AddFirst(v2);

    fOptStatEntries = AddCheckButton(v2, "Entries", kStatOptStatEntries);

    fOptStatMean = AddCheckButton(v2, "Mean", kStatOptStatMean);

    fOptStatRMS = AddCheckButton(v2, "RMS", kStatOptStatRMS);

    fOptStatIntegral = AddCheckButton(v2, "Integral", kStatOptStatIntegral);

    fOptStatErrors = AddCheckButton(v2, "Errors", kStatOptStatErrors);

    h->AddFrame(v2, fLayoutExpandXY);

    gf->AddFrame(h, fLayoutExpandX);


    TGHorizontalFrame *h2 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h2);

    TGHorizontalFrame *h3 = new TGHorizontalFrame(h2);

    fTrashListFrame->AddFirst(h3);

    fStatFormatLabel = new TGLabel(h3, "Paint format:");

    h3->AddFrame(fStatFormatLabel, layout);

    h2->AddFrame(h3, fLayoutExpandX);

    fStatFormat = AddTextEntry(h2, "", kStatFormat);

    gf->AddFrame(h2, fLayoutExpandX);

    f->AddFrame(gf, fLayoutExpandXYMargin);


    fOptStatName->SetToolTipText("Show / Hide the histogram name");

    fOptStatOverflow->SetToolTipText("Show / Hide the number of overflows");

    fOptStatUnderflow->SetToolTipText("Show / Hide the number of underflows");

    fOptStatSkewness->SetToolTipText("Show / Hide the skewness");

    fOptStatKurtosis->SetToolTipText("Show / Hide the kurtosis");

    fOptStatEntries->SetToolTipText("Show / Hide the number of entries");

    fOptStatMean->SetToolTipText("Show / Hide the mean value");

    fOptStatRMS->SetToolTipText("Show / Hide root-mean-square (RMS)");

    fOptStatIntegral->SetToolTipText("Show / Hide the integral of bins");

    fOptStatErrors->SetToolTipText("Show / Hide the errors");

    fStatFormat->SetToolTipText("Paint format of stat options");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Fit Options' group frame to the 'Stats' tab.


 void TStyleManager::AddStatsFit(TGCompositeFrame *f)

 {

    TGLayoutHints *layout = new TGLayoutHints(kLHintsNormal, 0, 0, 5);

    fTrashListLayout->Add(layout);


    TGGroupFrame *gf = new TGGroupFrame(f, "Fit Options");

    fTrashListFrame->AddFirst(gf);

    TGHorizontalFrame *h = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h);

    TGVerticalFrame *v1 = new TGVerticalFrame(h);

    fTrashListFrame->AddFirst(v1);

    fOptFitValues = AddCheckButton(v1, "Values", kStatOptFitValues);

    fOptFitProbability = AddCheckButton(v1, "Probability",

                                        kStatOptFitProbability);

    h->AddFrame(v1, fLayoutExpandXY);

    TGVerticalFrame *v2 = new TGVerticalFrame(h);

    fTrashListFrame->AddFirst(v2);

    fOptFitErrors = AddCheckButton(v2, "Errors", kStatOptFitErrors);

    fOptFitChi = AddCheckButton(v2, "Chi", kStatOptFitChi);

    h->AddFrame(v2, fLayoutExpandXY);

    gf->AddFrame(h, fLayoutExpandX);

    TGHorizontalFrame *h2 = new TGHorizontalFrame(gf);

    fTrashListFrame->AddFirst(h2);

    TGHorizontalFrame *h3 = new TGHorizontalFrame(h2);

    fTrashListFrame->AddFirst(h3);

    fFitFormatLabel = new TGLabel(h3, "Paint format:");

    h3->AddFrame(fFitFormatLabel, layout);

    h2->AddFrame(h3, fLayoutExpandX);

    fFitFormat = AddTextEntry(h2, "", kStatFitFormat);

    gf->AddFrame(h2, fLayoutExpandX);

    f->AddFrame(gf, fLayoutExpandXMargin);


    fOptFitValues->SetToolTipText("Show / Hide the parameter name and value");

    fOptFitProbability->SetToolTipText("Show / Hide probability)");

    fOptFitErrors->SetToolTipText("Show / Hide the errors");

    fOptFitChi->SetToolTipText("Show / Hide Chisquare");

    fFitFormat->SetToolTipText("Paint format of fit options");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the tab 'PS / PDF' to the editor.


 void TStyleManager::CreateTabPsPdf(TGCompositeFrame *tab)

 {

    AddPsPdfHeader(tab);

    AddPsPdfTitle(tab);

    TGHorizontalFrame *h = new TGHorizontalFrame(tab);

    fTrashListFrame->AddFirst(h);

    AddPsPdfPaperSize(h);

    TGVerticalFrame *v = new TGVerticalFrame(h);

    fTrashListFrame->AddFirst(v);

    AddPsPdfLineScale(v);

    AddPsPdfColorModel(v);

    h->AddFrame(v, fLayoutExpandXY);

    tab->AddFrame(h, fLayoutExpandX);

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Header' group frame to the 'PS / PDF' tab.


 void TStyleManager::AddPsPdfHeader(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Header");

    fTrashListFrame->AddFirst(gf);

    fHeaderPS = AddTextEntry(gf, "", kPSPDFHeaderPS);

    f->AddFrame(gf, fLayoutExpandXMargin);


    fHeaderPS->SetToolTipText("PostScript header");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Title' group frame to the 'PS / PDF' tab.


 void TStyleManager::AddPsPdfTitle(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Title");

    fTrashListFrame->AddFirst(gf);

    fTitlePS = AddTextEntry(gf, "", kPSPDFTitlePS);

    f->AddFrame(gf, fLayoutExpandXMargin);


    fTitlePS->SetToolTipText("PostScript title");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Color Model' group frame to the 'PS / PDF' tab.


 void TStyleManager::AddPsPdfColorModel(TGCompositeFrame *f)

 {

    fColorModelPS = new TGButtonGroup(f, "Color Model",

                                     kChildFrame | kHorizontalFrame | kFitWidth);


    fColorModelPS->SetLayoutManager(new TGMatrixLayout(fColorModelPS, 1, 2, 15));

    fColorModelPSRGB = new TGRadioButton(fColorModelPS, "RGB",

                                           kPSPDFColorModelPSRGB);

    fColorModelPSRGB->Associate(this);

    fColorModelPSCMYK = new TGRadioButton(fColorModelPS, "CMYK",

                                           kPSPDFColorModelPSCMYK);

    fColorModelPSCMYK->Associate(this);

    fColorModelPS->Show();

    TGLayoutHints *layout2 =

                 new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 5, 5, 5, 12);

    fTrashListLayout->Add(layout2);

    f->AddFrame(fColorModelPS, layout2);

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Paper Size' group frame to the 'PS / PDF' tab.


 void TStyleManager::AddPsPdfPaperSize(TGCompositeFrame *f)

 {

    TGGroupFrame *gf = new TGGroupFrame(f, "Paper Size");

    fTrashListFrame->AddFirst(gf);

    fPaperSizePredef = AddPaperSizeEntry(gf, kPSPDFPaperSizePredef);

    fPaperSizeX = AddNumberEntry(gf, 0, 0, 0, kPSPDFPaperSizeX, "Width:",

                         0, 6, TGNumberFormat::kNESRealOne,

                         TGNumberFormat::kNEAPositive,

                         TGNumberFormat::kNELLimitMinMax, 1, 40);

    fPaperSizeY = AddNumberEntry(gf, 0, 0, 0, kPSPDFPaperSizeY, "Height:",

                         0, 6, TGNumberFormat::kNESRealOne,

                         TGNumberFormat::kNEAPositive,

                         TGNumberFormat::kNELLimitMinMax, 1, 40);

    f->AddFrame(gf, fLayoutExpandXMargin);


    fPaperSizeX->GetNumberEntry()->SetToolTipText("Width of the printing area");

    fPaperSizeY->GetNumberEntry()->SetToolTipText("Height of the printing area");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add the 'Line scale' number entry to the 'PS / PDF' tab.


 void TStyleManager::AddPsPdfLineScale(TGCompositeFrame *f)

 {

    TGLayoutHints *layout = new TGLayoutHints(kLHintsExpandX, 10, 20, 5, 5);

    fTrashListLayout->Add(layout);


    TGHorizontalFrame *gf = new TGHorizontalFrame(f);

    fTrashListFrame->AddFirst(gf);

    fLineScalePS = AddNumberEntry(gf, 0, 0, 0, kPSPDFLineScalePS, "Line scale:",

                         0, 6, TGNumberFormat::kNESRealOne,

                         TGNumberFormat::kNEAPositive,

                         TGNumberFormat::kNELLimitMinMax, 0.1, 10);

    f->AddFrame(gf, layout);


    fLineScalePS->GetNumberEntry()->SetToolTipText("Line scale factor when drawing lines on PostScript");

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add a title to the frame f.


 void TStyleManager::AddTitle(TGCompositeFrame *f, const char *s)

 {

    TGLayoutHints *layout1 = new TGLayoutHints(kLHintsExpandX, 5, 0, 7);

    fTrashListLayout->Add(layout1);

    TGLayoutHints *layout2 = new TGLayoutHints(kLHintsExpandX, 0, 0, 6, 6);

    fTrashListLayout->Add(layout2);


    TGHorizontalFrame *h = new TGHorizontalFrame(f);

    fTrashListFrame->AddFirst(h);


    TGLabel *lab = new TGLabel(h, s);

    fTrashListFrame->AddFirst(lab);

    h->AddFrame(lab);


    TGHorizontal3DLine *line = new TGHorizontal3DLine(h, 4, 2, kFALSE);

    fTrashListFrame->AddFirst(line);

    h->AddFrame(line, layout1);


    f->AddFrame(h, layout2);

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add a color entry to the frame f.


 TGColorSelect *TStyleManager::AddColorEntry(TGCompositeFrame *f, Int_t id)

 {

    TGLayoutHints *layout = new TGLayoutHints(kLHintsBottom, 0, 5, 3, 3);

    fTrashListLayout->Add(layout);


    TGColorSelect *cs = new TGColorSelect(f, 0, id);

    cs->Associate(this);

    f->AddFrame(cs, layout);

    return cs;

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add a fill style entry to the frame f.


 TGedPatternSelect *TStyleManager::AddFillStyleEntry(TGCompositeFrame *f,

                                                     Int_t id)

 {

    TGLayoutHints *layout = new TGLayoutHints(kLHintsBottom, 0, 0, 3, 3);

    fTrashListLayout->Add(layout);


    TGedPatternSelect *gps = new TGedPatternSelect(f, 0, id);

    gps->Associate(this);

    f->AddFrame(gps, layout);

    return gps;

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add a marker style entry to the frame f.


 TGedMarkerSelect *TStyleManager::AddMarkerStyleEntry(TGCompositeFrame *f,

                                                      Int_t id)

 {

    TGLayoutHints *layout = new TGLayoutHints(kLHintsCenterY, 0, 5, 3, 3);

    fTrashListLayout->Add(layout);


    TGedMarkerSelect *gms = new TGedMarkerSelect(f, 0, id);

    gms->Associate(this);

    f->AddFrame(gms, layout);

    return gms;

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add a marker size entry to the frame f.


 TGComboBox *TStyleManager::AddMarkerSizeEntry(TGCompositeFrame *f, Int_t id)

 {

    char a[10];

    TGComboBox *cb = new TGComboBox(f, id);

    cb->Associate(this);

    for (Int_t i = 1; i <= 15; i++) {

       snprintf(a, 10, "%.1f", 0.2 * i);

       cb->AddEntry(a, i);

    }

    cb->Resize(1, 22);

    f->AddFrame(cb, fLayoutExpandXCenterYMargin);

    return cb;

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add a number entry to the frame f. A caption can be added.


 TGNumberEntry *TStyleManager::AddNumberEntry(TGCompositeFrame *f, Int_t e1,

          Int_t e2, Int_t e3, Int_t id, const char *s, Double_t init, Int_t digits,

          TGNumberFormat::EStyle nfS, TGNumberFormat::EAttribute nfA,

          TGNumberFormat::ELimit nfL, Double_t min, Double_t max)

 {

    TGHorizontalFrame *h = new TGHorizontalFrame(f);

    fTrashListFrame->AddFirst(h);

    if (strlen(s)) {

       TGLabel *lab = new TGLabel(h, s);

       fTrashListFrame->AddFirst(lab);

       TGLayoutHints *layout = new TGLayoutHints(kLHintsNormal, e1, 0, 3);

       fTrashListLayout->Add(layout);

       h->AddFrame(lab, layout);

    }

    TGNumberEntry *ne = new TGNumberEntry(h, init, digits, id,

                                          nfS, nfA, nfL, min, max);

    ne->Associate(this);

    if ((e1 == 0) && (e2 == 0) && (e3 == 0)) {

       TGLayoutHints *layout1 = new TGLayoutHints(kLHintsRight);

       fTrashListLayout->Add(layout1);

       h->AddFrame(ne, layout1);

    } else {

       TGLayoutHints *layout2 = new TGLayoutHints(kLHintsNormal, e2, e3);

       fTrashListLayout->Add(layout2);

       h->AddFrame(ne, layout2);

    }

    if (strlen(s)) {

       TGLayoutHints *layout3 =

                  new TGLayoutHints(kLHintsExpandX | kLHintsCenterY, 0, 2, 3, 3);

       fTrashListLayout->Add(layout3);

       f->AddFrame(h, layout3);

    } else {

       TGLayoutHints *layout4 =

                  new TGLayoutHints(kLHintsNormal | kLHintsCenterY, 0, 2, 3, 3);

       fTrashListLayout->Add(layout4);

       f->AddFrame(h, layout4);

    }

    return ne;

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add a line width entry to the frame f.


 TGLineWidthComboBox *TStyleManager::AddLineWidthEntry(TGCompositeFrame *f,

                                                       Int_t id)

 {

    TGLayoutHints *layout = new TGLayoutHints(kLHintsExpandX, 0, 0, 3, 3);

    fTrashListLayout->Add(layout);


    TGHorizontalFrame *h = new TGHorizontalFrame(f);

    fTrashListFrame->AddFirst(h);

    TGLineWidthComboBox *lwcb = new TGLineWidthComboBox(h, id);

    lwcb->Associate(this);

    lwcb->Resize(1, 22);

    h->AddFrame(lwcb, fLayoutExpandX);

    f->AddFrame(h, layout);

    return lwcb;

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add a line style entry to the frame f.


 TGLineStyleComboBox *TStyleManager::AddLineStyleEntry(TGCompositeFrame *f,

                                                       Int_t id)

 {

    TGLineStyleComboBox *lscb = new TGLineStyleComboBox(f, id);

    lscb->Associate(this);

    lscb->Resize(1, 22);

    f->AddFrame(lscb, fLayoutExpandXCenterYMargin);

    return lscb;

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add a text button to the frame f.


 TGTextButton *TStyleManager::AddTextButton(TGCompositeFrame *f,

                                            const char *s, Int_t id)

 {

    TGLayoutHints *layout = new TGLayoutHints(kLHintsExpandX, 0, 0, 3, 3);

    fTrashListLayout->Add(layout);


    TGTextButton *tb = new TGTextButton(f, s, id);

    tb->Associate(this);

    f->AddFrame(tb, layout);

    return tb;

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add a font type combo box to the frame f.


 TGFontTypeComboBox *TStyleManager::AddFontTypeEntry(TGCompositeFrame *f,

                                                     Int_t id)

 {

    TGFontTypeComboBox *ftcb = new TGFontTypeComboBox(f, id);

    ftcb->Associate(this);

    ftcb->Resize(1, 22);

    f->AddFrame(ftcb, fLayoutExpandXCenterYMargin);

    return ftcb;

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add a text align combo box to the frame f.


 TGComboBox *TStyleManager::AddTextAlignEntry(TGCompositeFrame *f, Int_t id)

 {

    TGComboBox *cb = new TGComboBox(f, id);

    cb->Associate(this);

    cb->AddEntry("11 Bottom, Left",   11);

    cb->AddEntry("21 Bottom, Middle", 21);

    cb->AddEntry("31 Bottom, Right",  31);

    cb->AddEntry("12 Middle, Left",   12);

    cb->AddEntry("22 Middle, Middle", 22);

    cb->AddEntry("32 Middle, Right",  32);

    cb->AddEntry("13 Top, Left",      13);

    cb->AddEntry("23 Top, Middle",    23);

    cb->AddEntry("33 Top, Right",     33);

    cb->Resize(1, 22);

    f->AddFrame(cb, fLayoutExpandXCenterYMargin);

    return cb;

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add a border mode button group to the frame f.


 TGButtonGroup *TStyleManager::AddBorderModeEntry(TGCompositeFrame *f,

                                                 Int_t id1, Int_t id2, Int_t id3)

 {

    TGButtonGroup *bg = new TGButtonGroup(f, "Border");

    TGRadioButton *sunk = new TGRadioButton(bg, "Sunken", id1);

    sunk->Associate(this);

    fTrashListFrame->AddFirst(sunk);

    TGRadioButton *none = new TGRadioButton(bg, "None"  , id2);

    none->Associate(this);

    fTrashListFrame->AddFirst(none);

    TGRadioButton *rais = new TGRadioButton(bg, "Raised", id3);

    rais->Associate(this);

    fTrashListFrame->AddFirst(rais);

    bg->Show();

    f->AddFrame(bg, fLayoutExpandXYMargin);

    return bg;

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add a date format combo box to the frame f.


 TGComboBox *TStyleManager::AddDateFormatEntry(TGCompositeFrame *f, Int_t id)

 {

    TGComboBox *cb = new TGComboBox(f, id);

    cb->Associate(this);

    cb->AddEntry("Wed Sep 25 17:10:35 2002", 1);

    cb->AddEntry("2002-09-25",               2);

    cb->AddEntry("2002-09-25 17:10:35",      3);

    cb->Resize(1, 22);

    cb->GetListBox()->Resize(cb->GetListBox()->GetDefaultSize().fWidth, 55);

    f->AddFrame(cb, fLayoutExpandXCenterYMargin);

    return cb;

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add a check button to the frame f.


 TGCheckButton *TStyleManager::AddCheckButton(TGCompositeFrame *f, const char *s,

                                              Int_t id, Int_t e1, Int_t e2)

 {

    TGLayoutHints *layout = new TGLayoutHints(kLHintsNormal, 0, e1, 4, e2);

    fTrashListLayout->Add(layout);


    TGHorizontalFrame *h = new TGHorizontalFrame(f);

    fTrashListFrame->AddFirst(h);

    TGCheckButton *cb = new TGCheckButton(h, s, id);

    cb->Associate(this);

    h->AddFrame(cb, layout);

    f->AddFrame(h);

    return cb;

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add a text entry to the frame f. A caption can be added.


 TGTextEntry *TStyleManager::AddTextEntry(TGCompositeFrame *f,

                                          const char *s, Int_t id)

 {

    TGHorizontalFrame *h = new TGHorizontalFrame(f);

    fTrashListFrame->AddFirst(h);

    if (strlen(s)) {

       TGLabel *lab = new TGLabel(h, s);

       fTrashListFrame->AddFirst(lab);

       TGLayoutHints *layout1 = new TGLayoutHints(kLHintsNormal, 0, 0, 3);

       fTrashListLayout->Add(layout1);

       h->AddFrame(lab, layout1);

    }

    TGTextEntry *te = new TGTextEntry(h, "", id);

    te->Associate(this);

    te->Resize(57, 22);

    if (strlen(s)) {

       TGLayoutHints *layout2 = new TGLayoutHints(kLHintsRight, 20);

       fTrashListLayout->Add(layout2);

       h->AddFrame(te, layout2);

    } else

       h->AddFrame(te, fLayoutExpandX);

    TGLayoutHints *layout3 =

                  new TGLayoutHints(kLHintsExpandX | kLHintsCenterY, 0, 2, 3, 3);

    fTrashListLayout->Add(layout3);

    f->AddFrame(h, layout3);

    return te;

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Add a prefered paper size combo box to the frame f.


 TGComboBox *TStyleManager::AddPaperSizeEntry(TGCompositeFrame *f, Int_t id)

 {

    TGComboBox *cb = new TGComboBox(f, id);

    cb->Associate(this);

    cb->AddEntry("Custom size (cm)",   1);

    cb->AddEntry("Custom size (inch)", 2);

    cb->AddEntry("A4 (cm)",            3);

    cb->AddEntry("US Letter (inch)",   4);

    cb->AddEntry("US Letter (cm)",   4);

    cb->Resize(1, 22);

    cb->GetListBox()->Resize(cb->GetListBox()->GetDefaultSize().fWidth, 70);

    f->AddFrame(cb, fLayoutExpandXCenterYMargin);

    return cb;

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called when an item of the menu is selected.


 void TStyleManager::DoMenu(Int_t menuID)

 {

    switch (menuID) {

       case kMenuNew:          DoNew();              break;

       case kMenuDelete:       DoDelete();           break;

       case kMenuRename:       DoRename();           break;

       case kMenuImportCanvas: DoImportCanvas();     break;

       case kMenuImportMacro:  DoImportMacro(kTRUE); break;

       case kMenuExport:       DoExport();           break;

       case kMenuExit:         DoExit();             break;

       case kMenuHelp:         DoHelp(42);           break;

       case kMenuHelpEditor:   DoHelp(fCurTabNum);   break;

       case kMenuHelpGeneral:  DoHelp(0);            break;

       case kMenuHelpCanvas:   DoHelp(1);            break;

       case kMenuHelpPad:      DoHelp(2);            break;

       case kMenuHelpHistos:   DoHelp(3);            break;

       case kMenuHelpAxis:     DoHelp(4);            break;

       case kMenuHelpTitle:    DoHelp(5);            break;

       case kMenuHelpStats:    DoHelp(6);            break;

       case kMenuHelpPSPDF:    DoHelp(7);            break;

    }

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called to import a style from a C++ macro file. If create=kTRUE,

 /// a new style is created. Otherwise, the current style is reseted.


 void TStyleManager::DoImportMacro(Bool_t create)

 {

    // Import a style from a macro.

    // If create = kTRUE, a new style is created.

    // Otherwise, the selected style is:

    //             - reseted with the macro's values.

    //             - recreated (if it is one of the 5 basic styles).


    if ((!create) && (!strcmp(fCurSelStyle->GetName(), "Default"))) {

       if ((!strcmp(fCurSelStyle->GetName(),gStyle->GetName())))

          gStyle->Reset("Default");

       else {

          delete gROOT->GetStyle("Default");

          new TStyle("Default", "Default Style");

       }

    } else if ((!create) && (!strcmp(fCurSelStyle->GetName(), "Plain"))) {

       if ((!strcmp(fCurSelStyle->GetName(),gStyle->GetName())))

          gStyle->Reset("Plain");

       else {

          delete gROOT->GetStyle("Plain");

          new TStyle("Plain",   "Plain Style (no colors/fill areas)");

       }

    } else if ((!create) && (!strcmp(fCurSelStyle->GetName(), "Bold"))) {

       if ((!strcmp(fCurSelStyle->GetName(),gStyle->GetName())))

          gStyle->Reset("Bold");

       else {

          delete gROOT->GetStyle("Bold");

          new TStyle("Bold",    "Bold Style");

       }

    } else if ((!create) && (!strcmp(fCurSelStyle->GetName(), "Video"))) {

       if ((!strcmp(fCurSelStyle->GetName(),gStyle->GetName())))

          gStyle->Reset("Video");

       else {

          delete gROOT->GetStyle("Video");

          new TStyle("Video",   "Style for video presentation histograms");

       }

    } else if ((!create) && (!strcmp(fCurSelStyle->GetName(), "Pub"))) {

       if ((!strcmp(fCurSelStyle->GetName(),gStyle->GetName())))

          gStyle->Reset("Pub");

       else {

          delete gROOT->GetStyle("Pub");

          new TStyle("Pub",     "Style for Publications");

       }

    } else {

       CreateMacro();

       if (!create) {

          TString newName;

          newName.Form("Style_%s.C", fCurSelStyle->GetName());

          fCurMacro->fFilename = StrDup(newName.Data());

       }

       new TGFileDialog(gClient->GetRoot(), this, kFDOpen, fCurMacro);

       if (fCurMacro->fFilename != 0) {

          gROOT->ProcessLine(Form(".x %s", fCurMacro->fFilename));

          fCurMacro->fFilename = StrDup(gSystem->BaseName(fCurMacro->fFilename));

       }

    }


    BuildList();

 }


 ////////////////////////////////////////////////////////////////////////////////

 ///  Slot called when the user select an item in the available styles' list.

 /// Update the preview, the editor, the status bar. The current selected

 /// style is changed.


 void TStyleManager::DoListSelect()

 {

    // Select the new style and update the state of the style manager.

    fCurSelStyle = gROOT->GetStyle(((TGTextLBEntry*) fListComboBox->

                                     GetSelectedEntry())->GetText()->GetString());


    fStyleChanged = kFALSE;


    // Update the status bar.

    UpdateStatusBar();


    // Update the editor (if opened).

    if (fMoreAndNotLess) {

       DisconnectEditor(fCurTabNum);

       UpdateEditor(fCurTabNum);

       ConnectEditor(fCurTabNum);

    }


    // Update the preview, if it exists and is visible.

    if (fPreviewWindow && fPreviewWindow->IsMapped())

       DoEditionUpdatePreview();


    // Refresh the tooltip of the fMakeDefault's button.

    TString newTip;

    newTip.Form("'%s'", fCurSelStyle->GetName());

    newTip += " become current style";

    fMakeDefault->SetToolTipText(newTip.Data());


    // Refresh.

    fListComboBox->MapSubwindows();

    fListComboBox->Layout();

 }


 ////////////////////////////////////////////////////////////////////////////////

 ///  Slot called when the user click on the run time update check button.

 /// If b=kTRUE, the user asks for a real time preview.


 void TStyleManager::DoRealTime(Bool_t b)

 {

    if (b) {

       fEditionUpdatePreview->SetEnabled(kFALSE);

       fRealTimePreview = kTRUE;

       DoEditionUpdatePreview();

    } else {

       fEditionUpdatePreview->SetEnabled(kTRUE);

       fRealTimePreview = kFALSE;

    }

 }


 ////////////////////////////////////////////////////////////////////////////////

 ///  Slot called when the user click on the preview check button. If b=kTRUE,

 /// the user asks for a preview, otherwise they want to close it.


 void TStyleManager::DoPreview(Bool_t b)

 {

    if (b) {

       fPreviewButton->SetState(kButtonDown, kFALSE);

       if (fPreviewWindow) {

          DoEditionUpdatePreview();

          fPreviewWindow->MapTheWindow();

       } else {

          if (fCurPad && fCurObj) {

             TQObject::Disconnect("TCanvas", "Closed()");

             fPreviewWindow = new TStylePreview(GetMainFrame(), fCurSelStyle, fCurPad);

             TQObject::Connect("TCanvas", "Closed()", "TStyleManager", this, "DoSelectNoCanvas()");

          }

       }

       fPreviewWindow->Connect("CloseWindow()", "TStyleManager", this, "DoPreviewClosed()");

       fPreviewRealTime->SetEnabled(kTRUE);

       if (fRealTimePreview) {

          fPreviewRealTime->SetState(kButtonDown, kFALSE);

          fEditionUpdatePreview->SetEnabled(kFALSE);

       } else {

          fPreviewRealTime->SetState(kButtonUp, kFALSE);

          fEditionUpdatePreview->SetEnabled(kTRUE);

       }

    } else DoPreviewClosed();

 }


 ////////////////////////////////////////////////////////////////////////////////

 ///  Slot called to close the preview, via the preview check button, or

 /// when the preview window is closed via the window manager.


 void TStyleManager::DoPreviewClosed()

 {

    fPreviewWindow->Disconnect("CloseWindow()");

    fPreviewButton->SetState(kButtonUp, kFALSE);

    fPreviewRealTime->SetEnabled(kFALSE);

    fEditionUpdatePreview->SetEnabled(kFALSE);

    fPreviewWindow->UnmapWindow();

 }


 ////////////////////////////////////////////////////////////////////////////////

 ///  Slot called to make the current selected style (in the ComboBox)

 /// become gStyle.


 void TStyleManager::DoMakeDefault()

 {

    gROOT->SetStyle(fCurSelStyle->GetName());

    fCurStyle->SetText(gStyle->GetName());

 }


 ////////////////////////////////////////////////////////////////////////////////

 ///  Slot called to choose on which object(s) the 'Apply' button will

 /// have an effect.


 void TStyleManager::DoApplyOnSelect(Int_t i)

 {

    fAllAndNotCurrent = (i == kTopApplyOnAll);

 }


 ////////////////////////////////////////////////////////////////////////////////

 ///  Slot called when the user clicks on the 'Apply' button. Apply the

 /// current selected style to the specified object(s)


 void TStyleManager::DoApplyOn()

 {

    TStyle *tmp = gStyle;

    gStyle = fCurSelStyle;


    if (fAllAndNotCurrent) {

       // Apply on all canvases, excluding the preview.

       TCanvas *tmpCanvas = (TCanvas *) (gROOT->GetListOfCanvases()->First());

       while (tmpCanvas) {

          if ((!fPreviewWindow) || (tmpCanvas != fPreviewWindow->GetMainCanvas())) {

             tmpCanvas->UseCurrentStyle();

             tmpCanvas->Modified();

             tmpCanvas->Update();

          }

          tmpCanvas = (TCanvas *) (gROOT->GetListOfCanvases()->After(tmpCanvas));

       }

    } else

       if (fCurPad && fCurObj) {

          // Apply on selected object and refresh all canvases containing the object.

          fCurObj->UseCurrentStyle();

          TCanvas *tmpCanvas = (TCanvas *) (gROOT->GetListOfCanvases()->First());

          while (tmpCanvas) {

             if (((!fPreviewWindow) || (tmpCanvas != fPreviewWindow->GetMainCanvas()))

              && ((tmpCanvas == fCurObj) || tmpCanvas->FindObject(fCurObj))) {

                tmpCanvas->Modified();

                tmpCanvas->Update();

             }

             tmpCanvas = (TCanvas *) (gROOT->GetListOfCanvases()->After(tmpCanvas));

          }

       }


    gStyle = tmp;

 }


 ////////////////////////////////////////////////////////////////////////////////

 ///  Slot called when the user try to show or hide the editor part of the

 /// style manager.


 void TStyleManager::DoMoreLess()

 {

    fMoreAndNotLess = !fMoreAndNotLess;

    if (fMoreAndNotLess) {

       // Redraw the tabs.

       SetWMSizeHints(fSMWidth, fSMHeight, fSMWidth, fSMHeight, 0, 0);

       ShowFrame(fEditionFrame);

       fEditionFrame->ShowFrame(fEditionTab);

       fEditionFrame->ShowFrame(fEditionButtonFrame);

       fMoreLess->SetText("&Close <<");

       Resize(fSMWidth, fSMHeight);


       // Update Editor's values.

       DisconnectEditor(fCurTabNum);

       UpdateEditor(fCurTabNum);

       ConnectEditor(fCurTabNum);

       fMoreLess->SetToolTipText("Close the editor");

    } else {

       // Hide the tabs.

       HideFrame(fEditionFrame);

       fEditionFrame->HideFrame(fEditionTab);

       fEditionFrame->HideFrame(fEditionButtonFrame);

       fMoreLess->SetText("&Edit >>");

       Resize(GetDefaultSize());

       SetWMSizeHints(fSMWidth, GetHeight(), fSMWidth, GetHeight(), 0, 0);

       fMoreLess->SetToolTipText("Open the editor");

    }

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called when the user clicks on the 'Update preview' button.


 void TStyleManager::DoEditionUpdatePreview()

 {

    if ((!fCurPad) || (!fCurObj)) return;


    if (fPreviewWindow) {

       TQObject::Disconnect("TCanvas", "Closed()");

       fPreviewWindow->Update(fCurSelStyle, fCurPad);

       TQObject::Connect("TCanvas", "Closed()", "TStyleManager", this, "DoSelectNoCanvas()");

    }

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called when the user changes the current tab.


 void TStyleManager::DoChangeTab(Int_t i)

 {

    //  Disconnect the signal/slots communication mechanism from the previous

    // tab and connect them onto the new one.

    DisconnectEditor(fCurTabNum);

    fCurTabNum = i;

    UpdateEditor(fCurTabNum);

    ConnectEditor(fCurTabNum);

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called when the user changes the current axis tab.


 void TStyleManager::DoChangeAxisTab(Int_t i)

 {

    fCurTabAxisNum = i;

 }


 ////////////////////////////////////////////////////////////////////////////////

 ///  Slot called when the user close a TCanvas. Update the labels and the

 /// pointers to the current pad and the current object.


 void TStyleManager::DoSelectNoCanvas()

 {

    fCurPad = 0;

    fCurObj = 0;


    if (fPreviewWindow && fPreviewWindow->IsMapped())

       DoPreview(kFALSE);


    fCurPadTextEntry->SetText("No pad selected");

    fCurObjTextEntry->SetText("No object selected");

    fImportCascade->DisableEntry(kMenuImportCanvas);

    fApplyOnButton->SetEnabled(kFALSE);

    fToolBarImportCanvas->SetEnabled(kFALSE);

    fPreviewButton->SetEnabled(kFALSE);

    fPreviewRealTime->SetEnabled(kFALSE);

    fEditionUpdatePreview->SetEnabled(kFALSE);

 }


 ////////////////////////////////////////////////////////////////////////////////

 ///  Slot called when the user clicks on a TCanvas or on any object inside

 /// a TCanvas. Update the pointers to the current pad and the current object.


 void TStyleManager::DoSelectCanvas(TVirtualPad *pad, TObject *obj, Int_t mouseButton)

 {

    if (mouseButton != kButton2Down) return;


    if (!pad || !obj) {

       DoSelectNoCanvas();

       return;

    }


    // Disable the selection of the preview.

    if (fPreviewWindow && (pad->GetCanvas() == fPreviewWindow->GetMainCanvas()))

       return;


    // Did the user select the same canvas as before ?

    Bool_t samePad = (fCurPad && (pad->GetCanvas() == fCurPad->GetCanvas()));


    fCurPad = pad;

    fCurObj = obj;

    Bool_t preview = (fPreviewWindow && fPreviewWindow->IsMapped());


    if ((!samePad) && preview) DoPreview(kFALSE);


    // Update the information' label about the selected objects.

    TString sPad;

    if (fCurPad->GetName() && strlen(fCurPad->GetName()))

       sPad.Append(fCurPad->GetName());

    else

       sPad.Append("[no name]");

    sPad.Append(" - '");

    if (fCurPad->GetTitle() && strlen(fCurPad->GetTitle()))

       sPad.Append(fCurPad->GetTitle());

    else

       sPad.Append("[no title]");

    sPad.Append("'::");

    sPad.Append(fCurPad->ClassName());

    fCurPadTextEntry->SetText(sPad);

    TString sObj;

    if (strlen(fCurObj->GetName()))

       sObj.Append(fCurObj->GetName());

    else

       sObj.Append("[no name]");

    sObj.Append("::");

    sObj.Append(fCurObj->ClassName());

    fCurObjTextEntry->SetText(sObj);


    if (!samePad) {

       fImportCascade->EnableEntry(kMenuImportCanvas);

       fApplyOnButton->SetEnabled(kTRUE);

       fToolBarImportCanvas->SetEnabled(kTRUE);

       if (preview) {

          DoPreview(kTRUE);

       } else {

          fPreviewButton->SetEnabled(kTRUE);

          fPreviewRealTime->SetEnabled(kFALSE);

          fEditionUpdatePreview->SetEnabled(kFALSE);

       }

    }

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called to close the style manager via the window manager.


 void TStyleManager::CloseWindow()

 {

    Hide();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the fill color is modified by the user.


 void TStyleManager::ModFillColor()

 {

    fCurSelStyle->SetFillColor(TColor::GetColor(fFillColor->GetColor()));

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the fill style is modified by the user.


 void TStyleManager::ModFillStyle()

 {

    fCurSelStyle->SetFillStyle(fFillStyle->GetPattern());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the hatches line width is modified by the user.


 void TStyleManager::ModHatchesLineWidth()

 {

    fCurSelStyle->SetHatchesLineWidth(fHatchesLineWidth->GetSelected());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the hatches spacing is modified by the user.


 void TStyleManager::ModHatchesSpacing()

 {

    fCurSelStyle->SetHatchesSpacing(fHatchesSpacing->GetNumber());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the marker color is modified by the user.


 void TStyleManager::ModMarkerColor()

 {

    fCurSelStyle->SetMarkerColor(TColor::GetColor(fMarkerColor->GetColor()));

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the marker style is modified by the user.


 void TStyleManager::ModMarkerStyle()

 {

    fCurSelStyle->SetMarkerStyle(fMarkerStyle->GetMarkerStyle());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the marker size is modified by the user.


 void TStyleManager::ModMarkerSize()

 {

    fCurSelStyle->SetMarkerSize(fMarkerSize->GetSelected() * 0.2);

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the screen factor is modified by the user.


 void TStyleManager::ModScreenFactor()

 {

    fCurSelStyle->SetScreenFactor(fScreenFactor->GetNumber());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the line color is modified by the user.


 void TStyleManager::ModLineColor()

 {

    fCurSelStyle->SetLineColor(TColor::GetColor(fLineColor->GetColor()));

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the line width is modified by the user.


 void TStyleManager::ModLineWidth()

 {

    fCurSelStyle->SetLineWidth(fLineWidth->GetSelected());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the line style is modified by the user.


 void TStyleManager::ModLineStyle()

 {

    fCurSelStyle->SetLineStyle(fLineStyle->GetSelected());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the line style editor is opened by the user.


 void TStyleManager::ModLineStyleEdit()

 {

    // TODO Open a LineStyle editor

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the text color is modified by the user.


 void TStyleManager::ModTextColor()

 {

    fCurSelStyle->SetTextColor(TColor::GetColor(fTextColor->GetColor()));

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the text size is modified by the user.


 void TStyleManager::ModTextSize()

 {

    fCurSelStyle->SetTextSize(fTextSize->GetNumber());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the text size mode is modified by the user.


 void TStyleManager::ModTextSizeInPixels(Bool_t b)

 {

    Int_t tmp = fCurSelStyle->GetTextFont() / 10;

    Int_t mod = fCurSelStyle->GetTextFont() % 10;

    Double_t h = TMath::Max(fCurSelStyle->GetCanvasDefH(), 100);

    if (b) {

       fCurSelStyle->SetTextFont(tmp * 10 + 3);

       fTextSize->SetFormat(TGNumberFormat::kNESInteger,

                            TGNumberFormat::kNEAPositive);

       fTextSize->SetLimits(TGNumberFormat::kNELLimitMinMax, 0, h);

       if (mod == 2)

          fCurSelStyle->SetTextSize(fCurSelStyle->GetTextSize() * h);

    } else {

       fCurSelStyle->SetTextFont(tmp * 10 + 2);

       fTextSize->SetFormat(TGNumberFormat::kNESRealThree,

                            TGNumberFormat::kNEAPositive);

       fTextSize->SetLimits(TGNumberFormat::kNELLimitMinMax, 0, 1);

       if (mod == 3)

          fCurSelStyle->SetTextSize(fCurSelStyle->GetTextSize() / h);

    }

    fTextSize->SetNumber(fCurSelStyle->GetTextSize());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the text font is modified by the user.


 void TStyleManager::ModTextFont()

 {

    Int_t tmp = fCurSelStyle->GetTextFont() % 10;

    fCurSelStyle->SetTextFont(fTextFont->GetSelected() * 10 + tmp);

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the text align is modified by the user.


 void TStyleManager::ModTextAlign()

 {

    fCurSelStyle->SetTextAlign(fTextAlign->GetSelected());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the text angle is modified by the user.


 void TStyleManager::ModTextAngle()

 {

    fCurSelStyle->SetTextAngle(fTextAngle->GetNumber());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the canvas color is modified by the user.


 void TStyleManager::ModCanvasColor()

 {

    fCurSelStyle->SetCanvasColor(TColor::GetColor(fCanvasColor->GetColor()));

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the canvas default abscissa is modified by the user.


 void TStyleManager::ModCanvasDefX()

 {

    fCurSelStyle->SetCanvasDefX(fCanvasDefX->GetIntNumber());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the canvas default ordinate is modified by the user.


 void TStyleManager::ModCanvasDefY()

 {

    fCurSelStyle->SetCanvasDefY(fCanvasDefY->GetIntNumber());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the canvas default width is modified by the user.


 void TStyleManager::ModCanvasDefW()

 {

    fCurSelStyle->SetCanvasDefW(fCanvasDefW->GetIntNumber());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the canvas default height is modified by the user.


 void TStyleManager::ModCanvasDefH()

 {

    fCurSelStyle->SetCanvasDefH(fCanvasDefH->GetIntNumber());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the canvas border mode is modified by the user.


 void TStyleManager::ModCanvasBorderMode()

 {

    Int_t i = kCanvasBorderModeSunken;

    TGButton *but = 0;

    while ((but = fCanvasBorderMode->Find(i)) && !but->IsDown())

       i++;

    fCurSelStyle->SetCanvasBorderMode(i - 1 - kCanvasBorderModeSunken);

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the canvas border size is modified by the user.


 void TStyleManager::ModCanvasBorderSize()

 {

    fCurSelStyle->SetCanvasBorderSize(fCanvasBorderSize->GetSelected());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the OptDate boolean is modified by the user.


 void TStyleManager::ModOptDateBool()

 {

    if (fOptDateBool->IsDown())

       fCurSelStyle->SetOptDate(4);

    else

       fCurSelStyle->SetOptDate(0);

    DisconnectEditor(fCurTabNum);

    UpdateEditor(fCurTabNum);

    ConnectEditor(fCurTabNum);

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the date text color is modified by the user.


 void TStyleManager::ModAttDateTextColor()

 {

    // To modify this entry, the user must have check 'Show'

    fCurSelStyle->GetAttDate()->SetTextColor(TColor::GetColor(fAttDateTextColor->GetColor()));

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the date text size is modified by the user.


 void TStyleManager::ModAttDateTextSize()

 {

    fCurSelStyle->GetAttDate()->SetTextSize(fAttDateTextSize->GetNumber());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the date text size mode is modified by the user.


 void TStyleManager::ModAttDateTextSizeInPixels(Bool_t b)

 {

    Int_t tmp = fCurSelStyle->GetAttDate()->GetTextFont() / 10;

    Int_t mod = fCurSelStyle->GetAttDate()->GetTextFont() % 10;

    Double_t h = TMath::Max(fCurSelStyle->GetCanvasDefH(), 100);


    if (b) {

       fCurSelStyle->GetAttDate()->SetTextFont(tmp * 10 + 3);

       fAttDateTextSize->SetFormat(TGNumberFormat::kNESInteger,

                            TGNumberFormat::kNEAPositive);

       fAttDateTextSize->SetLimits(TGNumberFormat::kNELLimitMinMax, 0, h);

       if (mod == 2)

          fCurSelStyle->GetAttDate()->SetTextSize(fCurSelStyle->GetAttDate()->GetTextSize() * h);

    } else {

       fCurSelStyle->GetAttDate()->SetTextFont(tmp * 10 + 2);

       fAttDateTextSize->SetFormat(TGNumberFormat::kNESRealThree,

                            TGNumberFormat::kNEAPositive);

       fAttDateTextSize->SetLimits(TGNumberFormat::kNELLimitMinMax, 0, 1);

       if (mod == 3)

          fCurSelStyle->GetAttDate()->SetTextSize(fCurSelStyle->GetAttDate()->GetTextSize() / h);

    }

    fAttDateTextSize->SetNumber(fCurSelStyle->GetAttDate()->GetTextSize());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the date text format is modified by the user.


 void TStyleManager::ModOptDateFormat()

 {

    Int_t formatPrec = fCurSelStyle->GetOptDate() % 10;

    fCurSelStyle->SetOptDate((fOptDateFormat->GetSelected() - 1) * 10

                               + formatPrec);

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the date text font is modified by the user.


 void TStyleManager::ModAttDateTextFont()

 {

    Int_t fontPrec = fCurSelStyle->GetAttDate()->GetTextFont() % 10;

    fCurSelStyle->GetAttDate()->SetTextFont(fAttDateTextFont->GetSelected() * 10

                                           + fontPrec);

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the date text align is modified by the user.


 void TStyleManager::ModAttDateTextAlign()

 {

    fCurSelStyle->GetAttDate()->SetTextAlign(fAttDateTextAlign->GetSelected());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the date text angle is modified by the user.


 void TStyleManager::ModAttDateTextAngle()

 {

    fCurSelStyle->GetAttDate()->SetTextAngle(fAttDateTextAngle->GetNumber());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the date abscissa is modified by the user.


 void TStyleManager::ModDateX()

 {

    fCurSelStyle->SetDateX(fDateX->GetIntNumber() * 0.01);

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the date ordinate is modified by the user.


 void TStyleManager::ModDateY()

 {

    fCurSelStyle->SetDateY(fDateY->GetIntNumber() * 0.01);

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the pad left margin is modified by the user.


 void TStyleManager::ModPadLeftMargin()

 {

    fCurSelStyle->SetPadLeftMargin(fPadLeftMargin->GetIntNumber() * 0.01);

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the pad right margin is modified by the user.


 void TStyleManager::ModPadRightMargin()

 {

    fCurSelStyle->SetPadRightMargin(fPadRightMargin->GetIntNumber() * 0.01);

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the pad top margin is modified by the user.


 void TStyleManager::ModPadTopMargin()

 {

    fCurSelStyle->SetPadTopMargin(fPadTopMargin->GetIntNumber() * 0.01);

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the pad bottom margin is modified by the user.


 void TStyleManager::ModPadBottomMargin()

 {

    fCurSelStyle->SetPadBottomMargin(fPadBottomMargin->GetIntNumber() * 0.01);

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the pad border mode is modified by the user.


 void TStyleManager::ModPadBorderMode()

 {

    Int_t i = kPadBorderModeSunken;

    TGButton *but = 0;

    while ((but = fPadBorderMode->Find(i)) && !but->IsDown())

       i++;

    fCurSelStyle->SetPadBorderMode(i - 1 - kPadBorderModeSunken);

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the pad border size is modified by the user.


 void TStyleManager::ModPadBorderSize()

 {

    fCurSelStyle->SetPadBorderSize(fPadBorderSize->GetSelected());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the pad color is modified by the user.


 void TStyleManager::ModPadColor()

 {

    fCurSelStyle->SetPadColor(TColor::GetColor(fPadColor->GetColor()));

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the pad tick X boolean is modified by the user.


 void TStyleManager::ModPadTickX()

 {

    fCurSelStyle->SetPadTickX(fPadTickX->IsDown());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the pad tick Y boolean is modified by the user.


 void TStyleManager::ModPadTickY()

 {

    fCurSelStyle->SetPadTickY(fPadTickY->IsDown());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the pad grid X boolean is modified by the user.


 void TStyleManager::ModPadGridX()

 {

    fCurSelStyle->SetPadGridX(fPadGridX->IsDown());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the pad grid Y boolean is modified by the user.


 void TStyleManager::ModPadGridY()

 {

    fCurSelStyle->SetPadGridY(fPadGridY->IsDown());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the grid line color is modified by the user.


 void TStyleManager::ModGridColor()

 {

    fCurSelStyle->SetGridColor(TColor::GetColor(fGridColor->GetColor()));

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the grid line width is modified by the user.


 void TStyleManager::ModGridWidth()

 {

    fCurSelStyle->SetGridWidth(fGridWidth->GetSelected());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the grid line style is modified by the user.


 void TStyleManager::ModGridStyle()

 {

    fCurSelStyle->SetGridStyle(fGridStyle->GetSelected());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the histos fill color is modified by the user.


 void TStyleManager::ModHistFillColor()

 {

    fCurSelStyle->SetHistFillColor(TColor::GetColor(fHistFillColor->GetColor()));

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the histos fill style is modified by the user.


 void TStyleManager::ModHistFillStyle()

 {

    fCurSelStyle->SetHistFillStyle(fHistFillStyle->GetPattern());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the histos line color is modified by the user.


 void TStyleManager::ModHistLineColor()

 {

    fCurSelStyle->SetHistLineColor(TColor::GetColor(fHistLineColor->GetColor()));

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the histos line width is modified by the user.


 void TStyleManager::ModHistLineWidth()

 {

    fCurSelStyle->SetHistLineWidth(fHistLineWidth->GetSelected());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the histos line style is modified by the user.


 void TStyleManager::ModHistLineStyle()

 {

    fCurSelStyle->SetHistLineStyle(fHistLineStyle->GetSelected());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the histos bar width is modified by the user.


 void TStyleManager::ModBarWidth()

 {

    fCurSelStyle->SetBarWidth(fBarWidth->GetNumber());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the histos bar offset is modified by the user.


 void TStyleManager::ModBarOffset()

 {

    fCurSelStyle->SetBarOffset(fBarOffset->GetNumber());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 ///  Slot called whenever the histos minimum zero boolean is modified

 /// by the user.


 void TStyleManager::ModHistMinimumZero()

 {

    fCurSelStyle->SetHistMinimumZero(fHistMinimumZero->IsDown());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the paint text format is modified by the user.


 void TStyleManager::ModPaintTextFormat()

 {

    fCurSelStyle->SetPaintTextFormat(fPaintTextFormat->GetText());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the number of contours is modified by the user.


 void TStyleManager::ModNumberContours()

 {

    fCurSelStyle->SetNumberContours(fNumberContours->GetIntNumber());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the lego inner radius is modified by the user.


 void TStyleManager::ModLegoInnerR()

 {

    fCurSelStyle->SetLegoInnerR(fLegoInnerR->GetIntNumber() *0.01);

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the frame fill color is modified by the user.


 void TStyleManager::ModFrameFillColor()

 {

    fCurSelStyle->SetFrameFillColor(TColor::GetColor(fFrameFillColor->GetColor()));

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the frame fill style is modified by the user.


 void TStyleManager::ModFrameFillStyle()

 {

    fCurSelStyle->SetFrameFillStyle(fFrameFillStyle->GetPattern());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the frame line color is modified by the user.


 void TStyleManager::ModFrameLineColor()

 {

    fCurSelStyle->SetFrameLineColor(TColor::GetColor(fFrameLineColor->GetColor()));

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the frame line width is modified by the user.


 void TStyleManager::ModFrameLineWidth()

 {

    fCurSelStyle->SetFrameLineWidth(fFrameLineWidth->GetSelected());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the frame line style is modified by the user.


 void TStyleManager::ModFrameLineStyle()

 {

    fCurSelStyle->SetFrameLineStyle(fFrameLineStyle->GetSelected());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the palette editor is opened by the user.


 void TStyleManager::ModPaletteEdit()

 {

    // TODO Open a palette editor

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the frame border mode is modified by the user.


 void TStyleManager::ModFrameBorderMode()

 {

    Int_t i = kFrameBorderModeSunken;

    TGButton *but = 0;

    while ((but = fFrameBorderMode->Find(i)) && !but->IsDown())

       i++;

    fCurSelStyle->SetFrameBorderMode(i - 1 - kFrameBorderModeSunken);

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the frame border size is modified by the user.


 void TStyleManager::ModFrameBorderSize()

 {

    fCurSelStyle->SetFrameBorderSize(fFrameBorderSize->GetSelected());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the function line color is modified by the user.


 void TStyleManager::ModFuncColor()

 {

    fCurSelStyle->SetFuncColor(TColor::GetColor(fFuncColor->GetColor()));

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the function line width is modified by the user.


 void TStyleManager::ModFuncWidth()

 {

    fCurSelStyle->SetFuncWidth(fFuncWidth->GetSelected());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the function line style is modified by the user.


 void TStyleManager::ModFuncStyle()

 {

    fCurSelStyle->SetFuncStyle(fFuncStyle->GetSelected());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the draw border boolean is modified by the user.


 void TStyleManager::ModDrawBorder()

 {

    fCurSelStyle->SetDrawBorder(fDrawBorder->IsDown());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the end error size is modified by the user.


 void TStyleManager::ModEndErrorSize()

 {

    fCurSelStyle->SetEndErrorSize(fEndErrorSize->GetNumber());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the error along X is modified by the user.


 void TStyleManager::ModErrorX()

 {

    fCurSelStyle->SetErrorX(fErrorX->GetIntNumber() * 0.001);

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the time offset is modified by the user.


 void TStyleManager::ModTimeOffset()

 {

    Double_t offset = 0;

    Int_t year  =  ((Int_t) fTimeOffsetDate->GetNumber())/10000;

    Int_t month = (((Int_t) fTimeOffsetDate->GetNumber())/100) % 100;

    Int_t day   =  ((Int_t) fTimeOffsetDate->GetNumber()) % 100;


    while (day > 1) {

       day--;

       offset += 3600 * 24;

    }


    Int_t oneMonthInSecs;

    while (month > 1) {

       month--;

       switch (month) {

          case 2:

             if (year % 4) oneMonthInSecs = 3600 * 24 * 28;

                      else oneMonthInSecs = 3600 * 24 * 29;

             break;

          case 1: case 3: case 5: case 7: case 8: case 10: case 12:

             oneMonthInSecs = 3600 * 24 * 31;

             break;

          default:

             oneMonthInSecs = 3600 * 24 * 30;

       }

       offset += oneMonthInSecs;

    }


    Int_t oneYearInSecs;

    while (year < 1995) {

       if (year % 4) oneYearInSecs = 3600 * 24 * 365;

                else oneYearInSecs = 3600 * 24 * 366;

       offset -= oneYearInSecs;

       year++;

    }

    while (year > 1995) {

       year--;

       if (year % 4) oneYearInSecs = 3600 * 24 * 365;

                else oneYearInSecs = 3600 * 24 * 366;

       offset += oneYearInSecs;

    }


    offset += 788918400 + fTimeOffsetTime->GetNumber();


    fCurSelStyle->SetTimeOffset(offset);

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the strip decimal boolean is modified by the user.


 void TStyleManager::ModStripDecimals()

 {

    fCurSelStyle->SetStripDecimals(!fStripDecimals->IsDown());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 ///  Slot called whenever the apply on XYZ button is clicked. The settings of

 /// the current selected axis pad are applyed on all axis.

 /// NB: The logarithmic scale option isn't modified by this method.


 void TStyleManager::ModApplyOnXYZ()

 {

    switch (fCurTabAxisNum) {

       case 0: // X axis

          fCurSelStyle->SetAxisColor(fCurSelStyle->GetAxisColor("x"), "yz");

          fCurSelStyle->SetTickLength(fCurSelStyle->GetTickLength("x"), "yz");

          fCurSelStyle->SetTitleColor(fCurSelStyle->GetTitleColor("x"), "yz");

          fCurSelStyle->SetTitleFont(fCurSelStyle->GetTitleFont("x"), "yz");

          fCurSelStyle->SetTitleSize(fCurSelStyle->GetTitleSize("x"), "yz");

          fCurSelStyle->SetTitleOffset(fCurSelStyle->GetTitleOffset("x"), "yz");

          fCurSelStyle->SetNdivisions(fCurSelStyle->GetNdivisions("x"), "yz");

          fCurSelStyle->SetLabelColor(fCurSelStyle->GetLabelColor("x"), "yz");

          fCurSelStyle->SetLabelFont(fCurSelStyle->GetLabelFont("x"), "yz");

          fCurSelStyle->SetLabelSize(fCurSelStyle->GetLabelSize("x"), "yz");

          fCurSelStyle->SetLabelOffset(fCurSelStyle->GetLabelOffset("x"), "yz");

          break;

       case 1: // Y axis

          fCurSelStyle->SetAxisColor(fCurSelStyle->GetAxisColor("y"), "xz");

          fCurSelStyle->SetTickLength(fCurSelStyle->GetTickLength("y"), "xz");

          fCurSelStyle->SetTitleColor(fCurSelStyle->GetTitleColor("y"), "xz");

          fCurSelStyle->SetTitleFont(fCurSelStyle->GetTitleFont("y"), "xz");

          fCurSelStyle->SetTitleSize(fCurSelStyle->GetTitleSize("y"), "xz");

          fCurSelStyle->SetTitleOffset(fCurSelStyle->GetTitleOffset("y"), "xz");

          fCurSelStyle->SetNdivisions(fCurSelStyle->GetNdivisions("y"), "xz");

          fCurSelStyle->SetLabelColor(fCurSelStyle->GetLabelColor("y"), "xz");

          fCurSelStyle->SetLabelFont(fCurSelStyle->GetLabelFont("y"), "xz");

          fCurSelStyle->SetLabelSize(fCurSelStyle->GetLabelSize("y"), "xz");

          fCurSelStyle->SetLabelOffset(fCurSelStyle->GetLabelOffset("y"), "xz");

          break;


       case 2: // Z axis

          fCurSelStyle->SetAxisColor(fCurSelStyle->GetAxisColor("z"), "xy");

          fCurSelStyle->SetTickLength(fCurSelStyle->GetTickLength("z"), "xy");

          fCurSelStyle->SetTitleColor(fCurSelStyle->GetTitleColor("z"), "xy");

          fCurSelStyle->SetTitleFont(fCurSelStyle->GetTitleFont("z"), "xy");

          fCurSelStyle->SetTitleSize(fCurSelStyle->GetTitleSize("z"), "xy");

          fCurSelStyle->SetTitleOffset(fCurSelStyle->GetTitleOffset("z"), "xy");

          fCurSelStyle->SetNdivisions(fCurSelStyle->GetNdivisions("z"), "xy");

          fCurSelStyle->SetLabelColor(fCurSelStyle->GetLabelColor("z"), "xy");

          fCurSelStyle->SetLabelFont(fCurSelStyle->GetLabelFont("z"), "xy");

          fCurSelStyle->SetLabelSize(fCurSelStyle->GetLabelSize("z"), "xy");

          fCurSelStyle->SetLabelOffset(fCurSelStyle->GetLabelOffset("z"), "xy");

          break;

    }


    DisconnectEditor(fCurTabNum);

    UpdateEditor(fCurTabNum);

    ConnectEditor(fCurTabNum);

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the X axis title size is modified by the user.


 void TStyleManager::ModXTitleSize()

 {

    fCurSelStyle->SetTitleSize(fXTitleSize->GetNumber(), "X");

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the X axis title size mode is modified by the user.


 void TStyleManager::ModXTitleSizeInPixels(Bool_t b)

 {

    Int_t tmp = fCurSelStyle->GetTitleFont("X") / 10;

    Int_t mod = fCurSelStyle->GetTitleFont("X") % 10;

    Double_t h = TMath::Max(fCurSelStyle->GetCanvasDefH(), 100);

    if (b) {

       fCurSelStyle->SetTitleFont(tmp * 10 + 3, "X");

       fXTitleSize->SetFormat(TGNumberFormat::kNESInteger,

                            TGNumberFormat::kNEAPositive);

       fXTitleSize->SetLimits(TGNumberFormat::kNELLimitMinMax, 0, h);

       if (mod == 2)

          fCurSelStyle->SetTitleSize(fCurSelStyle->GetTitleSize("X") * h, "X");

    } else {

       fCurSelStyle->SetTitleFont(tmp * 10 + 2, "X");

       fXTitleSize->SetFormat(TGNumberFormat::kNESRealThree,

                            TGNumberFormat::kNEAPositive);

       fXTitleSize->SetLimits(TGNumberFormat::kNELLimitMinMax, 0, 1);

       if (mod == 3)

          fCurSelStyle->SetTitleSize(fCurSelStyle->GetTitleSize("X") / h, "X");

    }

    fXTitleSize->SetNumber(fCurSelStyle->GetTitleSize("X"));

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the X axis title color is modified by the user.


 void TStyleManager::ModXTitleColor()

 {

    fCurSelStyle->SetTitleColor(TColor::GetColor(fXTitleColor->GetColor()), "X");

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the X axis title offset is modified by the user.


 void TStyleManager::ModXTitleOffset()

 {

    fCurSelStyle->SetTitleOffset(fXTitleOffset->GetNumber(), "X");

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the X axis title font is modified by the user.


 void TStyleManager::ModXTitleFont()

 {

    Int_t fontPrec = fCurSelStyle->GetTitleFont("X") % 10;

    fCurSelStyle->SetTitleFont(fXTitleFont->GetSelected() * 10 + fontPrec, "X");

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the X axis label size is modified by the user.


 void TStyleManager::ModXLabelSize()

 {

    fCurSelStyle->SetLabelSize(fXLabelSize->GetNumber(), "X");

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the X axis label size mode is modified by the user.


 void TStyleManager::ModXLabelSizeInPixels(Bool_t b)

 {

    Int_t tmp = fCurSelStyle->GetLabelFont("X") / 10;

    Int_t mod = fCurSelStyle->GetLabelFont("X") % 10;

    Double_t h = TMath::Max(fCurSelStyle->GetCanvasDefH(), 100);

    if (b) {

       fCurSelStyle->SetLabelFont(tmp * 10 + 3, "X");

       fXLabelSize->SetFormat(TGNumberFormat::kNESInteger,

                            TGNumberFormat::kNEAPositive);

       fXLabelSize->SetLimits(TGNumberFormat::kNELLimitMinMax, 0, h);

       if (mod == 2)

          fCurSelStyle->SetLabelSize(fCurSelStyle->GetLabelSize("X") * h, "X");

    } else {

       fCurSelStyle->SetLabelFont(tmp * 10 + 2, "X");

       fXLabelSize->SetFormat(TGNumberFormat::kNESRealThree,

                            TGNumberFormat::kNEAPositive);

       fXLabelSize->SetLimits(TGNumberFormat::kNELLimitMinMax, 0, 1);

       if (mod == 3)

          fCurSelStyle->SetLabelSize(fCurSelStyle->GetLabelSize("X") / h, "X");

    }

    fXLabelSize->SetNumber(fCurSelStyle->GetLabelSize("X"));

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the X axis label color is modified by the user.


 void TStyleManager::ModXLabelColor()

 {

    fCurSelStyle->SetLabelColor(TColor::GetColor(fXLabelColor->GetColor()), "X");

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the X axis label offset is modified by the user.


 void TStyleManager::ModXLabelOffset()

 {

    fCurSelStyle->SetLabelOffset(fXLabelOffset->GetNumber(), "X");

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the X axis label font is modified by the user.


 void TStyleManager::ModXLabelFont()

 {

    Int_t fontPrec = fCurSelStyle->GetLabelFont("X") % 10;

    fCurSelStyle->SetLabelFont(fXLabelFont->GetSelected() * 10 + fontPrec, "X");

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the X axis color is modified by the user.


 void TStyleManager::ModXAxisColor()

 {

    fCurSelStyle->SetAxisColor(TColor::GetColor(fXAxisColor->GetColor()), "X");

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the X axis tick length is modified by the user.


 void TStyleManager::ModXTickLength()

 {

    fCurSelStyle->SetTickLength(fXTickLength->GetNumber(), "X");

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 ///  Slot called whenever the X axis log scale boolean is modified

 /// by the user.


 void TStyleManager::ModOptLogx()

 {

    fCurSelStyle->SetOptLogx(fOptLogx->IsDown());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 ///  Slot called whenever the X axis Number of divisions is modified

 /// by the user.


 void TStyleManager::ModXNdivisions()

 {

    Int_t sgn = -1;

    if (fXNdivisionsOptimize->IsDown()) sgn = 1;

    fCurSelStyle->SetNdivisions(sgn * (fXNdivMain->GetIntNumber()

                                + 100 * fXNdivSub->GetIntNumber()

                                + 10000 * fXNdivSubSub->GetIntNumber()), "X");

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the Y axis title size is modified by the user.


 void TStyleManager::ModYTitleSize()

 {

    fCurSelStyle->SetTitleSize(fYTitleSize->GetNumber(), "Y");

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the Y axis title size mode is modified by the user.


 void TStyleManager::ModYTitleSizeInPixels(Bool_t b)

 {

    Int_t tmp = fCurSelStyle->GetTitleFont("Y") / 10;

    Int_t mod = fCurSelStyle->GetTitleFont("Y") % 10;

    Double_t h = TMath::Max(fCurSelStyle->GetCanvasDefH(), 100);

    if (b) {

       fCurSelStyle->SetTitleFont(tmp * 10 + 3, "Y");

       fYTitleSize->SetFormat(TGNumberFormat::kNESInteger,

                              TGNumberFormat::kNEAPositive);

       fYTitleSize->SetLimits(TGNumberFormat::kNELLimitMinMax, 0, h);

       if (mod == 2)

          fCurSelStyle->SetTitleSize(fCurSelStyle->GetTitleSize("Y") * h, "Y");

    } else {

       fCurSelStyle->SetTitleFont(tmp * 10 + 2, "Y");

       fYTitleSize->SetFormat(TGNumberFormat::kNESRealThree,

                              TGNumberFormat::kNEAPositive);

       fYTitleSize->SetLimits(TGNumberFormat::kNELLimitMinMax, 0, 1);

       if (mod == 3)

          fCurSelStyle->SetTitleSize(fCurSelStyle->GetTitleSize("Y") / h, "Y");

    }

    fYTitleSize->SetNumber(fCurSelStyle->GetTitleSize("Y"));

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the Y axis title color is modified by the user.


 void TStyleManager::ModYTitleColor()

 {

    fCurSelStyle->SetTitleColor(TColor::GetColor(fYTitleColor->GetColor()), "Y");

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the Y axis title offset is modified by the user.


 void TStyleManager::ModYTitleOffset()

 {

    fCurSelStyle->SetTitleOffset(fYTitleOffset->GetNumber(), "Y");

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the Y axis title font is modified by the user.


 void TStyleManager::ModYTitleFont()

 {

    Int_t fontPrec = fCurSelStyle->GetTitleFont("Y") % 10;

    fCurSelStyle->SetTitleFont(fYTitleFont->GetSelected() * 10 + fontPrec, "Y");

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the Y axis label size is modified by the user.


 void TStyleManager::ModYLabelSize()

 {

    fCurSelStyle->SetLabelSize(fYLabelSize->GetNumber(), "Y");

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the Y axis label size mode is modified by the user.


 void TStyleManager::ModYLabelSizeInPixels(Bool_t b)

 {

    Int_t tmp = fCurSelStyle->GetLabelFont("Y") / 10;

    Int_t mod = fCurSelStyle->GetLabelFont("Y") % 10;

    Double_t h = TMath::Max(fCurSelStyle->GetCanvasDefH(), 100);

    if (b) {

       fCurSelStyle->SetLabelFont(tmp * 10 + 3, "Y");

       fYLabelSize->SetFormat(TGNumberFormat::kNESInteger,

                              TGNumberFormat::kNEAPositive);

       fYLabelSize->SetLimits(TGNumberFormat::kNELLimitMinMax, 0, h);

       if (mod == 2)

          fCurSelStyle->SetLabelSize(fCurSelStyle->GetLabelSize("Y") * h, "Y");

    } else {

       fCurSelStyle->SetLabelFont(tmp * 10 + 2, "Y");

       fYLabelSize->SetFormat(TGNumberFormat::kNESRealThree,

                              TGNumberFormat::kNEAPositive);

       fYLabelSize->SetLimits(TGNumberFormat::kNELLimitMinMax, 0, 1);

       if (mod == 3)

          fCurSelStyle->SetLabelSize(fCurSelStyle->GetLabelSize("Y") / h, "Y");

    }

    fYLabelSize->SetNumber(fCurSelStyle->GetLabelSize("Y"));

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the Y axis label color is modified by the user.


 void TStyleManager::ModYLabelColor()

 {

    fCurSelStyle->SetLabelColor(TColor::GetColor(fYLabelColor->GetColor()), "Y");

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the Y axis label offset is modified by the user.


 void TStyleManager::ModYLabelOffset()

 {

    fCurSelStyle->SetLabelOffset(fYLabelOffset->GetNumber(), "Y");

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the Y axis label font is modified by the user.


 void TStyleManager::ModYLabelFont()

 {

    Int_t fontPrec = fCurSelStyle->GetLabelFont("Y") % 10;

    fCurSelStyle->SetLabelFont(fYLabelFont->GetSelected() * 10 + fontPrec, "Y");

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the Y axis color is modified by the user.


 void TStyleManager::ModYAxisColor()

 {

    fCurSelStyle->SetAxisColor(TColor::GetColor(fYAxisColor->GetColor()), "Y");

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the Y axis tick length is modified by the user.


 void TStyleManager::ModYTickLength()

 {

    fCurSelStyle->SetTickLength(fYTickLength->GetNumber(), "Y");

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the Y axis log scale boolean is modified by the user.


 void TStyleManager::ModOptLogy()

 {

    fCurSelStyle->SetOptLogy(fOptLogy->IsDown());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 ///  Slot called whenever the Y axis Number of divisions is modified

 /// by the user.


 void TStyleManager::ModYNdivisions()

 {

    Int_t sgn = -1;

    if (fYNdivisionsOptimize->IsDown()) sgn = 1;

    fCurSelStyle->SetNdivisions(sgn * (fYNdivMain->GetIntNumber()

                                + 100 * fYNdivSub->GetIntNumber()

                                + 10000 * fYNdivSubSub->GetIntNumber()), "Y");

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the Z axis title size is modified by the user.


 void TStyleManager::ModZTitleSize()

 {

    fCurSelStyle->SetTitleSize(fZTitleSize->GetNumber(), "Z");

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the Z axis title size mode is modified by the user.


 void TStyleManager::ModZTitleSizeInPixels(Bool_t b)

 {

    Int_t tmp = fCurSelStyle->GetTitleFont("Z") / 10;

    Int_t mod = fCurSelStyle->GetTitleFont("Z") % 10;

    Double_t h = TMath::Max(fCurSelStyle->GetCanvasDefH(), 100);

    if (b) {

       fCurSelStyle->SetTitleFont(tmp * 10 + 3, "Z");

       fZTitleSize->SetFormat(TGNumberFormat::kNESInteger,

                              TGNumberFormat::kNEAPositive);

       fZTitleSize->SetLimits(TGNumberFormat::kNELLimitMinMax, 0, h);

       if (mod == 2)

          fCurSelStyle->SetTitleSize(fCurSelStyle->GetTitleSize("Z") * h, "Z");

    } else {

       fCurSelStyle->SetTitleFont(tmp * 10 + 2, "Z");

       fZTitleSize->SetFormat(TGNumberFormat::kNESRealThree,

                              TGNumberFormat::kNEAPositive);

       fZTitleSize->SetLimits(TGNumberFormat::kNELLimitMinMax, 0, 1);

       if (mod == 3)

          fCurSelStyle->SetTitleSize(fCurSelStyle->GetTitleSize("Z") / h, "Z");

    }

    fZTitleSize->SetNumber(fCurSelStyle->GetTitleSize("Z"));

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the Z axis title color is modified by the user.


 void TStyleManager::ModZTitleColor()

 {

    fCurSelStyle->SetTitleColor(TColor::GetColor(fZTitleColor->GetColor()), "Z");

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the Z axis title offset is modified by the user.


 void TStyleManager::ModZTitleOffset()

 {

    fCurSelStyle->SetTitleOffset(fZTitleOffset->GetNumber(), "Z");

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the Z axis title font is modified by the user.


 void TStyleManager::ModZTitleFont()

 {

    Int_t fontPrec = fCurSelStyle->GetTitleFont("Z") % 10;

    fCurSelStyle->SetTitleFont(fZTitleFont->GetSelected() * 10 + fontPrec, "Z");

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the Z axis label size is modified by the user.


 void TStyleManager::ModZLabelSize()

 {

    fCurSelStyle->SetLabelSize(fZLabelSize->GetNumber(), "Z");

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the Z axis Label size mode is modified by the user.


 void TStyleManager::ModZLabelSizeInPixels(Bool_t b)

 {

    Int_t tmp = fCurSelStyle->GetLabelFont("Z") / 10;

    Int_t mod = fCurSelStyle->GetLabelFont("Z") % 10;

    Double_t h = TMath::Max(fCurSelStyle->GetCanvasDefH(), 100);

    if (b) {

       fCurSelStyle->SetLabelFont(tmp * 10 + 3, "Z");

       fZLabelSize->SetFormat(TGNumberFormat::kNESInteger,

                              TGNumberFormat::kNEAPositive);

       fZLabelSize->SetLimits(TGNumberFormat::kNELLimitMinMax, 0, h);

       if (mod == 2)

          fCurSelStyle->SetLabelSize(fCurSelStyle->GetLabelSize("Z") * h, "Z");

    } else {

       fCurSelStyle->SetLabelFont(tmp * 10 + 2, "Z");

       fZLabelSize->SetFormat(TGNumberFormat::kNESRealThree,

                              TGNumberFormat::kNEAPositive);

       fZLabelSize->SetLimits(TGNumberFormat::kNELLimitMinMax, 0, 1);

       if (mod == 3)

          fCurSelStyle->SetLabelSize(fCurSelStyle->GetLabelSize("Z") / h, "Z");

    }

    fZLabelSize->SetNumber(fCurSelStyle->GetLabelSize("Z"));

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the Z axis label color is modified by the user.


 void TStyleManager::ModZLabelColor()

 {

    fCurSelStyle->SetLabelColor(TColor::GetColor(fZLabelColor->GetColor()), "Z");

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the Z axis label offset is modified by the user.


 void TStyleManager::ModZLabelOffset()

 {

    fCurSelStyle->SetLabelOffset(fZLabelOffset->GetNumber(), "Z");

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the Z axis label font is modified by the user.


 void TStyleManager::ModZLabelFont()

 {

    Int_t fontPrec = fCurSelStyle->GetLabelFont("Z") % 10;

    fCurSelStyle->SetLabelFont(fZLabelFont->GetSelected() * 10 + fontPrec, "Z");

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the Z axis color is modified by the user.


 void TStyleManager::ModZAxisColor()

 {

    fCurSelStyle->SetAxisColor(TColor::GetColor(fZAxisColor->GetColor()), "Z");

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the Z axis tick length is modified by the user.


 void TStyleManager::ModZTickLength()

 {

    fCurSelStyle->SetTickLength(fZTickLength->GetNumber(), "Z");

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the Z axis log scale boolean is modified by the user.


 void TStyleManager::ModOptLogz()

 {

    fCurSelStyle->SetOptLogz(fOptLogz->IsDown());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 ///  Slot called whenever the Z axis Number of divisions is modified

 /// by the user.


 void TStyleManager::ModZNdivisions()

 {

    Int_t sgn = -1;

    if (fZNdivisionsOptimize->IsDown()) sgn = 1;

    fCurSelStyle->SetNdivisions(sgn * (fZNdivMain->GetIntNumber()

                                + 100 * fZNdivSub->GetIntNumber()

                                + 10000 * fZNdivSubSub->GetIntNumber()), "Z");

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the OptTitle boolean is modified by the user.


 void TStyleManager::ModOptTitle()

 {

    fCurSelStyle->SetOptTitle(fOptTitle->IsDown());

    DisconnectEditor(fCurTabNum);

    UpdateEditor(fCurTabNum);

    ConnectEditor(fCurTabNum);

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the title fill color is modified by the user.


 void TStyleManager::ModTitleFillColor()

 {

    fCurSelStyle->SetTitleFillColor(TColor::GetColor(fTitleColor->GetColor()));

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the title fill style is modified by the user.


 void TStyleManager::ModTitleStyle()

 {

    fCurSelStyle->SetTitleStyle(fTitleStyle->GetPattern());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the title text color is modified by the user.


 void TStyleManager::ModTitleTextColor()

 {

    fCurSelStyle->SetTitleTextColor(TColor::GetColor(fTitleTextColor->GetColor()));

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the text size is modified by the user.


 void TStyleManager::ModTitleFontSize()

 {

    fCurSelStyle->SetTitleFontSize(fTitleFontSize->GetNumber());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the text size mode is modified by the user.


 void TStyleManager::ModTitleFontSizeInPixels(Bool_t b)

 {

    Int_t tmp = fCurSelStyle->GetTitleFont() / 10;

    Int_t mod = fCurSelStyle->GetTitleFont() % 10;

    Double_t h = TMath::Max(fCurSelStyle->GetCanvasDefH(), 100);

    if (b) {

       fCurSelStyle->SetTitleFont(tmp * 10 + 3);

       fTitleFontSize->SetFormat(TGNumberFormat::kNESInteger,

                                 TGNumberFormat::kNEAPositive);

       fTitleFontSize->SetLimits(TGNumberFormat::kNELLimitMinMax, 0, h);

       if (mod == 2)

          fCurSelStyle->SetTitleFontSize(fCurSelStyle->GetTitleFontSize() * h);

    } else {

       fCurSelStyle->SetTitleFont(tmp * 10 + 2);

       fTitleFontSize->SetFormat(TGNumberFormat::kNESRealThree,

                                 TGNumberFormat::kNEAPositive);

       fTitleFontSize->SetLimits(TGNumberFormat::kNELLimitMinMax, 0, 1);

       if (mod == 3)

          fCurSelStyle->SetTitleFontSize(fCurSelStyle->GetTitleFontSize() / h);

    }

    fTitleFontSize->SetNumber(fCurSelStyle->GetTitleFontSize());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the title text font is modified by the user.


 void TStyleManager::ModTitleFont()

 {

    Int_t tmp = fCurSelStyle->GetTitleFont() % 10;

    fCurSelStyle->SetTitleFont(fTitleFont->GetSelected() * 10 + tmp);

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the title text align is modified by the user.


 void TStyleManager::ModTitleAlign()

 {

    fCurSelStyle->SetTitleAlign(fTitleAlign->GetSelected());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the title border size is modified by the user.


 void TStyleManager::ModTitleBorderSize()

 {

    fCurSelStyle->SetTitleBorderSize(fTitleBorderSize->GetSelected());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the legend border size is modified by the user.


 void TStyleManager::ModLegendBorderSize()

 {

    fCurSelStyle->SetLegendBorderSize(fLegendBorderSize->GetSelected());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the title abscissa is modified by the user.


 void TStyleManager::ModTitleX()

 {

    fCurSelStyle->SetTitleX(fTitleX->GetIntNumber() * 0.01);

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the title ordinate is modified by the user.


 void TStyleManager::ModTitleY()

 {

    fCurSelStyle->SetTitleY(fTitleY->GetIntNumber() * 0.01);

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the title width is modified by the user.


 void TStyleManager::ModTitleW()

 {

    fCurSelStyle->SetTitleW(fTitleW->GetIntNumber() * 0.01);

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the title height is modified by the user.


 void TStyleManager::ModTitleH()

 {

    fCurSelStyle->SetTitleH(fTitleH->GetIntNumber() * 0.01);

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the stats fill color is modified by the user.


 void TStyleManager::ModStatColor(Pixel_t color)

 {

    fCurSelStyle->SetStatColor(TColor::GetColor(color));

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the stats fill style is modified by the user.


 void TStyleManager::ModStatStyle(Style_t pattern)

 {

    fCurSelStyle->SetStatStyle(pattern);

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the stats text color is modified by the user.


 void TStyleManager::ModStatTextColor(Pixel_t color)

 {

    fCurSelStyle->SetStatTextColor(TColor::GetColor(color));

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the text size is modified by the user.


 void TStyleManager::ModStatFontSize()

 {

    fCurSelStyle->SetStatFontSize(fStatFontSize->GetNumber());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the text size mode is modified by the user.


 void TStyleManager::ModStatFontSizeInPixels(Bool_t b)

 {

    Int_t tmp = fCurSelStyle->GetStatFont() / 10;

    Int_t mod = fCurSelStyle->GetStatFont() % 10;

    Double_t h = TMath::Max(fCurSelStyle->GetCanvasDefH(), 100);

    if (b) {

       fCurSelStyle->SetStatFont(tmp * 10 + 3);

       fStatFontSize->SetFormat(TGNumberFormat::kNESInteger,

                                TGNumberFormat::kNEANonNegative);

       fStatFontSize->SetLimits(TGNumberFormat::kNELLimitMinMax, 0, h);

       if (mod == 2)

          fCurSelStyle->SetStatFontSize(fCurSelStyle->GetStatFontSize() * h);

       fStatFontSize->SetNumber(fCurSelStyle->GetStatFontSize());

    } else {

       fCurSelStyle->SetStatFont(tmp * 10 + 2);

       fStatFontSize->SetFormat(TGNumberFormat::kNESRealThree,

                                TGNumberFormat::kNEANonNegative);

       fStatFontSize->SetLimits(TGNumberFormat::kNELLimitMinMax, 0., 1.);

       if (mod == 3)

          fCurSelStyle->SetStatFontSize(fCurSelStyle->GetStatFontSize() / h);

       fStatFontSize->SetNumber(fCurSelStyle->GetStatFontSize());

    }

    fStatFontSize->SetNumber(fCurSelStyle->GetStatFontSize());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the stats text font is modified by the user.


 void TStyleManager::ModStatFont()

 {

    Int_t tmp = fCurSelStyle->GetStatFont() % 10;

    fCurSelStyle->SetStatFont(fStatFont->GetSelected() * 10 + tmp);

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the stats abscissa is modified by the user.


 void TStyleManager::ModStatX()

 {

    fCurSelStyle->SetStatX((Float_t)fStatX->GetNumber());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the stats ordinate is modified by the user.


 void TStyleManager::ModStatY()

 {

    fCurSelStyle->SetStatY((Float_t)fStatY->GetNumber());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the stats width is modified by the user.


 void TStyleManager::ModStatW()

 {

    fCurSelStyle->SetStatW((Float_t)fStatW->GetNumber());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the stats height is modified by the user.


 void TStyleManager::ModStatH()

 {

    fCurSelStyle->SetStatH((Float_t)fStatH->GetNumber());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the stats border size is modified by the user.


 void TStyleManager::ModStatBorderSize()

 {

    fCurSelStyle->SetStatBorderSize(fStatBorderSize->GetSelected());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever one of the stats options is modified by the user.


 void TStyleManager::ModOptStat()

 {

    Int_t stat = 0;

    if (fOptStatName->IsDown())        stat +=1;

    if (fOptStatEntries->IsDown())     stat +=10;

    if (fOptStatMean->IsDown())        stat +=100;

    if (fOptStatRMS->IsDown())         stat +=1000;

    if (fOptStatUnderflow->IsDown())   stat +=10000;

    if (fOptStatOverflow->IsDown())    stat +=100000;

    if (fOptStatIntegral->IsDown())    stat +=1000000;

    if (fOptStatSkewness->IsDown())    stat +=10000000;

    if (fOptStatKurtosis->IsDown())    stat +=100000000;

    if (fOptStatErrors->IsDown()) {

       if (fOptStatMean->IsDown())     stat +=100;

       if (fOptStatRMS->IsDown())      stat +=1000;

       if (fOptStatSkewness->IsDown()) stat +=10000000;

       if (fOptStatKurtosis->IsDown()) stat +=100000000;

    }

    if (stat == 1) stat = 1000000001;

    fCurSelStyle->SetOptStat(stat);

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the stats paint format is modified by the user.


 void TStyleManager::ModStatFormat(const char *sformat)

 {

    fCurSelStyle->SetStatFormat(sformat);

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever one of the fit options is modified by the user.


 void TStyleManager::ModOptFit()

 {

    Int_t fit = 0;

    if (fOptFitValues->IsDown())      fit +=1;

    if (fOptFitErrors->IsDown())      fit +=10;

    if (fOptFitChi->IsDown())         fit +=100;

    if (fOptFitProbability->IsDown()) fit +=1000;

    if (fit == 1) fit = 10001;

    fCurSelStyle->SetOptFit(fit);

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the fit paint format is modified by the user.


 void TStyleManager::ModFitFormat(const char *fitformat)

 {

    fCurSelStyle->SetFitFormat(fitformat);

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the PS header is modified by the user.


 void TStyleManager::ModHeaderPS()

 {

    fCurSelStyle->SetHeaderPS(fHeaderPS->GetText());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the PS title is modified by the user.


 void TStyleManager::ModTitlePS()

 {

    fCurSelStyle->SetTitlePS(fTitlePS->GetText());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the PS color model is modified by the user.


 void TStyleManager::ModColorModelPS()

 {

    Int_t i = kPSPDFColorModelPSRGB;

    TGButton *but = 0;

    while ((but = fColorModelPS->Find(i)) && !but->IsDown()) i++;

    fCurSelStyle->SetColorModelPS(i - kPSPDFColorModelPSRGB);

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the PS line scale is modified by the user.


 void TStyleManager::ModLineScalePS()

 {

    fCurSelStyle->SetLineScalePS(fLineScalePS->GetNumber());

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the PS paper size is modified by the user.


 void TStyleManager::ModPaperSizePredef()

 {

    Float_t papSizeX;

    Float_t papSizeY;

    fCurSelStyle->GetPaperSize(papSizeX, papSizeY);


    if (fPaperSizePredef->GetSelected() == 1) {

       if (!fPaperSizeEnCm) {

          fPaperSizeEnCm = kTRUE;

          fPaperSizeX->SetNumber(papSizeX);

          fPaperSizeY->SetNumber(papSizeY);

       }

    } else if (fPaperSizePredef->GetSelected() == 2) {

       if (fPaperSizeEnCm) {

          fPaperSizeEnCm = kFALSE;

          fPaperSizeX->SetNumber(papSizeX * 0.394);

          fPaperSizeY->SetNumber(papSizeY * 0.394);

       }

    } else if (fPaperSizePredef->GetSelected() == 3) {

       fPaperSizeEnCm = kTRUE;

       fPaperSizeX->SetNumber(20);

       fPaperSizeY->SetNumber(26);

       fCurSelStyle->SetPaperSize(20, 26);

    } else if (fPaperSizePredef->GetSelected() == 4) {

       fPaperSizeEnCm = kFALSE;

       fPaperSizeX->SetNumber(20 * 0.394);

       fPaperSizeY->SetNumber(24 * 0.394);

       fCurSelStyle->SetPaperSize(20, 24);

    }

    DoEditor();

 }


 ////////////////////////////////////////////////////////////////////////////////

 /// Slot called whenever the PS paper size is modified by the user.


 void TStyleManager::ModPaperSizeXY()

 {

    if (fPaperSizeEnCm) {

       fCurSelStyle->SetPaperSize(fPaperSizeX->GetNumber(),

                                  fPaperSizeY->GetNumber());

       fPaperSizePredef->Select(1);

    } else {

       fCurSelStyle->SetPaperSize(fPaperSizeX->GetNumber() * 2.54,

                                  fPaperSizeY->GetNumber() * 2.54);

       fPaperSizePredef->Select(2);

    }

    DoEditor();

 }

TGMsgBox.h

TGStatusBar.h

TGNumberEntry.h

TStyleManager.h

TGColorSelect.h

TSystem.h

TGLabel.h

HelpSMText.h

TCanvas.h

TGFrame.h

TGComboBox.h

TGTab.h

TVirtualPad.h

TStyleDialog.h

TROOT.h

TG3DLine.h

TGButtonGroup.h

TGedMarkerSelect.h

TStyle.h

TRootHelpDialog.h

TGMenu.h

TStylePreview.h

TGFileDialog.h

TColor.h

TGToolBar.h

TGedPatternSelect.h

TGResourcePool.h

TGButton.h

TGLayout.h