TQtWidget.cxx

// @(#)root/qt:$Id$
// Author: Valeri Fine   23/01/2003

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

// Definition of TQtWidget class
// "double-buffere widget

#include <qapplication.h>

#if QT_VERSION >= 0x40000
#  include <QFocusEvent>
#  include <QPaintEvent>
#  include <QKeyEvent>
#  include <QShowEvent>
#  include <QResizeEvent>
#  include <QMouseEvent>
#  include <QCustomEvent>
#  include <QImage>
#  include <QDebug>
#endif /* QT_VERSION */

#include "TQtWidget.h"
#include "TQtTimer.h"

#include "TROOT.h"
#include "TEnv.h"
#include "TRint.h"
#include "TSystem.h"
#include "Getline.h"
#include "TGQt.h"
#include "TCanvas.h"
#include "Buttons.h"
#include <qevent.h>
#include <qpainter.h>
#include <qpixmap.h>
#include <qfileinfo.h>

#ifdef R__QTWIN32
// #include "Windows4Root.h"
#include "TWinNTSystem.h"
#include "Win32Constants.h"
#endif

// Class to adjust buffer within the method scope if needed

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

TQtWidgetBuffer::TQtWidgetBuffer(const QWidget *w, bool clear)
: fWidget(w),fBuffer(0), fIsImage(clear)
{
   if (fIsImage) {
      fBuffer = new  QImage(fWidget?fWidget->size():QSize(0,0),QImage::Format_ARGB32_Premultiplied);
//      ((QImage*)fBuffer)->fill(0);
   } else {
      fBuffer = new  QPixmap(fWidget?fWidget->size():QSize(0,0));
   }
}
////////////////////////////////////////////////////////////////////////////////
/// Copy ctor. Create the copy and account the new widget size

TQtWidgetBuffer::TQtWidgetBuffer(const TQtWidgetBuffer &b)
: fWidget(b.fWidget),fBuffer(0), fIsImage(b.fIsImage)
{
   if (fWidget && (fWidget->size() != QSize(0,0))) {
      if (fIsImage) {
         QImage resized =((QImage*)b.fBuffer)->scaled (fWidget->size());
         fBuffer = new  QImage(resized);
      } else {
         QPixmap resized =((QPixmap*) b.fBuffer)->scaled (fWidget->size());
         fBuffer = new  QPixmap(resized);
      }
   }
}
////////////////////////////////////////////////////////////////////////////////
/// dtor

TQtWidgetBuffer:: ~TQtWidgetBuffer()
{
   delete fBuffer;
   fBuffer = 0;
}

////////////////////////////////////////////////////////////////////////////////
/// Clear the buffer with the transparent color

void TQtWidgetBuffer::Clear()
{
   if (fBuffer &&  !fIsImage ) {
#ifdef R__WIN32
         ((QPixmap*)fBuffer)->fill(Qt::transparent);
#else
         QPainter p(fBuffer);
         p.fillRect(QRect(0,0,fBuffer->width(), fBuffer->height())
            ,Qt::transparent);
#endif
   }
}


//___________________________________________________________________

ClassImp(TQtWidget)

