    // @(#)root/gui:$Name:  $:$Id: TRootCanvas.cxx,v 1.80 2005/06/10 07:02:44 brun Exp $
    // Author: Fons Rademakers   15/01/98

    /*************************************************************************
     * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
     * All rights reserved.                                                  *
     *                                                                       *
     * For the licensing terms see $ROOTSYS/LICENSE.                         *
     * For the list of contributors see $ROOTSYS/README/CREDITS.             *
     *************************************************************************/

    //////////////////////////////////////////////////////////////////////////
    //                                                                      //
    // TRootCanvas                                                          //
    //                                                                      //
    // This class creates a main window with menubar, scrollbars and a      //
    // drawing area. The widgets used are the new native ROOT GUI widgets.  //
    //                                                                      //
    //////////////////////////////////////////////////////////////////////////

    #ifdef HAVE_CONFIG
    #include "config.h"
    #endif

    #include "TRootCanvas.h"
    #include "TRootApplication.h"
    #include "TRootHelpDialog.h"
    #include "TGClient.h"
    #include "TGCanvas.h"
    #include "TGMenu.h"
    #include "TGWidget.h"
    #include "TGFileDialog.h"
    #include "TGStatusBar.h"
    #include "TGTextEditDialogs.h"
    #include "TROOT.h"
    #include "TSystem.h"
    #include "TCanvas.h"
    #include "TBrowser.h"
    #include "TClassTree.h"
    #include "TMarker.h"
    #include "TStyle.h"
    #include "TVirtualX.h"
    #include "TApplication.h"
    #include "TFile.h"
    #include "TInterpreter.h"
    #include "TEnv.h"
    #include "Riostream.h"
    #include "TGDockableFrame.h"

    #include "TG3DLine.h"
    #include "TGToolBar.h"
    #include "TVirtualPadEditor.h"
    #include "TRootControlBar.h"
    #include "TGLabel.h"
    #include "TGuiBuilder.h"
    #include "TImage.h"
    #include "TError.h"

    #ifdef WIN32
    #include "TWin32SplashThread.h"
    #endif

    #include "HelpText.h"

    // Canvas menu command ids
    enum ERootCanvasCommands {
       kFileNewCanvas,
       kFileOpen,
       kFileSaveAs,
       kFileSaveAsRoot,
       kFileSaveAsC,
       kFileSaveAsPS,
       kFileSaveAsEPS,
       kFileSaveAsPDF,
       kFileSaveAsGIF,
       kFileSaveAsJPG,
       kFilePrint,
       kFileCloseCanvas,
       kFileQuit,

       kEditCut,
       kEditCopy,
       kEditPaste,
       kEditClearPad,
       kEditClearCanvas,
       kEditUndo,
       kEditRedo,

       kViewEditor,
       kViewToolbar,
       kViewEventStatus,
       kViewColors,
       kViewFonts,
       kViewMarkers,
       kViewIconify,
       kViewX3D,
       kViewOpenGL,

       kOptionAutoResize,
       kOptionResizeCanvas,
       kOptionMoveOpaque,
       kOptionResizeOpaque,
       kOptionInterrupt,
       kOptionRefresh,
       kOptionAutoExec,
       kOptionStatistics,
       kOptionHistTitle,
       kOptionFitParams,
       kOptionCanEdit,

       kInspectRoot,
       kInspectBrowser,
       kInspectBuilder,

       kClassesTree,

       kHelpAbout,
       kHelpOnCanvas,
       kHelpOnMenus,
       kHelpOnGraphicsEd,
       kHelpOnBrowser,
       kHelpOnObjects,
       kHelpOnPS,

       kToolModify,
       kToolArc,
       kToolLine,
       kToolArrow,
       kToolDiamond,
       kToolEllipse,
       kToolPad,
       kToolPave,
       kToolPLabel,
       kToolPText,
       kToolPsText,
       kToolGraph,
       kToolCurlyLine,
       kToolCurlyArc,
       kToolLatex,
       kToolMarker,
       kToolCutG

    };

    static const char *gOpenTypes[] = { "ROOT files",   "*.root",
                                        "All files",    "*",
                                        0,              0 };

    static const char *gSaveAsTypes[] = { "PostScript",   "*.ps",
                                          "Encapsulated PostScript", "*.eps",
                                          "PDF",          "*.pdf",
                                          "SVG",          "*.svg",
                                          "GIF",          "*.gif",
                                          "ROOT macros",  "*.C",
                                          "ROOT files",   "*.root",
                                          "XML",          "*.xml",
                                          "PNG",          "*.png",
                                          "XPM",          "*.xpm",
                                          "JPEG",         "*.jpg",
                                          "TIFF",         "*.tiff",
                                          "XCF",          "*.xcf",
                                          "All files",    "*",
                                          0,              0 };

    static ToolBarData_t gToolBarData[] = {
      // { filename,      tooltip,            staydown,  id,              button}
      { "newcanvas.xpm",  "New",              kFALSE,    kFileNewCanvas,  NULL },
      { "open.xpm",       "Open",             kFALSE,    kFileOpen,       NULL },
      { "save.xpm",       "Save As",          kFALSE,    kFileSaveAs,     NULL },
      { "printer.xpm",    "Print",            kFALSE,    kFilePrint,      NULL },
      { "",               "",                 kFALSE,    -1,              NULL },
      { "interrupt.xpm",  "Interrupt",        kFALSE,    kOptionInterrupt,NULL },
      { "refresh2.xpm",   "Refresh",          kFALSE,    kOptionRefresh,  NULL },
      { "",               "",                 kFALSE,    -1,              NULL },
      { "inspect.xpm",    "Inspect",          kFALSE,    kInspectRoot,    NULL },
      { "browser.xpm",    "Browser",          kFALSE,    kInspectBrowser, NULL },
      { 0,                0,                  kFALSE,    0,               NULL }
    };

    static ToolBarData_t gToolBarData1[] = {
      { "pointer.xpm",    "Modify",           kFALSE,    kToolModify,     NULL },
      { "arc.xpm",        "Arc",              kFALSE,    kToolArc,        NULL },
      { "line.xpm",       "Line",             kFALSE,    kToolLine,       NULL },
      { "arrow.xpm",      "Arrow",            kFALSE,    kToolArrow,      NULL },
      { "diamond.xpm",    "Diamond",          kFALSE,    kToolDiamond,    NULL },
      { "ellipse.xpm",    "Ellipse",          kFALSE,    kToolEllipse,    NULL },
      { "pad.xpm",        "Pad",              kFALSE,    kToolPad,        NULL },
      { "pave.xpm",       "Pave",             kFALSE,    kToolPave,       NULL },
      { "pavelabel.xpm",  "Pave Label",       kFALSE,    kToolPLabel,     NULL },
      { "pavetext.xpm",   "Pave Text",        kFALSE,    kToolPText,      NULL },
      { "pavestext.xpm",  "Paves Text",       kFALSE,    kToolPsText,     NULL },
      { "graph.xpm",      "Graph",            kFALSE,    kToolGraph,      NULL },
      { "curlyline.xpm",  "Curly Line",       kFALSE,    kToolCurlyLine,  NULL },
      { "curlyarc.xpm",   "Curly Arc",        kFALSE,    kToolCurlyArc,   NULL },
      { "latex.xpm",      "Text/Latex",       kFALSE,    kToolLatex,      NULL },
      { "marker.xpm",     "Marker",           kFALSE,    kToolMarker,     NULL },
      { "cut.xpm",        "Graphical Cut",    kFALSE,    kToolCutG,       NULL },
      { 0,                0,                  kFALSE,    0,               NULL }
    };

    //////////////////////////////////////////////////////////////////////////
    //                                                                      //
    // TRootContainer                                                       //
    //                                                                      //
    // Utility class used by TRootCanvas. The TRootContainer is the frame   //
    // embedded in the TGCanvas widget. The ROOT graphics goes into this    //
    // frame. This class is used to enable input events on this graphics    //
    // frame and forward the events to the TRootCanvas handlers.            //
    //                                                                      //
    //////////////////////////////////////////////////////////////////////////

    class TRootContainer : public TGCompositeFrame {
    private:
       TRootCanvas  *fCanvas;    // pointer back to canvas imp
    public:
       TRootContainer(TRootCanvas *c, Window_t id, const TGWindow *parent);

       Bool_t  HandleButton(Event_t *ev);
       Bool_t  HandleDoubleClick(Event_t *ev)
                    { return fCanvas->HandleContainerDoubleClick(ev); }
       Bool_t  HandleConfigureNotify(Event_t *ev)
                    { TGFrame::HandleConfigureNotify(ev);
                      return fCanvas->HandleContainerConfigure(ev); }
       Bool_t  HandleKey(Event_t *ev)
                    { return fCanvas->HandleContainerKey(ev); }
       Bool_t  HandleMotion(Event_t *ev)
                    { return fCanvas->HandleContainerMotion(ev); }
       Bool_t  HandleExpose(Event_t *ev)
                    { return fCanvas->HandleContainerExpose(ev); }
       Bool_t  HandleCrossing(Event_t *ev)
                    { return fCanvas->HandleContainerCrossing(ev); }
       void    SavePrimitive(ofstream &out, Option_t *);
       void    SetEditable(Bool_t) {}
    };

    //______________________________________________________________________________
    TRootContainer::TRootContainer(TRootCanvas *c, Window_t id, const TGWindow *p)
       : TGCompositeFrame(gClient, id, p)
    {
       // Create a canvas container.

       fCanvas = c;

       gVirtualX->GrabButton(fId, kAnyButton, kAnyModifier,
                             kButtonPressMask | kButtonReleaseMask,
                             kNone, kNone);

       AddInput(kKeyPressMask | kKeyReleaseMask | kPointerMotionMask |
                kExposureMask | kStructureNotifyMask | kLeaveWindowMask);
       fEditDisabled = kTRUE;
    }

    //______________________________________________________________________________
    Bool_t TRootContainer::HandleButton(Event_t *event)
    {
       // Directly handle scroll mouse buttons (4 and 5), only pass buttons
       // 1, 2 and 3 on to the TCanvas.

       TGViewPort *vp = (TGViewPort*)fParent;
       Int_t y = vp->GetVPos();
       UInt_t page = vp->GetHeight()/4;
       Int_t newpos;

       gVirtualX->SetInputFocus(GetMainFrame()->GetId());

       if (event->fCode == kButton4) {
          //scroll up
          newpos = y - page;
          if (newpos < 0) newpos = 0;
          fCanvas->fCanvasWindow->SetVsbPosition(newpos);
          return kTRUE;
       }
       if (event->fCode == kButton5) {
          // scroll down
          newpos = fCanvas->fCanvasWindow->GetVsbPosition() + page;
          fCanvas->fCanvasWindow->SetVsbPosition(newpos);
          return kTRUE;
       }
       return fCanvas->HandleContainerButton(event);
    }

    ClassImp(TRootCanvas)

    //______________________________________________________________________________
     TRootCanvas::TRootCanvas(TCanvas *c, const char *name, UInt_t width, UInt_t height)
       : TGMainFrame(gClient->GetRoot(), width, height), TCanvasImp(c)
    {
       // Create a basic ROOT canvas.

       CreateCanvas(name);

       ShowToolBar(kFALSE);
       ShowEditor(kFALSE);

       Resize(width, height);
    }

    //______________________________________________________________________________
     TRootCanvas::TRootCanvas(TCanvas *c, const char *name, Int_t x, Int_t y, UInt_t width, UInt_t height)
       : TGMainFrame(gClient->GetRoot(), width, height), TCanvasImp(c)
    {
       // Create a basic ROOT canvas.

       CreateCanvas(name);

       ShowToolBar(kFALSE);
       ShowEditor(kFALSE);

       MoveResize(x, y, width, height);
       SetWMPosition(x, y);
    }

    //______________________________________________________________________________
     void TRootCanvas::CreateCanvas(const char *name)
    {
       // Create the actual canvas.

       fButton    = 0;
       fAutoFit   = kTRUE;   // check also menu entry
       fEditor    = 0;

       // Create menus
       fFileSaveMenu = new TGPopupMenu(fClient->GetDefaultRoot());
       fFileSaveMenu->AddEntry(Form("%s.&ps",  name), kFileSaveAsPS);
       fFileSaveMenu->AddEntry(Form("%s.&eps", name), kFileSaveAsEPS);
       fFileSaveMenu->AddEntry(Form("%s.p&df", name), kFileSaveAsPDF);
       fFileSaveMenu->AddEntry(Form("%s.&gif", name), kFileSaveAsGIF);

       static Int_t img = 0;

       if (!img) {
          Int_t sav = gErrorIgnoreLevel;
          gErrorIgnoreLevel = kFatal;
          img = TImage::Create() ? 1 : -1;
          gErrorIgnoreLevel = sav;
       }
       if (img > 0) {
          fFileSaveMenu->AddEntry(Form("%s.&jpg",name),  kFileSaveAsJPG);
       }

       fFileSaveMenu->AddEntry(Form("%s.&C",   name), kFileSaveAsC);
       fFileSaveMenu->AddEntry(Form("%s.&root",name), kFileSaveAsRoot);

       fFileMenu = new TGPopupMenu(fClient->GetDefaultRoot());
       fFileMenu->AddEntry("&New Canvas",   kFileNewCanvas);
       fFileMenu->AddEntry("&Open...",      kFileOpen);
       fFileMenu->AddEntry("&Close Canvas", kFileCloseCanvas);
       fFileMenu->AddSeparator();
       fFileMenu->AddPopup("&Save",         fFileSaveMenu);
       fFileMenu->AddEntry("Save &As...",   kFileSaveAs);
       fFileMenu->AddSeparator();
       fFileMenu->AddEntry("&Print...",     kFilePrint);
       fFileMenu->AddSeparator();
       fFileMenu->AddEntry("&Quit ROOT",    kFileQuit);

       fEditClearMenu = new TGPopupMenu(fClient->GetDefaultRoot());
       fEditClearMenu->AddEntry("&Pad",     kEditClearPad);
       fEditClearMenu->AddEntry("&Canvas",  kEditClearCanvas);

       fEditMenu = new TGPopupMenu(fClient->GetDefaultRoot());
       fEditMenu->AddEntry("Cu&t",          kEditCut);
       fEditMenu->AddEntry("&Copy",         kEditCopy);
       fEditMenu->AddEntry("&Paste",        kEditPaste);
       fEditMenu->AddSeparator();
       fEditMenu->AddPopup("C&lear",        fEditClearMenu);
       fEditMenu->AddSeparator();
       fEditMenu->AddEntry("&Undo",         kEditUndo);
       fEditMenu->AddEntry("&Redo",         kEditRedo);

       fEditMenu->DisableEntry(kEditCut);
       fEditMenu->DisableEntry(kEditCopy);
       fEditMenu->DisableEntry(kEditPaste);
       fEditMenu->DisableEntry(kEditUndo);
       fEditMenu->DisableEntry(kEditRedo);

       fViewWithMenu = new TGPopupMenu(fClient->GetDefaultRoot());
       fViewWithMenu->AddEntry("&X3D",      kViewX3D);
       fViewWithMenu->AddEntry("&OpenGL",   kViewOpenGL);

       fViewMenu = new TGPopupMenu(fClient->GetDefaultRoot());
       fViewMenu->AddEntry("&Editor",       kViewEditor);
       fViewMenu->AddEntry("&Toolbar",      kViewToolbar);
       fViewMenu->AddEntry("Event &Status", kViewEventStatus);
       fViewMenu->AddSeparator();
       fViewMenu->AddEntry("&Colors",       kViewColors);
       fViewMenu->AddEntry("&Fonts",        kViewFonts);
       fViewMenu->AddEntry("&Markers",      kViewMarkers);
       fViewMenu->AddSeparator();
       fViewMenu->AddEntry("&Iconify",      kViewIconify);
       fViewMenu->AddSeparator();
       fViewMenu->AddPopup("&View With",    fViewWithMenu);

       fViewMenu->DisableEntry(kViewFonts);

       fOptionMenu = new TGPopupMenu(fClient->GetDefaultRoot());
       fOptionMenu->AddEntry("&Auto Resize Canvas",  kOptionAutoResize);
       fOptionMenu->AddEntry("&Resize Canvas",       kOptionResizeCanvas);
       fOptionMenu->AddEntry("&Move Opaque",         kOptionMoveOpaque);
       fOptionMenu->AddEntry("Resize &Opaque",       kOptionResizeOpaque);
       fOptionMenu->AddSeparator();
       fOptionMenu->AddEntry("&Interrupt",           kOptionInterrupt);
       fOptionMenu->AddEntry("R&efresh",             kOptionRefresh);
       fOptionMenu->AddSeparator();
       fOptionMenu->AddEntry("&Pad Auto Exec",       kOptionAutoExec);
       fOptionMenu->AddSeparator();
       fOptionMenu->AddEntry("&Statistics",          kOptionStatistics);
       fOptionMenu->AddEntry("Histogram &Title",     kOptionHistTitle);
       fOptionMenu->AddEntry("&Fit Parameters",      kOptionFitParams);
       fOptionMenu->AddEntry("Can Edit &Histograms", kOptionCanEdit);

       // Opaque options initialized in InitWindow()
       fOptionMenu->CheckEntry(kOptionAutoResize);
       if (gStyle->GetOptStat())
          fOptionMenu->CheckEntry(kOptionStatistics);
       if (gStyle->GetOptTitle())
          fOptionMenu->CheckEntry(kOptionHistTitle);
       if (gStyle->GetOptFit())
          fOptionMenu->CheckEntry(kOptionFitParams);
       if (gROOT->GetEditHistograms())
          fOptionMenu->CheckEntry(kOptionCanEdit);

       fInspectMenu = new TGPopupMenu(fClient->GetDefaultRoot());
       fInspectMenu->AddEntry("&ROOT",              kInspectRoot);
       fInspectMenu->AddEntry("&Start Browser",     kInspectBrowser);
       fInspectMenu->AddEntry("&Gui Builder",       kInspectBuilder);

       fClassesMenu = new TGPopupMenu(fClient->GetDefaultRoot());
       fClassesMenu->AddEntry("&Class Tree",        kClassesTree);

       fHelpMenu = new TGPopupMenu(fClient->GetDefaultRoot());
       fHelpMenu->AddLabel("Basic Help On...");
       fHelpMenu->AddSeparator();
       fHelpMenu->AddEntry("&Canvas",          kHelpOnCanvas);
       fHelpMenu->AddEntry("&Menus",           kHelpOnMenus);
       fHelpMenu->AddEntry("&Graphics Editor", kHelpOnGraphicsEd);
       fHelpMenu->AddEntry("&Browser",         kHelpOnBrowser);
       fHelpMenu->AddEntry("&Objects",         kHelpOnObjects);
       fHelpMenu->AddEntry("&PostScript",      kHelpOnPS);
       fHelpMenu->AddSeparator();
       fHelpMenu->AddEntry("&About ROOT...",   kHelpAbout);

       // This main frame will process the menu commands
       fFileMenu->Associate(this);
       fFileSaveMenu->Associate(this);
       fEditMenu->Associate(this);
       fEditClearMenu->Associate(this);
       fViewMenu->Associate(this);
       fViewWithMenu->Associate(this);
       fOptionMenu->Associate(this);
       fInspectMenu->Associate(this);
       fClassesMenu->Associate(this);
       fHelpMenu->Associate(this);

       // Create menubar layout hints
       fMenuBarLayout = new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX, 0, 0, 1, 1);
       fMenuBarItemLayout = new TGLayoutHints(kLHintsTop | kLHintsLeft, 0, 4, 0, 0);
       fMenuBarHelpLayout = new TGLayoutHints(kLHintsTop | kLHintsRight);

       // Create menubar
       fMenuBar = new TGMenuBar(this, 1, 1, kHorizontalFrame);
       fMenuBar->AddPopup("&File",    fFileMenu,    fMenuBarItemLayout);
       fMenuBar->AddPopup("&Edit",    fEditMenu,    fMenuBarItemLayout);
       fMenuBar->AddPopup("&View",    fViewMenu,    fMenuBarItemLayout);
       fMenuBar->AddPopup("&Options", fOptionMenu,  fMenuBarItemLayout);
       fMenuBar->AddPopup("&Inspect", fInspectMenu, fMenuBarItemLayout);
       fMenuBar->AddPopup("&Classes", fClassesMenu, fMenuBarItemLayout);
       fMenuBar->AddPopup("&Help",    fHelpMenu,    fMenuBarHelpLayout);

       AddFrame(fMenuBar, fMenuBarLayout);

       fHorizontal1 = new TGHorizontal3DLine(this);
       fHorizontal1Layout = new TGLayoutHints(kLHintsTop | kLHintsExpandX);

       // Create toolbar dock
       fToolDock = new TGDockableFrame(this);
       AddFrame(fToolDock, new TGLayoutHints(kLHintsExpandX, 0, 0, 1, 0));

       // will alocate it later
       fToolBar = 0;
       fVertical1 = 0;
       fVertical2 = 0;
       fVertical1Layout = 0;
       fVertical2Layout = 0;

       fToolBarSep = new TGHorizontal3DLine(this);
       fToolBarLayout = new TGLayoutHints(kLHintsTop |  kLHintsExpandX);
       AddFrame(fToolBarSep, fToolBarLayout);
       AddFrame(fHorizontal1, fHorizontal1Layout);

       fMainFrame = new TGCompositeFrame(this, GetWidth() + 4, GetHeight() + 4,
                                          kHorizontalFrame);
       fMainFrameLayout = new TGLayoutHints(kLHintsExpandX | kLHintsExpandY);

       // Create editor frame that will host the pad editor
       fEditorFrame = new TGCompositeFrame(fMainFrame, 170, fMainFrame->GetHeight()+4, kFixedWidth);
       fEditorLayout = new TGLayoutHints(kLHintsExpandY | kLHintsLeft);
       fMainFrame->AddFrame(fEditorFrame, fEditorLayout);

       // Create canvas and canvas container that will host the ROOT graphics
       fCanvasWindow = new TGCanvas(fMainFrame, GetWidth()+4, GetHeight()+4,
                                    kSunkenFrame | kDoubleBorder);
       fCanvasID = gVirtualX->InitWindow((ULong_t)fCanvasWindow->GetViewPort()->GetId());
       Window_t win = gVirtualX->GetWindowID(fCanvasID);
       fCanvasContainer = new TRootContainer(this, win, fCanvasWindow->GetViewPort());
       fCanvasWindow->SetContainer(fCanvasContainer);
       fCanvasLayout = new TGLayoutHints(kLHintsExpandX | kLHintsExpandY | kLHintsRight);

       fMainFrame->AddFrame(fCanvasWindow, fCanvasLayout);
       AddFrame(fMainFrame, fMainFrameLayout);

       // Create status bar
       int parts[] = { 33, 10, 10, 47 };
       fStatusBar = new TGStatusBar(this, 10, 10);
       fStatusBar->SetParts(parts, 4);

       fStatusBarLayout = new TGLayoutHints(kLHintsBottom | kLHintsLeft | kLHintsExpandX, 2, 2, 1, 1);

       AddFrame(fStatusBar, fStatusBarLayout);

       // Misc
       SetWindowName(name);
       SetIconName(name);
       SetIconPixmap("macro_s.xpm");
       SetClassHints("Canvas", "Canvas");

       SetMWMHints(kMWMDecorAll, kMWMFuncAll, kMWMInputModeless);

       MapSubwindows();

       // by default status bar, tool bar and pad editor are hidden
       HideFrame(fStatusBar);
       HideFrame(fToolBarSep);
       HideFrame(fHorizontal1);

       ShowToolBar(kFALSE);
       ShowEditor(kFALSE);

       // we need to use GetDefaultSize() to initialize the layout algorithm...
       Resize(GetDefaultSize());
    }

    //______________________________________________________________________________
     TRootCanvas::~TRootCanvas()
    {
       // Delete ROOT basic canvas. Order is significant. Delete in reverse
       // order of creation.

       if (fEditor) delete fEditor;

       if (!MustCleanup()) {
          delete fStatusBar;
          delete fStatusBarLayout;
          delete fCanvasContainer;
          delete fCanvasWindow;

          delete fEditorFrame;
          delete fEditorLayout;
          delete fMainFrame;
          delete fMainFrameLayout;
          delete fToolBarSep;
          delete fToolDock;
          delete fToolBarLayout;
          delete fVertical1;
          delete fVertical2;
          delete fHorizontal1;
          delete fVertical1Layout;
          delete fVertical2Layout;
          delete fHorizontal1Layout;

          delete fMenuBar;
          delete fMenuBarLayout;
          delete fMenuBarItemLayout;
          delete fMenuBarHelpLayout;
          delete fCanvasLayout;
          delete fToolBar;
       }

       delete fFileMenu;
       delete fFileSaveMenu;
       delete fEditMenu;
       delete fEditClearMenu;
       delete fViewMenu;
       delete fViewWithMenu;
       delete fOptionMenu;
       delete fInspectMenu;
       delete fClassesMenu;
       delete fHelpMenu;
    }

    //______________________________________________________________________________
     void TRootCanvas::Close()
    {
       // Called via TCanvasImp interface by TCanvas.

       if (fEditor) fEditor->DeleteEditors();
       if (TVirtualPadEditor::GetPadEditor(kFALSE) != 0)
          TVirtualPadEditor::Terminate();

       gVirtualX->CloseWindow();
    }

    //______________________________________________________________________________
     void TRootCanvas::ReallyDelete()
    {
       // Really delete the canvas and this GUI.

       if (fEditor) fEditor->DeleteEditors();
       if (TVirtualPadEditor::GetPadEditor(kFALSE) != 0)
          TVirtualPadEditor::Terminate();

       TVirtualPad *savepad = gPad;
       gPad = 0;        // hide gPad from CINT
       gInterpreter->DeleteGlobal(fCanvas);
       gPad = savepad;  // restore gPad for ROOT
       delete fCanvas;  // will in turn delete this object
    }

    //______________________________________________________________________________
     void TRootCanvas::CloseWindow()
    {
       // In case window is closed via WM we get here.

       DeleteWindow();
    }

    //______________________________________________________________________________
     UInt_t TRootCanvas::GetCwidth() const
    {
       // Return width of canvas container.

       return fCanvasContainer->GetWidth();
    }

    //______________________________________________________________________________
     UInt_t TRootCanvas::GetCheight() const
    {
       // Return height of canvas container.

       return fCanvasContainer->GetHeight();
    }

    //______________________________________________________________________________
     UInt_t TRootCanvas::GetWindowGeometry(Int_t &x, Int_t &y, UInt_t &w, UInt_t &h)
    {
       // Gets the size and position of the window containing the canvas. This
       // size includes the menubar and borders.

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

       Window_t childdum;
       gVirtualX->TranslateCoordinates(fId, gClient->GetDefaultRoot()->GetId(),
                                       0, 0, x, y, childdum);
       if (!fCanvas->GetShowEditor()) return 0;
       return fEditorFrame->GetWidth();
    }

    //______________________________________________________________________________
     void TRootCanvas::SetStatusText(const char *txt, Int_t partidx)
    {
       // Set text in status bar.

       fStatusBar->SetText(txt, partidx);
    }

    //______________________________________________________________________________
     Bool_t TRootCanvas::ProcessMessage(Long_t msg, Long_t parm1, Long_t)
    {
       // Handle menu and other command generated by the user.

       TRootHelpDialog *hd;
       TList *lc;

       switch (GET_MSG(msg)) {

          case kC_COMMAND:

             switch (GET_SUBMSG(msg)) {

                case kCM_BUTTON:
                case kCM_MENU:

                   switch (parm1) {
                      // Handle toolbar items...
                      case kToolModify:
                         gROOT->SetEditorMode();
                         break;
                      case kToolArc:
                         gROOT->SetEditorMode("Arc");
                         break;
                      case kToolLine:
                         gROOT->SetEditorMode("Line");
                         break;
                      case kToolArrow:
                         gROOT->SetEditorMode("Arrow");
                         break;
                      case kToolDiamond:
                         gROOT->SetEditorMode("Diamond");
                         break;
                      case kToolEllipse:
                         gROOT->SetEditorMode("Ellipse");
                         break;
                      case kToolPad:
                         gROOT->SetEditorMode("Pad");
                         break;
                      case kToolPave:
                         gROOT->SetEditorMode("Pave");
                         break;
                      case kToolPLabel:
                         gROOT->SetEditorMode("PaveLabel");
                         break;
                      case kToolPText:
                         gROOT->SetEditorMode("PaveText");
                         break;
                      case kToolPsText:
                         gROOT->SetEditorMode("PavesText");
                         break;
                      case kToolGraph:
                         gROOT->SetEditorMode("PolyLine");
                         break;
                      case kToolCurlyLine:
                         gROOT->SetEditorMode("CurlyLine");
                         break;
                      case kToolCurlyArc:
                         gROOT->SetEditorMode("CurlyArc");
                         break;
                      case kToolLatex:
                         gROOT->SetEditorMode("Text");
                         break;
                      case kToolMarker:
                         gROOT->SetEditorMode("Marker");
                         break;
                      case kToolCutG:
                         gROOT->SetEditorMode("CutG");
                         break;

                      // Handle File menu items...
                      case kFileNewCanvas:
                         gROOT->GetMakeDefCanvas()();
                         break;
                      case kFileOpen:
                         {
                            static TString dir(".");
                            TGFileInfo fi;
                            fi.fFileTypes = gOpenTypes;
                            fi.fIniDir    = StrDup(dir);
                            new TGFileDialog(fClient->GetDefaultRoot(), this, kFDOpen,&fi);
                            if (!fi.fFilename) return kTRUE;
                            dir = fi.fIniDir;
                            new TFile(fi.fFilename, "update");
                         }
                         break;
                      case kFileSaveAs:
                         {
                            static TString dir(".");
                            static Int_t typeidx = 0;
                            static Bool_t overwr = kFALSE;
                            TGFileInfo fi;
                            fi.fFileTypes   = gSaveAsTypes;
                            fi.fIniDir      = StrDup(dir);
                            fi.fFileTypeIdx = typeidx;
                            fi.fOverwrite = overwr;
                            new TGFileDialog(fClient->GetDefaultRoot(), this, kFDSave, &fi);
                            if (!fi.fFilename) return kTRUE;
                            Bool_t  appendedType = kFALSE;
                            TString fn = fi.fFilename;
                            TString ft = fi.fFileTypes[fi.fFileTypeIdx+1];
                            dir     = fi.fIniDir;
                            typeidx = fi.fFileTypeIdx;
                            overwr  = fi.fOverwrite;
    again:
                            if (fn.EndsWith(".root") ||
                                fn.EndsWith(".ps")   ||
                                fn.EndsWith(".eps")  ||
                                fn.EndsWith(".pdf")  ||
                                fn.EndsWith(".svg")  ||
                                fn.EndsWith(".gif")  ||
                                fn.EndsWith(".xml")  ||
                                fn.EndsWith(".xpm")  ||
                                fn.EndsWith(".jpg")  ||
                                fn.EndsWith(".png")  ||
                                fn.EndsWith(".xcf")  ||
                                fn.EndsWith(".tiff")) {
                               gSystem->Sleep(60); // give X server time to refresh
                               fCanvas->SaveAs(fn);
                            } else if (fn.EndsWith(".C"))
                               fCanvas->SaveSource(fn);
                            else {
                               if (!appendedType) {
                                  if (ft.Index(".") != kNPOS) {
                                     fn += ft(ft.Index("."), ft.Length());
                                     appendedType = kTRUE;
                                     goto again;
                                  }
                               }
                               Warning("ProcessMessage", "file %s cannot be saved with this extension", fi.fFilename);
                            }
                         }
                         break;
                      case kFileSaveAsRoot:
                         fCanvas->SaveAs(".root");
                         break;
                      case kFileSaveAsC:
                         fCanvas->SaveSource();
                         break;
                      case kFileSaveAsPS:
                         fCanvas->SaveAs();
                         break;
                      case kFileSaveAsEPS:
                         fCanvas->SaveAs(".eps");
                         break;
                      case kFileSaveAsPDF:
                         fCanvas->SaveAs(".pdf");
                         break;
                      case kFileSaveAsGIF:
                         fCanvas->SaveAs(".gif");
                         break;
                      case kFileSaveAsJPG:
                         fCanvas->SaveAs(".jpg");
                         break;
                      case kFilePrint:
                         PrintCanvas();
                         break;
                      case kFileCloseCanvas:
                         if (!fEditor && (TVirtualPadEditor::GetPadEditor(kFALSE) != 0))
                            TVirtualPadEditor::Terminate();
                         SendCloseMessage();
                         break;
                      case kFileQuit:
                         if (!gApplication->ReturnFromRun()) {
                            if (fEditor) fEditor->DeleteEditors();
                            if (!fEditor && (TVirtualPadEditor::GetPadEditor(kFALSE) != 0))
                               TVirtualPadEditor::Terminate();
                            delete this;
                         }
                         if (TVirtualPadEditor::GetPadEditor(kFALSE) != 0)
                            TVirtualPadEditor::Terminate();
                         gApplication->Terminate(0);
                         break;

                      // Handle Edit menu items...
                      case kEditCut:
                         // still noop
                         break;
                      case kEditCopy:
                         // still noop
                         break;
                      case kEditPaste:
                         // still noop
                         break;
                      case kEditUndo:
                         // noop
                         break;
                      case kEditRedo:
                         // noop
                         break;
                      case kEditClearPad:
                         gPad->Clear();
                         gPad->Modified();
                         gPad->Update();
                         break;
                      case kEditClearCanvas:
                         fCanvas->Clear();
                         fCanvas->Modified();
                         fCanvas->Update();
                         break;

                      // Handle View menu items...
                      case kViewEditor:
                         fCanvas->ToggleEditor();
                         if (!fEditor) CreateEditor();
                         break;
                      case kViewToolbar:
                         fCanvas->ToggleToolBar();
                         break;
                      case kViewEventStatus:
                         fCanvas->ToggleEventStatus();
                         break;
                      case kViewColors:
                         {
                            TVirtualPad *padsav = gPad->GetCanvas();
                            TCanvas *m = new TCanvas("colors","Color Table");
                            TPad::DrawColorTable();
                            m->Update();
                            padsav->cd();
                         }
                         break;
                      case kViewFonts:
                         // noop
                         break;
                      case kViewMarkers:
                         {
                            TVirtualPad *padsav = gPad->GetCanvas();
                            TCanvas *m = new TCanvas("markers","Marker Types",600,200);
                            TMarker::DisplayMarkerTypes();
                            m->Update();
                            padsav->cd();
                         }
                         break;
                      case kViewIconify:
                         Iconify();
                         break;
                      case kViewX3D:
                         gPad->GetViewer3D("x3d");
                         break;
                      case kViewOpenGL:
                         gPad->GetViewer3D("ogl");
                         break;

                      // Handle Option menu items...
                      case kOptionAutoExec:
                         fCanvas->ToggleAutoExec();
                         if (fCanvas->GetAutoExec()) {
                            fOptionMenu->CheckEntry(kOptionAutoExec);
                         } else {
                            fOptionMenu->UnCheckEntry(kOptionAutoExec);
                         }
                         break;
                      case kOptionAutoResize:
                         {
                            fAutoFit = fAutoFit ? kFALSE : kTRUE;
                            int opt = fCanvasContainer->GetOptions();
                            if (fAutoFit) {
                               opt &= ~kFixedSize;
                               fOptionMenu->CheckEntry(kOptionAutoResize);
                            } else {
                               opt |= kFixedSize;
                               fOptionMenu->UnCheckEntry(kOptionAutoResize);
                            }
                            fCanvasContainer->ChangeOptions(opt);
                            // in case of autofit this will generate a configure
                            // event for the container and this will force the
                            // update of the TCanvas
                            //Layout();
                         }
                         Layout();
                         break;
                      case kOptionResizeCanvas:
                         FitCanvas();
                         break;
                      case kOptionMoveOpaque:
                         if (fCanvas->OpaqueMoving()) {
                            fCanvas->MoveOpaque(0);
                            fOptionMenu->UnCheckEntry(kOptionMoveOpaque);
                         } else {
                            fCanvas->MoveOpaque(1);
                            fOptionMenu->CheckEntry(kOptionMoveOpaque);
                         }
                         break;
                      case kOptionResizeOpaque:
                         if (fCanvas->OpaqueResizing()) {
                            fCanvas->ResizeOpaque(0);
                            fOptionMenu->UnCheckEntry(kOptionResizeOpaque);
                         } else {
                            fCanvas->ResizeOpaque(1);
                            fOptionMenu->CheckEntry(kOptionResizeOpaque);
                         }
                         break;
                      case kOptionInterrupt:
                         gROOT->SetInterrupt();
                         break;
                      case kOptionRefresh:
                         fCanvas->Paint();
                         fCanvas->Update();
                         break;
                      case kOptionStatistics:
                         if (gStyle->GetOptStat()) {
                            gStyle->SetOptStat(0);
                            delete gPad->FindObject("stats");
                            fOptionMenu->UnCheckEntry(kOptionStatistics);
                         } else {
                            gStyle->SetOptStat(1);
                            fOptionMenu->CheckEntry(kOptionStatistics);
                         }
                         gPad->Modified();
                         fCanvas->Update();
                         break;
                      case kOptionHistTitle:
                         if (gStyle->GetOptTitle()) {
                            gStyle->SetOptTitle(0);
                            delete gPad->FindObject("title");
                            fOptionMenu->UnCheckEntry(kOptionHistTitle);
                         } else {
                            gStyle->SetOptTitle(1);
                            fOptionMenu->CheckEntry(kOptionHistTitle);
                         }
                         gPad->Modified();
                         fCanvas->Update();
                         break;
                      case kOptionFitParams:
                         if (gStyle->GetOptFit()) {
                            gStyle->SetOptFit(0);
                            fOptionMenu->UnCheckEntry(kOptionFitParams);
                         } else {
                            gStyle->SetOptFit(1);
                            fOptionMenu->CheckEntry(kOptionFitParams);
                         }
                         gPad->Modified();
                         fCanvas->Update();
                         break;
                      case kOptionCanEdit:
                         if (gROOT->GetEditHistograms()) {
                            gROOT->SetEditHistograms(kFALSE);
                            fOptionMenu->UnCheckEntry(kOptionCanEdit);
                         } else {
                            gROOT->SetEditHistograms(kTRUE);
                            fOptionMenu->CheckEntry(kOptionCanEdit);
                         }
                         break;

                      // Handle Inspect menu items...
                      case kInspectRoot:
                         fCanvas->cd();
                         gROOT->Inspect();
                         fCanvas->Update();
                         break;
                      case kInspectBrowser:
                         new TBrowser("browser");
                         break;
                      case kInspectBuilder:
                         TGuiBuilder::Instance();
                         break;

                      // Handle Inspect menu items...
                      case kClassesTree:
                         {
                            char cdef[64];
                            lc = (TList*)gROOT->GetListOfCanvases();
                            if (lc->FindObject("ClassTree")) {
                               sprintf(cdef,"ClassTree_%d",lc->GetSize()+1);
                            } else {
                               sprintf(cdef,"%s","ClassTree");
                            }
                            new TClassTree(cdef,"TObject");
                            fCanvas->Update();
                         }
                         break;

                      // Handle Help menu items...
                      case kHelpAbout:
                         {
    #ifdef R__UNIX
                            TString rootx;
    # ifdef ROOTBINDIR
                            rootx = ROOTBINDIR;
    # else
                            rootx = gSystem->Getenv("ROOTSYS");
                            if (!rootx.IsNull()) rootx += "/bin";
    # endif
                            rootx += "/root -a &";
                            gSystem->Exec(rootx);
    #else
    #ifdef WIN32
                            new TWin32SplashThread(kTRUE);
    #else

                            char str[32];
                            sprintf(str, "About ROOT %s...", gROOT->GetVersion());
                            hd = new TRootHelpDialog(this, str, 600, 400);
                            hd->SetText(gHelpAbout);
                            hd->Popup();
    #endif
    #endif
                         }
                         break;
                      case kHelpOnCanvas:
                         hd = new TRootHelpDialog(this, "Help on Canvas...", 600, 400);
                         hd->SetText(gHelpCanvas);
                         hd->Popup();
                         break;
                      case kHelpOnMenus:
                         hd = new TRootHelpDialog(this, "Help on Menus...", 600, 400);
                         hd->SetText(gHelpPullDownMenus);
                         hd->Popup();
                         break;
                      case kHelpOnGraphicsEd:
                         hd = new TRootHelpDialog(this, "Help on Graphics Editor...", 600, 400);
                         hd->SetText(gHelpGraphicsEditor);
                         hd->Popup();
                         break;
                      case kHelpOnBrowser:
                         hd = new TRootHelpDialog(this, "Help on Browser...", 600, 400);
                         hd->SetText(gHelpBrowser);
                         hd->Popup();
                         break;
                      case kHelpOnObjects:
                         hd = new TRootHelpDialog(this, "Help on Objects...", 600, 400);
                         hd->SetText(gHelpObjects);
                         hd->Popup();
                         break;
                      case kHelpOnPS:
                         hd = new TRootHelpDialog(this, "Help on PostScript...", 600, 400);
                         hd->SetText(gHelpPostscript);
                         hd->Popup();
                         break;
                   }
                default:
                   break;
             }
          default:
             break;
       }
       return kTRUE;
    }

    //______________________________________________________________________________
     Int_t TRootCanvas::InitWindow()
    {
       // Called by TCanvas ctor to get window indetifier.

       if (fCanvas->OpaqueMoving())
          fOptionMenu->CheckEntry(kOptionMoveOpaque);
       if (fCanvas->OpaqueResizing())
          fOptionMenu->CheckEntry(kOptionResizeOpaque);

       return fCanvasID;
    }

    //______________________________________________________________________________
     void TRootCanvas::SetCanvasSize(UInt_t w, UInt_t h)
    {
       // Set size of canvas container. Units in pixels.

       // turn off autofit, we want to stay at the given size
       fAutoFit = kFALSE;
       fOptionMenu->UnCheckEntry(kOptionAutoResize);
       int opt = fCanvasContainer->GetOptions();
       opt |= kFixedSize;    // turn on fixed size mode
       fCanvasContainer->ChangeOptions(opt);
       fCanvasContainer->SetWidth(w);
       fCanvasContainer->SetHeight(h);
       Layout();  // force layout (will update container to given size)
       fCanvas->Resize();
       fCanvas->Update();
    }

    //______________________________________________________________________________
     void TRootCanvas::SetWindowPosition(Int_t x, Int_t y)
    {
       // Set canvas position (units in pixels).

       Move(x, y);
    }

    //______________________________________________________________________________
     void TRootCanvas::SetWindowSize(UInt_t w, UInt_t h)
    {
       // Set size of canvas( units in pixels).

       Resize(w, h);
    }

    //______________________________________________________________________________
     void TRootCanvas::RaiseWindow()
    {
       // Put canvas window on top of the window stack.

       gVirtualX->RaiseWindow(GetId());
    }

    //______________________________________________________________________________
     void TRootCanvas::SetWindowTitle(const char *title)
    {
       // Change title on window.

       SetWindowName(title);
       SetIconName(title);
       fToolDock->SetWindowName(Form("ToolBar: %s", title));
    }

    //______________________________________________________________________________
     void TRootCanvas::FitCanvas()
    {
       // Fit canvas container to current window size.

       if (!fAutoFit) {
          int opt = fCanvasContainer->GetOptions();
          int oopt = opt;
          opt &= ~kFixedSize;   // turn off fixed size mode
          fCanvasContainer->ChangeOptions(opt);
          Layout();  // force layout
          fCanvas->Resize();
          fCanvas->Update();
          fCanvasContainer->ChangeOptions(oopt);
       }
    }

     //______________________________________________________________________________
     void TRootCanvas::PrintCanvas()
    {
       // Print the canvas.

       Int_t ret = 0;
       Bool_t pname = kTRUE;
       char *printer, *printCmd;
       static TString sprinter, sprintCmd;

       if (sprinter == "")
          printer = StrDup(gEnv->GetValue("Print.Printer", ""));
       else
          printer = StrDup(sprinter);
       if (sprintCmd == "")
    #ifndef WIN32
          printCmd = StrDup(gEnv->GetValue("Print.Command", ""));
    #else
          printCmd = StrDup(gEnv->GetValue("Print.Command", "start AcroRd32.exe /p"));
    #endif
       else
          printCmd = StrDup(sprintCmd);

       new TGPrintDialog(fClient->GetDefaultRoot(), this, 400, 150,
                         &printer, &printCmd, &ret);
       if (ret) {
          sprinter  = printer;
          sprintCmd = printCmd;

          if (sprinter == "")
             pname = kFALSE;

          TString fn = "rootprint";
          FILE *f = gSystem->TempFileName(fn, gEnv->GetValue("Print.Directory", gSystem->TempDirectory()));
          fclose(f);
          fn += ".pdf";
          fCanvas->Print(fn);

          TString cmd = sprintCmd;
          if (cmd.Contains("%p"))
             cmd.ReplaceAll("%p", sprinter);
          else if (pname) {
             cmd += " "; cmd += sprinter; cmd += " ";
          }

          if (cmd.Contains("%f"))
             cmd.ReplaceAll("%f", fn);
          else {
             cmd += " "; cmd += fn; cmd += " ";
          }

          gSystem->Exec(cmd);
          gSystem->Unlink(fn);
       }
       delete [] printer;
       delete [] printCmd;
    }

    //______________________________________________________________________________
     void TRootCanvas::ShowMenuBar(Bool_t show)
    {
       // Show or hide menubar.

       if (show)  ShowFrame(fMenuBar);
       else       HideFrame(fMenuBar);
    }

    //______________________________________________________________________________
     void TRootCanvas::ShowStatusBar(Bool_t show)
    {
       // Show or hide statusbar.

       UInt_t h = GetHeight();
       UInt_t sh = fStatusBar->GetHeight();

       if (show) {
          ShowFrame(fStatusBar);
          fViewMenu->CheckEntry(kViewEventStatus);
          h = h + sh;
       } else {
          HideFrame(fStatusBar);
          fViewMenu->UnCheckEntry(kViewEventStatus);
          h = h - sh;
       }
       Resize(GetWidth(), h);
    }

    //______________________________________________________________________________
     void TRootCanvas::ShowEditor(Bool_t show)
    {
       // Show or hide side frame.

       TVirtualPad *savedPad = 0;
       savedPad = (TVirtualPad *) gPad;
       gPad = Canvas();

       UInt_t w = GetWidth();
       UInt_t e = fEditorFrame->GetWidth();
       UInt_t h = GetHeight();
       UInt_t s = fHorizontal1->GetHeight();

       if (show) {
          if (!fEditor) CreateEditor();
          if (TVirtualPadEditor::GetPadEditor(kFALSE) != 0) {
                TVirtualPadEditor::HideEditor();
          }
          ShowFrame(fHorizontal1);
          fMainFrame->ShowFrame(fEditorFrame);
          fViewMenu->CheckEntry(kViewEditor);
          w = w + e;
          h = h + s;
       } else {
          HideFrame(fHorizontal1);
          fMainFrame->HideFrame(fEditorFrame);
          fViewMenu->UnCheckEntry(kViewEditor);
          w = w - e;
          h = h - s;
       }
       Resize(w, h);

       if (savedPad) gPad = savedPad;
    }

    //______________________________________________________________________________
     void TRootCanvas::CreateEditor()
    {
       // Create embedded editor.

       if (TVirtualPadEditor::GetPadEditor(kFALSE) != 0) {
             TVirtualPadEditor::HideEditor();
       }
       fEditorFrame->SetEditable();
       gPad = Canvas();
       // next two lines are related to the old editor
       TString show = gEnv->GetValue("Canvas.ShowEditor","false");
       gEnv->SetValue("Canvas.ShowEditor","true");
       fEditor = TVirtualPadEditor::LoadEditor();
       fEditor->SetGlobal(kFALSE);
       fEditorFrame->SetEditable(0);
       // next line is related to the old editor
       if (show == "false") gEnv->SetValue("Canvas.ShowEditor","false");
    }

    //______________________________________________________________________________
     void TRootCanvas::ShowToolBar(Bool_t show)
    {
       // Show or hide toolbar.

       Int_t i;

       if (show) {
          ShowFrame(fToolDock);
       } else {
          HideFrame(fToolDock);
       }

       if (show && !fToolBar) {
          fToolBar = new TGToolBar(fToolDock, 60, 20, kHorizontalFrame);
          fToolDock->AddFrame(fToolBar, fHorizontal1Layout);

          int spacing = 6;
          for (i = 0; gToolBarData[i].fPixmap; i++) {
             if (strlen(gToolBarData[i].fPixmap) == 0) {
                spacing = 6;
                continue;
             }
             fToolBar->AddButton(this, &gToolBarData[i], spacing);
             spacing = 0;
          }
          fVertical1 = new TGVertical3DLine(fToolBar);
          fVertical2 = new TGVertical3DLine(fToolBar);
          fVertical1Layout = new TGLayoutHints(kLHintsLeft | kLHintsExpandY, 4,2,0,0);
          fVertical2Layout = new TGLayoutHints(kLHintsLeft | kLHintsExpandY, 2,0,0,0);
          fToolBar->AddFrame(fVertical1, fVertical1Layout);
          fToolBar->AddFrame(fVertical2, fVertical2Layout);

          spacing = 6;
          for (i = 0; gToolBarData1[i].fPixmap; i++) {
             if (strlen(gToolBarData1[i].fPixmap) == 0) {
                spacing = 6;
                continue;
             }
             fToolBar->AddButton(this, &gToolBarData1[i], spacing);
             spacing = 0;
          }
          fToolDock->MapSubwindows();
          fToolDock->SetWindowName(Form("ToolBar: %s", GetWindowName()));
       }

       if (!fToolBar) return;

       UInt_t h = GetHeight();
       UInt_t th = fToolBar->GetHeight() + fToolBarSep->GetHeight();

       if (show) {
          ShowFrame(fToolBar);
          ShowFrame(fToolBarSep);
          fViewMenu->CheckEntry(kViewToolbar);
          h = h + th;
       } else {
          HideFrame(fToolBar);
          HideFrame(fToolBarSep);
          fViewMenu->UnCheckEntry(kViewToolbar);
          h = h - th;
       }
       Resize(GetWidth(), h);
    }

    //______________________________________________________________________________
     Bool_t TRootCanvas::HandleContainerButton(Event_t *event)
    {
       // Handle mouse button events in the canvas container.

       Int_t button = event->fCode;
       Int_t x = event->fX;
       Int_t y = event->fY;

       if (event->fType == kButtonPress) {
          fButton = button;
          if (button == kButton1)
             fCanvas->HandleInput(kButton1Down, x, y);
          if (button == kButton2)
             fCanvas->HandleInput(kButton2Down, x, y);
          if (button == kButton3) {
             fCanvas->HandleInput(kButton3Down, x, y);
             fButton = 0;  // button up is consumed by TContextMenu
          }

       } else if (event->fType == kButtonRelease) {
          if (button == kButton1)
             fCanvas->HandleInput(kButton1Up, x, y);
          if (button == kButton2)
             fCanvas->HandleInput(kButton2Up, x, y);
          if (button == kButton3)
             fCanvas->HandleInput(kButton3Up, x, y);

          fButton = 0;
       }

       return kTRUE;
    }

    //______________________________________________________________________________
     Bool_t TRootCanvas::HandleContainerDoubleClick(Event_t *event)
    {
       // Handle mouse button double click events in the canvas container.

       Int_t button = event->fCode;
       Int_t x = event->fX;
       Int_t y = event->fY;

       if (button == kButton1)
          fCanvas->HandleInput(kButton1Double, x, y);
       if (button == kButton2)
          fCanvas->HandleInput(kButton2Double, x, y);
       if (button == kButton3)
          fCanvas->HandleInput(kButton3Double, x, y);

       return kTRUE;
    }

    //______________________________________________________________________________
     Bool_t TRootCanvas::HandleContainerConfigure(Event_t *)
    {
       // Handle configure (i.e. resize) event.

       if (fAutoFit) {
          fCanvas->Resize();
          fCanvas->Update();
       }

       if (fCanvas->HasFixedAspectRatio()) {
          // get menu height
          static Int_t dh = 0;
          if (!dh)
             dh = GetHeight() - fCanvasContainer->GetHeight();
          UInt_t h = TMath::Nint(fCanvasContainer->GetWidth()/
                                 fCanvas->GetAspectRatio()) + dh;
          SetWindowSize(GetWidth(), h);
       }
       return kTRUE;
    }

    //______________________________________________________________________________
     Bool_t TRootCanvas::HandleContainerKey(Event_t *event)
    {
       // Handle keyboard events in the canvas container.

      if (event->fType == kGKeyPress) {
          fButton = event->fCode;
          UInt_t keysym;
          char str[2];
          gVirtualX->LookupString(event, str, sizeof(str), keysym);
          if (str[0] == 3)   // ctrl-c sets the interrupt flag
             gROOT->SetInterrupt();
          fCanvas->HandleInput(kKeyPress, str[0], keysym);
       } else if (event->fType == kKeyRelease)
          fButton = 0;

       return kTRUE;
    }

    //______________________________________________________________________________
     Bool_t TRootCanvas::HandleContainerMotion(Event_t *event)
    {
       // Handle mouse motion event in the canvas container.

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

       if (fButton == 0)
          fCanvas->HandleInput(kMouseMotion, x, y);
       if (fButton == kButton1)
          fCanvas->HandleInput(kButton1Motion, x, y);

       return kTRUE;
    }

    //______________________________________________________________________________
     Bool_t TRootCanvas::HandleContainerExpose(Event_t *event)
    {
       // Handle expose events.

       if (event->fCount == 0)
          fCanvas->Flush();

       return kTRUE;
    }

    //______________________________________________________________________________
     Bool_t TRootCanvas::HandleContainerCrossing(Event_t *event)
    {
       // Handle enter/leave events. Only leave is activated at the moment.

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

       // pointer grabs create also an enter and leave event but with fCode
       // either kNotifyGrab or kNotifyUngrab, don't propagate these events
       if (event->fType == kLeaveNotify && event->fCode == kNotifyNormal)
          fCanvas->HandleInput(kMouseLeave, x, y);

       return kTRUE;
    }

    //______________________________________________________________________________
    void TRootContainer::SavePrimitive(ofstream &out, Option_t *)
    {
       // Save a canvas container as a C++ statement(s) on output stream out.

       out << endl << "   // canvas container" << endl;
       out << "   Int_t canvasID = gVirtualX->InitWindow((ULong_t)"
           << GetParent()->GetParent()->GetName() << "->GetId());" << endl;
       out << "   Window_t winC = gVirtualX->GetWindowID(canvasID);" << endl;
       out << "   TGCompositeFrame *";
       out << GetName() << " = new TGCompositeFrame(gClient,winC"
           << "," << GetParent()->GetName() << ");" << endl;
    }