LoupeOnPad.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (c) IPNL, IN2P3, CNRS                                       *
 *   Contibutor(s) :                                                       *
 *      Jeremie Dudouet  dudouet(AT)ipnl.in2p3.fr [2014]                   *
 *      Olivier Stezowski stezow(AT)ipnl.in2p3.fr [2014]                   *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include "Buttons.h"

#include "LoupeOnPad.h"

LoupeOnPad::LoupeOnPad(TCanvas *canvas) :
    TObject(),
    fCanvas(canvas),
    fCurrentPadNumber(1),
    fLastX(),
    fLastY(),
    fDeltaX(1),
    fDeltaY(1),
    fToggleLoupe(true),
    fToggleMouse(false)
{   
    // in this case connect the current canvas
    if ( fCanvas == 0x0 ) {
        if ( TVirtualPad::Pad() )
            fCanvas = TVirtualPad::Pad()->GetCanvas();
        else {
            //fLog.SetProcessMethod("Connect(TCanvas* )");
            //fLog << error << "gPad not existing" << dolog;
        }
    }

    if ( fCanvas ) {
        // to catch event on the canvas
        fCanvas->Connect("ProcessedEvent(Int_t, Int_t, Int_t, TObject*)",
                         "LoupeOnPad",
                         this,
                         "HandleMovement(Int_t, Int_t, Int_t, TObject*)");
        fCanvas->Connect("Closed()",
                         "LoupeOnPad",
                         this,
                         "Delete(Option_t *)");

        fCanvas->GetListOfPrimitives()->Add(this);

        std::cout << "LoupeOnPad connected to " << fCanvas->GetName() << std::endl;
    }
}

LoupeOnPad::~LoupeOnPad()
{
    //    std::cout << " LoupeOnPad::~LoupeOnPad() " << std::endl;
    Clear();
    if ( fCanvas ) {
        if ( TQObject::Disconnect(fCanvas,"ProcessedEvent(Int_t, Int_t, Int_t, TObject*)",
                                  this,"HandleMovement(Int_t, Int_t, Int_t, TObject*)") &&
             TQObject::Disconnect(fCanvas,"Closed()",this,"Delete(Option_t *)") ) {
            std::cout << "Disconnect done for canvas" << std::endl;
        }
        else  std::cout << "Disconnect fail canvas" << std::endl;

        std::cout << "LoupeOnPad disconnected from " << fCanvas->GetName() << std::endl;
    }
}

Int_t LoupeOnPad::GetPadNumber(Int_t add_x, Int_t add_y)
{
    Int_t padnumber = 0;

    // should never be the case ...
    if ( fCanvas == 0x0 )
        return padnumber;

    // no subpad
    if ( fCanvas->GetPad(1) == 0x0 )
        return padnumber;

    Double_t x1 = fCanvas->GetPad(1)->GetXlowNDC(); Int_t nb_x = 1, nb_tot = 2, delta_pad = 0; Bool_t count_x = true; TPad *pad;

    while ( (pad=(TPad *)fCanvas->GetPad(nb_tot++)) ) {
        if ( pad->GetXlowNDC() > x1 && count_x ) {
            x1 = pad->GetXlowNDC();
            nb_x++;
        }
        else { count_x = false; }
    }

    delta_pad = add_x + add_y * nb_x;
    if ( delta_pad < 0 ) {
        padnumber = TMath::Max(0,fCurrentPadNumber+delta_pad);
    }
    else {
        padnumber = TMath::Min(nb_tot,fCurrentPadNumber+delta_pad);
    }

    return padnumber;
}