////////////////////////////////////////////////////////////////////////////////
//
//  TQtWidget is a QWidget with the QPixmap double buffer
//  It is designed to back the ROOT TCanvasImp class interface  and it can be used
//  as a regular Qt Widget to create Qt-based GUI with the embedded TCanvas objects
//
//           This widget can be used as a Qt "custom widget"
//         to build a custom GUI interfaces with  Qt Designer
//
// The class emits the Qt signals and has Qt public slots
//
//  Public slots:  (Qt)
//
//   virtual void cd();  // make the associated TCanvas the current one (shortcut to TCanvas::cd())
//   virtual void cd(int subpadnumber); // as above - shortcut to Canvas::cd(int subpadnumber)
//   void Disconnect(); // disconnect the QWidget from the ROOT TCanvas (used in the class dtor)
//   void Refresh();    // force the associated TCanvas::Update to be called
//   virtual bool Save(const QString &fileName) const;  // Save the widget image with some ppixmap file
//   virtual bool Save(const char    *fileName) const;
//   virtual bool Save(const QString &fileName,const char *format,int quality=60) const;
//   virtual bool Save(const char    *fileName,const char *format,int quality=60) const;
//
//  signals        (Qt)
//
//    CanvasPainted();  // Signal the TCanvas has been painted onto the screen
//    Saved(bool ok);   // Signal the TCanvas has been saved into the file
//    RootEventProcessed(TObject *selected, unsigned int event, TCanvas *c);
//                      // Signal the Qt mouse/keyboard event has been process by ROOT
//                      // This "signal" is emitted by the enabled mouse events only.
//                      // See: EnableSignalEvents
//                      // ---  DisableSignalEvents
//
//  public methods:
//    The methods below define whether the TQtWidget object emits "RootEventProcessed" Qt signals
//     (By default no  RootEventProcessed Qt signal is emitted )
//     void EnableSignalEvents (UInt_t f)
//     void DisableSignalEvents(UInt_t f),
//         where f is a bitwise OR of the mouse event flags:
//                  kMousePressEvent       // TCanvas processed QEvent mousePressEvent
//                  kMouseMoveEvent        // TCanvas processed QEvent mouseMoveEvent
//                  kMouseReleaseEvent     // TCanvas processed QEvent mouseReleaseEvent
//                  kMouseDoubleClickEvent // TCanvas processed QEvent mouseDoubleClickEvent
//                  kKeyPressEvent         // TCanvas processed QEvent keyPressEvent
//                  kEnterEvent            // TCanvas processed QEvent enterEvent
//                  kLeaveEvent            // TCanvas processed QEvent leaveEvent
//
//  For example to create the custom responce to the mouse crossing TCanvas
//  connect the RootEventProsecced signal with your qt slot:
//
// connect(tQtWidget,SIGNAL(RootEventProcessed(TObject *, unsigned int, TCanvas *))
//          ,this,SLOT(CanvasEvent(TObject *, unsigned int, TCanvas *)));
//  . . .
//
//void qtrootexample1::CanvasEvent(TObject *obj, unsigned int event, TCanvas *)
//{
//  TQtWidget *tipped = (TQtWidget *)sender();
//  const char *objectInfo =
//        obj->GetObjectInfo(tipped->GetEventX(),tipped->GetEventY());
//  QString tipText ="You have ";
//  if  (tipped == tQtWidget1)
//     tipText +="clicked";
//  else
//     tipText +="passed";
//  tipText += " the object <";
//  tipText += obj->GetName();
//  tipText += "> of class ";
//  tipText += obj->ClassName();
//  tipText += " : ";
//  tipText += objectInfo;
//
//   QWhatsThis::display(tipText)
// }
//
////////////////////////////////////////////////////////////////////////////////

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

TQtWidget::TQtWidget(QWidget* mother, const char* name, Qt::WFlags f,bool embedded) :
      QWidget(mother,f)
        ,fBits(0),fNeedStretch(false),fCanvas(0),fPixmapID(0),fPixmapScreen(0)
        ,fPaint(TRUE),fSizeChanged(FALSE),fDoubleBufferOn(FALSE),fEmbedded(embedded)
        ,fWrapper(0),fSaveFormat("PNG"),fInsidePaintEvent(false),fOldMousePos(-1,-1)
        ,fIgnoreLeaveEnter(0),fRefreshTimer(0)
{
   if (name && name[0]) setObjectName(name);
   Init() ;
}

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

TQtWidget::TQtWidget(QWidget* mother, Qt::WFlags f,bool embedded) :
      QWidget(mother,f)
     ,fBits(0),fNeedStretch(false),fCanvas(0),fPixmapID(0)
     ,fPixmapScreen(0),fPaint(TRUE),fSizeChanged(FALSE)
     ,fDoubleBufferOn(FALSE),fEmbedded(embedded),fWrapper(0),fSaveFormat("PNG")
     ,fInsidePaintEvent(false),fOldMousePos(-1,-1),fIgnoreLeaveEnter(0),fRefreshTimer(0)
{ setObjectName("tqtwidget"); Init() ;}

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

void TQtWidget::Init()
{
  setFocusPolicy(Qt::WheelFocus);
  setAttribute(Qt::WA_NoSystemBackground);
  setAutoFillBackground(false);
  QPalette  p = palette();
  p.setBrush(QPalette::Window, Qt::transparent);
  setPalette(p);

  if (fEmbedded) {
    if (!gApplication) InitRint();
    int minw = 10;
    int minh = 10;
    setMinimumSize(minw,minh);
     Bool_t batch = gROOT->IsBatch();
    if (!batch) gROOT->SetBatch(kTRUE); // to avoid the recursion within TCanvas ctor
    TGQt::RegisterWid(this);
    fCanvas = new TCanvas(objectName().toStdString().c_str(),minw,minh, TGQt::RegisterWid(this));
    gROOT->SetBatch(batch);
    //   schedule the flush operation fCanvas->Flush(); via timer
    Refresh();
  }
  fSizeHint = QWidget::sizeHint();
  setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding,QSizePolicy::MinimumExpanding));
