GEVPage.hh

Go to the documentation of this file.

//======================================================================
/*! \file GEVPage.hh
 *
 *  Déclaration des méthodes de la classe GEVPage, qui définit
 *  une page de spectres pour l'analyse.
 */
//======================================================================


#ifndef GEV_PAGE_HH
#define GEV_PAGE_HH

#define GEV_PAGE_DEFAULT_WIDTH    800   ///< Largeur par défaut des pages de spectres
#define GEV_PAGE_DEFAULT_HEIGHT   600   ///< Hauteur par défaut des pages de spectres

// includes Event
#include "GEVPageProperties.hh"
#include "SpectrumList.hh"
#include "GEVPad.hh"
#include "GEVPreferences.hh"
#include "GEVPadContour.hh"

// includes ROOT
#include <TGFrame.h>
#include <TRootEmbeddedCanvas.h>
#include <TCanvas.h>
#include <TGMenu.h>

//======================================================================
/*! \class GEVPage
 *
 *  Page de spectres pour l'interface graphique. La page n'est pas
 *  "propriétaire" des spectres, et ne les détruit pas lorsqu'elle
 *  est détruite.
 *
 *  Les pages disposent de leur propre barre de menus, ainsi que d'un
 *  menu contextuel qui correspond aux pads, et les menus conxtuels
 *  des objets Root sont bloqués, ce qui permet de limiter les actions
 *  utilisateur dans les pages.
 */

class GEVPage : public GNamed, public GEVPageProperties, public GListT<GEVPad>, public TGMainFrame
{
  friend class GEVPageManager;

//----------------------------------------------------------------------
  /*! \object_doc */
  GObject(GEVPage);
//----------------------------------------------------------------------

  /// Itérateur des pads de la collection (liste)
  typedef GListIterT<GEVPad>   iterator;


    /// Identification des menus
    enum PageMenus
    {
      // menu page
      menuPageSave     = 0x00000001,
      menuPageExport   = 0x00000002,
        menuPageExportPs   = 0x00000100,
        menuPageExportEps  = 0x00000101,
        menuPageExportGif  = 0x00000102,
        menuPageExportCpp  = 0x00000103,
        menuPageExportRoot = 0x00000104,
      menuPagePrint    = 0x00000003,
      menuPageNewPad   = 0x00000004,
      menuPageDivide   = 0x00000005,

      // menu display
      menuPageRefresh     = 0x00001000,
      menuPageSetStat     = 0x00001001,
      menuPageNoStat      = 0x00001002,

      menuPagePlotsRange  = 0x00001003,
      menuPagePlotsOpts   = 0x00001004,
      menuPagePlotsSelect = 0x00001005,

      menuPageProperties  = 0x00001006,
      menuPageHide        = 0x00001007,

      // menu contextuel page
      menuContextPageNewPad = 0x01000000,

      // menu contextuel pad
      menuContextPadUnzoom = 0x02000000,
      menuContextPadXLog   = 0x02000001,
      menuContextPadYLog   = 0x02000002,
      menuContextPadZLog   = 0x02000003,
      menuContextPadAutoX  = 0x02000004,
      menuContextPadAutoY  = 0x02000005,
      menuContextPadAutoZ  = 0x02000006,
      menuContextPadAxis   = 0x02000007,
        // sous-menu statistiques
        menuContextPadStatShow    = 0x02100000,
        menuContextPadStatAll     = 0x02100001,
        menuContextPadStatNone    = 0x02100002,
        menuContextPadStatEntries = 0x02100003,
        menuContextPadStatMean    = 0x02100004,
        menuContextPadStatRMS     = 0x02100005,
        menuContextPadStatCont    = 0x02100006,
        // sous-menu spectres
        menuContextPadSpecProp    = 0x02200000,
        menuContextPadSpecSelect  = 0x02200001,
        // sous-menu contours
        menuContextPadContDisplay = 0x02300000,
        menuContextPadContReset   = 0x02300001,
        // sous-menu outils
        menuContextPadFitError    = 0x02400000,
        menuContextPadFitPeak     = 0x02400001,
        menuContextPadFitDecay    = 0x02400002,

      // pad
      menuContextPadExportAs   = 0x02000010,
      menuContextPadProperties = 0x02000020,
      menuContextPadDivide     = 0x02000030,
      menuContextPadDelete     = 0x02000040
    };

    /// Identification du contexte des événements dans la page
    enum PageContext
    {
      contextDefault = 0,
      contextNewPad  = 1
    };

