MINFEmbeddedCanvas.cxx

Go to the documentation of this file.

//*CMZ :  2.21/08 11/03/99  16.36.20  by  Fons Rademakers
//*CMZ :  2.20/00 03/11/98  19.52.59  by  Fons Rademakers
//*CMZ :  2.00/10 16/07/98  18.50.45  by  Fons Rademakers
//*-- Author :    Fons Rademakers   15/07/98

//*KEEP,CopyRight,T=C.
/*************************************************************************
 * Copyright(c) 1995-1999, The ROOT System, All rights reserved.         *
 * Authors: Rene Brun, Fons Rademakers.                                  *
 * For list of contributors see $ROOTSYS/AA_CREDITS.                     *
 *                                                                       *
 * Permission to use, copy, modify and distribute this software and its  *
 * documentation for non-commercial purposes is hereby granted without   *
 * fee, provided that the above copyright notice appears in all copies   *
 * and that both the copyright notice and this permission notice appear  *
 * in the supporting documentation. The authors make no claims about the *
 * suitability of this software for any purpose. It is provided "as is"  *
 * without express or implied warranty.                                  *
 *************************************************************************/
//*KEND.

//                                                                      //
// MINFEmbeddedCanvas                                                  //
//                                                                      //
// This class creates a TGCanvas in which a TCanvas is created. Use     //
// GetCanvas() to get a pointer to the TCanvas.                         //
//                                                                      //

// MINF includes which need to be gotten rid of.
#include "MINF_Classes/MINFDisplayFrame.h"
#include "MINF_Classes/MINFEmbeddedCanvas.h"

#include "TCanvas.h"
#include "TROOT.h"

//                                                                      //
// MINFEmbeddedContainer                                               //
//                                                                      //
// Utility class used by MINFEmbeddedCanvas. The MINFEmbeddedContainer//
// 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 MINFEmbeddedCanvas     //
// handlers.                                                            //
//                                                                      //

class MINFEmbeddedContainer : public TGCompositeFrame {
private:
   MINFEmbeddedCanvas  *fCanvas;    // pointer back to embedded canvas
public:
   MINFEmbeddedContainer(MINFEmbeddedCanvas *c, Window_t id, const TGWindow *parent);

   Bool_t HandleButton(Event_t *ev) {
     return fCanvas->HandleContainerButton(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);
   }
};

//______________________________________________________________________________
MINFEmbeddedContainer::MINFEmbeddedContainer(MINFEmbeddedCanvas *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);

   gVirtualX->SelectInput(fId, kKeyPressMask | kKeyReleaseMask | kExposureMask |
                     kPointerMotionMask | kStructureNotifyMask | kLeaveWindowMask);
}

ClassImp(MINFEmbeddedCanvas)

//______________________________________________________________________________
MINFEmbeddedCanvas::MINFEmbeddedCanvas(const char *name, const TGWindow *p,
            UInt_t w, UInt_t h, UInt_t options, ULong_t back)
   : TGCanvas(p, w, h, options, back)
{
   // Create an TCanvas embedded in a TGFrame. A pointer to the TCanvas can
   // be obtained via the GetCanvas() member function.

   fButton  = 0;
   fAutoFit = kTRUE;
   fShowEventStatus = kFALSE;

   Int_t wid = gVirtualX->InitWindow((ULong_t)GetViewPort()->GetId());
   Window_t win = gVirtualX->GetWindowID(wid);
   fCanvasContainer = new MINFEmbeddedContainer(this, win, GetViewPort());
   SetContainer(fCanvasContainer);

   fCanvas = new TCanvas(name, 10, 10, wid);
}

//______________________________________________________________________________
MINFEmbeddedCanvas::~MINFEmbeddedCanvas()
{
   // Delete embedded ROOT canvas.

   delete fCanvas;
   delete fCanvasContainer;
}