#ifdef R__QTWIN32
   // Set the application icon for all ROOT widgets
   static HICON rootIcon = 0;
   if (!rootIcon) {
      HICON hIcon = ::LoadIcon(::GetModuleHandle(NULL), MAKEINTRESOURCE(101));
      if (!hIcon) hIcon = LoadIcon(NULL, IDI_APPLICATION);
      rootIcon = hIcon;
      SetClassLong(winId(),        // handle to window
                   GCL_HICON,      // index of value to change
                   LONG(rootIcon)  // new value
      );
    }
#endif
}
////////////////////////////////////////////////////////////////////////////////

TQtWidget::~TQtWidget()
{
   TCanvas *c = 0;
   // to block the double deleting from
   gVirtualX->SelectWindow(-1);
   TGQt::UnRegisterWid(this);
   if (fEmbedded) {
      // one has to set CanvasID = 0 to disconnect things properly.
      c = fCanvas;
      ResetCanvas();
      delete c;
   } else {
      ResetCanvas();
   }
   delete fPixmapID;     fPixmapID = 0;
   delete fPixmapScreen; fPixmapScreen = 0;
}

////////////////////////////////////////////////////////////////////////////////
/// Adjust the widget buffer size

void TQtWidget::AdjustBufferSize()
{
   TQtWidgetBuffer &buf = SetBuffer();
   QSize s(buf.Width(),buf.Height());
   if ( s != size() )  {
#if 0
       qDebug() << "TQtWidget::AdjustBufferSize(): "
             << this
             << s << size();
#endif
      if (fPixmapID) {
         TQtWidgetBuffer *bf = new TQtWidgetBuffer(*fPixmapID);
         delete  fPixmapID;     fPixmapID = bf;
      }
      if (fPixmapScreen) {
         TQtWidgetBuffer *bf = new TQtWidgetBuffer(*fPixmapScreen);
         delete  fPixmapScreen; fPixmapScreen = bf;
      }
   }
}
////////////////////////////////////////////////////////////////////////////////
/// Alias for GetCanvas method

TCanvas  *TQtWidget::Canvas()
{
   return GetCanvas();
}

////////////////////////////////////////////////////////////////////////////////
/// static: return TCanvas by TQtWidget pointer

TCanvas   *TQtWidget::Canvas(TQtWidget *widget)
{
   return widget ? widget->Canvas() : 0 ;
}

////////////////////////////////////////////////////////////////////////////////
/// static: return the TQtWidget backend for TCanvas *canvas object

TQtWidget *TQtWidget::Canvas(const TCanvas *canvas)
{
   return canvas ? Canvas(canvas->GetCanvasID()) : 0;
}
////////////////////////////////////////////////////////////////////////////////
/// static: return TQtWidget by TCanvas id

TQtWidget *TQtWidget::Canvas(Int_t id)
{
   return dynamic_cast<TQtWidget *>(TGQt::iwid(id));
}

////////////////////////////////////////////////////////////////////////////////
///
/// Instantiate ROOT from within Qt application if needed
/// Return the TRint pointer
/// Most parametrs are passed to TRint class ctor
///
/// Bool_t prompt = kTRUE;  Instantiate ROOT with ROOT command prompt
///                 kFALSE; No ROOT prompt. The default for Qt GUI applications
///
///  The prompt option can be defined via ROOT parameter file ".rootrc"
/// .rootrc:
///    . . .
///  Gui.Prompt   yes
///