  protected:
    GEVPageManager      * parent;       ///< Pointeur sur la liste de pages associéeb8a@

    UInt_t                init_x;       ///< Position X de la page à sa création
    UInt_t                init_y;       ///< Position Y de la page à sa création
    UInt_t                width_diff;   ///< Différence de taille entre le canevas et la fenêtre
    UInt_t                height_diff;  ///< Différence de taille entre le canevas et la fenêtre

    TRootEmbeddedCanvas * canvas;       ///< Pointeur sur le canevas ROOT associé9f465b@

    static UInt_t         page_pos_x;   ///< Position en x de la dernière page créée
    static UInt_t         page_pos_y;   ///< Position en y de la dernière page créée

    static  bool          fit_error;    ///< Teste le menu de fit avec histogramme d'erreur

    bool                  constructed;  ///< Teste si la page est déjà construite

    // widgets des pages
    TGMenuBar           * w_page_menu_bar;            ///<  Barre de menu des pages
    TGPopupMenu         * w_page_menu_page;           ///<    Menu des actions sur la page
    TGPopupMenu         * w_page_menu_display;        ///<    Menu des réglages et options d'affichage

    TGPopupMenu         * w_page_export_menu;         ///<    Menu d'exportation des pages

    UInt_t                w_context_mode;             ///<  Contexte des actions dans la page
    GEVPad              * w_context_pad;              ///<  Pointeur sur la zone concernée par les actions

    TGPopupMenu         * w_page_context_menu;        ///<  Menu contextuel de fond de page

    TGPopupMenu         * w_pad_context_menu;         ///<  Menu contextuel (pour les Pads)
    TGPopupMenu         * w_pad_context_menu_stat;    ///<  Sous-menu contextuel: statistiques
    TGPopupMenu         * w_pad_context_menu_spec;    ///<  Sous-menu contextuel: spectres
    TGPopupMenu         * w_pad_context_menu_cont;    ///<  Sous-menu contextuel: contours
    TGPopupMenu         * w_pad_context_menu_tools;   ///<  Sous-menu contextuel: outils

    static  string        file_name;                  ///< nom de fichier de page
    static  string        export_name;                ///< nom de fichier exportéans la page

  public:

//----------------------------------------------------------------------
//  CONSTRUCTEUR / AFFECTATION / DESTRUCTEUR

    // Constructeurs
    GEVPage ( GEVPageManager * parent,
              const string   & title,
              const UInt_t     nx,
              const UInt_t     ny,
              const Int_t      w = GEVPreferences::page_width,
              const Int_t      h = GEVPreferences::page_height );

    // Constructeur de recopie
    GEVPage ( const GEVPage & original );

    // Destructeur
    virtual ~GEVPage ( );

  protected:

    virtual void ResetExportMenu ();

    // Création des pads par défaut
    virtual void SetDefaultPads ( const UInt_t nx, const UInt_t ny, const UInt_t n );

    virtual void DeleteSpectrumPad ( );
    virtual void UpdatePadNames    ( );

  public:
    // Construction effective de la page
    virtual void Construct ();

    /*! Redéfinition de la fonction pour GNamedListT (pour liste pouvant être triée).
     *  C'est le résultat de GNamed::Compare.
     *  \param  obj     page à comparer
     */
    inline virtual int  Compare ( const GEVPage &obj ) const
      { return (GNamed::Compare(obj)); }


    virtual GEVPad  * AddPad ( const Double_t x0 = 0.,
                               const Double_t x1 = 1.,
                               const Double_t y0 = 0.,
                               const Double_t y1 = 1.,
                               const GEVPad  *after = NULL );

    virtual GEVPad  * AddPad ( GEVPad       * new_pad,
                               const GEVPad * after = NULL );

    virtual void      DividePage  ( const UInt_t nx, const UInt_t ny );

    virtual void      DividePad   ( const UInt_t pad_num, const UInt_t nx, const UInt_t ny );
    virtual void      DividePad   ( GEVPad     * pad,     const UInt_t nx, const UInt_t ny );

//----------------------------------------------------------------------
//  METHODES DE BASE

    GEVPageManager  * GetPageManager  ( ) const;
    GEVPad          * GetPadPtr       ( const UInt_t num );
    UInt_t            GetPadNumber    ( ) const;
    TCanvas         * GetCanvas       ( ) const;
    string            GetPageName     ( ) const;

//----------------------------------------------------------------------
//  AFFICHAGE DES PAGES

