Logo ROOT   6.30.04
Reference Guide
 All Namespaces Files Pages
TGSplitFrame.cxx
Go to the documentation of this file.
1 // @(#)root/gui:$Id$
2 // Author: Bertrand Bellenot 23/01/2008
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 
12 #include "TGFrame.h"
13 #include "TGLayout.h"
14 #include "TGMenu.h"
15 #include "TGSplitter.h"
16 #include "TGSplitFrame.h"
17 #include "TGInputDialog.h"
18 #include "TGResourcePool.h"
19 #include "TRootContextMenu.h"
20 #include "TClassMenuItem.h"
21 #include "TContextMenu.h"
22 #include "TString.h"
23 #include "TClass.h"
24 #include "TList.h"
25 #include "Riostream.h"
26 
27 ClassImp(TGSplitTool);
28 ClassImp(TGSplitFrame);
29 
30 ////////////////////////////////////////////////////////////////////////////////
31 /// Create a split frame tool tip. P is the tool tips parent window (normally
32 /// fClient->GetRoot() and f is the frame to which the tool tip is associated.
33 
34 TGSplitTool::TGSplitTool(const TGWindow *p, const TGFrame *f)
35  : TGCompositeFrame(p, 10, 10, kHorizontalFrame | kRaisedFrame | kFixedSize)
36 {
37  SetWindowAttributes_t attr;
38  attr.fMask = kWAOverrideRedirect | kWASaveUnder;
39  attr.fOverrideRedirect = kTRUE;
40  attr.fSaveUnder = kTRUE;
41 
42  gVirtualX->ChangeWindowAttributes(fId, &attr);
43  SetBackgroundColor(fClient->GetResourcePool()->GetTipBgndColor());
44 
45  fRectGC.SetFillStyle(kFillSolid);
46  fRectGC.SetForeground(0x99ff99);
47 
48  TClass *cl = TClass::GetClass("TGSplitFrame");
49  cl->MakeCustomMenuList();
50  TList *ml = cl->GetMenuList();
51  ((TClassMenuItem *)ml->At(1))->SetTitle("Cleanup Frame");
52  ((TClassMenuItem *)ml->At(2))->SetTitle("Close and Collapse");
53  ((TClassMenuItem *)ml->At(3))->SetTitle("Undock Frame");
54  ((TClassMenuItem *)ml->At(4))->SetTitle("Dock Frame Back");
55  ((TClassMenuItem *)ml->At(5))->SetTitle("Switch to Main");
56  ((TClassMenuItem *)ml->At(6))->SetTitle("Horizontally Split...");
57  ((TClassMenuItem *)ml->At(7))->SetTitle("Vertically Split...");
58  fContextMenu = new TContextMenu("SplitFrameContextMenu", "Actions");
59  fMap.SetOwner(kTRUE);
60  fMap.SetOwnerValue(kFALSE);
61  MapSubwindows();
62  if (f) Resize(f->GetWidth()/10, f->GetHeight()/10);
63  AddInput(kButtonPressMask | kButtonReleaseMask | kPointerMotionMask);
64 
65  fWindow = f;
66  fX = fY = -1;
67 }
68 
69 ////////////////////////////////////////////////////////////////////////////////
70 /// TGSplitTool destructor.
71 
72 TGSplitTool::~TGSplitTool()
73 {
74  delete fContextMenu;
75 }
76 
77 ////////////////////////////////////////////////////////////////////////////////
78 /// Add a rectangle representation of a split frame in the map, together
79 /// with the frame itself.
80 
81 void TGSplitTool::AddRectangle(TGFrame *frame, Int_t x, Int_t y, Int_t w, Int_t h)
82 {
83  TGRectMap *rect = new TGRectMap(x, y, w, h);
84  fMap.Add(rect, frame);
85 }
86 
87 ////////////////////////////////////////////////////////////////////////////////
88 /// Redraw split frame tool.
89 
90 void TGSplitTool::DoRedraw()
91 {
92  TGRectMap *rect;
93  TMapIter next(&fMap);
94  while ((rect = (TGRectMap*)next())) {
95  gVirtualX->FillRectangle(fId, GetBckgndGC()(), rect->fX,
96  rect->fY, rect->fW, rect->fH);
97  gVirtualX->DrawRectangle(fId, GetBlackGC()(), rect->fX, rect->fY,
98  rect->fW, rect->fH);
99  }
100  DrawBorder();
101 }
102 
103 ////////////////////////////////////////////////////////////////////////////////
104 /// Draw border of tool window.
105 
106 void TGSplitTool::DrawBorder()
107 {
108  gVirtualX->DrawLine(fId, GetShadowGC()(), 0, 0, fWidth-2, 0);
109  gVirtualX->DrawLine(fId, GetShadowGC()(), 0, 0, 0, fHeight-2);
110  gVirtualX->DrawLine(fId, GetBlackGC()(), 0, fHeight-1, fWidth-1, fHeight-1);
111  gVirtualX->DrawLine(fId, GetBlackGC()(), fWidth-1, fHeight-1, fWidth-1, 0);
112 }
113 
114 ////////////////////////////////////////////////////////////////////////////////
115 /// Handle mouse click events in the tool.
116 
117 Bool_t TGSplitTool::HandleButton(Event_t *event)
118 {
119  if (event->fType != kButtonPress)
120  return kTRUE;
121  Int_t px = 0, py = 0;
122  Window_t wtarget;
123  TGRectMap *rect;
124  TGSplitFrame *frm = 0;
125  TMapIter next(&fMap);
126  while ((rect = (TGRectMap*)next())) {
127  if (rect->Contains(event->fX, event->fY)) {
128  frm = (TGSplitFrame *)fMap.GetValue((const TObject *)rect);
129  gVirtualX->TranslateCoordinates(event->fWindow,
130  gClient->GetDefaultRoot()->GetId(),
131  event->fX, event->fY, px, py, wtarget);
132  fContextMenu->Popup(px, py, frm);
133  // connect PoppedDown signal to close the tool window
134  // when the menu is closed
135  TRootContextMenu *menu = ((TRootContextMenu *)fContextMenu->GetContextMenuImp());
136  ((TGPopupMenu *)menu)->Connect("PoppedDown()", "TGSplitTool", this, "Hide()");
137  return kTRUE;
138  }
139  }
140  Hide();
141  return kTRUE;
142 }
143 
144 ////////////////////////////////////////////////////////////////////////////////
145 /// handle mouse motion events
146 
147 Bool_t TGSplitTool::HandleMotion(Event_t *event)
148 {
149  static TGRectMap *rect = 0, *oldrect = 0;
150  TMapIter next(&fMap);
151  while ((rect = (TGRectMap*)next())) {
152  if (rect->Contains(event->fX, event->fY)) {
153  // if inside a rectangle, highlight it
154  if (rect != oldrect) {
155  if (oldrect) {
156  gVirtualX->FillRectangle(fId, GetBckgndGC()(), oldrect->fX,
157  oldrect->fY, oldrect->fW, oldrect->fH);
158  gVirtualX->DrawRectangle(fId, GetBlackGC()(), oldrect->fX, oldrect->fY,
159  oldrect->fW, oldrect->fH);
160  }
161  gVirtualX->FillRectangle(fId, fRectGC(), rect->fX, rect->fY, rect->fW,
162  rect->fH);
163  gVirtualX->DrawRectangle(fId, GetBlackGC()(), rect->fX, rect->fY,
164  rect->fW, rect->fH);
165  oldrect = rect;
166  }
167  return kTRUE;
168  }
169  }
170  if (oldrect) {
171  gVirtualX->FillRectangle(fId, GetBckgndGC()(), oldrect->fX,
172  oldrect->fY, oldrect->fW, oldrect->fH);
173  gVirtualX->DrawRectangle(fId, GetBlackGC()(), oldrect->fX, oldrect->fY,
174  oldrect->fW, oldrect->fH);
175  }
176  return kTRUE;
177 }
178 ////////////////////////////////////////////////////////////////////////////////
179 /// Hide tool window. Use this method to hide the tool in a client class.
180 
181 void TGSplitTool::Hide()
182 {
183  gVirtualX->GrabPointer(0, 0, 0, 0, kFALSE); // ungrab pointer
184  fMap.Delete();
185  UnmapWindow();
186 }
187 
188 ////////////////////////////////////////////////////////////////////////////////
189 /// Reset tool tip popup delay timer. Use this method to activate tool tip
190 /// in a client class.
191 
192 void TGSplitTool::Reset()
193 {
194  fMap.Delete();
195 }
196 
197 ////////////////////////////////////////////////////////////////////////////////
198 /// Set popup position within specified frame (as specified in the ctor).
199 /// To get back default behaviour (in the middle just below the designated
200 /// frame) set position to -1,-1.
201 
202 void TGSplitTool::SetPosition(Int_t x, Int_t y)
203 {
204  fX = x;
205  fY = y;
206 
207  if (fX < -1)
208  fX = 0;
209  if (fY < -1)
210  fY = 0;
211 
212  if (fWindow) {
213  if (fX > (Int_t) fWindow->GetWidth())
214  fX = fWindow->GetWidth();
215  if (fY > (Int_t) fWindow->GetHeight())
216  fY = fWindow->GetHeight();
217  }
218 }
219 
220 ////////////////////////////////////////////////////////////////////////////////
221 /// Show tool window.
222 
223 void TGSplitTool::Show(Int_t x, Int_t y)
224 {
225  Move(x, y);
226  MapWindow();
227  RaiseWindow();
228 
229  // last argument kFALSE forces all specified events to this window
230  gVirtualX->GrabPointer(fId, kButtonPressMask | kPointerMotionMask, kNone,
231  fClient->GetResourcePool()->GetGrabCursor(),
232  kTRUE, kFALSE);
233  // Long_t args[2];
234  // args[0] = x;
235  // args[1] = y;
236 }
237 
238 ////////////////////////////////////////////////////////////////////////////////
239 /// Default constructor.
240 
241 TGSplitFrame::TGSplitFrame(const TGWindow *p, UInt_t w, UInt_t h,
242  UInt_t options) : TGCompositeFrame(p, w, h, options),
243  fFrame(0), fSplitter(0), fFirst(0), fSecond(0)
244 {
245  fSplitTool = new TGSplitTool(gClient->GetDefaultRoot(), this);
246  fHRatio = fWRatio = 0.0;
247  fUndocked = 0;
248  AddInput(kStructureNotifyMask);
249  SetCleanup(kLocalCleanup);
250 }
251 
252 ////////////////////////////////////////////////////////////////////////////////
253 /// Destructor. Make cleanup.
254 
255 TGSplitFrame::~TGSplitFrame()
256 {
257  delete fSplitTool;
258  Cleanup();
259 }
260 
261 ////////////////////////////////////////////////////////////////////////////////
262 /// Add a frame in the split frame using layout hints l.
263 
264 void TGSplitFrame::AddFrame(TGFrame *f, TGLayoutHints *l)
265 {
266  TGCompositeFrame::AddFrame(f, l);
267  fFrame = f;
268 }
269 
270 ////////////////////////////////////////////////////////////////////////////////
271 /// Add a frame in the split frame using layout hints l.
272 
273 void TGSplitFrame::RemoveFrame(TGFrame *f)
274 {
275  TGCompositeFrame::RemoveFrame(f);
276  if (f == fFrame)
277  fFrame = 0;
278 }
279 
280 ////////////////////////////////////////////////////////////////////////////////
281 /// Recursively cleanup child frames.
282 
283 void TGSplitFrame::Cleanup()
284 {
285  TGCompositeFrame::Cleanup();
286  fFirst = 0;
287  fSecond = 0;
288  fSplitter = 0;
289  fUndocked = 0;
290 }
291 
292 ////////////////////////////////////////////////////////////////////////////////
293 /// Return the top level split frame.
294 
295 TGSplitFrame *TGSplitFrame::GetTopFrame()
296 {
297  TGSplitFrame *top = this;
298  TGWindow *w = (TGWindow *)GetParent();
299  TGSplitFrame *p = dynamic_cast<TGSplitFrame *>(w);
300  while (p) {
301  top = p;
302  w = (TGWindow *)p->GetParent();
303  p = dynamic_cast<TGSplitFrame *>(w);
304  }
305  return top;
306 }
307 
308 ////////////////////////////////////////////////////////////////////////////////
309 /// Close (unmap and remove from the list of frames) the frame contained in
310 /// this split frame.
311 
312 void TGSplitFrame::Close()
313 {
314  if (fFrame) {
315  fFrame->UnmapWindow();
316  RemoveFrame(fFrame);
317  }
318  fFrame = 0;
319 }
320 
321 ////////////////////////////////////////////////////////////////////////////////
322 /// Close (unmap, remove from the list of frames and destroy) the frame
323 /// contained in this split frame. Then unsplit the parent frame.
324 
325 void TGSplitFrame::CloseAndCollapse()
326 {
327  if (!fSplitter || !fFirst || !fSecond) {
328  TGSplitFrame *parent = (TGSplitFrame *)GetParent();
329  if (parent->GetFirst() && parent->GetSecond()) {
330  if (parent->GetFirst() == this)
331  parent->UnSplit("first");
332  else if (parent->GetSecond() == this)
333  parent->UnSplit("second");
334  }
335  }
336 }
337 ////////////////////////////////////////////////////////////////////////////////
338 /// Emit Undocked() signal.
339 
340 void TGSplitFrame::Docked(TGFrame* frame)
341 {
342  Emit("Docked(TGFrame*)", (Long_t)frame);
343 }
344 
345 ////////////////////////////////////////////////////////////////////////////////
346 /// Extract the frame contained in this split frame an reparent it in a
347 /// transient frame. Keep a pointer on the transient frame to be able to
348 /// swallow the child frame back to this.
349 
350 void TGSplitFrame::ExtractFrame()
351 {
352  if (fFrame) {
353  fFrame->UnmapWindow();
354  fUndocked = new TGTransientFrame(gClient->GetDefaultRoot(), GetMainFrame(), 800, 600);
355  fFrame->ReparentWindow(fUndocked);
356  fUndocked->AddFrame(fFrame, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY));
357  // Layout...
358  fUndocked->MapSubwindows();
359  fUndocked->Layout();
360  fUndocked->MapWindow();
361  RemoveFrame(fFrame);
362  fUndocked->Connect("CloseWindow()", "TGSplitFrame", this, "SwallowBack()");
363  Undocked(fFrame);
364  }
365 }
366 
367 ////////////////////////////////////////////////////////////////////////////////
368 /// Handles resize events for this frame.
369 /// This is needed to keep as much as possible the sizes ratio between
370 /// all subframes.
371 
372 Bool_t TGSplitFrame::HandleConfigureNotify(Event_t *)
373 {
374  if (!fFirst) {
375  // case of resizing a frame with the splitter (and not from parent)
376  TGWindow *w = (TGWindow *)GetParent();
377  TGSplitFrame *p = dynamic_cast<TGSplitFrame *>(w);
378  if (p) {
379  if (p->GetFirst()) {
380  // set the correct ratio for this child
381  Float_t hratio = (Float_t)p->GetFirst()->GetHeight() / (Float_t)p->GetHeight();
382  Float_t wratio = (Float_t)p->GetFirst()->GetWidth() / (Float_t)p->GetWidth();
383  p->SetHRatio(hratio);
384  p->SetWRatio(wratio);
385  }
386  }
387  return kTRUE;
388  }
389  // case of resize event comes from the parent (i.e. by rezing TGMainFrame)
390  if ((fHRatio > 0.0) && (fWRatio > 0.0)) {
391  Float_t h = fHRatio * (Float_t)GetHeight();
392  fFirst->SetHeight((UInt_t)h);
393  Float_t w = fWRatio * (Float_t)GetWidth();
394  fFirst->SetWidth((UInt_t)w);
395  }
396  // memorize the actual ratio for next resize event
397  fHRatio = (Float_t)fFirst->GetHeight() / (Float_t)GetHeight();
398  fWRatio = (Float_t)fFirst->GetWidth() / (Float_t)GetWidth();
399  fClient->NeedRedraw(this);
400  if (!gVirtualX->InheritsFrom("TGX11"))
401  Layout();
402  return kTRUE;
403 }
404 
405 ////////////////////////////////////////////////////////////////////////////////
406 /// Horizontally split the frame.
407 
408 void TGSplitFrame::HSplit(UInt_t h)
409 {
410  // return if already split
411  if ((fSplitter != 0) || (fFirst != 0) || (fSecond != 0) || (fFrame != 0))
412  return;
413  UInt_t height = (h > 0) ? h : fHeight/2;
414  // set correct option (vertical frame)
415  ChangeOptions((GetOptions() & ~kHorizontalFrame) | kVerticalFrame);
416  // create first split frame with fixed height - required for the splitter
417  fFirst = new TGSplitFrame(this, fWidth, height, kSunkenFrame | kFixedHeight);
418  // create second split frame
419  fSecond = new TGSplitFrame(this, fWidth, height, kSunkenFrame);
420  // create horizontal splitter
421  fSplitter = new TGHSplitter(this, 4, 4);
422  // set the splitter's frame to the first one
423  fSplitter->SetFrame(fFirst, kTRUE);
424  fSplitter->Connect("ProcessedEvent(Event_t*)", "TGSplitFrame", this,
425  "OnSplitterClicked(Event_t*)");
426  // add all frames
427  TGCompositeFrame::AddFrame(fFirst, new TGLayoutHints(kLHintsExpandX));
428  TGCompositeFrame::AddFrame(fSplitter, new TGLayoutHints(kLHintsLeft |
429  kLHintsTop | kLHintsExpandX));
430  TGCompositeFrame::AddFrame(fSecond, new TGLayoutHints(kLHintsExpandX |
431  kLHintsExpandY));
432 }
433 
434 ////////////////////////////////////////////////////////////////////////////////
435 /// Vertically split the frame.
436 
437 void TGSplitFrame::VSplit(UInt_t w)
438 {
439  // return if already split
440  if ((fSplitter != 0) || (fFirst != 0) || (fSecond != 0) || (fFrame != 0))
441  return;
442  UInt_t width = (w > 0) ? w : fWidth/2;
443  // set correct option (horizontal frame)
444  ChangeOptions((GetOptions() & ~kVerticalFrame) | kHorizontalFrame);
445  // create first split frame with fixed width - required for the splitter
446  fFirst = new TGSplitFrame(this, width, fHeight, kSunkenFrame | kFixedWidth);
447  // create second split frame
448  fSecond = new TGSplitFrame(this, width, fHeight, kSunkenFrame);
449  // create vertical splitter
450  fSplitter = new TGVSplitter(this, 4, 4);
451  // set the splitter's frame to the first one
452  fSplitter->SetFrame(fFirst, kTRUE);
453  fSplitter->Connect("ProcessedEvent(Event_t*)", "TGSplitFrame", this,
454  "OnSplitterClicked(Event_t*)");
455  // add all frames
456  TGCompositeFrame::AddFrame(fFirst, new TGLayoutHints(kLHintsExpandY));
457  TGCompositeFrame::AddFrame(fSplitter, new TGLayoutHints(kLHintsLeft |
458  kLHintsTop | kLHintsExpandY));
459  TGCompositeFrame::AddFrame(fSecond, new TGLayoutHints(kLHintsExpandX |
460  kLHintsExpandY));
461 }
462 
463 ////////////////////////////////////////////////////////////////////////////////
464 /// Map this split frame in the small overview tooltip.
465 
466 void TGSplitFrame::MapToSPlitTool(TGSplitFrame *top)
467 {
468  Int_t px = 0, py = 0;
469  Int_t rx = 0, ry = 0;
470  Int_t cx, cy, cw, ch;
471  Window_t wtarget;
472  if (!fFirst && !fSecond) {
473  TGSplitFrame *parent = dynamic_cast<TGSplitFrame *>((TGFrame *)fParent);
474  if (parent && parent->fSecond == this) {
475  if (parent->GetOptions() & kVerticalFrame)
476  ry = parent->GetFirst()->GetHeight();
477  if (parent->GetOptions() & kHorizontalFrame)
478  rx = parent->GetFirst()->GetWidth();
479  }
480  gVirtualX->TranslateCoordinates(GetId(), top->GetId(),
481  fX, fY, px, py, wtarget);
482  cx = ((px-rx)/10)+2;
483  cy = ((py-ry)/10)+2;
484  cw = (fWidth/10)-4;
485  ch = (fHeight/10)-4;
486  top->GetSplitTool()->AddRectangle(this, cx, cy, cw, ch);
487  return;
488  }
489  if (fFirst)
490  fFirst->MapToSPlitTool(top);
491  if (fSecond)
492  fSecond->MapToSPlitTool(top);
493 }
494 
495 ////////////////////////////////////////////////////////////////////////////////
496 /// Handle mouse click events on the splitter.
497 
498 void TGSplitFrame::OnSplitterClicked(Event_t *event)
499 {
500  Int_t px = 0, py = 0;
501  Window_t wtarget;
502  if (event->fType != kButtonPress)
503  return;
504  if (event->fCode != kButton3)
505  return;
506  gVirtualX->TranslateCoordinates(event->fWindow,
507  gClient->GetDefaultRoot()->GetId(),
508  event->fX, event->fY, px, py, wtarget);
509  TGSplitFrame *top = GetTopFrame();
510  top->GetSplitTool()->Reset();
511  top->GetSplitTool()->Resize(1+top->GetWidth()/10, 1+top->GetHeight()/10);
512  top->MapToSPlitTool(top);
513  top->GetSplitTool()->Show(px, py);
514 }
515 
516 ////////////////////////////////////////////////////////////////////////////////
517 /// Horizontally split the frame, and if it contains a child frame, ask
518 /// the user where to keep it (top or bottom). This is the method used
519 /// via the context menu.
520 
521 void TGSplitFrame::SplitHor()
522 {
523  char side[200];
524  snprintf(side, 200, "top");
525  if (fFrame) {
526  new TGInputDialog(gClient->GetRoot(), GetTopFrame(),
527  "In which side the actual frame has to be kept (top / bottom)",
528  side, side);
529  if ( strcmp(side, "") == 0 ) // Cancel button was pressed
530  return;
531  }
532  SplitHorizontal(side);
533 }
534 
535 ////////////////////////////////////////////////////////////////////////////////
536 /// Horizontally split the frame, and if it contains a child frame, ask
537 /// the user where to keep it (top or bottom). This method is the actual
538 /// implementation.
539 
540 void TGSplitFrame::SplitHorizontal(const char *side)
541 {
542  if (fFrame) {
543  TGFrame *frame = fFrame;
544  frame->UnmapWindow();
545  frame->ReparentWindow(gClient->GetDefaultRoot());
546  RemoveFrame(fFrame);
547  HSplit();
548  if (!strcmp(side, "top")) {
549  frame->ReparentWindow(GetFirst());
550  GetFirst()->AddFrame(frame, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY));
551  }
552  else if (!strcmp(side, "bottom")) {
553  frame->ReparentWindow(GetSecond());
554  GetSecond()->AddFrame(frame, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY));
555  }
556  }
557  else {
558  HSplit();
559  }
560  MapSubwindows();
561  Layout();
562 }
563 
564 ////////////////////////////////////////////////////////////////////////////////
565 /// Vertically split the frame, and if it contains a child frame, ask
566 /// the user where to keep it (left or right). This is the method used
567 /// via the context menu.
568 
569 void TGSplitFrame::SplitVer()
570 {
571  char side[200];
572  snprintf(side, 200, "left");
573  if (fFrame) {
574  new TGInputDialog(gClient->GetRoot(), GetTopFrame(),
575  "In which side the actual frame has to be kept (left / right)",
576  side, side);
577  if ( strcmp(side, "") == 0 ) // Cancel button was pressed
578  return;
579  }
580  SplitVertical(side);
581 }
582 
583 ////////////////////////////////////////////////////////////////////////////////
584 /// Vertically split the frame, and if it contains a child frame, ask
585 /// the user where to keep it (left or right). This method is the actual
586 /// implementation.
587 
588 void TGSplitFrame::SplitVertical(const char *side)
589 {
590  if (fFrame) {
591  TGFrame *frame = fFrame;
592  frame->UnmapWindow();
593  frame->ReparentWindow(gClient->GetDefaultRoot());
594  RemoveFrame(fFrame);
595  VSplit();
596  if (!strcmp(side, "left")) {
597  frame->ReparentWindow(GetFirst());
598  GetFirst()->AddFrame(frame, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY));
599  }
600  else if (!strcmp(side, "right")) {
601  frame->ReparentWindow(GetSecond());
602  GetSecond()->AddFrame(frame, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY));
603  }
604  }
605  else {
606  VSplit();
607  }
608  MapSubwindows();
609  Layout();
610 }
611 
612 ////////////////////////////////////////////////////////////////////////////////
613 /// Swallow back the child frame previously extracted, and close its
614 /// parent (transient frame).
615 
616 void TGSplitFrame::SwallowBack()
617 {
618  if (!fUndocked) {
619  fUndocked = dynamic_cast<TGTransientFrame *>((TQObject*)gTQSender);
620  }
621  if (fUndocked) {
622  TGFrameElement *el = dynamic_cast<TGFrameElement*>(fUndocked->GetList()->First());
623  if (!el || !el->fFrame) return;
624  TGSplitFrame *frame = (TGSplitFrame *)el->fFrame;
625  frame->UnmapWindow();
626  fUndocked->RemoveFrame(frame);
627  frame->ReparentWindow(this);
628  AddFrame(frame, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY));
629  // Layout...
630  MapSubwindows();
631  Layout();
632  fUndocked->CloseWindow();
633  fUndocked = 0;
634  Docked(frame);
635  }
636 }
637 
638 ////////////////////////////////////////////////////////////////////////////////
639 /// Switch (exchange) two frames.
640 /// frame is the source, dest is the destination (the new parent)
641 /// prev is the frame that has to be exchanged with the source
642 /// (the one actually in the destination)
643 
644 void TGSplitFrame::SwitchFrames(TGFrame *frame, TGCompositeFrame *dest,
645  TGFrame *prev)
646 {
647  // get parent of the source (its container)
648  TGCompositeFrame *parent = (TGCompositeFrame *)frame->GetParent();
649 
650  // unmap the window (to avoid flickering)
651  prev->UnmapWindow();
652  // remove it from the destination frame
653  dest->RemoveFrame(prev);
654  // temporary reparent it to root (desktop window)
655  prev->ReparentWindow(gClient->GetDefaultRoot());
656 
657  // now unmap the source window (still to avoid flickering)
658  frame->UnmapWindow();
659  // remove it from its parent (its container)
660  parent->RemoveFrame(frame);
661  // reparent it to the target location
662  frame->ReparentWindow(dest);
663  // add it to its new parent (for layout managment)
664  dest->AddFrame(frame, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY));
665  // Layout...
666  frame->Resize(dest->GetDefaultSize());
667  dest->MapSubwindows();
668  dest->Layout();
669 
670  // now put back the previous one in the previous source parent
671  // reparent to the previous source container
672  prev->ReparentWindow(parent);
673  // add it to the frame (for layout managment)
674  parent->AddFrame(prev, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY));
675  // Layout...
676  prev->Resize(parent->GetDefaultSize());
677  parent->MapSubwindows();
678  parent->Layout();
679 }
680 
681 ////////////////////////////////////////////////////////////////////////////////
682 /// Switch the actual embedded frame to the main (first) split frame.
683 
684 void TGSplitFrame::SwitchToMain()
685 {
686  TGFrame *source = fFrame;
687  TGSplitFrame *dest = GetTopFrame()->GetFirst();
688  TGFrame *prev = (TGFrame *)(dest->GetFrame());
689  if ((source != prev) && (source != dest))
690  SwitchFrames(source, dest, prev);
691 }
692 
693 ////////////////////////////////////////////////////////////////////////////////
694 /// Emit Undocked() signal.
695 
696 void TGSplitFrame::Undocked(TGFrame* frame)
697 {
698  Emit("Undocked(TGFrame*)", (Long_t)frame);
699 }
700 
701 ////////////////////////////////////////////////////////////////////////////////
702 /// Close (unmap and remove from the list of frames) the frame contained in
703 /// this split frame.
704 
705 void TGSplitFrame::UnSplit(const char *which)
706 {
707  TGCompositeFrame *keepframe = 0;
708  TGSplitFrame *kframe = 0, *dframe = 0;
709  if (!strcmp(which, "first")) {
710  dframe = GetFirst();
711  kframe = GetSecond();
712  }
713  else if (!strcmp(which, "second")) {
714  dframe = GetSecond();
715  kframe = GetFirst();
716  }
717  if (!kframe || !dframe)
718  return;
719  keepframe = (TGCompositeFrame *)kframe->GetFrame();
720  if (keepframe) {
721  keepframe->UnmapWindow();
722  keepframe->ReparentWindow(gClient->GetDefaultRoot());
723  kframe->RemoveFrame(keepframe);
724  }
725  Cleanup();
726  if (keepframe) {
727  keepframe->ReparentWindow(this);
728  AddFrame(keepframe, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY));
729  }
730  MapSubwindows();
731  Layout();
732 }
733 
734 ////////////////////////////////////////////////////////////////////////////////
735 /// Save a splittable frame as a C++ statement(s) on output stream out.
736 
737 void TGSplitFrame::SavePrimitive(std::ostream &out, Option_t *option /*= ""*/)
738 {
739  if (fBackground != GetDefaultFrameBackground()) SaveUserColor(out, option);
740 
741  out << std::endl << " // splittable frame" << std::endl;
742  out << " TGSplitFrame *";
743  out << GetName() << " = new TGSplitFrame(" << fParent->GetName()
744  << "," << GetWidth() << "," << GetHeight();
745 
746  if (fBackground == GetDefaultFrameBackground()) {
747  if (!GetOptions()) {
748  out << ");" << std::endl;
749  } else {
750  out << "," << GetOptionString() <<");" << std::endl;
751  }
752  } else {
753  out << "," << GetOptionString() << ",ucolor);" << std::endl;
754  }
755  if (option && strstr(option, "keep_names"))
756  out << " " << GetName() << "->SetName(\"" << GetName() << "\");" << std::endl;
757 
758  // setting layout manager if it differs from the main frame type
759  // coverity[returned_null]
760  // coverity[dereference]
761  TGLayoutManager * lm = GetLayoutManager();
762  if ((GetOptions() & kHorizontalFrame) &&
763  (lm->InheritsFrom(TGHorizontalLayout::Class()))) {
764  ;
765  } else if ((GetOptions() & kVerticalFrame) &&
766  (lm->InheritsFrom(TGVerticalLayout::Class()))) {
767  ;
768  } else {
769  out << " " << GetName() <<"->SetLayoutManager(";
770  lm->SavePrimitive(out, option);
771  out << ");"<< std::endl;
772  }
773 
774  SavePrimitiveSubframes(out, option);
775 }