TApplication *TQtWidget::InitRint( Bool_t /*prompt*/, const char *appClassName, int *argc, char **argv,
          void *options, int numOptions, Bool_t noLogo)
{
   static int localArgc     =0;
   static char **localArgv  =0;
   if (!gApplication) {
       QStringList args  = QCoreApplication::arguments ();
       localArgc = argc ? *argc : args.size();
       // check the Gui.backend and Factory
       TString guiBackend(gEnv->GetValue("Gui.Backend", "native"));
       guiBackend.ToLower();
       // Enforce Qt-base Gui.Backend and Gui.Factory from within ROOT-based Qt-application
       if (!guiBackend.BeginsWith("qt",TString::kIgnoreCase)) {
         gEnv->SetValue("Gui.Backend", "qt");
       }
       TString guiFactory(gEnv->GetValue("Gui.Factory", "native"));
       guiFactory.ToLower();
#if ROOT_VERSION_CODE >= ROOT_VERSION(5,16,0)
       TApplication::NeedGraphicsLibs() ;
#endif
       if (!guiFactory.BeginsWith("qt",TString::kIgnoreCase )){
         // Check for the extention
         char *extLib = gSystem->DynamicPathName("libQtRootGui",kTRUE);
         if (extLib) {
            gEnv->SetValue("Gui.Factory", "qtgui");
         } else {
            gEnv->SetValue("Gui.Factory", "qt");
         }
         delete [] extLib;
       }
       if (!argc && !argv ) {
          localArgv  = new char*[args.size()]; // leaking :-(
          for (int i = 0; i < args.size(); ++i) {
             QString nextarg = args.at(i);
             Int_t nchi = nextarg.length()+1;
             localArgv[i]= new char[nchi];
             memcpy(localArgv[i], nextarg.toAscii().constData(),nchi-1);
             localArgv[i][nchi-1]=0;
          }
       } else {
         localArgv  = argv;
       }

       TRint *rint = new TRint(appClassName, &localArgc, localArgv, options,numOptions,noLogo);
       // To mimic what TRint::Run(kTRUE) does.
       Int_t prompt= gEnv->GetValue("Gui.Prompt", (Int_t)0);
       if (prompt) {
           Getlinem(kInit, rint->GetPrompt());
       } else {
           // disable the TTermInputHandler too to avoid the crash under X11
           // to get the pure "GUI" application
           TSeqCollection* col = gSystem->GetListOfFileHandlers();
           TIter next(col);
           TFileHandler* o=0;
           while ( ( o=(TFileHandler*) next() ) ) {
              if ( o->GetFd()== 0 ) {
                o->Remove();
                break;
              }
           }
           // Remove Ctrl-C, there will be ROOT prompt anyway
           gSystem->RemoveSignalHandler(rint->GetSignalHandler());
       }
       TQtTimer::Create()->start(0);
   }
   return gApplication;
}

////////////////////////////////////////////////////////////////////////////////
/// Erases the entire widget and its double buffer

void TQtWidget::Erase()
{
  SetBuffer();
//  buf.fill(this,QPoint(0,0));
  if (fPixmapScreen)  fPixmapScreen->Clear();
  if (fPixmapID)      fPixmapID->Clear();
  // erase();
}

////////////////////////////////////////////////////////////////////////////////
/// [slot] to make this embedded canvas the current one

void TQtWidget::cd()
{
  cd(0);
}
 ///////////////////////////////////////////////////////////////////////////////
 /// [slot] to make this embedded canvas / pad the current one

void TQtWidget::cd(int subpadnumber)
{
  TCanvas *c = fCanvas;
  if (c) {
     c->cd(subpadnumber);
  }
}
////////////////////////////////////////////////////////////////////////////////
/// [slot] Disconnect the Qt widget from TCanvas object before deleting
/// to avoid the dead lock
/// one has to set CanvasID = 0 to disconnect things properly.

void TQtWidget::Disconnect()
{
   fCanvas = 0;
}
////////////////////////////////////////////////////////////////////////////////
/// [slot]  to allow Qt signal refreshing the ROOT TCanvas if needed
/// use the permanent single shot timer to eliminate
/// the redundand refreshing for the sake of the performance

void TQtWidget::Refresh()
{
   if (!fRefreshTimer) {
      fRefreshTimer  = new QTimer(this);
      fRefreshTimer->setSingleShot(true);
      fRefreshTimer->setInterval(0);
      connect(fRefreshTimer, SIGNAL(timeout()), this, SLOT(RefreshCB()));
   }
   fRefreshTimer->start();
}
////////////////////////////////////////////////////////////////////////////////
/// [slot]  to allow Qt signal refreshing the ROOT TCanvas if needed

void TQtWidget::RefreshCB()
{
   TCanvas *c = Canvas();
   if (c) {
      c->Modified();
      c->Resize();
      c->Update();
   }
   if (!fInsidePaintEvent) { update(); }
   else {
      qDebug() << " TQtWidget::Refresh() update inside of paintEvent !!!" << this;
   }
}
////////////////////////////////////////////////////////////////////////////////
///  remember my host TCanvas and adopt its name

void TQtWidget::SetCanvas(TCanvas *c)
{
   fCanvas = c;
   // qDebug() << "TQtWidget::SetCanvas(TCanvas *c)" << fCanvas << fCanvas->GetName() ;
   setObjectName(fCanvas->GetName());
}

////////////////////////////////////////////////////////////////////////////////
/// The custom response to the special WIN32 events
/// These events are not present with X11 systems

