TGuiBldDragManager.cxx

Go to the documentation of this file.

// @(#)root/guibuilder:$Id: 99541fed972db7e4279fadcd4c0a0f0ae28a0a4d $
// Author: Valeriy Onuchin   12/09/04
 
/*************************************************************************
 * Copyright (C) 1995-2004, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
 
 
#include "TGuiBldDragManager.h"
#include "TGuiBldEditor.h"
#include "TRootGuiBuilder.h"
 
#include "TTimer.h"
#include "TList.h"
#include "TClass.h"
#include "TSystem.h"
#include "TROOT.h"
#include "TColor.h"
#include "TImage.h"
 
#include "TError.h"
#include "TClassMenuItem.h"
#include "TMethod.h"
#include "TMethodCall.h"
#include "TBaseClass.h"
#include "TDataMember.h"
#include "TMethodArg.h"
#include "TToggle.h"
#include "TDataType.h"
#include "TObjString.h"
#include "TInterpreter.h"
 
#include "KeySymbols.h"
#include "TGResourcePool.h"
#include "TGMenu.h"
#include "TGFileDialog.h"
#include "TGMsgBox.h"
#include "TRandom.h"
#include "TGButton.h"
#include "TGMdi.h"
#include "TGTextEntry.h"
#include "TGDockableFrame.h"
#include "TGColorDialog.h"
#include "TGFontDialog.h"
#include "TGComboBox.h"
#include "TGCanvas.h"
#include "TGLabel.h"
#include "TGProgressBar.h"
#include "TGScrollBar.h"
#include "TVirtualX.h"
#include "strlcpy.h"
#include "snprintf.h"
 
#undef DEBUG_LOCAL
 
 
/** \class TGuiBldDragManager
    \ingroup guibuilder
 
Drag and drop manager used by the ROOT GUI Builder.
 
*/
 
 
ClassImp(TGuiBldDragManager);
 
static UInt_t gGridStep = 8;
static TGuiBldDragManager *gGuiBldDragManager = 0;
TGColorDialog *TGuiBldDragManager::fgGlobalColorDialog = 0;
TGFontDialog *TGuiBldDragManager::fgGlobalFontDialog = 0;
 
static const char *gSaveMacroTypes[] = {
   "Macro files", "*.C",
   "All files",   "*",
   0,             0
};
 
static const char *gImageTypes[] = {
   "All files", "*",
   "XPM",     "*.xpm",
   "GIF",     "*.gif",
   "PNG",     "*.png",
   "JPEG",    "*.jpg",
   "TARGA",   "*.tga",
   "BMP",     "*.bmp",
   "ICO",     "*.ico",
   "XCF",     "*.xcf",
   "CURSORS", "*.cur",
   "PPM",     "*.ppm",
   "PNM",     "*.pnm",
   "XBM",     "*.xbm",
   "TIFF",    "*.tiff",
   "Encapsulated PostScript", "*.eps",
   "PostScript", "*.ps",
   "PDF",        "*.pdf",
   "ASImage XML","*.xml",
    0,             0
};
 
 
////////////////////////////////////////////////////////////////////////////////
 
 
class TGuiBldMenuDialog : public TGTransientFrame {
 
friend class TGuiBldDragManager;
 
public:
   TGButton       *fOK;       // OK button
   //TGButton     *fApply;    // apply button
   TGButton       *fCancel;   // cancel button
   TObject        *fObject;   // selected object/frame
   TMethod        *fMethod;   // method to be applied
   TGLayoutHints  *fL1;       // internally used layout hints
   TGLayoutHints  *fL2;       // internally used layout hints
   TList          *fWidgets;  // list of widgets
 
public:
   ~TGuiBldMenuDialog() override;
   TGuiBldMenuDialog(const TGWindow *main, TObject *obj, TMethod *method);
 
   const char *GetParameters();
   void CloseWindow() override;
   void ConnectButtonSignals();
   void Build();
   void Popup();
   void ApplyMethod();
   void Add(const char *argname, const char *value, const char *type);
 
};
 
static TGuiBldMenuDialog *gMenuDialog = 0;
 
 
////////////////////////////////////////////////////////////////////////////////
/// ctor.
 
TGuiBldMenuDialog::TGuiBldMenuDialog(const TGWindow *main, TObject *obj, TMethod *method) :
    TGTransientFrame(gClient->GetDefaultRoot(), main, 200, 100)
{
   fObject = obj;
   fMethod = method;
   if (!obj) return; // zombie
 
   fWidgets = new TList();
 
   fL1 = new TGLayoutHints(kLHintsTop | kLHintsCenterX, 0, 0, 5, 0);
   fL2 = new TGLayoutHints(kLHintsTop | kLHintsLeft, 5, 5, 5, 5);
 
   TString title = obj->ClassName();
   title += "::";
   title += method->GetName();
 
   Build();
   ConnectButtonSignals();
 
   SetWindowName(title);
   SetIconName(title);
   SetEditDisabled(kEditDisable);
 
   //TRootGuiBuilder::PropagateBgndColor(this, TRootGuiBuilder::GetBgnd());
}
 
////////////////////////////////////////////////////////////////////////////////
/// dtor.
 