    virtual void SetPadGeometry ( const UInt_t pad, const Double_t x0, const Double_t x1, const Double_t y0, const Double_t y1 );
    virtual void SetPadMargins  ( const UInt_t pad, const Double_t xmgl, const Double_t xmgr, const Double_t ymgu, const Double_t ymgd );


    // mise à jour de la page
    virtual void    Update ( ) const;

    // afficher/ferme une page (sans la détruire)
    virtual void    Show        ( );
    virtual void    Hide        ( );
    virtual void    ResizePage  ( const UInt_t w, const UInt_t h);

    virtual bool    CheckName     ( const string &page_name );
    virtual bool    Rename        ( const string &page_name );
    virtual string  GetExportName ( );

    // fermeture définitive (destruction de la page)
    virtual void    ClosePage ( );

    virtual GEVPlot       * AddSpectrum    ( const UInt_t pad, const string &spec_name );
    virtual void            RemoveSpectrum ( const Spectrum *sp );
    virtual bool            UsesSpectrum   ( const Spectrum *sp ) const;

    virtual GEVPadContour * AddContour         ( const UInt_t pad, const string &ct_name, const Int_t mode = GEVPadContour::ctDrawNormal );
    virtual void            RemoveContour      ( const RContour *ct );
    virtual bool            UsesContour        ( const RContour *ct ) const;
    virtual void            ResetContourCounts     ( ) const;
    virtual void            IncrementContourCounts ( ) const;

//----------------------------------------------------------------------
//  SLOTS ET FONCTIONS DES MENUS

    // traitement des événements: menus
    virtual void    ProcessedEvent      ( Int_t event, Int_t x, Int_t y, TObject * selected );
    virtual void    SetContextEventPad  ( Int_t x, Int_t y );
    virtual void    ProcessDefaultEvent ( Int_t event, Int_t x, Int_t y, TObject * selected );
    virtual void    ProcessPosition     ( Int_t event, Int_t x, Int_t y, TObject * selected, TH1 * hi_ptr );
    virtual void    ProcessNewPadEvent  ( Int_t event, Int_t x, Int_t y, TObject * selected );

    virtual void    MenuActivated ( Int_t menu );

    virtual void    PadMenuFitPeak         ( );
    virtual void    PadMenuFitDecay        ( );
    virtual void    PadMenuFitSelectSpec1D ( Spectrum *& sp_fit, Spectrum *& sp_err );

    virtual void    SavePage      ( );
    virtual void    ExportPage    ( );
    virtual void    PrintPage     ( );
    virtual void    DoPageRefresh ( );
    virtual void    PageSetStat   ( );
    virtual void    PageSetNoStat ( );

    virtual void    PageSetPlotsRange  ( );
    virtual void    PageSetPlotsOpts   ( );
    virtual void    PageSetPlotsSelect ( );

//----------------------------------------------------------------------
//  ENTREES/SORTIE DES PAGES

    virtual bool      Write           ( FILE * fptr ) const;
    virtual bool      WriteProperties ( FILE * fptr ) const;

    static  GEVPage * Read            ( FILE * fptr, GEVPageManager *pg_mgr );
    virtual bool      ReadProperties  ( FILE * fptr );

    virtual bool      Save ( const string & f_name ) const;

//----------------------------------------------------------------------
//  pour ROOT...
  public:
    /*! Définition à usage de ROOT... */
    ClassDef(GEVPage,0);
} ;


//----------------------------------------------------------------------
//  METHODES INLINE

/*! Retourne le pointeur sur le gestionnaire de pages.
 */
inline GEVPageManager * GEVPage::GetPageManager ( ) const
  { return ( parent ); }

/*! Retourne le nombre de zones graphiques de la page.
 */
inline UInt_t GEVPage::GetPadNumber ( ) const
  { return (GListT<GEVPad>::GetSize()); }

/*! Retourne un pointeur sur un des pads de la page.
 *  \param  num   numéro du pad
 */
inline GEVPad * GEVPage::GetPadPtr ( const UInt_t num )
  { return ( Goto(num) ); }
//  { return ( (num < GListT<GEVPad>::GetSize()) ? Goto(num) : NULL ); }


/*! Retourne le TCanvas associé à la page.
 */
inline TCanvas * GEVPage::GetCanvas ( ) const
  { return (canvas->GetCanvas()); }

/*! Retourne le nom de la page.*/
inline string GEVPage::GetPageName ( ) const
  { return (GNamed::GetName()); }

//======================================================================
#endif