void
TQtWidget::customEvent(QEvent *e)
{
   switch (e->type() - QEvent::User) {
   case kEXITSIZEMOVE:
      { // WM_EXITSIZEMOVE
         fPaint = TRUE;
         exitSizeEvent();
         break;
      }
   case kENTERSIZEMOVE:
      {
         //  WM_ENTERSIZEMOVE
         fSizeChanged=FALSE;
         fPaint = FALSE;
         break;
      }
   case kFORCESIZE:
   default:
      {
         // Force resize
         fPaint       = TRUE;
         fSizeChanged = TRUE;
         exitSizeEvent();
         break;
      }
   };
}
 ///////////////////////////////////////////////////////////////////////////////
 /// The custom response to the Qt QContextMenuEvent
 /// Map QContextMenuEvent to the ROOT kButton3Down = 3  event

void TQtWidget::contextMenuEvent(QContextMenuEvent *e)
{
   TCanvas *c = Canvas();
   if (e && c && (e->reason() != QContextMenuEvent::Mouse) ) {
      e->accept();
      c->HandleInput(kButton3Down, e->x(), e->y());
   }
}
////////////////////////////////////////////////////////////////////////////////
/// The custom response to the Qt QFocusEvent "in"
/// this imposes an extra protection to avoid TObject interaction with
/// mouse event accidently

void TQtWidget::focusInEvent ( QFocusEvent *e )
{
   if (!fWrapper && e->gotFocus()) {
      setMouseTracking(TRUE);
   }
}
////////////////////////////////////////////////////////////////////////////////
/// The custom response to the Qt QFocusEvent "out"
/// this imposes an extra protection to avoid TObject interaction with
/// mouse event accidently

void TQtWidget::focusOutEvent ( QFocusEvent *e )
{
   if (!fWrapper && e->lostFocus()) {
      setMouseTracking(FALSE);
   }
}

////////////////////////////////////////////////////////////////////////////////
/// Map the Qt mouse press button event to the ROOT TCanvas events
/// Mouse events occur when a mouse button is pressed or released inside
/// a widget or when the mouse cursor is moved.

void TQtWidget::mousePressEvent (QMouseEvent *e)
{
   //    kButton1Down   =  1, kButton2Down   =  2, kButton3Down   =  3,

   EEventType rootButton = kNoEvent;
   Qt::ContextMenuPolicy currentPolicy = contextMenuPolicy();
   fOldMousePos = e->pos();
   TCanvas *c = Canvas();
   if (c && !fWrapper ){
      switch (e->button ())
      {
      case Qt::LeftButton:  rootButton = kButton1Down; break;
      case Qt::RightButton: {
         // respect the QWidget::contextMenuPolicy
         // treat this event as QContextMenuEvent
         if ( currentPolicy == Qt::DefaultContextMenu) {
            e->accept();
            QContextMenuEvent evt(QContextMenuEvent::Other, e->pos() );
            QApplication::sendEvent(this, &evt);
         } else {
            rootButton = kButton3Down;
         }
         break;
      }
      case Qt::MidButton:   rootButton = kButton2Down; break;
         default: break;
      };
      if (rootButton != kNoEvent) {
         e->accept();
         if (rootButton == kButton3Down) {
            bool lastvalue = c->TestBit(kNoContextMenu);
            c->SetBit(kNoContextMenu);
            c->HandleInput(rootButton, e->x(), e->y());
            c->SetBit(kNoContextMenu, lastvalue);
         } else {
            c->HandleInput(rootButton, e->x(), e->y());
         }
         EmitSignal(kMousePressEvent);
         return;
      }
   } else {
      e->ignore();
   }
   QWidget::mousePressEvent(e);
}

////////////////////////////////////////////////////////////////////////////////
///  Map the Qt mouse move pointer event to the ROOT TCanvas events
///  kMouseMotion   = 51,
///  kButton1Motion = 21, kButton2Motion = 22, kButton3Motion = 23, kKeyPress = 24

void TQtWidget::mouseMoveEvent (QMouseEvent * e)
{
   EEventType rootButton = kMouseMotion;
   if ( fOldMousePos != e->pos() && fIgnoreLeaveEnter < 2  ) { // workaround of Qt 4.5.x bug
      fOldMousePos = e->pos();
      TCanvas *c = Canvas();
      if (c && !fWrapper){
         if (e->buttons() & Qt::LeftButton) { rootButton = kButton1Motion; }
         e->accept();
         c->HandleInput(rootButton, e->x(), e->y());
         EmitSignal(kMouseMoveEvent);
         return;
      } else {
         e->ignore();
      }
   }
   QWidget::mouseMoveEvent(e);
}