TGuiBldMenuDialog::~TGuiBldMenuDialog()
{
   fWidgets->Delete();
   delete fWidgets;
   delete fL1;
   delete fL2;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Connect buttons signals
 
void TGuiBldMenuDialog::ConnectButtonSignals()
{
   fOK->Connect("Pressed()", "TGuiBldDragManager", gGuiBldDragManager, "DoDialogOK()");
   //fApply->Connect("Pressed()", "TGuiBldDragManager", gGuiBldDragManager, "DoDialogApply()");
   fCancel->Connect("Pressed()", "TGuiBldDragManager", gGuiBldDragManager, "DoDialogCancel()");
}
 
////////////////////////////////////////////////////////////////////////////////
/// execute method for object with input args
 
void TGuiBldMenuDialog::ApplyMethod()
{
   const char *params = GetParameters();
   fObject->Execute(fMethod->GetName(), params);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Return input parameters as single string.
 
const char *TGuiBldMenuDialog::GetParameters()
{
   static char params[1024];
   char param[256];
 
   TObjString   *str;
   TObject      *obj;
 
   Int_t selfobjpos;
//   if (fMenu->GetContextMenu()->GetSelectedMenuItem())
//      selfobjpos = fMenu->GetContextMenu()->GetSelectedMenuItem()->GetSelfObjectPos();
//   else
   selfobjpos = -1;
 
   params[0] = 0;
   TIter next(fWidgets);
   Int_t nparam = 0;
 
   while ((obj = next())) {        // first element is label, skip...
      if (obj->IsA() != TGLabel::Class()) break;
      obj = next();                // get either TGTextEntry or TGComboBox
      str = (TObjString *) next(); // get type string
 
      nparam++;
 
      const char *type = str->GetString().Data();
      const char *data = 0;
 
      if (obj->IsA() == TGTextEntry::Class())
         data = ((TGTextEntry *) obj)->GetBuffer()->GetString();
 
      // TODO: Combobox...
 
      // if necessary, replace the selected object by it's address
      if (selfobjpos == nparam-1) {
         if (params[0]) strlcat(params, ",", 1024-strlen(params));
         snprintf(param, 255, "(TObject*)0x%zx", (size_t)fObject);
         strlcat(params, param, 1024-strlen(params));
      }
 
      if (params[0]) strlcat(params, ",", 1024-strlen(params));
      if (data) {
         if (!strncmp(type, "char*", 5))
            snprintf(param, 255, "\"%s\"", data);
         else
            strlcpy(param, data, sizeof(param));
      } else
         strlcpy(param, "0", sizeof(param));
 
      strlcat(params, param, 1024-strlen(params));
   }
 
   // if selected object is the last argument, have to insert it here
   if (selfobjpos == nparam) {
      if (params[0]) strlcat(params, ",", 1024-strlen(params));
      snprintf(param, 255, "(TObject*)0x%zx", (size_t)fObject);
      strlcat(params, param, 1024-strlen(params));
   }
 
   return params;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Create a string describing method argument.
 
static TString CreateArgumentTitle(TMethodArg *argument)
{
   static TString ret;
 
   if (argument) {
      ret.Form("(%s)  %s", argument->GetTitle(), argument->GetName());
      if (argument->GetDefault() && *(argument->GetDefault())) {
         ret += "  [default: ";
         ret += argument->GetDefault();
         ret += "]";
      }
   }
 
   return ret;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Add a label and text input field.
 
void TGuiBldMenuDialog::Add(const char *argname, const char *value, const char *type)
{
   TGLabel      *l = new TGLabel(this, argname);
   TGTextBuffer *b = new TGTextBuffer(20);
   b->AddText(0, value);
   TGTextEntry  *t = new TGTextEntry(this, b);
 
   t->Connect("ReturnPressed()", "TGuiBldDragManager", gGuiBldDragManager, "DoDialogOK()");
   t->Resize(260, t->GetDefaultHeight());
   AddFrame(l, fL1);
   AddFrame(t, fL2);
 
   fWidgets->Add(l);
   fWidgets->Add(t);
   fWidgets->Add(new TObjString(type));
}
 
////////////////////////////////////////////////////////////////////////////////
/// Close window
 
void TGuiBldMenuDialog::CloseWindow()
{
   gGuiBldDragManager->DoDialogCancel();
}
 
////////////////////////////////////////////////////////////////////////////////
/// Build dialog
 
void TGuiBldMenuDialog::Build()
{
   TMethodArg *argument = 0;
   Int_t selfobjpos = -1;
 
   TIter next(fMethod->GetListOfMethodArgs());
   Int_t argpos = 0;
 
   while ((argument = (TMethodArg *) next())) {
      // Do not input argument for self object
      if (selfobjpos != argpos) {
         TString arg_name = CreateArgumentTitle(argument);
         const char *argname = arg_name.Data();
         const char *type = argument->GetTypeName();
         TDataType  *datatype = gROOT->GetType(type);
         const char *charstar = "char*";
         char basictype[32];
 
         if (datatype) {
            strlcpy(basictype, datatype->GetTypeName(), sizeof(basictype));
         } else {
            TClass *cl = TClass::GetClass(type);
            if (strncmp(type, "enum", 4) && (cl && !(cl->Property() & kIsEnum)))
               Warning("Dialog", "data type is not basic type, assuming (int)");
            strlcpy(basictype, "int", sizeof(basictype));
         }
 
         if (strchr(argname, '*')) {
            strlcat(basictype, "*", 32-strlen(basictype));
            type = charstar;
         }
 
         TDataMember *m = argument->GetDataMember();
         if (m && m->GetterMethod(fObject->IsA())) {
 
            // Get the current value and form it as a text:
            char val[256];
 
            if (!strncmp(basictype, "char*", 5)) {
               char *tdefval = 0;
               m->GetterMethod()->Execute(fObject, "", &tdefval);
               if (tdefval && strlen(tdefval))
                  strlcpy(val, tdefval, sizeof(val));
            } else if (!strncmp(basictype, "float", 5) ||
                       !strncmp(basictype, "double", 6)) {
               Double_t ddefval = 0.0;
               m->GetterMethod()->Execute(fObject, "", ddefval);
               snprintf(val, 255, "%g", ddefval);
            } else if (!strncmp(basictype, "char", 4) ||
                       !strncmp(basictype, "bool", 4) ||
                       !strncmp(basictype, "int", 3)  ||
                       !strncmp(basictype, "long", 4) ||
                       !strncmp(basictype, "short", 5)) {
               Longptr_t ldefval = 0L;
               m->GetterMethod()->Execute(fObject, "", ldefval);
               snprintf(val, 255, "%zi", (size_t)ldefval);
            }
 
            // Find out whether we have options ...
 
            if (m->GetOptions()) {
               Warning("Dialog", "option menu not yet implemented");
            } else {
               // we haven't got options - textfield ...
               Add(argname, val, type);
            }
         } else {    // if m not found ...
 
            char val[256] = "";
            const char *tval = argument->GetDefault();
            if (tval) strlcpy(val, tval, sizeof(val));
            Add(argname, val, type);
         }
      }
      argpos++;
   }
 
   // add OK, Apply, Cancel buttons
   TGHorizontalFrame *hf = new TGHorizontalFrame(this, 60, 20, kFixedWidth);
   TGLayoutHints     *l1 = new TGLayoutHints(kLHintsCenterY | kLHintsExpandX, 5, 5, 0, 0);
   UInt_t  width = 0, height = 0;
 
   fWidgets->Add(l1);
 
   fOK = new TGTextButton(hf, "&OK", 1);
   hf->AddFrame(fOK, l1);
   fWidgets->Add(fOK);
   width  = TMath::Max(width, fOK->GetDefaultWidth());
 
/*
   fApply = new TGTextButton(hf, "&Apply", 2);
   hf->AddFrame(fApply, l1);
   fWidgets->Add(fApply);
   height = fApply->GetDefaultHeight();
   width  = TMath::Max(width, fApply->GetDefaultWidth());
*/
 
   fCancel = new TGTextButton(hf, "&Cancel", 3);
   hf->AddFrame(fCancel, l1);
   fWidgets->Add(fCancel);
   height = fCancel->GetDefaultHeight();
   width  = TMath::Max(width, fCancel->GetDefaultWidth());
 
   // place buttons at the bottom
   l1 = new TGLayoutHints(kLHintsBottom | kLHintsCenterX, 0, 0, 5, 5);
   AddFrame(hf, l1);
   fWidgets->Add(l1);
   fWidgets->Add(hf);
 
   hf->Resize((width + 20) * 3, height);
 
   // map all widgets and calculate size of dialog
   MapSubwindows();
}
 
////////////////////////////////////////////////////////////////////////////////
/// Popup dialog.
 
void TGuiBldMenuDialog::Popup()
{
   UInt_t width  = GetDefaultWidth();
   UInt_t height = GetDefaultHeight();
 
   Resize(width, height);
 
   Window_t wdummy;
   Int_t x = (Int_t)((TGFrame*)fMain)->GetWidth();
   Int_t y = (Int_t)((TGFrame*)fMain)->GetHeight();
   gVirtualX->TranslateCoordinates(fMain->GetId(), fClient->GetDefaultRoot()->GetId(),
                                   x, y, x, y, wdummy);
 
   x += 10;
   y += 10;
 
   // make the message box non-resizable
   SetWMSize(width, height);
   SetWMSizeHints(width, height, width, height, 0, 0);
 
   SetMWMHints(kMWMDecorAll | kMWMDecorResizeH  | kMWMDecorMaximize |
                              kMWMDecorMinimize | kMWMDecorMenu,
               kMWMFuncAll  | kMWMFuncResize    | kMWMFuncMaximize |
                              kMWMFuncMinimize,
               kMWMInputModeless);
 
   Move(x, y);
   SetWMPosition(x, y);
   MapRaised();
   fClient->WaitFor(this);
}
 
 
///////////////////////// auxiliary static functions ///////////////////////////
////////////////////////////////////////////////////////////////////////////////
/// Helper. Return a window located at point x,y (in screen coordinates)
 
static Window_t GetWindowFromPoint(Int_t x, Int_t y)
{
   Window_t src, dst, child;
   Window_t ret = 0;
   Int_t xx = x;
   Int_t yy = y;
 
   if (!gGuiBldDragManager || gGuiBldDragManager->IsStopped() ||
       !gClient->IsEditable()) return 0;
 
   dst = src = child = gVirtualX->GetDefaultRootWindow();
 
   while (child && dst) {
      src = dst;
      dst = child;
      gVirtualX->TranslateCoordinates(src, dst, xx, yy, xx, yy, child);
      ret = dst;
   }
   return ret;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Helper to layout
 
static void layoutFrame(TGFrame *frame)
{
   if (!frame || !frame->InheritsFrom(TGCompositeFrame::Class())) {
      return;
   }
 
   TGCompositeFrame *comp = (TGCompositeFrame*)frame;
 
   if (comp->GetLayoutManager()) {
      comp->GetLayoutManager()->Layout();
   } else {
      comp->Layout();
   }
   gClient->NeedRedraw(comp);
 
   TIter next(comp->GetList());
   TGFrameElement *fe;
 
   while ((fe = (TGFrameElement*)next())) {
      layoutFrame(fe->fFrame);
      gClient->NeedRedraw(fe->fFrame);
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// Our own error handler (not used yet)
 
static void GuiBldErrorHandler(Int_t /*level*/, Bool_t /*abort*/,
                                 const char * /*location*/, const char * /*msg*/)
{
}
 
////////////////////////////////////////////////////////////////////////////////
class TGuiBldDragManagerGrid {
 
public:
   static UInt_t   fgStep;
   static ULong_t  fgPixel;
   static TGGC    *fgBgnd;
 
   Pixmap_t    fPixmap;
   TGWindow   *fWindow;
   Int_t       fWinId;
 
   TGuiBldDragManagerGrid();
   ~TGuiBldDragManagerGrid();
   void  Draw();
   void  SetStep(UInt_t step);
   void  InitPixmap();
   void  InitBgnd();
};
 
UInt_t   TGuiBldDragManagerGrid::fgStep = gGridStep;
ULong_t  TGuiBldDragManagerGrid::fgPixel = 0;
TGGC    *TGuiBldDragManagerGrid::fgBgnd = 0;
 
////////////////////////////////////////////////////////////////////////////////
/// Create a grid background for the selected window
 
TGuiBldDragManagerGrid::TGuiBldDragManagerGrid()
{
   fPixmap = 0;
   fWindow = 0;
   fWinId = 0;
 
   if (!fgBgnd) {
      InitBgnd();
   }
   SetStep(fgStep);
}
 
////////////////////////////////////////////////////////////////////////////////
/// ctor.
 
TGuiBldDragManagerGrid::~TGuiBldDragManagerGrid()
{
   fWindow = gClient->GetWindowById(fWinId);
 
   if (fWindow) {
      fWindow->SetBackgroundPixmap(0);
      fWindow->SetBackgroundColor(((TGFrame*)fWindow)->GetBackground());
      gClient->NeedRedraw(fWindow, kTRUE);
   }
   if (fPixmap) {
      gVirtualX->DeletePixmap(fPixmap);
   }
 
   fPixmap = 0;
   fWindow = 0;
   fWinId = 0;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set the grid step
 
void TGuiBldDragManagerGrid::SetStep(UInt_t step)
{
   if (!gClient || !gClient->IsEditable()) {
      return;
   }
 
   fWindow = (TGWindow*)gClient->GetRoot();
   fWinId = fWindow->GetId();
   fgStep = step;
   InitPixmap();
 
}
 
////////////////////////////////////////////////////////////////////////////////
/// Create grid background.
 
void TGuiBldDragManagerGrid::InitBgnd()
{
   if (fgBgnd) {
      return;
   }
 
   fgBgnd = new TGGC(TGFrame::GetBckgndGC());
 
   Float_t r, g, b;
 
   r = 232./255;
   g = 232./255;
   b = 226./255;
 
   fgPixel = TColor::RGB2Pixel(r, g, b);
   fgBgnd->SetForeground(fgPixel);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Create grid background pixmap
 
void TGuiBldDragManagerGrid::InitPixmap()
{
   if (fPixmap) {
      gVirtualX->DeletePixmap(fPixmap);
   }
 
   fPixmap = gVirtualX->CreatePixmap(gClient->GetDefaultRoot()->GetId(), fgStep, fgStep);
   gVirtualX->FillRectangle(fPixmap, fgBgnd->GetGC(), 0, 0, fgStep, fgStep);
 
   if(fgStep > 2) {
      gVirtualX->FillRectangle(fPixmap, TGFrame::GetShadowGC()(),
                               fgStep - 1, fgStep - 1, 1, 1);
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// Draw grid over edited frame.
 
void TGuiBldDragManagerGrid::Draw()
{
   if (!gClient || !gClient->IsEditable()) {
      return;
   }
 
   fWindow = gClient->GetWindowById(fWinId);
 
   if (fWindow && (fWindow != gClient->GetRoot())) {
      fWindow->SetBackgroundPixmap(0);
      fWindow->SetBackgroundColor(((TGFrame*)fWindow)->GetBackground());
      gClient->NeedRedraw(fWindow);
   }
 
   if (!fPixmap) {
      InitPixmap();
   }
 
   fWindow = (TGWindow*)gClient->GetRoot();
   fWinId = fWindow->GetId();
   fWindow->SetBackgroundPixmap(fPixmap);
 
   gClient->NeedRedraw(fWindow);
}
 
 
////////////////////////////////////////////////////////////////////////////////
class TGuiBldDragManagerRepeatTimer : public TTimer {
 
private:
   TGuiBldDragManager *fManager;   // back pointer
 
public:
   TGuiBldDragManagerRepeatTimer(TGuiBldDragManager *m, Long_t ms) :
                                 TTimer(ms, kTRUE) { fManager = m; }
   Bool_t Notify() override { fManager->HandleTimer(this); Reset(); return kFALSE; }
};
 
 
////////////////////////////////////////////////////////////////////////////////
class TGGrabRect : public TGFrame {
 
private:
   Pixmap_t    fPixmap;
   ECursor     fType;
 
public:
   TGGrabRect(Int_t type);
   ~TGGrabRect() override {}
 
   Bool_t HandleButton(Event_t *ev) override;
   ECursor GetType() const { return fType; }
};
 
////////////////////////////////////////////////////////////////////////////////
/// ctor.
 
TGGrabRect::TGGrabRect(Int_t type) :
      TGFrame(gClient->GetDefaultRoot(), 8, 8, kTempFrame)
{
   fType = kTopLeft;
 
   switch (type) {
      case 0:
         fType = kTopLeft;
         break;
      case 1:
         fType = kTopSide;
         break;
      case 2:
         fType = kTopRight;
         break;
      case 3:
         fType = kBottomLeft;
         break;
      case 4:
         fType = kLeftSide;
         break;
      case 5:
         fType = kRightSide;
         break;
      case 6:
         fType = kBottomSide;
         break;
      case 7:
         fType = kBottomRight;
         break;
   }
 
   SetWindowAttributes_t attr;
   attr.fMask             = kWAOverrideRedirect | kWASaveUnder;
   attr.fOverrideRedirect = kTRUE;
   attr.fSaveUnder        = kTRUE;
 
   gVirtualX->ChangeWindowAttributes(fId, &attr);
 
   fPixmap = gVirtualX->CreatePixmap(gVirtualX->GetDefaultRootWindow(), 8, 8);
   const TGGC *bgc = TRootGuiBuilder::GetPopupHlghtGC();
//fClient->GetResourcePool()->GetSelectedBckgndGC();
   TGGC *gc = new TGGC(TGFrame::GetBckgndGC());
 
   Pixel_t back;
   fClient->GetColorByName("black", back);
   gc->SetBackground(back);
   gc->SetForeground(back);
 
   gVirtualX->FillRectangle(fPixmap, bgc->GetGC(), 0, 0, 7, 7);
   gVirtualX->DrawRectangle(fPixmap, gc->GetGC(), 0, 0, 7, 7);
//   gVirtualX->DrawRectangle(fPixmap, fClient->GetResourcePool()->GetSelectedBckgndGC()->GetGC(), 1, 1, 5, 5);
 
   AddInput(kButtonPressMask);
   SetBackgroundPixmap(fPixmap);
 
   gVirtualX->SetCursor(fId, gVirtualX->CreateCursor(fType));
}
 
////////////////////////////////////////////////////////////////////////////////
/// Handle button press event.
 
Bool_t TGGrabRect::HandleButton(Event_t *ev)
{
   gGuiBldDragManager->CheckDragResize(ev);
   return kTRUE;
}
 
////////////////////////////////////////////////////////////////////////////////
class TGAroundFrame : public TGFrame {
 
public:
   TGAroundFrame();
   ~TGAroundFrame() override {}
};
 
////////////////////////////////////////////////////////////////////////////////
/// ctor.
 
TGAroundFrame::TGAroundFrame() : TGFrame(gClient->GetDefaultRoot(), 1, 1,
                                         kTempFrame | kOwnBackground)
{
   SetWindowAttributes_t attr;
   attr.fMask             = kWAOverrideRedirect | kWASaveUnder;
   attr.fOverrideRedirect = kTRUE;
   attr.fSaveUnder        = kTRUE;
 
   gVirtualX->ChangeWindowAttributes(fId, &attr);
   ULong_t blue;
   fClient->GetColorByName("blue", blue);
   SetBackgroundColor(blue);
}
 
 
////////////////////////////////////////////////////////////////////////////////
class TGuiBldDragManagerPimpl {
 
friend class TGuiBldDragManager;
 
private:
   TGuiBldDragManager     *fManager;   // drag and drop manager
   TTimer            *fRepeatTimer;    // repeat rate timer (when mouse stays pressed)
   TGFrame           *fGrab;           // grabbed/selected frame
   TGLayoutHints     *fGrabLayout;     // layout of grabbed frame
   TGFrame           *fSaveGrab;       // used during context menu handling
   TGFrame           *fClickFrame;     // last clicked frame
   TGuiBldDragManagerGrid *fGrid;      //
   ECursor            fResizeType;     // defines resize type
   Int_t              fX0, fY0;        // initial drag position in pixels
   Int_t              fX, fY;          // current drag position in pixels
   Int_t              fXf, fYf;        // offset of initial position inside frame
   Int_t              fGrabX, fGrabY;  //
   const TGWindow    *fGrabParent;     // parent of the grabbed/selected frame
   Int_t              fLastPopupAction;//
   Bool_t             fReplaceOn;
   TGGrabRect        *fGrabRect[8];    // small rectangles drawn over grabbed/selected frame
   TGFrame           *fAroundFrame[4]; // red lines drawn over laid out frame
   Bool_t             fGrabRectHidden;
   TGFrameElement    *fGrabListPosition;
   Bool_t             fButtonPressed;  //
   Bool_t             fCompacted;   //
   TGFrame           *fPlane; // highlighted plain composite frame when mose is moving
   TGFrame           *fSpacePressedFrame; // frame which was grabbed via spacebar pressed
   Bool_t             fPlacePopup; // kTRUE is menu fo frame was placed
   TList             *fFrameMenuTrash; // trash list
   TGFrame           *fMenuObject;     // object/frame for which context menu is created
 
public:
   TGuiBldDragManagerPimpl(TGuiBldDragManager *m) {
      fManager = m;
      fRepeatTimer = new TGuiBldDragManagerRepeatTimer(m, 100);
 
      int i = 0;
      for (i = 0; i <8; i++) {
         fGrabRect[i] = new TGGrabRect(i);
      }
      for (i = 0; i <4; i++) {
         fAroundFrame[i] = new TGAroundFrame();
      }
 
      fFrameMenuTrash = new TList();
 
      ResetParams();
   }
   void ResetParams() {
      fGrab = 0;
      fSaveGrab = 0;
      fClickFrame = 0;
      fGrid = 0;
      fX0 = fY0 = fX = fY = fXf = fYf = fGrabX = fGrabY = 0;
      fGrabParent = 0;
      fResizeType = kPointer;
      fLastPopupAction = kNoneAct;
      fReplaceOn = kFALSE;
      fGrabLayout = 0;
      fGrabRectHidden = kFALSE;
      fGrabListPosition = 0;
      fButtonPressed = kFALSE;
      fCompacted = kFALSE;
      fPlane = 0;
      fSpacePressedFrame = 0;
      fPlacePopup = kFALSE;
      fFrameMenuTrash->Delete();
      fMenuObject = 0;
   }
 
   ~TGuiBldDragManagerPimpl() {
      int i;
      for (i = 0; i <8; i++) {
         delete fGrabRect[i];
      }
      for (i = 0; i <4; i++) {
         delete fAroundFrame[i];
      }
 
      delete fRepeatTimer;
      delete fGrab;
      fFrameMenuTrash->Delete();
      delete fFrameMenuTrash;
 
      if (fPlane) {
         fPlane->ChangeOptions(fPlane->GetOptions() & ~kRaisedFrame);
         gClient->NeedRedraw(fPlane, kTRUE);
         fPlane = 0;
      }
   }
};
 
 
////////////////////////////////////////////////////////////////////////////////
TGuiBldDragManager::TGuiBldDragManager() : TVirtualDragManager() ,
                    TGFrame(gClient->GetDefaultRoot(), 1, 1)
{
   // Constructor. Create "fantom window".
 
   SetWindowAttributes_t attr;
   attr.fMask             = kWAOverrideRedirect | kWASaveUnder;
   attr.fOverrideRedirect = kTRUE;
   attr.fSaveUnder        = kTRUE;
 
   gVirtualX->ChangeWindowAttributes(fId, &attr);
 
   gGuiBldDragManager = this;
   fPimpl = new TGuiBldDragManagerPimpl(this);
 
   fSelectionIsOn = kFALSE;
   fFrameMenu     = 0;
   fLassoMenu     = 0;
   fEditor        = 0;
   fBuilder       = 0;
   fLassoDrawn    = kFALSE;
   fDropStatus    = kFALSE;
   fStop          = kTRUE;
   fSelected      = 0;
   fListOfDialogs = 0;
 
   Reset1();
   CreateListOfDialogs();
 
   TString tmpfile = gSystem->TempDirectory();
   char *s = gSystem->ConcatFileName(tmpfile.Data(),
               TString::Format("RootGuiBldClipboard%d.C", gSystem->GetPid()));
   fPasteFileName = s;
   delete [] s;
 
   s = gSystem->ConcatFileName(tmpfile.Data(),
               TString::Format("RootGuiBldTmpFile%d.C", gSystem->GetPid()));
   fTmpBuildFile = s;
   delete [] s;
 
   fName = "Gui Builder Drag Manager";
   SetWindowName(fName.Data());
 
   // let's try to solve the problems by myself
   SetErrorHandler(GuiBldErrorHandler);
 
   fClient->UnregisterWindow(this);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Destructor
 
TGuiBldDragManager::~TGuiBldDragManager()
{
   SetEditable(kFALSE);
 
   delete fPimpl;
 
   delete fBuilder;
   fBuilder = 0;
 
//   delete fEditor;
//   fEditor = 0;
 
   delete fFrameMenu;
   fFrameMenu =0;
 
   delete fLassoMenu;
   fLassoMenu = 0;
 
   if (!gSystem->AccessPathName(fPasteFileName.Data())) {
      gSystem->Unlink(fPasteFileName.Data());
   }
 
   delete fListOfDialogs;
 
   gGuiBldDragManager = 0;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Reset some parameters
 
void TGuiBldDragManager::Reset1()
{
   TVirtualDragManager::Init();
   fTargetId = 0;
   fPimpl->fPlacePopup = kFALSE;
   SetCursorType(kPointer);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Create a list of dialog methods
 
void TGuiBldDragManager::CreateListOfDialogs()
{
   fListOfDialogs = new TList();
 
   TList *methodList = IsA()->GetListOfMethods();
   TIter next(methodList);
   TString str;
   TMethod *method;
 
   while ((method = (TMethod*) next())) {
      str = method->GetCommentString();
      if (str.Contains("*DIALOG")) {
         fListOfDialogs->Add(method);
      }
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// Draw grid on editable frame and restore background on previously edited one
 
void TGuiBldDragManager::Snap2Grid()
{
   if (fStop) {
      return;
   }
 
   delete fPimpl->fGrid;
 
   fPimpl->fGrid = new TGuiBldDragManagerGrid();
   fPimpl->fGrid->Draw();
}
 
////////////////////////////////////////////////////////////////////////////////
/// Return the grid step
 
UInt_t TGuiBldDragManager::GetGridStep()
{
   return fPimpl->fGrid ? fPimpl->fGrid->fgStep : 1;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set the grid step
 
void TGuiBldDragManager::SetGridStep(UInt_t step)
{
   fPimpl->fGrid->SetStep(step);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Return kTRUE if event is rejected for processing by drag manager
 
Bool_t TGuiBldDragManager::IgnoreEvent(Event_t *event)
{
   if (fStop || !fClient || !fClient->IsEditable()) return kTRUE;
   if (event->fType == kClientMessage) return kFALSE;
   if (event->fType == kDestroyNotify) return kFALSE;
 
   TGWindow *w = fClient->GetWindowById(event->fWindow);
 
   if (w) {
      if (IsEditDisabled(w)) {
         w = GetEditableParent((TGFrame*)w);
         return !w;
      }
   } else {
      return kTRUE;
   }
   return kFALSE;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Return a pointer to the parent window (which is being edited)
 
TGFrame* TGuiBldDragManager::InEditable(Window_t id)
{
   if (fStop || !id) {
      return 0;
   }
 
   Window_t preparent = id;
   Window_t parent = (Window_t)gVirtualX->GetParent(id);
 
   while (!parent || (parent != fClient->GetDefaultRoot()->GetId())) {
      if (parent == fClient->GetRoot()->GetId()) {
         TGWindow *w = fClient->GetWindowById(preparent);
         return (w ? (TGFrame*)w : 0);
      }
      preparent = parent;
      parent = gVirtualX->GetParent(parent);
   }
   return 0;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Find the first composite parent of window
 
TGCompositeFrame *TGuiBldDragManager::FindCompositeFrame(Window_t id)
{
   if (fStop || !id) {
      return 0;
   }
 
   Window_t parent = id;
 
   while (!parent || (parent != fClient->GetDefaultRoot()->GetId())) {
      TGWindow *w = fClient->GetWindowById(parent);
      if (w) {
         if (w->InheritsFrom(TGCompositeFrame::Class())) {
            return (TGCompositeFrame*)w;
         }
      }
      parent = gVirtualX->GetParent(parent);
   }
   return 0;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set cursor for selected/grabbed frame.
 
void TGuiBldDragManager::SetCursorType(Int_t cur)
{
   if (fStop) {
      return;
   }
 
   static UInt_t gid = 0;
   static UInt_t rid = 0;
 
   if (fPimpl->fGrab && (gid != fPimpl->fGrab->GetId())) {
      gVirtualX->SetCursor(fPimpl->fGrab->GetId(),
                           gVirtualX->CreateCursor((ECursor)cur));
      gid = fPimpl->fGrab->GetId();
   }
   if (fClient->IsEditable() && (rid != fClient->GetRoot()->GetId())) {
      gVirtualX->SetCursor(fClient->GetRoot()->GetId(),
                           gVirtualX->CreateCursor((ECursor)cur));
      rid = fClient->GetRoot()->GetId();
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// Check resize type event.
 
Bool_t TGuiBldDragManager::CheckDragResize(Event_t *event)
{
   if (fStop) {
      return kFALSE;
   }
 
   Bool_t ret = kFALSE;
   fPimpl->fResizeType = kPointer;
 
   for (int i = 0; i < 8; i++) {
      if (fPimpl->fGrabRect[i]->GetId() == event->fWindow) {
         fPimpl->fResizeType = fPimpl->fGrabRect[i]->GetType();
         ret = kTRUE;
      }
   }
 
   if ((event->fType == kButtonPress) && (fPimpl->fResizeType != kPointer)) {
      fDragType = kDragResize;
      ret = kTRUE;
   }
 
   SetCursorType(ret ? fPimpl->fResizeType : kPointer);
   return ret;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Redraw the edited window
 
void TGuiBldDragManager::DoRedraw()
{
   if (fStop || !fClient || !fClient->IsEditable()) {
      return;
   }
 
   TGWindow *root = (TGWindow*)fClient->GetRoot();
 
   fClient->NeedRedraw(root, kTRUE);
 
   if (fBuilder) {
      fClient->NeedRedraw(fBuilder, kTRUE);
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// Switch editable
 
void TGuiBldDragManager::SwitchEditable(TGFrame *frame)
{
   if (fStop || !frame) {
      return;
   }
 
   TGCompositeFrame *comp = 0;
 
   if (frame->InheritsFrom(TGCompositeFrame::Class()) && CanChangeLayout(frame)) {
      comp = (TGCompositeFrame *)frame;
   } else if (frame->GetParent()->InheritsFrom(TGCompositeFrame::Class())) {
      comp = (TGCompositeFrame *)frame->GetParent();
   }
 
   if (!comp) {
      return;
   }
 
   TString str = comp->ClassName();
   str += "::";
   str += comp->GetName();
 
   if (IsEditDisabled(comp)) {
      if (fBuilder) {
         str += " cannot be edited.";
         fBuilder->UpdateStatusBar(str.Data());
      }
      return;
   }
 
   if (frame != comp) {
      SelectFrame(frame);
   }
 
   if (comp->IsEditable()) {
      return;
   }
 
   RaiseMdiFrame(comp);
   comp->SetEditable(kTRUE);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Grab/Select frame
 
void TGuiBldDragManager::SelectFrame(TGFrame *frame, Bool_t add)
{
   if (fStop || !frame || (frame->GetParent() == fClient->GetDefaultRoot()) ||
       !fClient->IsEditable()) {
      return;
   }
 
   TString str = frame->ClassName();
   str += "::";
   str += frame->GetName();
 
   if (IsGrabDisabled(frame)) {
      if (fBuilder) {
         str += "can not be selected";
         fBuilder->UpdateStatusBar(str.Data());
      }
      return;
   }
 
   // do not grab mdi frames (quick hack)
   if (fBuilder && frame->InheritsFrom(TGMdiFrame::Class())) {
      return;
   }
 
 
   static Int_t x, x0, y, y0, xx, yy;
   Window_t c;
 
   RaiseMdiFrame(FindMdiFrame(frame));
   frame->MapRaised();
 
   if (!add) {
 
      fDragType = (fDragType != kDragCopy ) ?  kDragMove : fDragType;
 
      gVirtualX->TranslateCoordinates(frame->GetId(),
                                      fClient->GetDefaultRoot()->GetId(),
                                      0, 0, x0, y0, c);
 
      x = x0 + frame->GetWidth();
      y = y0 + frame->GetHeight();
 
      if (fBuilder) {
         str += " selected";
         str += (IsEditDisabled(frame) || IsFixedLayout(frame)  ? ". This frame cannot be edited." :
                 " ");
         str += " Press SpaceBar to unselect the frame.";
         if (IsFixedSize(frame)) str += " This frame cannot be resized.";
 
         fBuilder->UpdateStatusBar(str.Data());
      }
 
   } else { //shift mask is on
 
      gVirtualX->TranslateCoordinates(frame->GetId(),
                                      fClient->GetDefaultRoot()->GetId(),
                                      0, 0, xx, yy, c);
 
      fDragType = kDragLasso;
      fPimpl->fX0 = x0 = TMath::Min(x0, xx);
      fPimpl->fX = x = TMath::Max(x, xx + (Int_t)frame->GetWidth());
      fPimpl->fY0 = y0 = TMath::Min(y0, yy);
      fPimpl->fY = y = TMath::Max(y, yy + (Int_t)frame->GetHeight());
 
      DrawLasso();
   }
 
   fFrameUnder = fPimpl->fGrab = frame;
   fPimpl->fGrab->RequestFocus();
 
   // quick hack. the special case for TGCanvases
   if (frame->InheritsFrom(TGCanvas::Class())) {
      fSelected = ((TGCanvas*)frame)->GetContainer();
 
      if (!IsEditDisabled(fSelected)) {
         fSelected->SetEditable(kTRUE);
         if (fBuilder && fBuilder->GetAction()) {
            PlaceFrame((TGFrame*)fBuilder->ExecuteAction(), 0);
         }
      }
   } else {
      fSelected = fPimpl->fGrab;
   }
   ChangeSelected(fPimpl->fGrab);
 
   SetCursorType(kMove);
 
   SetLassoDrawn(kFALSE);
   DrawGrabRectangles(fPimpl->fGrab);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Inform outside wold that selected frame was changed
 
void TGuiBldDragManager::ChangeSelected(TGFrame *fr)
{
   if (fStop) {
      return;
   }
 
   TGFrame *sel = fr;
 
   if (fBuilder && (sel == fBuilder->GetMdiMain()->GetCurrent())) {
      sel = 0;
   }
 
   if (!fr) {
      UngrabFrame();
   }
 
   if (fEditor) {
      fEditor->ChangeSelected(sel);
   }
 
   if (fBuilder) {
      fBuilder->ChangeSelected(sel);
      //fBuilder->Update();
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// grab frame (see SelectFrame)
 
void TGuiBldDragManager::GrabFrame(TGFrame *frame)
{
   if (fStop || !frame || !fClient->IsEditable()) {
      return;
   }
 
   fPimpl->fGrabParent = frame->GetParent();
   fPimpl->fGrabX = frame->GetX();
   fPimpl->fGrabY = frame->GetY();
 
   Window_t c;
 
   gVirtualX->TranslateCoordinates(frame->GetId(),
                                   fClient->GetDefaultRoot()->GetId(),
                                   0, 0, fPimpl->fX0, fPimpl->fY0, c);
 
   fPimpl->fX = fPimpl->fX0;
   fPimpl->fY = fPimpl->fY0;
 
   if (frame->GetFrameElement() && frame->GetFrameElement()->fLayout) {
      fPimpl->fGrabLayout = frame->GetFrameElement()->fLayout;
   }
 
   if (fPimpl->fGrabParent && frame->GetFrameElement() &&
       fPimpl->fGrabParent->InheritsFrom(TGCompositeFrame::Class())) {
      TList *li = ((TGCompositeFrame*)fPimpl->fGrabParent)->GetList();
      fPimpl->fGrabListPosition = (TGFrameElement*)li->Before(frame->GetFrameElement());
      ((TGCompositeFrame*)fPimpl->fGrabParent)->RemoveFrame(frame);
   }
 
   SetWindowAttributes_t attr;
   attr.fMask             = kWAOverrideRedirect | kWASaveUnder;
   attr.fOverrideRedirect = kTRUE;
   attr.fSaveUnder        = kTRUE;
 
   gVirtualX->ChangeWindowAttributes(frame->GetId(), &attr);
 
   frame->UnmapWindow();
   frame->ReparentWindow(fClient->GetDefaultRoot(), fPimpl->fX0, fPimpl->fY0);
   gVirtualX->Update(1);
   frame->Move(fPimpl->fX0, fPimpl->fY0);
   frame->MapRaised();
 
   if (fBuilder) {
      //fBuilder->Update();
      TString str = frame->ClassName();
      str += "::";
      str += frame->GetName();
      str += " is grabbed";
 
      fBuilder->UpdateStatusBar(str.Data());
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// Ungrab/Unselect selected/grabbed frame.
 
void TGuiBldDragManager::UngrabFrame()
{
   if (fStop || !fPimpl->fGrab) {
      return;
   }
 
   SetCursorType(kPointer);
   HideGrabRectangles();
 
   DoRedraw();
 
   if (fBuilder) {
      //fBuilder->Update();
      TString str = fPimpl->fGrab->ClassName();
      str += "::";
      str += fPimpl->fGrab->GetName();
      str += " ungrabbed";
      fBuilder->UpdateStatusBar(str.Data());
   }
   fSelected = fPimpl->fGrab = 0;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Helper for IsPointVisible
 
static Bool_t IsParentOfGrab(Window_t id, const TGWindow *grab)
{
   const TGWindow *parent = grab;
 
   while (parent && (parent != gClient->GetDefaultRoot())) {
      if (parent->GetId() == id) {
         return kTRUE;
      }
      parent = parent->GetParent();
   }
 
   return kFALSE;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Helper function for IsSelectedWindow method
 
Bool_t TGuiBldDragManager::IsPointVisible(Int_t xi, Int_t yi)
{
   Window_t w = gVirtualX->GetDefaultRootWindow();
   Window_t src, dst, child;
   Int_t x = xi;
   Int_t y = yi;
   Bool_t ret = kFALSE;
 
   gVirtualX->TranslateCoordinates(fPimpl->fGrab->GetId(), w, x, y, x, y, child);
 
   dst = src = child = w;
 
   while (child) {
      src = dst;
      dst = child;
      gVirtualX->TranslateCoordinates(src, dst, x, y, x, y, child);
 
      if (IsParentOfGrab(child, fPimpl->fGrab)) {
         return kTRUE;
      }
   }
 
   return ret;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Return kTRUE if grabbed/selected frame is not overlapped by other windows.
 
Bool_t TGuiBldDragManager::IsSelectedVisible()
{
   if (fStop || !fPimpl->fGrab || !fClient->IsEditable()) {
      return kFALSE;
   }
 
   if (fBuilder) {
      TGMdiFrame *mdi = fBuilder->FindEditableMdiFrame(fPimpl->fGrab);
      if (mdi && (mdi != fBuilder->GetMdiMain()->GetCurrent())) {
         return kFALSE;
      }
   }
 
   // popup menu was placed
   if (fPimpl->fPlacePopup) {
      return kTRUE;
   }
 
   static Long64_t was = gSystem->Now();
   static Bool_t visible = kFALSE;
 
   Long64_t now = gSystem->Now();
 
   if (now-was < 100) {
      return visible;
   }
   was = now;
 
   visible = kFALSE;
 
   if (!IsPointVisible(2, 2)) {
      return visible;
   }
 
   if (!IsPointVisible(2, fPimpl->fGrab->GetHeight()-2)) {
      return visible;
   }
 
   if (!IsPointVisible(fPimpl->fGrab->GetWidth()-2, 2)) {
      return visible;
   }
 
   if (!IsPointVisible(fPimpl->fGrab->GetWidth()-2,
                       fPimpl->fGrab->GetHeight()-2)) {
      return visible;
   }
 
   visible = kTRUE;
 
   return visible;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Draw small grab rectangles around grabbed/selected/frame
 
void TGuiBldDragManager::DrawGrabRectangles(TGWindow *win)
{
   if (fStop) {
      return;
   }
 
   TGFrame *frame = win ? (TGFrame *)win : fPimpl->fGrab;
 
   if (!frame || !fClient->IsEditable() || fPimpl->fPlacePopup) {
      return;
   }
 
   Window_t w = gVirtualX->GetDefaultRootWindow();
   Window_t c; Int_t x, y;
 
   gVirtualX->TranslateCoordinates(frame->GetId(), w,  0, 0, x, y, c);
 
   if (frame->InheritsFrom(TGCompositeFrame::Class()) &&
       CanChangeLayout(frame) && !frame->IsLayoutBroken()) {
      fPimpl->fAroundFrame[0]->MoveResize(x-3, y-3, frame->GetWidth()+6, 2);
      fPimpl->fAroundFrame[0]->MapRaised();
      fPimpl->fAroundFrame[1]->MoveResize(x+frame->GetWidth()+3, y-3, 2, frame->GetHeight()+6);
      fPimpl->fAroundFrame[1]->MapRaised();
      fPimpl->fAroundFrame[2]->MoveResize(x-3, y+frame->GetHeight()+2, frame->GetWidth()+6, 2);
      fPimpl->fAroundFrame[2]->MapRaised();
      fPimpl->fAroundFrame[3]->MoveResize(x-3, y-3, 2, frame->GetHeight()+6);
      fPimpl->fAroundFrame[3]->MapRaised();
   } else {
      for (int i = 0; i < 4; i++) fPimpl->fAroundFrame[i]->UnmapWindow();
   }
 
   // draw rectangles
   DrawGrabRect(0, x - 6, y - 6);
   DrawGrabRect(1, x + frame->GetWidth()/2 - 3, y - 6);
   DrawGrabRect(2, x + frame->GetWidth(), y - 6);
   DrawGrabRect(3, x - 6, y + frame->GetHeight());
   DrawGrabRect(4, x - 6, y + frame->GetHeight()/2 - 3);
   DrawGrabRect(5, x + frame->GetWidth(), y + frame->GetHeight()/2 - 3);
   DrawGrabRect(6, x + frame->GetWidth()/2 - 3, y + frame->GetHeight());
   DrawGrabRect(7, x + frame->GetWidth(), y + frame->GetHeight());
 
   fPimpl->fGrabRectHidden = kFALSE;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Helper method to draw grab rectangle at position x,y
 
void TGuiBldDragManager::DrawGrabRect(Int_t i, Int_t x, Int_t y)
{
   if (fStop) {
      return;
   }
 
   fPimpl->fGrabRect[i]->Move(x, y);
   fPimpl->fGrabRect[i]->MapRaised();
}
 
////////////////////////////////////////////////////////////////////////////////
/// Raise composite frame when mouse is moving over it.
/// That allows to highlight position of "plain" composite frames.
 
void TGuiBldDragManager::HighlightCompositeFrame(Window_t win)
{
   static Window_t gw = 0;
 
   if (fStop || !win || (win == gw)) {
      return;
   }
 
   TGWindow *w = fClient->GetWindowById(win);
 
   if (!w || (w == fPimpl->fPlane) || w->GetEditDisabled() || w->IsEditable() ||
       !w->InheritsFrom(TGCompositeFrame::Class())) {
      return;
   }
 
   TGFrame *frame = (TGFrame*)w;
   UInt_t opt = frame->GetOptions();
 
   if ((opt & kRaisedFrame) || (opt & kSunkenFrame)) {
      return;
   }
 
   gw = win;
   if (fPimpl->fPlane) {
      fPimpl->fPlane->ChangeOptions(fPimpl->fPlane->GetOptions() & ~kRaisedFrame);
      fClient->NeedRedraw(fPimpl->fPlane, kTRUE);
   }
   fPimpl->fPlane = frame;
   fPimpl->fPlane->ChangeOptions(opt | kRaisedFrame);
   fClient->NeedRedraw(fPimpl->fPlane, kTRUE);
 
   if (fBuilder) {
      TString str = frame->ClassName();
      str += "::";
      str += frame->GetName();
      fBuilder->UpdateStatusBar(str.Data());
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// The main event loop is  originated here
/// It repeatedly queries pointer state and position on the screen.
/// From this info an Event_t structure is built.
 
Bool_t TGuiBldDragManager::HandleTimer(TTimer *t)
{
   return HandleTimerEvent(0, t);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Handle timer events or events coming from the recorder.
 
Bool_t TGuiBldDragManager::HandleTimerEvent(Event_t *e, TTimer *t)
{
   static Int_t gy = 0;
   static Int_t gx = 0;
   static UInt_t gstate = 0;
   static Window_t gw = 0;
 
   Bool_t ret = kTRUE;
 
   // if nothing is edited stop timer and reset everything
   if (!fClient || !fClient->IsEditable()) {
      SetEditable(kFALSE);
      return kFALSE;
   }
   if (!IsSelectedVisible()) {
      HideGrabRectangles();
   }
   if (e) {
      if (fPimpl->fRepeatTimer) {
         // we are replaying events from the recorder...
         fPimpl->fRepeatTimer->Reset();
         fPimpl->fRepeatTimer->Remove();
      }
      if (e->fType == kButtonPress)
         return HandleButtonPress(e);
      else if (e->fType == kButtonRelease)
         return HandleButtonRelease(e);
      else if (e->fState & kButton1Mask)
         return HandleMotion(e);
      return kTRUE;
   }
   Window_t dum;
   Event_t ev;
   ev.fCode = kButton1;
   ev.fType = kMotionNotify;
   ev.fState = 0;
 
   gVirtualX->QueryPointer(gVirtualX->GetDefaultRootWindow(), dum, dum,
                           ev.fXRoot, ev.fYRoot, ev.fX, ev.fY, ev.fState);
 
   ev.fWindow = GetWindowFromPoint(ev.fXRoot, ev.fYRoot);
 
   if (ev.fWindow && (gw == ev.fWindow) && (gstate == ev.fState) &&
       (ev.fYRoot == gy) && (ev.fXRoot == gx)) {
      return kFALSE;
   }
 
   gw = ev.fWindow;
   gstate = ev.fState;
   ev.fState &= ~16;    // ignore "num lock" pressed
   ev.fState &= ~2;     // ignore "caps lock" pressed
 
   if (!fDragging && !fMoveWaiting && !fPimpl->fButtonPressed &&
       ((ev.fState == kButton1Mask) || (ev.fState == kButton3Mask) ||
        (ev.fState == (kButton1Mask | kKeyShiftMask)) ||
        (ev.fState == (kButton1Mask | kKeyControlMask)))) {
 
      if (ev.fState & kButton1Mask) ev.fCode = kButton1;
      if (ev.fState & kButton3Mask) ev.fCode = kButton3;
 
      ev.fType = kButtonPress;
      t->SetTime(40);
 
      if (fPimpl->fPlane && fClient->GetWindowById(fPimpl->fPlane->GetId())) {
         fPimpl->fPlane->ChangeOptions(fPimpl->fPlane->GetOptions() & ~kRaisedFrame);
         fClient->NeedRedraw(fPimpl->fPlane, kTRUE);
      } else {
         fPimpl->fPlane = 0;
      }
 
      ret = HandleButtonPress(&ev);
      TimerEvent(&ev);
      return ret;
   }
 
   if ((fDragging || fMoveWaiting) && (!ev.fState || (ev.fState == kKeyShiftMask)) &&
       fPimpl->fButtonPressed) {
 
      ev.fType = kButtonRelease;
      t->SetTime(100);
 
      ret = HandleButtonRelease(&ev);
      TimerEvent(&ev);
      return ret;
   }
 
   fPimpl->fButtonPressed = (ev.fState & kButton1Mask) ||
                            (ev.fState & kButton2Mask) ||
                            (ev.fState & kButton3Mask);
 
   if ((ev.fYRoot == gy) && (ev.fXRoot == gx)) return kFALSE;
 
   gy = ev.fYRoot;
   gx = ev.fXRoot;
 
   if (!fMoveWaiting && !fDragging && !ev.fState) {
      if (!CheckDragResize(&ev) && fClient->GetWindowById(ev.fWindow)) {
         HighlightCompositeFrame(ev.fWindow);
      }
   } else if (ev.fState & kButton1Mask) {
      HandleMotion(&ev);
      TimerEvent(&ev);
   }
   return ret;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Recognize what was done when mouse button pressed
 
Bool_t TGuiBldDragManager::RecognizeGesture(Event_t *event, TGFrame *frame)
{
   if (fStop) {
      return kFALSE;
   }
 
   if (((event->fCode != kButton1) && (event->fCode != kButton3)) ||
       !frame || !fClient->IsEditable()) {
      return kFALSE;
   }
 
   TGFrame *context_fr = 0;
   Bool_t mdi = kFALSE;
 
   // hack for editable mdi frames
   if (frame->IsEditable() && frame->InheritsFrom(TGMdiFrame::Class())) {
      context_fr = frame;
      mdi = kTRUE;
   }
 
   // handle context menu
   if (event->fCode == kButton3) {
      if (!fPimpl->fSpacePressedFrame) {
         if (!mdi) {
            SelectFrame(frame);
            context_fr = fSelected;
         }
      } else {
         context_fr = fPimpl->fSpacePressedFrame;
      }
 
      HandleButon3Pressed(event, context_fr);
      return kTRUE;
   }
 
   fDragType = kDragNone;
 
   if (!fSelectionIsOn) {
      fPimpl->fX0 = event->fXRoot;
      fPimpl->fY0 = event->fYRoot;
   }
 
   //HideGrabRectangles();
   fPimpl->fClickFrame = frame;
 
   if (fBuilder && fBuilder->IsExecutable() &&
       frame->InheritsFrom(TGCompositeFrame::Class())) {
      UngrabFrame();
      frame->SetEditable(kTRUE);
      fSource = 0;
      fDragType = kDragLasso;
      goto out;
   }
 
   if (event->fState & kKeyShiftMask) {
      // drag grabbed frame with shift key pressed should create a copy of grabbed frame
      // move a copy of editable and selected frame
      if (frame == fPimpl->fGrab) {
         fSource = frame;
         fDragType = kDragCopy;
         gVirtualX->SetCursor(frame->GetId(), gVirtualX->CreateCursor(kMove));
         goto out;
      }
 
      // otherwise do lasso selection
      if (!fSelectionIsOn) {
         fSelectionIsOn = kTRUE;
      } else {
         fPimpl->fX = event->fXRoot;
         fPimpl->fY = event->fYRoot;
         fDragType = kDragLasso;
         DrawLasso();
         return kTRUE;
      }
   }
 
   CheckDragResize(event);
 
   if (frame->IsEditable()) {
      fSource = 0;
 
      if (fDragType != kDragResize) {
 
         // move editable and selected frame
         if (frame == fPimpl->fGrab) {
            fSource = frame;
            fDragType = kDragMove;
            gVirtualX->SetCursor(frame->GetId(), gVirtualX->CreateCursor(kMove));
            goto out;
         }
 
         fDragType = kDragLasso;
      }
   } else if ((fDragType != kDragResize) && !fPimpl->fSpacePressedFrame) {
 
      // special case of TGCanvas
      if (!fPimpl->fGrab && frame->InheritsFrom(TGCanvas::Class()))  {
         TGFrame *cont = ((TGCanvas*)frame)->GetContainer();
 
         if (!cont->IsEditable()) {
            cont->SetEditable(kTRUE);
            fDragType = kDragLasso;
            goto out;
         }
      }
 
      fSource = frame;
      SelectFrame(frame, event->fState & kKeyShiftMask);
   }
 
   if ((fDragType == kDragNone) && !fPimpl->fSpacePressedFrame) {
      SwitchEditable(frame);
      fSource = 0;
 
      // try again
      CheckDragResize(event);
 
      if (fDragType == kDragNone) {
         return kFALSE;
      }
   }
 
out:
   Window_t c;
 
   gVirtualX->TranslateCoordinates(fClient->GetDefaultRoot()->GetId(),
                                   frame->GetId(),
                                   event->fXRoot, event->fYRoot,
                                   fPimpl->fXf, fPimpl->fYf, c);
   fPimpl->fX = event->fXRoot;
   fPimpl->fY = event->fYRoot;
 
   fMoveWaiting = kTRUE;
   DoRedraw();
 
   return kTRUE;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Handle 3d mouse pressed (popup context menu)
 
void TGuiBldDragManager::HandleButon3Pressed(Event_t *event, TGFrame *frame)
{
   if (fStop || !frame) {
      return;
   }
 
   if (fClient->GetWaitForEvent() == kUnmapNotify) {
      return;
   }
 
   if (frame == fSelected) {
      Menu4Frame(frame, event->fXRoot, event->fYRoot);
   } else if (frame->IsEditable())  {
      if (fLassoDrawn) {
         Menu4Lasso(event->fXRoot, event->fYRoot);
      } else {
         Menu4Frame(frame, event->fXRoot, event->fYRoot);
      }
   } else {
      TGFrame *base = InEditable(frame->GetId());
      if (base) {
         //SelectFrame(base);
         Menu4Frame(base, event->fXRoot, event->fYRoot);
      } else {
         Menu4Frame(frame, event->fXRoot, event->fYRoot);
      }
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// Handle button event occurred in some ROOT frame
 
Bool_t TGuiBldDragManager::HandleButton(Event_t *event)
{
   if (fStop) {
      return kFALSE;
   }
 
   if (event->fCode != kButton3) {
      CloseMenus();
   }
 
   if (event->fType == kButtonPress) {
      return HandleButtonPress(event);
   } else {
      return HandleButtonRelease(event);
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// Resize events
 
Bool_t TGuiBldDragManager::HandleConfigureNotify(Event_t *event)
{
   if (fStop) {
      return kFALSE;
   }
 
   TGWindow *w = fClient->GetWindowById(event->fWindow);
 
   if (!w) {
      return kFALSE;
   }
 
   fPimpl->fCompacted = kFALSE;
   return kFALSE;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Handle repaint event
 
Bool_t TGuiBldDragManager::HandleExpose(Event_t *event)
{
   if (fStop) {
      return kFALSE;
   }
 
   static Long64_t was = gSystem->Now();
   static Window_t win = 0;
   Long64_t now = gSystem->Now();
 
   if (event->fCount || (win == event->fWindow) || (now-was < 50) || fDragging) {
      if (fDragging) {
         HideGrabRectangles();
      }
      return kFALSE;
   }
 
   if (gMenuDialog) {
      HideGrabRectangles();
      gMenuDialog->RaiseWindow();
      return kFALSE;
   }
 
   if (fLassoDrawn) {
      DrawLasso();
   } else {
      if (IsSelectedVisible()) {
         DrawGrabRectangles();
      }
   }
 
   win = event->fWindow;
   was = now;
 
   return kFALSE;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Handle all events.
 
Bool_t TGuiBldDragManager::HandleEvent(Event_t *event)
{
   if (fStop) {
      return kFALSE;
   }
 
   if (IgnoreEvent(event)) {
      return kFALSE;
   }
 
   switch (event->fType) {
 
      case kExpose:
         return HandleExpose(event);
 
      case kConfigureNotify:
         while (gVirtualX->CheckEvent(fId, kConfigureNotify, *event))
            ;
         return HandleConfigureNotify(event);
 
      case kGKeyPress:
      case kKeyRelease:
         return HandleKey(event);
 
      case kFocusIn:
      case kFocusOut:
         //HandleFocusChange(event);
         break;
 
      case kButtonPress:
         {
            Int_t dbl_clk = kFALSE;
 
            static Window_t gDbw = 0;
            static Long_t gLastClick = 0;
            static UInt_t gLastButton = 0;
            static Int_t gDbx = 0;
            static Int_t gDby = 0;
 
            if ((event->fTime - gLastClick < 350) &&
                (event->fCode == gLastButton) &&
                (TMath::Abs(event->fXRoot - gDbx) < 6) &&
                (TMath::Abs(event->fYRoot - gDby) < 6) &&
                (event->fWindow == gDbw)) {
               dbl_clk = kTRUE;
            }
 
            if (dbl_clk) {
               if (event->fState & kKeyControlMask) {
                  HandleAction(kEndEditAct);
                  return kTRUE;
               } else if (!(event->fState & 0xFF)) {
                  TGFrame *w = (TGFrame*)fClient->GetWindowById(event->fWindow);
 
                  if (w && (w->GetEditDisabled() & kEditDisableBtnEnable)) {
                     return w->HandleDoubleClick(event);
                  }
                  if (SaveFrame(fTmpBuildFile.Data())) {
                     gROOT->Macro(fTmpBuildFile.Data());
                  }
                  // an easy way to start editting
                  if (fBuilder) fBuilder->HandleMenu(kGUIBLD_FILE_START);
                  return kTRUE;
               }
            } else {
               gDbw = event->fWindow;
               gLastClick = event->fTime;
               gLastButton = event->fCode;
               gDbx = event->fXRoot;
               gDby = event->fYRoot;
 
               Bool_t ret = HandleButtonPress(event);
               return ret;
            }
 
            return kFALSE;
         }
 
      case kButtonRelease:
         return HandleButtonRelease(event);
 
      case kEnterNotify:
      case kLeaveNotify:
         //HandleCrossing(event);
         break;
 
      case kMotionNotify:
         while (gVirtualX->CheckEvent(fId, kMotionNotify, *event))
            ;
         return HandleMotion(event);
 
      case kClientMessage:
         return HandleClientMessage(event);
 
      case kDestroyNotify:
         return HandleDestroyNotify(event);
 
      case kSelectionNotify:
         //HandleSelection(event);
         break;
 
      case kSelectionRequest:
         //HandleSelectionRequest(event);
         break;
 
      case kSelectionClear:
         //HandleSelectionClear(event);
         break;
 
      case kColormapNotify:
         //HandleColormapChange(event);
         break;
 
      default:
         //Warning("HandleEvent", "unknown event (%#x) for (%#x)", event->fType, fId);
         break;
   }
 
   return kFALSE;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Mouse double click handler (never should happen)
 
Bool_t TGuiBldDragManager::HandleDoubleClick(Event_t *)
{
   if (fStop) {
      return kFALSE;
   }
 
   return kFALSE;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Return a parent which can handle button events.
 
TGFrame *TGuiBldDragManager::GetBtnEnableParent(TGFrame *fr)
{
   TGWindow *parent = fr;
 
   while (parent && (parent != fClient->GetDefaultRoot())) {
      if (parent->GetEditDisabled() & kEditDisableBtnEnable) {
         return (TGFrame*)parent;
      }
      parent = (TGWindow*)parent->GetParent();
   }
   return 0;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Unmap all popups
 
void TGuiBldDragManager::UnmapAllPopups()
{
   TList *li = fClient->GetListOfPopups();
   if (!li->GetEntries()) {
      return;
   }
 
   TGPopupMenu *pup;
   TIter next(li);
 
   while ((pup = (TGPopupMenu*)next())) {
      pup->UnmapWindow();
      fClient->ResetWaitFor(pup);
   }
   gVirtualX->GrabPointer(0, 0, 0, 0, kFALSE);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Handle button press event
 
Bool_t TGuiBldDragManager::HandleButtonPress(Event_t *event)
{
   if (fStop) {
      return kFALSE;
   }
 
   fPimpl->fButtonPressed = kTRUE;
   fPimpl->fPlacePopup = kFALSE;
 
   if (fPimpl->fPlane) {
      fPimpl->fPlane->ChangeOptions(fPimpl->fPlane->GetOptions() & ~kRaisedFrame);
      fClient->NeedRedraw(fPimpl->fPlane, kTRUE);
   }
 
   if (gMenuDialog) { // keep editor on the top
      gMenuDialog->RaiseWindow();
   }
 
   // keep undocked toolbar on the top
   //(but under win32 key handling will be broken : todo)
   if (gVirtualX->InheritsFrom("TGX11") && fBuilder &&
       fBuilder->GetToolDock()->IsUndocked()) {
      fBuilder->GetToolDock()->GetUndocked()->RaiseWindow();
   }
 
   // keep color dialog on the top
   if (fgGlobalColorDialog && fgGlobalColorDialog->IsMapped()) {
      fgGlobalColorDialog->RaiseWindow();
      return kFALSE;
   }
 
   if ( ((event->fCode != kButton1) && (event->fCode != kButton3)) ||
        (event->fType != kButtonPress) || IgnoreEvent(event)) {
      return kFALSE;
   }
 
   Reset1();
   //HideGrabRectangles();
 
   Window_t w = GetWindowFromPoint(event->fXRoot, event->fYRoot);
   TGFrame *fr = 0;
 
   if (w) {
      fr = (TGFrame*)fClient->GetWindowById(w);
      if (!fr) {
         return kFALSE;
      }
 
      //fr->HandleButton(event);
      if (!IsEventsDisabled(fr)) {
         TGFrame *btnframe = GetBtnEnableParent(fr);
         if (btnframe) {
            event->fUser[0] = fr->GetId();
            btnframe->HandleButton(event);
         }
      }
 
      if (IsGrabDisabled(fr)) {
         fr = GetEditableParent(fr);
      }
 
      if (!fr) {
         return kFALSE;
      }
   } else {
      return kFALSE;
   }
 
   return RecognizeGesture(event, fr);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Handle button release event
 
Bool_t TGuiBldDragManager::HandleButtonRelease(Event_t *event)
{
   if (fStop) {
      return kFALSE;
   }
 
   // unmap all waiting popups
   if (fClient->GetWaitForEvent() == kUnmapNotify) {
      UnmapAllPopups();
   }
 
   TGWindow *w = fClient->GetWindowById(event->fWindow);
 
   if (w && !IsEventsDisabled(w)) {
      TGFrame *btnframe = GetBtnEnableParent((TGFrame*)w);
      if (btnframe) {
         event->fUser[0] = w->GetId();
         btnframe->HandleButton(event);
      }
   }
 
   fPimpl->fButtonPressed = kFALSE;
   gVirtualX->SetCursor(fClient->GetRoot()->GetId(), gVirtualX->CreateCursor(kPointer));
   EndDrag();
   fSelectionIsOn &= (event->fState & kKeyShiftMask);
 
   if (fLassoDrawn) {
      DrawLasso();
      return kTRUE;
   }
 
   if (fPimpl->fClickFrame && !fSelectionIsOn) {
 
      // make editable the clicked frame if no lasso was drawn
      if ((fPimpl->fClickFrame == fPimpl->fGrab) && (fSelected == fPimpl->fGrab) &&
           !fPimpl->fGrab->IsEditable()) {
         SwitchEditable(fPimpl->fClickFrame);
         return kTRUE;
 
      // select/grab clicked frame if there was no grab frame
      } else if (!fPimpl->fGrab || ((fPimpl->fClickFrame != fPimpl->fGrab) &&
                                    (fPimpl->fClickFrame != fSelected))) {
         SelectFrame(fPimpl->fClickFrame);
         return kTRUE;
      }
 
   }
 
   SelectFrame(fPimpl->fGrab);
 
   return kTRUE;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Handle key event
 
Bool_t TGuiBldDragManager::HandleKey(Event_t *event)
{
   if (fStop) {
      return kFALSE;
   }
 
   char   tmp[10];
   UInt_t keysym;
   Bool_t ret = kFALSE;
   TGFileInfo fi;
   static TString dir(".");
   static Bool_t overwr = kFALSE;
   TString fname;
 
   TGWindow *w = fClient->GetWindowById(GetWindowFromPoint(event->fXRoot, event->fYRoot));
 
   if (!w || !fPimpl) {
      return kFALSE;
   }
 
   if (w->GetEditDisabled() & kEditDisableKeyEnable) {
      return ((TGFrame*)w)->HandleKey(event);
   }
 
   if (event->fType != kGKeyPress) {
      return kFALSE;
   }
 
   if (IsEditDisabled(w)) {
      TGFrame *parent = GetEditableParent((TGFrame*)w);
      if (parent) {
         event->fWindow = parent->GetId();
         parent->HandleKey(event);
      } else {
         return ((TGFrame*)w)->HandleKey(event);
      }
   }
 
   fPimpl->fSpacePressedFrame = 0;
 
   if (fPimpl->fPlane) {
      fPimpl->fPlane->ChangeOptions(fPimpl->fPlane->GetOptions() & ~kRaisedFrame);
      fClient->NeedRedraw(fPimpl->fPlane, kTRUE);
   }
 
   CloseMenus();
 
   fi.fFileTypes = gSaveMacroTypes;
   fi.SetIniDir(dir);
   fi.fOverwrite = overwr;
 
   gVirtualX->LookupString(event, tmp, sizeof(tmp), keysym);
 
   if (event->fState & kKeyControlMask) {
 
      switch ((EKeySym)keysym & ~0x20) {
         case kKey_Return:
         case kKey_Enter:
            HandleReturn(kTRUE);
            ret = kTRUE;
            break;
         case kKey_X:
            HandleCut();
            ret = kTRUE;
            break;
         case kKey_C:
            HandleCopy();
            ret = kTRUE;
            break;
         case kKey_V:
            if (fPimpl->fClickFrame && !fPimpl->fClickFrame->IsEditable()) {
               fPimpl->fClickFrame->SetEditable(kTRUE);
            }
            HandlePaste();
            ret = kTRUE;
            break;
         case kKey_B:
         {
            if (fPimpl->fGrab ) {
               BreakLayout();
            }
            ret = kTRUE;
            break;
         }
         case kKey_L:
         {
            if (fPimpl->fGrab && (fPimpl->fClickFrame != fClient->GetRoot())) {
               Compact(kFALSE);
            } else {
               Compact(kTRUE);
            }
            ret = kTRUE;
            break;
         }
         case kKey_R:
            HandleReplace();
            ret = kTRUE;
            break;
         case kKey_S:
            Save();
            ret = kTRUE;
            break;
         case kKey_G:
            HandleGrid();
            ret = kTRUE;
            break;
         case kKey_H:
            SwitchLayout();
            ret = kTRUE;
            break;
         case kKey_N:
            if (fBuilder) {
               fBuilder->NewProject();
            } else {
               TGMainFrame *main = new TGMainFrame(fClient->GetDefaultRoot(), 300, 300);
               main->MapRaised();
               main->SetEditable(kTRUE);
            }
            ret = kTRUE;
            break;
         case kKey_O:
            if (fBuilder) {
               fBuilder->NewProject();
            } else {
               TGMainFrame *main = new TGMainFrame(fClient->GetDefaultRoot(), 300, 300);
               main->MapRaised();
               main->SetEditable(kTRUE);
            }
            new TGFileDialog(fClient->GetDefaultRoot(), this, kFDSave, &fi);
 
            if (!fi.fFilename) return kTRUE;
            dir = fi.fIniDir;
            overwr = fi.fOverwrite;
            fname = gSystem->BaseName(gSystem->UnixPathName(fi.fFilename));
 
            if (fname.EndsWith(".C")) {
               gROOT->Macro(fname.Data());
            } else {
               Int_t retval;
               new TGMsgBox(fClient->GetDefaultRoot(), this, "Error...",
                            TString::Format("file (%s) must have extension .C", fname.Data()),
                            kMBIconExclamation, kMBRetry | kMBCancel, &retval);
               if (retval == kMBRetry) {
                  HandleKey(event);
               }
            }
            ret = kTRUE;
            break;
         default:
            break;
      }
   } else {
      switch ((EKeySym)keysym) {
         case kKey_Delete:
         case kKey_Backspace:
            HandleDelete(event->fState & kKeyShiftMask);
            ret = kTRUE;
            break;
         case kKey_Return:
         case kKey_Enter:
            //UnmapAllPopups();
            HandleReturn(kFALSE);
            ret = kTRUE;
            break;
         case kKey_Left:
         case kKey_Right:
         case kKey_Up:
         case kKey_Down:
            if (fLassoDrawn) {
               HandleAlignment(keysym, event->fState & kKeyShiftMask);
            } else if (fPimpl->fGrab) {
               HandleLayoutOrder((keysym == kKey_Right) || (keysym == kKey_Down));
            }
            ret = kTRUE;
            break;
         case kKey_Space:
            //UnmapAllPopups();
            if (fPimpl->fGrab) {
               SwitchEditable(fPimpl->fGrab);
 
               TGFrame *p = (TGFrame*)GetEditableParent(fPimpl->fGrab);
 
               if (p) {
                  if (fBuilder && p == fBuilder->GetMdiMain()->GetCurrent()) {
                     UngrabFrame();
                  } else {
                     SelectFrame(p);
                     fSource = fPimpl->fSpacePressedFrame = p;
                  }
               }
            }
            ret = kTRUE;
            break;
         default:
            break;
      }
   }
   if (fBuilder) {
      fBuilder->SetAction(0);
      //fBuilder->Update();
   }
 
   if (fLassoDrawn) {
      DrawLasso();
   }
 
   return ret;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Reparent frames
 
void TGuiBldDragManager::ReparentFrames(TGFrame *newfr, TGCompositeFrame *oldfr)
{
   if (fStop || !fClient->IsEditable() || (newfr == fClient->GetDefaultRoot())) {
      return;
   }
 
   Int_t x0, y0, xx, yy;
   Window_t c;
   static TGLayoutHints *hints = new TGLayoutHints(kLHintsNormal, 2, 2, 2, 2);
 
   if (!newfr || !newfr->GetId() || !oldfr || !oldfr->GetId()) return;
 
   gVirtualX->TranslateCoordinates(newfr->GetId(), oldfr->GetId(),
                                   0, 0, x0, y0, c);
 
   x0 = x0 < 0 ? 0 : x0;
   y0 = y0 < 0 ? 0 : y0;
   Int_t x = x0 + newfr->GetWidth();
   Int_t y = y0 + newfr->GetHeight();
 
   TGCompositeFrame *comp = 0;
 
   if (newfr->InheritsFrom(TGCompositeFrame::Class())) {
      comp = (TGCompositeFrame*)newfr;
      comp->SetLayoutBroken();
   }
 
   TIter next(oldfr->GetList());
   TGFrameElement *el;
 
   while ((el = (TGFrameElement*)next())) {
      TGFrame *frame = el->fFrame;
 
      if ((frame->GetX() >= x0) && (frame->GetY() >= y0) &&
          (frame->GetX() + (Int_t)frame->GetWidth() <= x) &&
          (frame->GetY() + (Int_t)frame->GetHeight() <= y)) {
 
         if (frame == fPimpl->fGrab) {
            UngrabFrame();
         }
 
         oldfr->RemoveFrame(frame);
 
         gVirtualX->TranslateCoordinates(oldfr->GetId(), newfr->GetId(),
                                        frame->GetX(), frame->GetY(), xx, yy, c);
 
         frame->ReparentWindow(newfr, xx, yy);
 
         if (comp) {
            comp->AddFrame(frame, hints); // el->fLayout);
         }
      }
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// Return the list of frames inside of some area
 
TList *TGuiBldDragManager::GetFramesInside(Int_t x0, Int_t y0, Int_t x, Int_t y)
{
   if (fStop) {
      return 0;
   }
 
   Int_t xx, yy;
 
   if (!fClient->GetRoot()->InheritsFrom(TGCompositeFrame::Class())) {
      return 0;
   }
 
   TList *list = new TList();
 
   xx = x0; yy = y0;
   x0 = TMath::Min(xx, x); x = TMath::Max(xx, x);
   y0 = TMath::Min(yy, y); y = TMath::Max(yy, y);
 
   TIter next(((TGCompositeFrame*)fClient->GetRoot())->GetList());
   TGFrameElement *el;
 
   while ((el = (TGFrameElement*)next())) {
      if ((el->fFrame->GetX() >= x0) && (el->fFrame->GetY() >= y0) &&
          (el->fFrame->GetX() + (Int_t)el->fFrame->GetWidth() <= x) &&
          (el->fFrame->GetY() + (Int_t)el->fFrame->GetHeight() <= y)) {
         list->Add(el->fFrame);
      }
   }
   if (list->IsEmpty()) {
      delete list;
      return 0;
   }
   return list;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Drop canvas container
 
void TGuiBldDragManager::DropCanvas(TGCanvas *canvas)
{
   if (fStop) {
      return;
   }
 
   TGCompositeFrame *comp = (TGCompositeFrame*)canvas->GetParent();
   comp->SetEditable(kTRUE);
 
   TGCompositeFrame *cont = (TGCompositeFrame*)canvas->GetContainer();
   Int_t x = canvas->GetX();
   Int_t y = canvas->GetY();
 
   cont->SetEditDisabled(cont->GetEditDisabled() & ~kEditDisableGrab);
   cont->ReparentWindow(comp, x, y);
   canvas->SetContainer(0);
   comp->AddFrame(cont);
   DeleteFrame(canvas);
 
   if (fBuilder) {
      TString str = cont->ClassName();
      str += "::";
      str += cont->GetName();
      str += " dropped.";
      fBuilder->UpdateStatusBar(str.Data());
   }
   SelectFrame(cont);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Create a new TGCanvas and place container into it
 
void TGuiBldDragManager::PutToCanvas(TGCompositeFrame *cont)
{
   if (fStop || !cont) {
      return;
   }
 
   TGCompositeFrame *comp = (TGCompositeFrame*)cont->GetParent();
   comp->SetEditable(kTRUE);
 
   UInt_t w = cont->GetWidth()/2;
   UInt_t h = cont->GetHeight()/2;
 
   w = w < 100 ? 100 : w;
   h = h < 100 ? 100 : h;
 
   TGCanvas *canvas = new TGCanvas(comp, w, h);
   canvas->Move(cont->GetX(), cont->GetY());
   comp->RemoveFrame(cont);
   comp->AddFrame(canvas);
   cont->ReparentWindow(canvas->GetViewPort());
   canvas->SetContainer(cont);
   cont->SetCleanup(kDeepCleanup);
   canvas->MapSubwindows();
   canvas->MapWindow();
   SelectFrame(canvas);
 
   if (fBuilder) {
      fBuilder->UpdateStatusBar("Grab action performed. Press Cntrl-Return to Drop grabbed frame.");
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// Handling of  return/enter key pressing
///
/// If on is kFALSE:
///    If Return or Enter key was pressed - Grab Act
///    If lasso is  drawn - new composite frame is created and
///                         all frames inside lasso adopted as children.
///    If lasso is not drawn and selected frame is composite one,
///                       - new TGCanvas widget is created and selected frame became
///                         container for this canvas.
///
/// If on is kTRUE:
///    If Return or Enter key was pressed with Control Key - Drop Act,
///    The opposite action to the Grab Act.
///    If selected/grabbed frame is not a TGCanvas widget -
///          all frames inside the grabbed/selected frame are "dropped" into
///          the underlying frame and the grabbed frame is deleted.
///
///    If selected/grabbed frame is a TGCanvas widget -
///          container frame "dropped" to editable frame
 
void TGuiBldDragManager::HandleReturn(Bool_t on)
{
   if (fStop) {
      return;
   }
 
   Int_t x0, y0, x, y, xx, yy;
   Window_t c;
   TGCompositeFrame *parent = 0;
   TList *li = 0;
 
   if (!fClient->GetRoot()->InheritsFrom(TGCompositeFrame::Class()) ||
       !fClient->IsEditable()) {
      return;
   }
 
   // if grabbed frame is editable - we need to switch edit to parent
   if (fPimpl->fGrab && fPimpl->fGrab->IsEditable()) {
      ((TGFrame*)fPimpl->fGrab->GetParent())->SetEditable(kTRUE);
   }
 
   if (fPimpl->fGrab && !fLassoDrawn) {
      if (!on) {
         if (fPimpl->fGrab->InheritsFrom(TGCompositeFrame::Class()) &&
            !fPimpl->fGrab->InheritsFrom(TGCanvas::Class()) &&
            !fPimpl->fGrab->InheritsFrom(TGContainer::Class()) &&
            CanChangeLayout(fPimpl->fGrab) &&
            CanChangeLayout((TGWindow*)fPimpl->fGrab->GetParent())) {
            PutToCanvas((TGCompositeFrame*)fPimpl->fGrab);
            return;
         }
      } else {
 
         if ((fPimpl->fGrab->IsA() == TGCanvas::Class()) &&
             !((TGCanvas*)fPimpl->fGrab)->GetContainer()->InheritsFrom(TGContainer::Class()) &&
             CanChangeLayout((TGWindow*)fPimpl->fGrab->GetParent())) {
            DropCanvas((TGCanvas*)fPimpl->fGrab);
            return;
         }
      }
   }
 
   TGCompositeFrame *comp = (TGCompositeFrame*)fClient->GetRoot();
 
   if (fLassoDrawn) {
 
      gVirtualX->TranslateCoordinates(fClient->GetDefaultRoot()->GetId(),
                                      fClient->GetRoot()->GetId(),
                                      fPimpl->fX, fPimpl->fY, x, y, c);
      gVirtualX->TranslateCoordinates(fClient->GetDefaultRoot()->GetId(),
                                      fClient->GetRoot()->GetId(),
                                      fPimpl->fX0, fPimpl->fY0, x0, y0, c);
 
      xx = x0; yy = y0;
      x0 = TMath::Min(xx, x); x = TMath::Max(xx, x);
      y0 = TMath::Min(yy, y); y = TMath::Max(yy, y);
 
      li = GetFramesInside(x0, y0, x, y);
 
      if (!on && li) {
         parent = new TGCompositeFrame(comp, x - x0, y - y0);
         parent->MoveResize(x0, y0, x - x0, y - y0);
         ReparentFrames(parent, comp);
 
         comp->AddFrame(parent);
         parent->MapWindow();
         SetLassoDrawn(kFALSE);
         SelectFrame(parent);
 
         if (fBuilder) {
            TString str = "Grab action performed.";
            str += " Press Cntrl-Return to Drop grabbed frames.";
            str += " Press Return for TCanvas Grab";
            fBuilder->UpdateStatusBar(str.Data());
         }
      }
   } else if (on && fPimpl->fGrab) {
 
      // check if it is forbidden
      if (!CanChangeLayout(fPimpl->fGrab) ||
          !CanChangeLayout((TGWindow*)fPimpl->fGrab->GetParent())) {
         if (fBuilder) {
            fBuilder->UpdateStatusBar("Drop action disabled");
         }
         return;
      }
 
      if (fPimpl->fGrab->InheritsFrom(TGCompositeFrame::Class())) {
         parent = (TGCompositeFrame*)fPimpl->fGrab;
      } else {
         //parent = (TGCompositeFrame*)fPimpl->fGrab->GetParent();
      }
      if (parent) {
         ReparentFrames(comp, parent);
         DeleteFrame(fPimpl->fGrab);
         UngrabFrame();
         ChangeSelected(0);   //update editors
 
         if (fBuilder) {
            fBuilder->UpdateStatusBar("Drop action performed");
         }
      }
   }
   delete li;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Align frames located inside lasso area.
 
void TGuiBldDragManager::HandleAlignment(Int_t to, Bool_t lineup)
{
   if (fStop) {
      return;
   }
 
   Int_t x0, y0, x, y, xx, yy;
   Window_t c;
   TGCompositeFrame *comp = 0;
 
   if (!fClient->GetRoot()->InheritsFrom(TGCompositeFrame::Class()) ||
       !fClient->IsEditable()) {
      return;
   }
 
   if (fLassoDrawn) {
      gVirtualX->TranslateCoordinates(fClient->GetDefaultRoot()->GetId(),
                                      fClient->GetRoot()->GetId(),
                                      fPimpl->fX, fPimpl->fY, x, y, c);
      gVirtualX->TranslateCoordinates(fClient->GetDefaultRoot()->GetId(),
                                      fClient->GetRoot()->GetId(),
                                      fPimpl->fX0, fPimpl->fY0, x0, y0, c);
 
      xx = x0; yy = y0;
      x0 = TMath::Min(xx, x); x = TMath::Max(xx, x);
      y0 = TMath::Min(yy, y); y = TMath::Max(yy, y);
 
      comp = (TGCompositeFrame*)fClient->GetRoot();
 
      ToGrid(x, y);
      ToGrid(x0, y0);
 
      TIter next(comp->GetList());
      TGFrameElement *el;
      TGFrame *prev = 0;
 
      while ((el = (TGFrameElement*)next())) {
         TGFrame *fr = el->fFrame;
 
         if ((fr->GetX() >= x0) && (fr->GetY() >= y0) &&
             (fr->GetX() + (Int_t)fr->GetWidth() <= x) &&
             (fr->GetY() + (Int_t)fr->GetHeight() <= y)) {
 
            switch ((EKeySym)to) {
               case kKey_Left:
                  fr->Move(x0, fr->GetY());
                  if (lineup) {
                     // coverity[dead_error_line]
                     if (prev) fr->Move(fr->GetX(), prev->GetY() + prev->GetHeight());
                     else fr->Move(x0, y0);
                  }
                  break;
               case kKey_Right:
                  fr->Move(x - fr->GetWidth(), fr->GetY());
                  if (lineup) {
                     if (prev) fr->Move(fr->GetX(), prev->GetY() + prev->GetHeight());
                     else fr->Move(x - fr->GetWidth(), y0);
                  }
                  break;
               case kKey_Up:
                  fr->Move(fr->GetX(), y0);
                  if (lineup) {
                     if (prev) fr->Move(prev->GetX() + prev->GetWidth(), fr->GetY());
                     else fr->Move(x0, y0);
                  }
                  break;
               case kKey_Down:
                  fr->Move(fr->GetX(), y - fr->GetHeight());
                  if (lineup) {
                     if (prev) fr->Move(prev->GetX() + prev->GetWidth(), fr->GetY());
                     else fr->Move(x0, y - fr->GetHeight());
                  }
                  break;
               default:
                  break;
            }
            prev = fr;
         }
      }
   }
   if (fLassoDrawn) {
      DrawLasso();
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// Handle delete or crop action
///
/// crop is kFALSE - delete action
///   - if lasso is drawn -> all frames inside lasso area are deleted
///   - if frame is grabbed/selected -> the frame is deleted
/// crop is kTRUE - crop action
///   - if lasso is drawn -> all frames outside of lasso area are deleted
///   - if frame is grabbed/selected -> all frames except the grabbed frame are deleted
///     In both cases the main frame is shrunk to the size of crop area.
 
void TGuiBldDragManager::HandleDelete(Bool_t crop)
{
   if (fStop) {
      return;
   }
 
   Int_t x0, y0, x, y, xx, yy, w, h;
   Window_t c;
 
   if (!fClient->GetRoot()->InheritsFrom(TGCompositeFrame::Class()) ||
       !fClient->IsEditable()) {
      return;
   }
 
   TGCompositeFrame *comp = 0;
   Bool_t fromGrab = kFALSE;
   TGFrame *frame = fPimpl->fGrab;
 
   if (fBuilder && crop) {
      comp = fBuilder->FindEditableMdiFrame(fClient->GetRoot());
   } else {
      comp = (TGCompositeFrame*)fClient->GetRoot();
   }
 
   if (frame && !CanChangeLayout((TGWindow*)frame->GetParent())) {
      frame = GetMovableParent(frame);
 
      if (!frame) {
         TString str = fPimpl->fGrab->ClassName();
         str += "::";
         str += fPimpl->fGrab->GetName();
         str += " cannot be deleted";
 
         if (fBuilder) {
            fBuilder->UpdateStatusBar(str.Data());
         }
         return;
      }
   }
 
   // prepare to crop grabbed frame
   if (frame && !fLassoDrawn && crop) {
      gVirtualX->TranslateCoordinates(frame->GetId(),
                                      fClient->GetDefaultRoot()->GetId(),
                                      -2, -2,
                                      fPimpl->fX0, fPimpl->fY0, c);
 
      fPimpl->fX = fPimpl->fX0 + frame->GetWidth()+4;
      fPimpl->fY = fPimpl->fY0 + frame->GetHeight()+4;
      fromGrab = kTRUE;
   }
 
   x0 = fPimpl->fX0; y0 = fPimpl->fY0;
   x  = fPimpl->fX;  y  = fPimpl->fY;
   if (comp) {
      gVirtualX->TranslateCoordinates(fClient->GetDefaultRoot()->GetId(),
                                      comp->GetId(),
                                      fPimpl->fX, fPimpl->fY, x, y, c);
      gVirtualX->TranslateCoordinates(fClient->GetDefaultRoot()->GetId(),
                                      comp->GetId(),
                                      fPimpl->fX0, fPimpl->fY0, x0, y0, c);
   }
 
   xx = x0; yy = y0;
   x0 = TMath::Min(xx, x); x = TMath::Max(xx, x);
   y0 = TMath::Min(yy, y); y = TMath::Max(yy, y);
   w = x - x0;
   h = y - y0;
 
   if (fLassoDrawn || fromGrab) {
      if (comp) {
         TIter next(comp->GetList());
         TGFrameElement *el;
 
         while ((el = (TGFrameElement*)next())) {
            TGFrame *fr = el->fFrame;
 
            if ((fr->GetX() >= x0) && (fr->GetY() >= y0) &&
                (fr->GetX() + (Int_t)fr->GetWidth() <= x) &&
                (fr->GetY() + (Int_t)fr->GetHeight() <= y)) {
               if (!crop) {
                  DeleteFrame(fr);
               } else {
                  fr->Move(fr->GetX() - x0, fr->GetY() - y0);
               }
            } else {
               if (crop) {
                  DeleteFrame(fr);
               }
            }
         }
         if (crop && comp) {
            gVirtualX->TranslateCoordinates(comp->GetId(), comp->GetParent()->GetId(),
                                             x0, y0, xx, yy, c);
 
            comp->MoveResize(xx, yy, w, h);
 
            if (comp->GetParent()->InheritsFrom(TGMdiDecorFrame::Class())) {
               TGMdiDecorFrame *decor = (TGMdiDecorFrame *)comp->GetParent();
 
               gVirtualX->TranslateCoordinates(decor->GetId(), decor->GetParent()->GetId(),
                                               xx, yy, xx, yy, c);
 
               Int_t b = 2 * decor->GetBorderWidth();
               decor->MoveResize(xx, yy, comp->GetWidth() + b,
                                 comp->GetHeight() + b + decor->GetTitleBar()->GetDefaultHeight());
            }
         }
      }
   } else { //  no lasso drawn -> delete selected frame
      if (frame)
         DeleteFrame(frame);
      UngrabFrame();
      ChangeSelected(0);   //update editors
   }
   SetLassoDrawn(kFALSE);
 
   if (fBuilder) {
      //fBuilder->Update();
      fBuilder->UpdateStatusBar(crop ? "Crop action performed" : "Delete action performed");
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// Delete frame
 
void TGuiBldDragManager::DeleteFrame(TGFrame *frame)
{
   if (fStop || !frame) {
      return;
   }
 
   // remove the frame from the list tree and reset the editor...
   fEditor->RemoveFrame(frame);
 
   frame->UnmapWindow();
 
   TGCompositeFrame *comp = 0;
 
   if (frame->GetParent()->InheritsFrom(TGCompositeFrame::Class())) {
      comp = (TGCompositeFrame*)frame->GetParent();
   }
 
   if (comp) {
      comp->RemoveFrame(frame);
   }
 
   if (frame == fPimpl->fGrab) {
      UngrabFrame();
   }
 
   fClient->UnregisterWindow(frame);
 
   // mem.leak paid for robustness (with possibility "undelete")
   frame->ReparentWindow(fClient->GetDefaultRoot());
}
 
////////////////////////////////////////////////////////////////////////////////
/// Handle cut action
 
void TGuiBldDragManager::HandleCut()
{
   if (fStop || !fPimpl->fGrab) {
      return;
   }
 
   //
   fPimpl->fGrab = GetMovableParent(fPimpl->fGrab);
   HandleCopy();
   DeleteFrame(fPimpl->fGrab);
   ChangeSelected(0);   //update editors
}
 
////////////////////////////////////////////////////////////////////////////////
/// Handle copy. This method is also used by SaveFrame method.
/// In later case  brk_layout == kFALSE
 
void TGuiBldDragManager::HandleCopy(Bool_t brk_layout)
{
   if (fStop || !fPimpl->fGrab) {
      return;
   }
 
   TGMainFrame *tmp = new TGMainFrame(fClient->GetDefaultRoot(),
                                      fPimpl->fGrab->GetWidth(),
                                      fPimpl->fGrab->GetHeight());
 
   // save coordinates
   Int_t x0 = fPimpl->fGrab->GetX();
   Int_t y0 = fPimpl->fGrab->GetY();
 
   // save parent name
   TString name = fPimpl->fGrab->GetParent()->GetName();
 
   ((TGWindow*)fPimpl->fGrab->GetParent())->SetName(tmp->GetName());
 
   fPimpl->fGrab->SetX(0);
   fPimpl->fGrab->SetY(0);
 
   TGFrameElement *fe = fPimpl->fGrab->GetFrameElement();
 
   if (fe) {
      tmp->GetList()->Add(fe);
   }
 
   tmp->SetLayoutBroken(brk_layout);
 
   if (!brk_layout) { //save frame
      tmp->SetMWMHints(kMWMDecorAll, kMWMFuncAll, kMWMInputFullApplicationModal);
      tmp->SetWMSize(tmp->GetWidth(), tmp->GetHeight());
      tmp->SetWMSizeHints(tmp->GetDefaultWidth(), tmp->GetDefaultHeight(), 10000, 10000, 0, 0);
      const char *short_name = gSystem->BaseName(fPasteFileName.Data());
      tmp->SetWindowName(short_name);
      tmp->SetIconName(short_name);
      tmp->SetClassHints(short_name, short_name);
      // some problems here under win32
      if (gVirtualX->InheritsFrom("TGX11")) tmp->SetIconPixmap("bld_rgb.xpm");
   }
   Bool_t quite =  brk_layout || (fPasteFileName == fTmpBuildFile);
   tmp->SaveSource(fPasteFileName.Data(), quite ? "keep_names quiet" : "keep_names");
   tmp->GetList()->Remove(fe);
 
   fPimpl->fGrab->SetX(x0);
   fPimpl->fGrab->SetY(y0);
 
   ((TGWindow*)fPimpl->fGrab->GetParent())->SetName(name.Data());
 
   if (fBuilder) {
      TString str = fPimpl->fGrab->ClassName();
      str += "::";
      str += fPimpl->fGrab->GetName();
      str += " copied to clipboard";
      fBuilder->UpdateStatusBar(str.Data());
   }
 
   delete tmp;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Handle paste action.
 
void TGuiBldDragManager::HandlePaste()
{
   if (fStop) {
      return;
   }
 
   Int_t xp = 0;
   Int_t yp = 0;
 
   if (gSystem->AccessPathName(fPasteFileName.Data())) {
      return;
   }
 
   fPasting = kTRUE;
   gROOT->Macro(fPasteFileName.Data());
 
   Window_t c;
   TGFrame *root = (TGFrame*)fClient->GetRoot();
 
   if (!fPimpl->fReplaceOn) {
      gVirtualX->TranslateCoordinates(fClient->GetDefaultRoot()->GetId(),
                                      root->GetId(),
                                      fPimpl->fX0, fPimpl->fY0, xp, yp, c);
      ToGrid(xp, yp);
 
      // fPasteFrame is defined in TVirtualDragManager.h
      // fPasteFrame is a TGMainFrame consisting "the frame to paste"
      // into the editable frame (aka fClient->GetRoot())
 
      if (fPasteFrame) {
         TGMainFrame *main = (TGMainFrame*)fPasteFrame;
         TGFrame *paste = ((TGFrameElement*)main->GetList()->First())->fFrame;
 
         UInt_t w = paste->GetWidth();
         UInt_t h = paste->GetHeight();
 
         if (xp + w > root->GetWidth()) {
            w = root->GetWidth() - xp -1;
         }
         if (yp + h > root->GetHeight()) {
            h = root->GetHeight() - yp -1;
         }
 
         paste->Resize(w, h);
         fPasteFrame->Move(xp, yp);
         fPimpl->fGrab = fPasteFrame;
         HandleReturn(1);  // drop
      }
   }
 
   fPasting = kFALSE;
 
   if (fBuilder) {
      fBuilder->UpdateStatusBar("Paste action performed");
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// Replace frame (doesn't work yet properly)
 
void TGuiBldDragManager::DoReplace(TGFrame *frame)
{
   if (fStop || !frame || !fPimpl->fGrab || !fPimpl->fReplaceOn) {
      return;
   }
 
   Int_t w = fPimpl->fGrab->GetWidth();
   Int_t h = fPimpl->fGrab->GetHeight();
   Int_t x = fPimpl->fGrab->GetX();
   Int_t y = fPimpl->fGrab->GetY();
 
   if (fBuilder) {
      TString str = fPimpl->fGrab->ClassName();
      str += "::";
      str += fPimpl->fGrab->GetName();
      str += " replaced by ";
      str += frame->ClassName();
      str += "::";
      str += frame->GetName();
      fBuilder->UpdateStatusBar(str.Data());
   }
 
   TGFrameElement *fe = fPimpl->fGrab->GetFrameElement();
 
   if (fe) {
      fe->fFrame = 0;
      fPimpl->fGrab->DestroyWindow();
      delete fPimpl->fGrab;
      fPimpl->fGrab = 0;
 
      fe->fFrame = frame;
      frame->MoveResize(x, y, w, h);
      frame->MapRaised();
      frame->SetFrameElement(fe);
   }
 
   SelectFrame(frame);
   fPimpl->fReplaceOn = kFALSE;
 
   TGWindow *root = (TGWindow *)fClient->GetRoot();
   root->SetEditable(kFALSE);
   DoRedraw();
   root->SetEditable(kTRUE);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Handle replace
 
void TGuiBldDragManager::HandleReplace()
{
   if (fStop || !fPimpl->fGrab) {
      return;
   }
 
   fPimpl->fReplaceOn = kTRUE;
   TGFrame *frame = 0;
 
   if (fBuilder && fBuilder->IsExecutable())  {
      frame = (TGFrame *)fBuilder->ExecuteAction();
   } else {
      HandlePaste();
      frame = fPasteFrame;
   }
   DoReplace(frame);
   fPimpl->fReplaceOn = kFALSE;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Create a frame which is the same as currently edited frame
 
void TGuiBldDragManager::CloneEditable()
{
   if (fStop) {
      return;
   }
 
   TString tmpfile = gSystem->TempDirectory();
   char *s = gSystem->ConcatFileName(tmpfile.Data(), TString::Format("tmp%d.C",
                                     gRandom->Integer(100)));
   Save(s);
   gROOT->Macro(s);
   gSystem->Unlink(s);
   delete [] s;
 
   if (fClient->GetRoot()->InheritsFrom(TGFrame::Class())) {
      TGFrame *f = (TGFrame *)fClient->GetRoot();
      f->Resize(f->GetWidth() + 10, f->GetHeight() + 10);
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// Save an edited frame to the file
 
Bool_t TGuiBldDragManager::Save(const char *file)
{
   if (fStop || !fClient->GetRoot() || !fClient->IsEditable()) {
      return kFALSE;
   }
 
   TGMainFrame *main = (TGMainFrame*)fClient->GetRoot()->GetMainFrame();
   TGWindow *root = (TGWindow*)fClient->GetRoot();
   TString fname = file;
 
   root->SetEditable(kFALSE);
 
   static TImage *img = 0;
 
   if (!img) {
      img = TImage::Create();
   }
   img->FromWindow(main->GetId());
 
   if (!file || !file[0]) {
      static TString dir(".");
      static Bool_t overwr = kFALSE;
      TGFileInfo fi;
 
      fi.fFileTypes = gSaveMacroTypes;
      fi.SetIniDir(dir);
      fi.fOverwrite = overwr;
      new TGFileDialog(fClient->GetDefaultRoot(), this, kFDSave, &fi);
 
      if (!fi.fFilename) goto out;
      dir = fi.fIniDir;
      overwr = fi.fOverwrite;
      fname = gSystem->BaseName(gSystem->UnixPathName(fi.fFilename));
   }
 
   if (fname.EndsWith(".C")) {
      main->SetMWMHints(kMWMDecorAll, kMWMFuncAll, kMWMInputFullApplicationModal);
      main->SetWMSize(main->GetWidth(), main->GetHeight());
      main->SetWMSizeHints(main->GetDefaultWidth(), main->GetDefaultHeight(), 10000, 10000, 0, 0);
      main->SetWindowName(fname.Data());
      main->SetIconName(fname.Data());
      main->SetClassHints(fname.Data(), fname.Data());
      // some problems here under win32
      if (gVirtualX->InheritsFrom("TGX11")) main->SetIconPixmap("bld_rgb.xpm");
      main->SaveSource(fname.Data(), file ? "keep_names quiet" : "keep_names");
 
      if (fBuilder)
         fBuilder->AddMacro(fname.Data(), img);
 
   } else {
      Int_t retval;
      TString msg = TString::Format("file (%s) must have extension .C", fname.Data());
 
      new TGMsgBox(fClient->GetDefaultRoot(), main, "Error...", msg.Data(),
                   kMBIconExclamation, kMBRetry | kMBCancel, &retval);
 
      if (retval == kMBRetry) {
         return Save();
      }
   }
 
out:
   main->RaiseWindow();
   return kTRUE;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Save composite frame as macro
 
Bool_t TGuiBldDragManager::SaveFrame(const char *file)
{
   if (fStop || !fClient->GetRoot() || !fClient->IsEditable() ||
       !fPimpl->fGrab || !fPimpl->fGrab->InheritsFrom(TGCompositeFrame::Class())) {
      return kFALSE;
   }
 
   TString fname = file;
 
   TGFrame *frame = fPimpl->fGrab;
   SetEditable(kFALSE);
 
   static TImage *img = 0;
 
   if (!img) {
      img = TImage::Create();
   }
   img->FromWindow(frame->GetId());
 
   static TString dir(".");
   static Bool_t overwr = kFALSE;
 
   TString sav = fPasteFileName;
 
   if (!file) {
      TGFileInfo fi;
 
      fi.fFileTypes = gSaveMacroTypes;
      fi.SetIniDir(dir);
      fi.fOverwrite = overwr;
      new TGFileDialog(fClient->GetDefaultRoot(), frame, kFDSave, &fi);
 
      if (!fi.fFilename) {
         goto out;
      }
 
      dir = fi.fIniDir;
      overwr = fi.fOverwrite;
      fname = gSystem->BaseName(gSystem->UnixPathName(fi.fFilename));
   }
 
   if (fname.EndsWith(".C")) {
      fPasteFileName = fname;
      fPimpl->fGrab = frame;
      fStop = kFALSE;
      TGFrameElement *fe = frame->GetFrameElement();
 
      if (!fe) { // should never happen
         fe = new TGFrameElement();
         fe->fFrame = frame;
         fe->fState = kIsMapped;
         frame->SetFrameElement(fe);
         TGCompositeFrame *comp = (TGCompositeFrame*)frame->GetParent();
         comp->GetList()->Add(fe);
      }
      delete fe->fLayout;
      fe->fLayout = new TGLayoutHints(kLHintsExpandX | kLHintsExpandY);
 
      HandleCopy(kFALSE);
      fStop = kTRUE;
 
      fBuilder->AddMacro(fname.Data(), img);
   } else {
      Int_t retval;
      TString msg = TString::Format("file (%s) must have extension .C", fname.Data());
 
      new TGMsgBox(fClient->GetDefaultRoot(), frame, "Error...", msg.Data(),
                   kMBIconExclamation, kMBRetry | kMBCancel, &retval);
 
      if (retval == kMBRetry) {
         return SaveFrame();
      }
   }
 
out:
   fPasteFileName = sav;
   return kTRUE;
}
/*
////////////////////////////////////////////////////////////////////////////////
/// Not used yet. Return 0 if all child frames are inside area x,y, w,h
 
static Int_t canResize(TGFrame *frame, Int_t x, Int_t y, UInt_t &w, UInt_t &h)
{
   if (frame->InheritsFrom(TGCompositeFrame::Class())) return 0;
 
   TGCompositeFrame *comp = (TGCompositeFrame*)frame;
 
   TIter next(comp->GetList());
   TGFrameElement *fe;
   Int_t d = gGuiBldDragManager->GetGridStep();
   Int_t ret = 0;
 
   while ((fe = (TGFrameElement*)next())) {
      if (x + fe->fFrame->GetX() + fe->fFrame->GetWidth() > w) {
         w = fe->fFrame->GetX() + x  + fe->fFrame->GetWidth();
         ret |= 4;
      }
      if (y + fe->fFrame->GetY() + fe->fFrame->GetHeight() > h) {
         h = fe->fFrame->GetY() + y + fe->fFrame->GetHeight();
         ret |= 8;
      }
   }
   return ret;
}
*/
 
////////////////////////////////////////////////////////////////////////////////
/// handle resize
 
void TGuiBldDragManager::DoResize()
{
   if (fStop || !fClient->IsEditable()) {
      return;
   }
 
   TGFrame *fr = fPimpl->fGrab;
 
   if (!fr || IsFixedSize(fr) ||
        IsFixedLayout((TGWindow*)fr->GetParent())) {
 
      fr = (TGFrame*)GetResizableParent(fr);
 
      if (!fr ) {
         return;
      }
   }
 
   TGCompositeFrame *comp = 0;
 
   if (fr->InheritsFrom(TGCompositeFrame::Class())) {
      comp = (TGCompositeFrame*)fr;
   }
 
   Window_t c;
   Int_t x = fPimpl->fX;
   Int_t y = fPimpl->fY;
   UInt_t w = 0;
   UInt_t h = 0;
   UInt_t wp = ((TGFrame*)fr->GetParent())->GetWidth() - 2;
   UInt_t hp = ((TGFrame*)fr->GetParent())->GetHeight() - 2;
 
   gVirtualX->TranslateCoordinates(fClient->GetDefaultRoot()->GetId(),
                                   fr->GetId(), x, y, x, y, c);
 
   ToGrid(x, y);
   HighlightCompositeFrame(fr->GetParent()->GetId());
 
   switch (fPimpl->fResizeType) {
      case kTopLeft:
         if ((((int)fr->GetWidth() > x) || (x < 0)) &&
             (((int)fr->GetHeight() > y) || (y < 0))) {
 
            if (fr->GetY() + y < 2) {
               y = 2 - fr->GetY();
            }
            if (fr->GetX() + x < 2) {
               x = 2 - fr->GetX();
            }
            h = fr->GetHeight() - y;
            w = fr->GetWidth() - x;
            x = fr->GetX() + x;
            y = fr->GetY() + y;
 
            if (!IsFixedH(fr) && !IsFixedW(fr)) {
               fr->MoveResize(x, y, w, h);
               break;
            }
            if (IsFixedH(fr)) {
               fr->MoveResize(x, fr->GetY(), w, fr->GetDefaultHeight());
               break;
            }
            if (IsFixedW(fr)) {
               fr->MoveResize(fr->GetX(), y, fr->GetDefaultWidth(), h);
               break;
            }
         }
         break;
      case kTopRight:
         if ((x > 0) && (((int)fr->GetHeight() > y) || (y < 0))) {
 
            if (fr->GetY() + y < 2) {
               y = 2 - fr->GetY();
            }
            h = fr->GetHeight() - y;
 
            if (IsFixedW(fr)) {
               w =  fr->GetDefaultWidth();
            } else {
               w = fr->GetX() + x > Int_t(wp) ? wp - fr->GetX() : UInt_t(x);
            }
            x = fr->GetX();
            y = fr->GetY() + y;
 
            if (!IsFixedH(fr)) {
               fr->MoveResize(x, y, w, h);
            } else {
               fr->Resize(x, fr->GetDefaultHeight());
            }
         }
         break;
      case kTopSide:
         if (((int)fr->GetHeight() > y) || (y < 0)) {
            if (IsFixedH(fr)) {
               break;
            }
 
            if (fr->GetY() + y < 2) {
               y = 2 - fr->GetY();
            }
            h = fr->GetHeight() - y;
            w = fr->GetWidth();
            x = fr->GetX();
            y = fr->GetY() + y;
 
            fr->MoveResize(x, y, w, h);
         }
         break;
      case kBottomLeft:
         if ((((int)fr->GetWidth() > x) || (x < 0)) && (y > 0)) {
 
            if (fr->GetX() + x < 2) {
               x = 2 - fr->GetX();
            }
            h = fr->GetY() + y > Int_t(hp) ? hp - fr->GetY() : UInt_t(y);
            w = fr->GetWidth() - x;
            x = fr->GetX() + x;
 
            if (!IsFixedH(fr) && !IsFixedW(fr)) {
               fr->MoveResize(x, fr->GetY(), w, h);
               break;
            }
            if (IsFixedH(fr)) {
               fr->MoveResize(x, fr->GetY(), w, fr->GetDefaultHeight());
               break;
            }
            if (IsFixedW(fr)) {
               fr->MoveResize(fr->GetX(), fr->GetY(),
                              fr->GetDefaultWidth(), h);
               break;
            }
         }
         break;
      case kBottomRight:
         if ((x > 0) && (y > 0)) {
            w = !IsFixedW(fr) ? UInt_t(x) : fr->GetDefaultWidth();
            h = !IsFixedH(fr) ? UInt_t(y) : fr->GetDefaultHeight();
 
            h = fr->GetY() + h > hp ? hp - fr->GetY() : h;
            w = fr->GetX() + w > wp ? wp - fr->GetX() : w;
 
            //canResize(comp, 0, 0, w, h);
            fr->Resize(w, h);
         }
         break;
      case kBottomSide:
         if (y > 0) {
            if (IsFixedH(fr)) {
               break;
            }
 
            w = fr->GetWidth();
            h = fr->GetY() + y > (Int_t)hp ? hp - fr->GetY() : UInt_t(y);
 
            //canResize(comp, 0, 0, w, h);
            fr->Resize(w, h);
         }
         break;
      case kLeftSide:
         if ((int)fr->GetWidth() > x ) {
            if (IsFixedW(fr)) {
               break;
            }
 
            if (fr->GetX() + x < 2) {
               x = 2 - fr->GetX();
            }
            w = fr->GetWidth() - x;
            h = fr->GetHeight();
            y = fr->GetY();
            x = fr->GetX() + x;
 
            //canResize(comp, x, y, w, h);
            fr->MoveResize(x, y, w, h);
         }
         break;
      case kRightSide:
         if (x > 0) {
            if (IsFixedW(fr)) {
               break;
            }
 
            h = fr->GetHeight();
            w = fr->GetX() + x > (Int_t)wp ? wp - fr->GetX() : UInt_t(x);
            //canResize(comp, 0, 0, w, h);
            fr->Resize(w, h);
         }
         break;
      default:
         break;
   }
   if (comp && (!comp->IsLayoutBroken() || IsFixedLayout(comp))) {
      layoutFrame(comp);
   }
 
   gVirtualX->SetCursor(fClient->GetRoot()->GetId(),
                        gVirtualX->CreateCursor(fPimpl->fResizeType));
   w = fr->GetWidth();
   h = fr->GetHeight();
 
   if (fBuilder) {
      TString str = fr->ClassName();
      str += "::";
      str += fr->GetName();
      str += " resized   ";
      str += TString::Format("(%d x %d)", w, h);
      fBuilder->UpdateStatusBar(str.Data());
   }
 
   fClient->NeedRedraw(fr, kTRUE);
   DoRedraw();
   fEditor->ChangeSelected(fr); //to update the geometry frame after drag resize
}
 
////////////////////////////////////////////////////////////////////////////////
/// Handle move
 
void TGuiBldDragManager::DoMove()
{
   if (fStop || !fPimpl->fGrab || !fClient->IsEditable()) {
      return;
   }
 
   TGWindow *parent = (TGWindow*)fPimpl->fGrab->GetParent();
 
   // do not remove frame from fixed layout or non-editable parent
   if (IsFixedLayout(parent) || IsEditDisabled(parent)) {
      return;
   }
 
   Int_t x = fPimpl->fX - fPimpl->fXf;
   Int_t y = fPimpl->fY - fPimpl->fYf;
 
   static Int_t qq;
   static UInt_t w = 0;
   static UInt_t h = 0;
 
   if (w == 0) {
      gVirtualX->GetWindowSize(gVirtualX->GetDefaultRootWindow(), qq, qq, w, h);
   }
 
   //
   Bool_t move = (x > 0) && (y > 0) && ((x + fPimpl->fGrab->GetWidth()) < (w - 0)) &&
                 ((y + fPimpl->fGrab->GetHeight()) < (h - 30));
 
 
   // we are out of "win32 world"
   if (!move && !gVirtualX->InheritsFrom("TGX11")) {
      EndDrag();
      return;
   }
 
   fPimpl->fGrab->Move(x, y);
 
   if (fBuilder) {
      //fBuilder->Update();
      TString str = fPimpl->fGrab->ClassName();
      str += "::";
      str += fPimpl->fGrab->GetName();
      str += " is moved to absolute position   ";
      str += TString::Format("(%d , %d)", x, y);
      fBuilder->UpdateStatusBar(str.Data());
   }
 
   CheckTargetUnderGrab();
}
 
////////////////////////////////////////////////////////////////////////////////
/// Return a pointer to the parent mdi frame
 
TGFrame *TGuiBldDragManager::FindMdiFrame(TGFrame *in)
{
   if (fStop || !in) {
      return 0;
   }
 
   TGFrame *p = in;
 
   while (p && (p != fClient->GetDefaultRoot()) &&
         !p->InheritsFrom(TGMainFrame::Class())) {
      if (p->InheritsFrom(TGMdiFrame::Class())) {
         return p;
      }
      p = (TGFrame*)p->GetParent();
   }
   return 0;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Raise guibuilder's mdi frame.
 
void TGuiBldDragManager::RaiseMdiFrame(TGFrame *comp)
{
   if (fStop || !comp) {
      return;
   }
 
   if (comp && comp->InheritsFrom(TGMdiFrame::Class()) && fBuilder) {
      TGFrame *mdi = fBuilder->FindEditableMdiFrame(comp);
      if (mdi) {
         // dragged frame is taken from some main frame
         //if (fPimpl->fGrab && fClient->GetRoot()->InheritsFrom(TGMainFrame::Class())) {
         //   fBuilder->MapRaised();
         //}
      }
      if (fBuilder->GetMdiMain()->GetCurrent() != comp) {
         fBuilder->GetMdiMain()->SetCurrent((TGMdiFrame*)comp);
      }
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// Look for the drop target under grabbed/selected frame while moving
 
void TGuiBldDragManager::CheckTargetUnderGrab()
{
   if (fStop || !fPimpl->fGrab ) {
      return;
   }
 
   Int_t x = fPimpl->fGrab->GetX();
   Int_t y = fPimpl->fGrab->GetY();
   UInt_t w = fPimpl->fGrab->GetWidth();
   UInt_t h = fPimpl->fGrab->GetHeight();
 
   Bool_t ok = CheckTargetAtPoint(x - 1, y - 1);
 
   if (!ok) {
      ok = CheckTargetAtPoint(x + w + 1, y + h + 1);
   }
 
   if (!ok) {
      ok = CheckTargetAtPoint(x + w + 1, y - 1);
   }
 
   if (!ok) {
      CheckTargetAtPoint(x - 1, y + h + 1);
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// Helper. Look for the drop target under grabbed/selected frame while moving.
 
Bool_t TGuiBldDragManager::CheckTargetAtPoint(Int_t x, Int_t y)
{
   if (fStop || !fPimpl->fGrab) {
      return kFALSE;
   }
 
   UInt_t ww = fPimpl->fGrab->GetWidth();
   UInt_t hh = fPimpl->fGrab->GetHeight();
   Bool_t ret = kFALSE;
   Window_t c;
   TGWindow *win = 0;
 
   Window_t w = GetWindowFromPoint(x, y);
 
   if (w && (w != gVirtualX->GetDefaultRootWindow())) {
      win = fClient->GetWindowById(w);
      TGCompositeFrame *comp = 0;
 
      if (!win) {
         goto out;
      }
 
      if (win->InheritsFrom(TGCompositeFrame::Class())) {
         comp = (TGCompositeFrame *)win;
      } else if (win->GetParent() != fClient->GetDefaultRoot()) {
         comp = (TGCompositeFrame *)win->GetParent();
      }
 
      if (comp) {
         gVirtualX->TranslateCoordinates(fClient->GetDefaultRoot()->GetId(),
                                         comp->GetId(), x, y, x, y, c);
 
         RaiseMdiFrame(comp);
 
         if ((comp != fPimpl->fGrab) && (x >= 0) && (y >= 0) &&
             (x + ww <= comp->GetWidth()) &&
             (y + hh <= comp->GetHeight())) {
 
            if (comp != fTarget) {
               comp->HandleDragEnter(fPimpl->fGrab);
 
               if (fTarget) fTarget->HandleDragLeave(fPimpl->fGrab);
 
               else Snap2Grid();
            } else {
               if (fTarget) {
                  fTarget->HandleDragMotion(fPimpl->fGrab);
               }
            }
 
            fTarget = comp;
            fTargetId = comp->GetId();
            ret = kTRUE;
            return ret;
 
         } else {
            if (fTarget) {
               fTarget->HandleDragLeave(fPimpl->fGrab);
            }
            fTarget = 0;
            fTargetId = 0;
         }
      }
   }
 
out:
   if (fTarget) {
      fTarget->HandleDragLeave(fPimpl->fGrab);
   }
 
   if (!w || !win) {
      fTarget = 0;
      fTargetId = 0;
   }
   return ret;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Handle motion event
 
Bool_t TGuiBldDragManager::HandleMotion(Event_t *event)
{
   if (fStop) {
      return kFALSE;
   }
 
   static Long64_t was = gSystem->Now();
   static Int_t gy = event->fYRoot;
   static Int_t gx = event->fXRoot;
 
   Long64_t now = gSystem->Now();
 
   if ((now-was < 100) || !(event->fState & kButton1Mask) ||
       ((event->fYRoot == gy) && (event->fXRoot == gx))) {
      return kFALSE;
   }
 
   was = now;
   gy = event->fYRoot;
   gx = event->fXRoot;
 
   if (!fDragging) {
      if (fMoveWaiting && ((TMath::Abs(fPimpl->fX - event->fXRoot) > 10) ||
          (TMath::Abs(fPimpl->fY - event->fYRoot) > 10))) {
 
         return StartDrag(fSource, event->fXRoot, event->fYRoot);
      }
   } else {
      fPimpl->fX = event->fXRoot;
      fPimpl->fY = event->fYRoot;
 
      switch (fDragType) {
         case kDragLasso:
            DrawLasso();
            fSelectionIsOn = event->fState & kKeyShiftMask;
            break;
         case kDragMove:
         case kDragCopy:
         case kDragLink:
            DoMove();
            break;
         case kDragResize:
            DoResize();
            break;
         default:
            break;
      }
   }
   DrawGrabRectangles();
   return kTRUE;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Put created frame at position of the last mouse click
 
void TGuiBldDragManager::PlaceFrame(TGFrame *frame, TGLayoutHints *hints)
{
   Int_t x0, y0, x, y;
   Window_t c;
 
   if (fStop || !frame || !fClient->IsEditable()) {
      return;
   }
 
   frame->MapSubwindows();
   TGFrame *root = (TGFrame*)fClient->GetRoot();
 
   gVirtualX->TranslateCoordinates(fClient->GetDefaultRoot()->GetId(),
                                   root->GetId(),
                                   fPimpl->fX0 , fPimpl->fY0, x0, y0, c);
   gVirtualX->TranslateCoordinates(fClient->GetDefaultRoot()->GetId(),
                                   root->GetId(),
                                   fPimpl->fX , fPimpl->fY, x, y, c);
 
   ToGrid(x, y);
   ToGrid(x0, y0);
 
   UInt_t w = TMath::Abs(x - x0);
   UInt_t h = TMath::Abs(y - y0);
   x = x > x0 ? x0 : x;
   y = y > y0 ? y0 : y;
 
   // do not create frame with size smaller when default size
   w = w < frame->GetDefaultWidth() + 2 ? frame->GetDefaultWidth() + 2 : w;
   h = h < frame->GetDefaultHeight() + 2 ? frame->GetDefaultHeight() + 2 : h;
 
   // do not create frame out of editable space
   x = x + w > root->GetWidth() ? Int_t(root->GetWidth() - w) : x;
   y = y + h > root->GetHeight() ? Int_t(root->GetHeight() - h) : y;
 
   frame->Move(x, y);
 
   UInt_t grid = GetGridStep();
 
   if (IsFixedW(frame) || IsFixedH(frame) || IsFixedSize(frame)) {
      w = IsFixedW(frame) ? frame->GetDefaultWidth() : w;
      h = IsFixedH(frame) ? frame->GetDefaultHeight() : h;
      frame->Resize(w < grid ? grid : w, h < grid ? grid : h);
   } else {
      if (frame->InheritsFrom(TGVerticalFrame::Class())) {
         frame->Resize(w < grid ? 15*grid : w, h < grid ?  30*grid : h);
      } else if (frame->InheritsFrom(TGHorizontalFrame::Class())) {
         frame->Resize(w < grid ? 30*grid : w, h < grid ?  15*grid : h);
      }
      else frame->Resize(w < 2*grid ? 2*grid : w, h < 2*grid ?  2*grid : h);
   }
 
   frame->MapRaised();
   frame->SetCleanup(kDeepCleanup);
   frame->AddInput(kButtonPressMask);
 
   if (fClient->GetRoot()->InheritsFrom(TGCompositeFrame::Class())) {
      TGCompositeFrame *edit = (TGCompositeFrame*)fClient->GetRoot();
      edit->SetCleanup(kDeepCleanup);
      ReparentFrames(frame, edit);
      frame->MapRaised();
      //edit->SetLayoutBroken();
      UInt_t g = 2;
      // temporary hack for status bar
      if (frame->InheritsFrom("TGStatusBar")) {
         edit->AddFrame(frame, new TGLayoutHints(kLHintsBottom | kLHintsExpandX));
      }
      else {
         edit->AddFrame(frame, hints ? hints : new TGLayoutHints(kLHintsNormal, g, g, g, g));
      }
 
      if (hints && !edit->IsLayoutBroken()) {
         edit->GetLayoutManager()->Layout();
      } else {
         edit->Layout();
      }
   }
   if (fBuilder) {
      TString str = frame->ClassName();
      str += "::";
      str += frame->GetName();
      str += " created";
      fBuilder->UpdateStatusBar(str.Data());
   }
 
   if (frame->InheritsFrom(TGCanvas::Class())) {
      frame = ((TGCanvas*)frame)->GetContainer();
   }
 
   SelectFrame(frame);
 
}
////////////////////////////////////////////////////////////////////////////////
/// Draw lasso for allocation new object
 
void TGuiBldDragManager::DrawLasso()
{
   if (fStop || !fClient->IsEditable()) {
      return;
   }
 
   UngrabFrame();
 
   Int_t x0, y0, x, y;
   Window_t c;
   TGFrame *root = (TGFrame*)fClient->GetRoot();
 
   gVirtualX->TranslateCoordinates(fClient->GetDefaultRoot()->GetId(), root->GetId(),
                                   fPimpl->fX0 , fPimpl->fY0, x0, y0, c);
   gVirtualX->TranslateCoordinates(fClient->GetDefaultRoot()->GetId(), root->GetId(),
                                   fPimpl->fX , fPimpl->fY, x, y, c);
 
   UInt_t w, h;
   Bool_t xswap = kFALSE;
   Bool_t yswap = kFALSE;
 
   // check limits
 
   if ((x == x0) || ( y==y0 )) return; //lasso is not rectangle -> do not draw it
 
   if (x > x0) {
      x0 = x0 < 0 ? 0 : x0;
      w = x - x0;
   } else {
      x = x < 0 ? 0 : x;
      w = x0 - x;
      x0 = x;
      xswap = kTRUE;
   }
 
   if (y > y0) {
      y0 = y0 < 0 ? 0 : y0;
      h = y - y0;
   } else {
      y = y < 0 ? 0 : y;
      h = y0 - y;
      y0 = y;
      yswap = kTRUE;
   }
 
   w = x0 + w > root->GetWidth() ? root->GetWidth() - x0 : w;
   h = y0 + h > root->GetHeight() ? root->GetHeight() - y0 : h;
   x = x0 + w;
   y = y0 + h;
 
   ToGrid(x, y);
   ToGrid(x0, y0);
 
   // correct fPimpl->fX0 , fPimpl->fY0 , fPimpl->fX , fPimpl->fY
   gVirtualX->TranslateCoordinates(root->GetId(), fClient->GetDefaultRoot()->GetId(),
                                   xswap ? x : x0, yswap ? y : y0,
                                   fPimpl->fX0 , fPimpl->fY0,  c);
   gVirtualX->TranslateCoordinates(root->GetId(), fClient->GetDefaultRoot()->GetId(),
                                   xswap ? x0 : x, yswap ? y0 : y,
                                   fPimpl->fX , fPimpl->fY,  c);
   DoRedraw();
 
   gVirtualX->DrawRectangle(fClient->GetRoot()->GetId(),
                            GetBlackGC()(), x0, y0, w, h);
   gVirtualX->DrawRectangle(fClient->GetRoot()->GetId(),
                            GetBlackGC()(), x0+1, y0+1, w-2, h-2);
 
   gVirtualX->SetCursor(fId, gVirtualX->CreateCursor(kCross));
   gVirtualX->SetCursor(fClient->GetRoot()->GetId(), gVirtualX->CreateCursor(kCross));
 
   SetLassoDrawn(kTRUE);
   root->RequestFocus();
 
   if (fBuilder) {
      TString str = "Lasso drawn. Align frames inside or press Return key to grab frames.";
      fBuilder->UpdateStatusBar(str.Data());
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// Handle client message
 
Bool_t TGuiBldDragManager::HandleClientMessage(Event_t *event)
{
   if (fStop) {
      return kFALSE;
   }
 
   if ((event->fFormat == 32) && ((Atom_t)event->fUser[0] == gWM_DELETE_WINDOW) &&
       (event->fHandle != gROOT_MESSAGE)) {
 
      if (fPimpl->fPlane && (fPimpl->fPlane->GetId() == event->fWindow)) {
         fPimpl->fPlane = 0;
      }
 
      TGWindow *root = (TGWindow*)fClient->GetRoot();
      if (!root || (root == fClient->GetDefaultRoot())) {
         SetEditable(kFALSE);
         return kTRUE;
      }
      TGMainFrame *main = (TGMainFrame*)root->GetMainFrame();
 
      if (event->fWindow == main->GetId()) {
         if (main != fBuilder) {
            if (fEditor && !fEditor->IsEmbedded()) {
               delete fEditor;
               fEditor = 0;
            }
 
            SetEditable(kFALSE);
            return kTRUE;
         }
 
         delete fFrameMenu;
         fFrameMenu =0;
 
         delete fLassoMenu;
         fLassoMenu = 0;
 
         delete fPimpl->fGrid;
         fPimpl->fGrid = 0;
         Reset1();
 
      } else if (fBuilder && (event->fWindow == fBuilder->GetId())) {
         fBuilder->CloseWindow();
 
      } else if (fEditor && (event->fWindow == fEditor->GetMainFrame()->GetId())) {
         TQObject::Disconnect(fEditor);
         fEditor = 0;
      }
 
      // to avoid segv. stop editting
      SetEditable(kFALSE);
   }
 
   return kFALSE;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Handle destroy notify
 
Bool_t TGuiBldDragManager::HandleDestroyNotify(Event_t *event)
{
   if (fPimpl->fPlane && (fPimpl->fPlane->GetId() == event->fWindow)) {
      fPimpl->fPlane = 0;
   }
 
   return kFALSE;
}
 
 
////////////////////////////////////////////////////////////////////////////////
/// not used yet.
 
Bool_t TGuiBldDragManager::HandleSelection(Event_t *)
{
   if (fStop) {
      return kFALSE;
   }
 
   return kFALSE;
}
 
////////////////////////////////////////////////////////////////////////////////
/// not used yet.
 
Bool_t TGuiBldDragManager::HandleSelectionRequest(Event_t *)
{
   if (fStop) {
      return kFALSE;
   }
 
   return kFALSE;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Find parent frame which can be dragged
 
TGFrame *TGuiBldDragManager::GetMovableParent(TGWindow *p)
{
   if (fStop) {
      return 0;
   }
 
   TGFrame *ret = (TGFrame*)p;
   TGWindow *parent = (TGWindow*)ret->GetParent();
 
   while (parent && (parent != fClient->GetDefaultRoot())) {
      if (!IsFixedLayout(parent) && !IsEditDisabled(parent)) {
         return ret;
      }
      ret = (TGFrame*)parent;
      parent = (TGWindow*)ret->GetParent();
   }
 
   return 0;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Find parent frame which can be resized
 
TGWindow *TGuiBldDragManager::GetResizableParent(TGWindow *p)
{
   if (fStop) {
      return 0;
   }
 
   TGWindow *parent = p;
 
   while (parent && (parent != fClient->GetDefaultRoot())) {
      if (!IsFixedSize(parent) &&
          !IsFixedLayout((TGWindow*)parent->GetParent()) &&
          !IsEditDisabled((TGWindow*)parent->GetParent())) {
         return parent;
      }
      parent = (TGWindow*)parent->GetParent();
   }
 
   return 0;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Start dragging.
 
Bool_t TGuiBldDragManager::StartDrag(TGFrame *src, Int_t x, Int_t y)
{
   if (fStop || fDragging) {
      return kFALSE;
   }
 
   TGFrame *mov = src;
 
   // special case when frame was grabbed via spacebar pressing
   if (fPimpl->fSpacePressedFrame) {
      if (fDragType == kDragNone) {
         fDragType = kDragMove;
         mov = fPimpl->fSpacePressedFrame;
      } else {
         fPimpl->fSpacePressedFrame = 0;
      }
   }
 
   TGWindow *parent = (TGWindow*)(mov ? mov->GetParent() : 0);
 
   // do not remove frame from fixed layout or non-editable parent
   // try to drag "draggable parent"
   if (parent && (IsFixedLayout(parent) || IsEditDisabled(parent))) {
      mov = GetMovableParent(parent);
      if (!mov) {
         return kFALSE;
      }
   }
 
   SetEditable(kTRUE);  // grab server
 
   fPimpl->fX = x;
   fPimpl->fY = y;
   fSelectionIsOn = kFALSE;
 
   fPimpl->fRepeatTimer->Reset();
   gSystem->AddTimer(fPimpl->fRepeatTimer);
 
   fMoveWaiting = kFALSE;
   fDragging = kTRUE;
   if (src) gVirtualX->SetCursor(src->GetId(), gVirtualX->CreateCursor(kMove));
 
   switch (fDragType) {
      case kDragCopy:
         HandleCopy();
         HandlePaste();
         GrabFrame(fPimpl->fGrab);
         break;
      case kDragMove:
         fPimpl->fGrab = mov;
         GrabFrame(fPimpl->fGrab);
         break;
      default:
         //fPimpl->fGrab = 0;
         break;
   }
 
   return kTRUE;
}
 
////////////////////////////////////////////////////////////////////////////////
/// End dragging.
 
Bool_t TGuiBldDragManager::EndDrag()
{
   TGFrame *frame = 0;
   Bool_t ret = kFALSE;
 
   if (fStop) {
      return kFALSE;
   }
 
   fMoveWaiting = kFALSE;  // for sanity check
 
   if (fPimpl->fGrab && (fDragType >= kDragMove) && (fDragType <= kDragLink)) {
 
      ret = Drop();
 
   } else if (fBuilder && fBuilder->IsExecutable() &&
              (fDragType == kDragLasso) && !fSelectionIsOn) {
 
      frame = (TGFrame*)fBuilder->ExecuteAction();
      PlaceFrame(frame, fBuilder->GetAction()->fHints);
      SetLassoDrawn(kF