TCanvas * LoupeOnPad::CheckLoupeIsThere()
{
    TCanvas *loupe = 0x0;
    
    if ( fCanvas ) {
        loupe = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("LoupeOnPad");
        if (!loupe)
        {
            int ww = gPad->GetWw();
            int wh = gPad->GetWh();
            loupe = new TCanvas("LoupeOnPad","LoupeOnPad",1000,10,1000,(int)1000*wh/ww);
            loupe->ToggleToolBar();

            int LastPadNbr = 1;
            int i = 0;

            int fCurrentSave = fCurrentPadNumber;
            fCurrentPadNumber = 1;

            while(GetPadNumber(0,i)==fCanvas->cd(LastPadNbr)->GetNumber())
            {
                i++;
               LastPadNbr = fCanvas->cd(GetPadNumber(0,i))->GetNumber();
            }


            TPad *RefPad = (TPad*)fCanvas->cd(LastPadNbr);

            loupe->SetRightMargin(RefPad->GetRightMargin());
            loupe->SetTopMargin(RefPad->GetTopMargin());
            loupe->SetLeftMargin(RefPad->GetLeftMargin());
            loupe->SetBottomMargin(RefPad->GetBottomMargin());

            fCurrentPadNumber = fCurrentSave;

            loupe->Update();
            loupe->Modified();
        }
    }

    return loupe;
}

void LoupeOnPad::Clear(Option_t *)
{

    TPad *pad; TObject *obj;
    Int_t nb_tot = 0;
    while ( (pad=(TPad *)fCanvas->GetPad(nb_tot++)) ) {

        Bool_t modified = false;
        
        if ( (obj = pad->GetListOfPrimitives()->FindObject("LoupeOnPad_S")) ) {
            pad->GetListOfPrimitives()->Remove(obj);
            obj->Delete();
            modified = true;
        }
        if ( modified ) {
            pad->Modified();
            pad->Update();
        }
    }

    TCanvas *loupe = 0x0;
    if ( (loupe = (TCanvas*)gROOT->FindObject("LoopOnPad")) == 0x0 )
        return;

    while(loupe->GetListOfPrimitives()->GetSize()) loupe->GetListOfPrimitives()->RemoveFirst();
    loupe->Modified();
    loupe->Update();
}

void LoupeOnPad::ChangeCurrentPad(Int_t padnumber)
{
    TCanvas *loupe = 0x0;

    if ( (loupe = CheckLoupeIsThere()) == 0x0 || padnumber == 0 ) return;

    TObject *obj = 0x0; TPave *CurrentPave = 0x0; TVirtualPad *selectedpad = fCanvas->GetPad(padnumber);

    if ( selectedpad == 0x0 )return;

    if (!selectedpad->GetListOfPrimitives()->GetSize())
    {
        fCurrentPadNumber = padnumber;
        return;
    }

    if ( (CurrentPave=(TPave*)selectedpad->GetListOfPrimitives()->FindObject("LoupeOnPad_S")) ) CurrentPave->SetFillColor(kRed);
    else
    {
        CurrentPave = new TPave(0.,0.,1.,1.,0,"NDC");
        CurrentPave->SetFillColor(kRed);
        CurrentPave->SetFillStyle(3001);
        CurrentPave->SetName("LoupeOnPad_S");
        CurrentPave->SetBit(kCanDelete);
        CurrentPave->SetBit(kCannotPick);
        selectedpad->GetListOfPrimitives()->Add(CurrentPave);
    }

    selectedpad->Modified();
    selectedpad->Update();

    selectedpad = fCanvas->GetPad(fCurrentPadNumber);

    if ( selectedpad == 0x0 )return;

    if ( (CurrentPave=(TPave*)selectedpad->GetListOfPrimitives()->FindObject("LoupeOnPad_S")) )
    {
        CurrentPave->SetFillColor(kGray+3);
        selectedpad->Modified();
        selectedpad->Update();
    }

    selectedpad = fCanvas->GetPad(padnumber);

    loupe->cd();
    loupe->GetListOfPrimitives()->Clear("nodelete");
    TObjLink *lnk = selectedpad->GetListOfPrimitives()->FirstLink();
    while (lnk) {
        obj = lnk->GetObject();

        TString tmp = obj->GetName();
        if ( tmp == "LoupeOnPad_S" ) {
            lnk = lnk->Next();
            continue;
        }

        lnk->GetObject()->Draw(lnk->GetOption());
        lnk = lnk->Next();
    }

    loupe->SetFrameFillStyle(0);

    loupe->Update(); selectedpad->Modified(true); fCanvas->Update(); fCurrentPadNumber = padnumber;
}