//_______________________________________________________________________
void MINFEmbeddedCanvas::DrawEventStatus(Int_t event, Int_t px, Int_t py, TObject *selected)
{

//*-*-*-*-*-*-*Report name and title of primitive below the cursor*-*-*-*-*-*
//*-*          ===================================================
//
//    This function is called when the option "Event Status"
//    in the canvas menu "Options" is selected.
//

   const Int_t kTMAX=256;
   static char atext[kTMAX];

   if (!selected) return;

//#ifndef WIN32
#if 0
   static Int_t pxt, pyt;
   gPad->SetDoubleBuffer(0);           // Turn off double buffer mode
   gVirtualX->SetTextColor(1);
   gVirtualX->SetTextAlign(11);

   pxt = gPad->GetCanvas()->XtoAbsPixel(gPad->GetCanvas()->GetX1()) + 5;
   pyt = gPad->GetCanvas()->YtoAbsPixel(gPad->GetCanvas()->GetY1()) - 5;

   sprintf(atext,"%s / %s ", selected->GetName()
                           , selected->GetObjectInfo(px,py));
   for (Int_t i=strlen(atext);i<kTMAX-1;i++) atext[i] = ' ';
   atext[kTMAX-1] = 0;
   gVirtualX->DrawText(pxt, pyt, 0, 1, atext, TGXW::kOpaque);
#else
//gmi   if (!fCanvasImp) return; //this may happen when closing a TAttCanvas
   SetStatusText((Text_t *)(selected->GetTitle()),0);
   SetStatusText((Text_t *)(selected->GetName()),1);
   if (event == kKeyPress)
      sprintf(atext, "%c", (char) px);
   else
      sprintf(atext, "%d,%d", px, py);
   SetStatusText(atext,2);
   SetStatusText((Text_t *)(selected->GetObjectInfo(px,py)),3);
#endif
}

//______________________________________________________________________________
Bool_t MINFEmbeddedCanvas::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 (fShowEventStatus) DrawEventStatus(event->fType, x, y, fCanvas->GetSelected());
      if (button == kButton2)
         fCanvas->HandleInput(kButton2Down, x, y);
         SetUnZoomPad(fCanvas->GetSelectedPad());
      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 (fShowEventStatus) DrawEventStatus(event->fType, x, y, fCanvas->GetSelected());
      if (button == kButton2)
         fCanvas->HandleInput(kButton2Up, x, y);
      if (button == kButton3)
         fCanvas->HandleInput(kButton3Up, x, y);

      fButton = 0;
   }

   return kTRUE;
}

//______________________________________________________________________________
Bool_t MINFEmbeddedCanvas::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 (fShowEventStatus) DrawEventStatus(event->fType, x, y, fCanvas->GetSelected());
   if (button == kButton2)
      fCanvas->HandleInput(kButton2Double, x, y);
   if (button == kButton3)
      fCanvas->HandleInput(kButton3Double, x, y);

   return kTRUE;
}

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

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

//______________________________________________________________________________
Bool_t MINFEmbeddedCanvas::HandleContainerKey(Event_t *event)
{

// Handle mouse motion event in the canvas container.
   Int_t x = event->fX;
   Int_t y = event->fY;

// 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], 0);
      if (fShowEventStatus) DrawEventStatus(event->fType, x, y, fCanvas->GetSelected());
   } else if (event->fType == kKeyRelease)
      fButton = 0;

   return kTRUE;
}

//______________________________________________________________________________
Bool_t MINFEmbeddedCanvas::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 (fShowEventStatus) DrawEventStatus(event->fType, x, y, fCanvas->GetSelected());
   if (fButton == kButton1)
      fCanvas->HandleInput(kButton1Motion, x, y);
      if (fShowEventStatus) DrawEventStatus(event->fType, x, y, fCanvas->GetSelected());

   return kTRUE;
}

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

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

   return kTRUE;
}

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

   if (event->fType == kLeaveNotify)
      fCanvas->HandleInput(kMouseLeave, 0, 0);

   return kTRUE;
}

//_______________________________________________________________________
void MINFEmbeddedCanvas::SetStatusText(Text_t *txt, Int_t partidx)
{

// Set text in status bar.
   ((MINFDisplayFrame *) fParent)->SetStatusText(txt, partidx);
}

//_______________________________________________________________________
void MINFEmbeddedCanvas::SetUnZoomPad(TVirtualPad *pad)
{

// Set text in status bar.
   ((MINFDisplayFrame *) fParent)->SetUnZoomPad(pad);
}

---