////////////////////////////////////////////////////////////////////////////////
///  Map the Qt mouse button release event to the ROOT TCanvas events
///   kButton1Up     = 11, kButton2Up     = 12, kButton3Up     = 13

void TQtWidget::mouseReleaseEvent(QMouseEvent * e)
{
   EEventType rootButton = kNoEvent;
   fOldMousePos = QPoint(-1,-1);
   TCanvas *c = Canvas();
   if (c && !fWrapper){
      switch (e->button())
      {
      case Qt::LeftButton:  rootButton = kButton1Up; break;
      case Qt::RightButton: rootButton = kButton3Up; break;
      case Qt::MidButton:   rootButton = kButton2Up; break;
      default: break;
      };
      if (rootButton != kNoEvent) {
         e->accept();
         c->HandleInput(rootButton, e->x(), e->y());
         gPad->Modified();
         EmitSignal(kMouseReleaseEvent);
         return;
      }
   } else {
      e->ignore();
   }
   QWidget::mouseReleaseEvent(e);
}

////////////////////////////////////////////////////////////////////////////////
///  Map the Qt mouse double click button event to the ROOT TCanvas events
///  kButton1Double = 61, kButton2Double = 62, kButton3Double = 63

void TQtWidget::mouseDoubleClickEvent(QMouseEvent * e)
{
   EEventType rootButton = kNoEvent;
   TCanvas *c = Canvas();
   if (c && !fWrapper){
      switch (e->button())
      {
      case Qt::LeftButton:  rootButton = kButton1Double; break;
      case Qt::RightButton: rootButton = kButton3Double; break;
      case Qt::MidButton:   rootButton = kButton2Double; break;
      default: break;
      };
      if (rootButton != kNoEvent) {
         e->accept();
         c->HandleInput(rootButton, e->x(), e->y());
         EmitSignal(kMouseDoubleClickEvent);return;
      }
   }  else {
      e->ignore();
   }
   QWidget::mouseDoubleClickEvent(e);
}
////////////////////////////////////////////////////////////////////////////////
/// Map the Qt key press event to the ROOT TCanvas events
/// kKeyDown  =  4

void TQtWidget::keyPressEvent(QKeyEvent * e)
{
   TCanvas *c = Canvas();
   if (c && !fWrapper){
      c->HandleInput(kKeyPress, e->text().toStdString().c_str()[0], e->key());
      EmitSignal(kKeyPressEvent);
   } else {
      e->ignore();
   }
   QWidget::keyPressEvent(e);
}
////////////////////////////////////////////////////////////////////////////////
/// Map the Qt key release event to the ROOT TCanvas events
/// kKeyUp    = 14

void TQtWidget::keyReleaseEvent(QKeyEvent * e)
{
   QWidget::keyReleaseEvent(e);
}
////////////////////////////////////////////////////////////////////////////////
/// Map the Qt mouse enters widget event to the ROOT TCanvas events
/// kMouseEnter    = 52

void TQtWidget::enterEvent(QEvent *e)
{
   TCanvas *c = Canvas();
   if (c && !fIgnoreLeaveEnter && !fWrapper){
      c->HandleInput(kMouseEnter, 0, 0);
      EmitSignal(kEnterEvent);
   }
   QWidget::enterEvent(e);
}
////////////////////////////////////////////////////////////////////////////////
///  Map the Qt mouse leaves widget event to the ROOT TCanvas events
/// kMouseLeave    = 53

void TQtWidget::leaveEvent (QEvent *e)
{
   TCanvas *c = Canvas();
   if (c && !fIgnoreLeaveEnter && !fWrapper){
      c->HandleInput(kMouseLeave, 0, 0);
      EmitSignal(kLeaveEvent);
   }
   QWidget::leaveEvent(e);
}
////////////////////////////////////////////////////////////////////////////////
/// The widget will be erased and receive a paint event immediately after
/// processing the resize event.
/// No drawing need be (or should be) done inside this handler.