void LoupeOnPad::HandleMovement(Int_t eventType, Int_t eventX, Int_t eventY, TObject *select)
{
    Int_t addX = 0, addY = 0;
    select = 0x0;

    if( eventType == kMouseMotion)
    {
        fLastX = eventX;
        fLastY = eventY;

        return;
    }  
    
#ifndef R__MACOSX
#if ROOT_VERSION_CODE >= ROOT_VERSION(5,34,19)
   if( eventType == kArrowKeyRelease )
   {
       if(eventX>fLastX) addX = addX + fDeltaX;
       if(eventX<fLastX) addX = addX - fDeltaX;

       if(eventY>fLastY) addY = addY + fDeltaY;
       if(eventY<fLastY) addY = addY - fDeltaY;

       fLastX = eventX;
       fLastY = eventY;
   }
#endif
#endif
    
    if( eventType == kKeyPress ) {
        Int_t keysym = eventY;

//        if ( (EKeySym)keysym == kKey_d ) {
//            delete this;
//            return;
//        }
        if ( (EKeySym)keysym == kKey_t ) {
            fToggleLoupe = !fToggleLoupe;
        }
        if ( (EKeySym)keysym == kKey_Left || (EKeySym)keysym == kKey_4 ) {
            addX = addX - fDeltaX;
        }
        if ( (EKeySym)keysym == kKey_Up || (EKeySym)keysym == kKey_8  ) {
            addY = addY - fDeltaY;
        }
        if ( (EKeySym)keysym == kKey_Right || (EKeySym)keysym == kKey_6  ) {
            addX = addX + fDeltaX;
        }
        if ( (EKeySym)keysym == kKey_Down|| (EKeySym)keysym == kKey_2 ) {
            addY = addY + fDeltaY;
        }
        if ( (EKeySym)keysym == kKey_7 )  {
            addX = addX - fDeltaX;
            addY = addY - fDeltaY;
        }
        if ( (EKeySym)keysym == kKey_9  ) {
            addX = addX + fDeltaX;
            addY = addY - fDeltaY;
        }
        if ( (EKeySym)keysym == kKey_3  ) {
            addX = addX + fDeltaX;
            addY = addY + fDeltaY;
        }
        if ( (EKeySym)keysym == kKey_1 ) {
            addX = addX - fDeltaX;
            addY = addY + fDeltaY;
        }
//        if ( (EKeySym)keysym == kKey_h) {
//            printf("\n");
//            printf("\th: this help \n");
//            printf("any key to select pad under mouse \n");
//            printf("\tt: toggle on/off loupe on canvas \n");
//            printf("\tc: clear history \n");
//            printf("\tleft or 4  arrow: move to left pad\n");
//            printf("\tright or 6 arrow: move to right pad\n");
//            printf("\tup or 8 arrow: move up in pads\n");
//            printf("\tdown or 2 arrow: move down in pads\n");
//            printf("\td: delete LoupeOnPad \n");
//        }
        if ( (EKeySym)keysym == kKey_c) {
            Clear();
        } // to loop on task once or infinitely
        if ( (EKeySym)keysym == kKey_Space && fToggleLoupe ) {
            if ( fCanvas->GetSelectedPad() ) {
                ChangeCurrentPad ( fCanvas->GetSelectedPad()->GetNumber() );
            }
        }
    }
    if ( (addX || addY) && fToggleLoupe ) {
        ChangeCurrentPad( GetPadNumber(addX,addY) );

        TVirtualPad *selectedpad = fCanvas->GetPad(fCurrentPadNumber);
        if(!selectedpad->GetListOfPrimitives()->GetSize())ChangeCurrentPad( GetPadNumber(addX,addY) );

    }
}

ClassImp(LoupeOnPad)

void RunLoupeOnPad(TCanvas *c)
{
    TCanvas *cc = c;

    if ( c == 0x0 &&TVirtualPad::Pad() && TVirtualPad::Pad()->GetCanvas() )
        cc = TVirtualPad::Pad()->GetCanvas();

    if (cc)
        new LoupeOnPad(cc);
}