void TQtWidget::resizeEvent(QResizeEvent *e)
{
   if (!e) return;
   if (topLevelWidget()->isMinimized())      { fSizeChanged=FALSE; }
   else if (topLevelWidget()->isMaximized ()){
      fSizeChanged=TRUE;
      exitSizeEvent();
      fSizeChanged=TRUE;
   } else {
#ifdef R__QTWIN32
      if (!fPaint)  {
         // real resize event
         fSizeChanged=TRUE;
         fNeedStretch=true;
      } else {
#else
      {
         fSizeChanged=TRUE;
#if 0
         if (Qt::LeftButton == QApplication::mouseButtons())
         {
            fNeedStretch=true;
            fPaint = false;
         } else
#endif
         {
            fPaint = kTRUE;
            exitSizeEvent();
         }
#endif
      } }
}
////////////////////////////////////////////////////////////////////////////////
/// Set the default save format for the widget

void TQtWidget::SetSaveFormat(const char *format)
{
   fSaveFormat = TGQt::QtFileFormat(format);
}
////////////////////////////////////////////////////////////////////////////////
///
///  TQtWidget::Save(const QString &fileName) is a public Qt slot.
///  it saves the double buffer of this object using the default save
///  format  defined the file extension
///  If the "fileName" has no extension the "default" format is to be used instead
///  The default format is "PNG".
///  It can be changed with the TQtWidget::SetSaveFormat method
///

bool TQtWidget::Save(const char *fileName) const
{
    return Save(QString(fileName));
}
////////////////////////////////////////////////////////////////////////////////
///
///  TQtWidget::Save(const QString &fileName) is a public Qt slot.
///  it saves the double buffer of this object using the default save
///  format  defined the file extension
///  If the "fileName" has no extension the "default" format is to be used instead
///  The default format is "PNG".
///  It can be changed with the TQtWidget::SetSaveFormat method
///

bool TQtWidget::Save(const QString &fileName) const
{
   QString fileNameExtension = QFileInfo(fileName).suffix().toUpper();
   QString saveFormat;
   if (fileNameExtension.isEmpty() ) {
      saveFormat = fSaveFormat; // this is default
   } else {
      saveFormat = TGQt::QtFileFormat(fileNameExtension);
   }
   return Save(fileName,saveFormat.toStdString().c_str());
}

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

bool TQtWidget::Save(const char *fileName,const char *format,int quality)const
{
   return Save(QString(fileName),format,quality);
}
////////////////////////////////////////////////////////////////////////////////
///  TQtWidget::save is a public Qt slot.
///  it saves the double buffer of this object using QPixmap facility

bool TQtWidget::Save(const QString &fileName,const char *format,int quality)const
{
   bool Ok = false;
   bool rootFormatFound=kTRUE;
   QString saveType =  TGQt::RootFileFormat(format);
   if (saveType.isEmpty() )  {
      rootFormatFound = false;
      saveType = TGQt::QtFileFormat(format);
   }
   TCanvas *c = GetCanvas();
   if (rootFormatFound && c) {
      c->Print(fileName.toStdString().c_str(),saveType.toStdString().c_str());
      Ok = true;
   } else if (GetOffScreenBuffer()) {
      // Since the "+" is a legal part of the file name and it is used by Onuchin
      // to indicate  the "animation" mode, we have to proceed very carefully
      int dot = fileName.lastIndexOf('.');
      int plus = 0;
      if (dot > -1) {
         plus = fileName.indexOf('+',dot+1);
      }
      QString fln = (plus > -1) ? TGQt::GetNewFileName(fileName.left(plus)) : fileName;
      if (fCanvasDecorator.isNull()) {
         Ok = GetOffScreenBuffer()->save(fln,saveType.toStdString().c_str(),quality);
      } else {
         /// add decoration
      }
   }
   emit ((TQtWidget *)this)->Saved(Ok);
   return Ok;
}
////////////////////////////////////////////////////////////////////////////////
/// Set the double buffered mode on/off

void  TQtWidget::SetDoubleBuffer(bool on)
{
   if (fDoubleBufferOn != on ) {
      fDoubleBufferOn = on;
      if (on) SetBuffer();
   }
}
////////////////////////////////////////////////////////////////////////////////
/// Stretch the widget during sizing

void TQtWidget::stretchWidget(QResizeEvent * /*s*/)
{
   if  (!paintingActive() && fPixmapID) {
      QPainter pnt(this);
      pnt.drawPixmap(rect(),*GetOffScreenBuffer());
   }
   fNeedStretch = false;
}
////////////////////////////////////////////////////////////////////////////////
/// Response to the "exit size event"

void TQtWidget::exitSizeEvent ()
{
   if (!fSizeChanged ) return;
   {
      AdjustBufferSize();
   }
   //Refresh();
   TCanvas *c = Canvas();
   if (c)   c->Resize();
   // One more time to catch the last size
   Refresh();
}

////////////////////////////////////////////////////////////////////////////////
///  Set new fPaint flag
///  Returns: the previous version of the flag

bool TQtWidget::paintFlag(bool mode)
{
   bool flag = fPaint;
   fPaint = mode;
   return flag;
}
////////////////////////////////////////////////////////////////////////////////
/// Custom handler of the Qt show event
/// Non-spontaneous show events are sent to widgets immediately before
/// they are shown.
/// The spontaneous show events of top-level widgets are delivered afterwards.

void TQtWidget::showEvent ( QShowEvent *)
{
   TQtWidgetBuffer &buf = SetBuffer();
   QSize s(buf.Width(),buf.Height());
   if (s != size() )
   {
      fSizeChanged = kTRUE;
      exitSizeEvent();
   }
}

////////////////////////////////////////////////////////////////////////////////
/// Custom handler of the Qt paint event
/// A paint event is a request to repaint all or part of the widget.
/// It can happen as a result of repaint() or update(), or because the widget
/// was obscured and has now been uncovered, or for many other reasons.

void TQtWidget::paintEvent (QPaintEvent *e)
{
   fInsidePaintEvent = true;
   if (fNeedStretch) {
      stretchWidget((QResizeEvent *)0);
   } else {
#ifdef R__QTWIN32
      TQtWidgetBuffer &buf = SetBuffer();
      QSize s(buf.Width(),buf.Height());
      if ( fEmbedded && (s != size()) )
      {
         fSizeChanged = kTRUE;
         exitSizeEvent();
         fInsidePaintEvent = false;
         return;
      }
#endif
      QRegion region = e->region();
      if ( ( fPaint && !region.isEmpty() ) )
      {
         //  fprintf(stderr,"TQtWidget::paintEvent: window = %p; buffer =  %p\n",
         //  (QPaintDevice *)this, (QPaintDevice *)&GetBuffer());
         //  qDebug() << "1. TQtWidget::paintEvent this =" << (QPaintDevice *)this  << " buffer = " << fPixmapID << "redirected = " << QPainter::redirected(this)
         //    <<" IsDoubleBuffered()=" << IsDoubleBuffered() ;
         // qDebug() << "2. TQtWidget::paintEvent this =" << (QPaintDevice *)this  << " buffer = " << fPixmapID << " IsDoubleBuffered()=" << IsDoubleBuffered() ;
         QPainter screen(this);
         screen.setClipRegion(region);
         // paint the the TCanvas double buffer
         if (fPixmapID)  screen.drawPixmap(0,0,*GetOffScreenBuffer());
         if (!fCanvasDecorator.isNull()) fCanvasDecorator->paintEvent(screen,e);
      }
   }
   fInsidePaintEvent = false;
}
//  Layout methods:
////////////////////////////////////////////////////////////////////////////////
///  sets the preferred size of the widget.

void TQtWidget::SetSizeHint (const QSize &sz) {
   fSizeHint = sz;
}
////////////////////////////////////////////////////////////////////////////////
///  returns the preferred size of the widget.

QSize TQtWidget::sizeHint () const{
   return QWidget::sizeHint();
}
////////////////////////////////////////////////////////////////////////////////
/// returns the smallest size the widget can have.

QSize TQtWidget::minimumSizeHint () const{
   return QWidget::minimumSizeHint ();
}
////////////////////////////////////////////////////////////////////////////////
///  returns a QSizePolicy; a value describing the space requirements

QSizePolicy TQtWidget::sizePolicy () const{
   return QWidget::sizePolicy ();
}
////////////////////////////////////////////////////////////////////////////////

void  TQtWidget::EmitTestedSignal()
{
   TCanvas *c        = GetCanvas();
   TObject *selected = GetSelected();
   UInt_t evt      = GetEvent();
   emit RootEventProcessed(selected, evt, c);
}
////////////////////////////////////////////////////////////////////////////////
/// Set or unset the user status bits as specified in f.

void  TQtWidget::SetBit(UInt_t f, Bool_t set)
{
   if (set)
      SetBit(f);
   else
      ResetBit(f);
}
////////////////////////////////////////////////////////////////////////////////
/// Create (if needed) and return the buffer

TQtWidgetBuffer  &TQtWidget::SetBuffer() {
   TQtWidgetBuffer *buf = 0;
   if (IsDoubleBuffered() ) {
      if (!fPixmapID) fPixmapID = new TQtWidgetBuffer(this);
      buf = fPixmapID;
   } else {
      if (!fPixmapScreen) fPixmapScreen = new TQtWidgetBuffer(this,true);
      // qDebug() << "TQtWidget::SetBuffer() " << fPixmapScreen;
      buf = fPixmapScreen;
   }
   return  *buf;
}
////////////////////////////////////////////////////////////////////////////////
///  return the current widget buffer;

QPixmap  *TQtWidget::GetOffScreenBuffer()  const {
   return fPixmapID ? (QPixmap  *)fPixmapID->Buffer():0;
}