Logo ROOT   6.30.04
Reference Guide
 All Namespaces Files Pages
TGMdiMainFrame.cxx
Go to the documentation of this file.
1 // @(#)root/gui:$Id$
2 // Author: Bertrand Bellenot 20/08/2004
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2004, 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 /**************************************************************************
13 
14  This file is part of TGMdi an extension to the xclass toolkit.
15  Copyright (C) 1998-2002 by Harald Radke, Hector Peraza.
16 
17  This application is free software; you can redistribute it and/or
18  modify it under the terms of the GNU Library General Public
19  License as published by the Free Software Foundation; either
20  version 2 of the License, or (at your option) any later version.
21 
22  This application is distributed in the hope that it will be useful,
23  but WITHOUT ANY WARRANTY; without even the implied warranty of
24  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
25  Library General Public License for more details.
26 
27  You should have received a copy of the GNU Library General Public
28  License along with this library; if not, write to the Free
29  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
30 
31 **************************************************************************/
32 
33 //////////////////////////////////////////////////////////////////////////
34 // //
35 // TGMdiMainFrame. //
36 // //
37 // This file contains the TGMdiMainFrame class. //
38 // //
39 //////////////////////////////////////////////////////////////////////////
40 
41 #include "KeySymbols.h"
42 #include "TGFrame.h"
43 #include "TGMdiMainFrame.h"
44 #include "TGMdiDecorFrame.h"
45 #include "TGMdiFrame.h"
46 #include "TGMdiMenu.h"
47 #include "TGGC.h"
48 #include "TGResourcePool.h"
49 #include "Riostream.h"
50 #include "TList.h"
51 
52 ClassImp(TGMdiMainFrame);
53 ClassImp(TGMdiContainer);
54 ClassImp(TGMdiGeometry);
55 ClassImp(TGMdiFrameList);
56 
57 ////////////////////////////////////////////////////////////////////////////////
58 /// Create a MDI main frame.
59 
60 TGMdiMainFrame::TGMdiMainFrame(const TGWindow *p, TGMdiMenuBar *menuBar,
61  Int_t w, Int_t h, UInt_t options,
62  Pixel_t back) :
63  TGCanvas(p, w, h, options | kDoubleBorder | kSunkenFrame | kMdiMainFrame, back)
64 {
65  fContainer = new TGMdiContainer(this, 10, 10, kOwnBackground,
66  fClient->GetShadow(GetDefaultFrameBackground()));
67  TGCanvas::SetContainer(fContainer);
68 
69  fNumberOfFrames = 0;
70  fMenuBar = menuBar;
71  fChildren = 0;
72  fCurrent = 0;
73  fArrangementMode = 0;
74 
75  const TGResourcePool *res = GetResourcePool();
76  fBackCurrent = res->GetSelectedBgndColor();
77  fForeCurrent = res->GetSelectedFgndColor();
78  fForeNotCurrent = res->GetFrameBgndColor();
79  fBackNotCurrent = res->GetFrameShadowColor();
80  fFontCurrent = (TGFont *)res->GetMenuFont();
81  fFontNotCurrent = fFontCurrent;
82 
83  fBoxGC = new TGGC(*gClient->GetResourcePool()->GetFrameGC());
84  fBoxGC->SetForeground(fForeNotCurrent);
85  fBoxGC->SetBackground(fBackNotCurrent);
86  fBoxGC->SetFunction(kGXxor);
87  fBoxGC->SetLineWidth(TGMdiDecorFrame::kMdiBorderWidth-3);
88  fBoxGC->SetSubwindowMode(kIncludeInferiors);
89  fBoxGC->SetStipple(fClient->GetResourcePool()->GetCheckeredBitmap());
90  fBoxGC->SetFillStyle(kFillOpaqueStippled);
91 
92  fCurrentX = fCurrentY = 0;
93  fResizeMode = kMdiDefaultResizeMode;
94 
95  fWinListMenu = new TGPopupMenu(fClient->GetDefaultRoot());
96 
97  const TGMainFrame *main = (TGMainFrame *) GetMainFrame();
98  if (main){
99  Int_t keycode = gVirtualX->KeysymToKeycode(kKey_Tab);
100  main->BindKey(this, keycode, kKeyControlMask);
101  main->BindKey(this, keycode, kKeyControlMask | kKeyShiftMask);
102  keycode = gVirtualX->KeysymToKeycode(kKey_F4);
103  main->BindKey(this, keycode, kKeyControlMask);
104  ((TGFrame *)main)->Connect("ProcessedConfigure(Event_t*)",
105  "TGMdiMainFrame", this, "UpdateMdiButtons()");
106  }
107 
108  MapSubwindows();
109  Layout();
110  MapWindow();
111  SetWindowName();
112 }
113 
114 ////////////////////////////////////////////////////////////////////////////////
115 /// MDI main frame destructor.
116 
117 TGMdiMainFrame::~TGMdiMainFrame()
118 {
119  TGMdiFrameList *tmp, *travel = fChildren;
120 
121  while (travel) {
122  tmp = travel->GetNext();
123  delete travel;
124  travel = tmp;
125  }
126 
127  if (fFontCurrent) fClient->FreeFont((TGFont *)fFontCurrent);
128  if (fFontNotCurrent != fFontCurrent) fClient->FreeFont((TGFont *)fFontNotCurrent);
129 
130  delete fBoxGC;
131 
132  if (!MustCleanup()) {
133 
134  const TGMainFrame *main = (TGMainFrame *) GetMainFrame();
135 
136  if (main && main->InheritsFrom("TGMainFrame")) {
137  Int_t keycode = gVirtualX->KeysymToKeycode(kKey_Tab);
138  main->RemoveBind(this, keycode, kKeyControlMask);
139  main->RemoveBind(this, keycode, kKeyControlMask | kKeyShiftMask);
140  keycode = gVirtualX->KeysymToKeycode(kKey_F4);
141  main->RemoveBind(this, keycode, kKeyControlMask);
142  }
143  }
144 }
145 
146 ////////////////////////////////////////////////////////////////////////////////
147 /// Set MDI windows resize mode (opaque or transparent).
148 
149 void TGMdiMainFrame::SetResizeMode(Int_t mode)
150 {
151  TGMdiFrameList *travel;
152 
153  fResizeMode = mode;
154  for (travel = fChildren; travel; travel = travel->GetNext()) {
155  travel->GetDecorFrame()->SetResizeMode(mode);
156  }
157 }
158 
159 ////////////////////////////////////////////////////////////////////////////////
160 /// Handle keyboards events into MDI main frame.
161 
162 Bool_t TGMdiMainFrame::HandleKey(Event_t *event)
163 {
164  char input[10];
165  UInt_t keysym;
166 
167  if (event->fType == kGKeyPress) {
168  gVirtualX->LookupString(event, input, sizeof(input), keysym);
169  if ((EKeySym)keysym == kKey_Tab) {
170  if (event->fState & kKeyControlMask) {
171  if (event->fState & kKeyShiftMask) {
172  CirculateUp();
173  } else {
174  CirculateDown();
175  }
176  return kTRUE;
177  }
178  } else if ((EKeySym)keysym == kKey_F4) {
179  if (event->fState & kKeyControlMask) {
180  Close(GetCurrent());
181  return kTRUE;
182  }
183  }
184  }
185  return kFALSE;
186 }
187 
188 ////////////////////////////////////////////////////////////////////////////////
189 /// Add new MDI child window.
190 
191 void TGMdiMainFrame::AddMdiFrame(TGMdiFrame *frame)
192 {
193  TGMdiFrameList *travel;
194 
195  frame->UnmapWindow();
196 
197  travel = new TGMdiFrameList;
198  travel->SetCyclePrev(travel);
199  travel->SetCycleNext(travel);
200  travel->SetPrev(0);
201  if (fChildren) fChildren->SetPrev(travel);
202  travel->SetNext(fChildren);
203  fChildren = travel;
204 
205  travel->SetDecorFrame(new TGMdiDecorFrame(this, frame, frame->GetWidth(),
206  frame->GetHeight(), fBoxGC));
207 
208  travel->SetFrameId(frame->GetId());
209  travel->GetDecorFrame()->SetResizeMode(fResizeMode);
210 
211  if (fCurrentX + travel->GetDecorFrame()->GetWidth() > fWidth) fCurrentX = 0;
212  if (fCurrentY + travel->GetDecorFrame()->GetHeight() > fHeight) fCurrentY = 0;
213  travel->GetDecorFrame()->Move(fCurrentX, fCurrentY);
214 
215  fCurrentX += travel->GetDecorFrame()->GetTitleBar()->GetHeight() + fBorderWidth * 2;
216  fCurrentY += travel->GetDecorFrame()->GetTitleBar()->GetHeight() + fBorderWidth * 2;
217  travel->GetDecorFrame()->SetMdiButtons(travel->GetDecorFrame()->GetMdiButtons());
218 
219  fNumberOfFrames++;
220 
221  UpdateWinListMenu();
222  SetCurrent(travel);
223  Layout();
224 
225  SendMessage(fParent, MK_MSG(kC_MDI, kMDI_CREATE), travel->GetDecorFrame()->GetId(), 0);
226  FrameCreated(travel->GetDecorFrame()->GetId());
227 }
228 
229 ////////////////////////////////////////////////////////////////////////////////
230 /// Remove MDI child window.
231 
232 Bool_t TGMdiMainFrame::RemoveMdiFrame(TGMdiFrame *frame)
233 {
234  TGMdiFrameList *travel = fChildren;
235 
236  if (!frame) return kFALSE;
237 
238  if (frame->IsEditable()) frame->SetEditable(kFALSE);
239 
240  while (travel && (travel->GetFrameId() != frame->GetId()))
241  travel = travel->GetNext();
242  if (!travel) return kFALSE;
243 
244  if (travel == fCurrent) fCurrent = 0;
245 
246  // unlink the element from the fCycle list
247  travel->GetCyclePrev()->SetCycleNext(travel->GetCycleNext());
248  travel->GetCycleNext()->SetCyclePrev(travel->GetCyclePrev());
249 
250  // and from the main list
251  if (travel->GetNext()) {
252  travel->GetNext()->SetPrev(travel->GetPrev());
253  }
254  if (travel->GetPrev()) {
255  travel->GetPrev()->SetNext(travel->GetNext());
256  } else {
257  fChildren = travel->GetNext();
258  }
259 
260  if (!fCurrent) {
261  if (fChildren) SetCurrent(travel->GetCyclePrev());
262  }
263 
264  travel->GetDecorFrame()->RemoveFrame(frame);
265 
266  UInt_t old_id = frame->GetId();
267 
268  delete travel->fDecor;
269 
270  fNumberOfFrames--;
271 
272  UpdateWinListMenu();
273  Layout();
274 
275  SendMessage(fParent, MK_MSG(kC_MDI, kMDI_CLOSE), old_id, 0);
276  FrameClosed(old_id);
277 
278  return kTRUE;
279 }
280 
281 ////////////////////////////////////////////////////////////////////////////////
282 /// Set current (active) MDI child window (by id).
283 
284 Bool_t TGMdiMainFrame::SetCurrent(UInt_t id)
285 {
286  if (fCurrent && (fCurrent->GetDecorFrame()->GetId() == id)) {
287  fCurrent->GetDecorFrame()->RaiseWindow();
288  if (fCurrent->GetDecorFrame()->IsMaximized() && fMenuBar)
289  fMenuBar->ShowFrames(fCurrent->GetDecorFrame()->GetTitleBar()->GetWinIcon(),
290  fCurrent->GetDecorFrame()->GetTitleBar()->GetButtons());
291 
292  Emit("SetCurrent(TGMdiFrame*)", (long)fCurrent->GetDecorFrame()->GetMdiFrame());
293  return kTRUE;
294  }
295 
296  TGMdiFrameList *travel = fChildren;
297  while (travel && (travel->GetDecorFrame()->GetId() != id)) travel = travel->GetNext();
298  if (!travel) return kFALSE;
299 
300  return SetCurrent(travel);
301 }
302 
303 ////////////////////////////////////////////////////////////////////////////////
304 /// Set current (active) MDI child window (by frame pointer).
305 
306 Bool_t TGMdiMainFrame::SetCurrent(TGMdiFrame *f)
307 {
308  if (fCurrent && (fCurrent->GetDecorFrame()->GetMdiFrame() == f)) {
309  fCurrent->GetDecorFrame()->RaiseWindow();
310  if (fCurrent->GetDecorFrame()->IsMaximized() && fMenuBar)
311  fMenuBar->ShowFrames(fCurrent->GetDecorFrame()->GetTitleBar()->GetWinIcon(),
312  fCurrent->GetDecorFrame()->GetTitleBar()->GetButtons());
313  Emit("SetCurrent(TGMdiFrame*)", (long)fCurrent->GetDecorFrame()->GetMdiFrame());
314  return kTRUE;
315  }
316 
317  TGMdiFrameList *travel = fChildren;
318  while (travel && (travel->GetDecorFrame()->GetMdiFrame() != f)) travel = travel->GetNext();
319  if (!travel) return kFALSE;
320 
321  return SetCurrent(travel);
322 }
323 
324 ////////////////////////////////////////////////////////////////////////////////
325 /// Set current (active) MDI child window (by frame list).
326 
327 Bool_t TGMdiMainFrame::SetCurrent(TGMdiFrameList *newcurrent)
328 {
329  if (fCurrent && (fCurrent == newcurrent)) {
330  fCurrent->GetDecorFrame()->RaiseWindow();
331  if (fCurrent->GetDecorFrame()->IsMaximized() && fMenuBar)
332  fMenuBar->ShowFrames(fCurrent->GetDecorFrame()->GetTitleBar()->GetWinIcon(),
333  fCurrent->GetDecorFrame()->GetTitleBar()->GetButtons());
334  Emit("SetCurrent(TGMdiFrame*)", (long)fCurrent->GetDecorFrame()->GetMdiFrame());
335  return kTRUE;
336  }
337 
338  if (fCurrent) {
339  if (!fCurrent->GetDecorFrame()->IsMaximized())
340  fCurrent->GetDecorFrame()->GetTitleBar()->SetTitleBarColors(fForeNotCurrent,
341  fBackNotCurrent,
342  fFontNotCurrent);
343  }
344 
345  if (newcurrent) {
346  if (fCurrent) {
347  // unlink the element from the old position
348  newcurrent->GetCyclePrev()->SetCycleNext(newcurrent->GetCycleNext());
349  newcurrent->GetCycleNext()->SetCyclePrev(newcurrent->GetCyclePrev());
350  // and link it to the top of the window fCycle stack
351  newcurrent->SetCyclePrev(fCurrent);
352  newcurrent->SetCycleNext(fCurrent->GetCycleNext());
353  fCurrent->SetCycleNext(newcurrent);
354  newcurrent->GetCycleNext()->SetCyclePrev(newcurrent);
355  } else {
356  // no current? well, put it at the head of the list...
357  if (fChildren && newcurrent != fChildren) {
358  // unlink the element from the old position
359  newcurrent->GetCyclePrev()->SetCycleNext(newcurrent->GetCycleNext());
360  newcurrent->GetCycleNext()->SetCyclePrev(newcurrent->GetCyclePrev());
361  // and link it to the beginning of the window list
362  newcurrent->SetCyclePrev(fChildren);
363  newcurrent->SetCycleNext(fChildren->GetCycleNext());
364  fChildren->SetCycleNext(newcurrent);
365  newcurrent->GetCycleNext()->SetCyclePrev(newcurrent);
366  }
367  }
368  }
369 
370  fCurrent = newcurrent;
371 
372  if (!fCurrent) return kFALSE;
373 
374  if (!fCurrent->GetDecorFrame()->IsMaximized())
375  fCurrent->GetDecorFrame()->GetTitleBar()->SetTitleBarColors(fForeCurrent,
376  fBackCurrent,
377  fFontCurrent);
378 
379  fCurrent->GetDecorFrame()->RaiseWindow();
380  Emit("SetCurrent(TGMdiFrame*)", (long)fCurrent->GetDecorFrame()->GetMdiFrame());
381 
382  fWinListMenu->RCheckEntry(fCurrent->GetDecorFrame()->GetId(), 0, kMaxInt);
383 
384  if (fCurrent->GetDecorFrame()->IsMaximized() && fMenuBar)
385  fMenuBar->ShowFrames(fCurrent->GetDecorFrame()->GetTitleBar()->GetWinIcon(),
386  fCurrent->GetDecorFrame()->GetTitleBar()->GetButtons());
387 
388  return kTRUE;
389 }
390 
391 ////////////////////////////////////////////////////////////////////////////////
392 /// Bring the lowest window to the top.
393 
394 void TGMdiMainFrame::CirculateUp()
395 {
396  if (fCurrent) {
397  fCurrent->GetDecorFrame()->GetTitleBar()->SetTitleBarColors(fForeNotCurrent,
398  fBackNotCurrent,
399  fFontNotCurrent);
400 
401  fCurrent = fCurrent->GetCycleNext();
402 
403  fCurrent->GetDecorFrame()->RaiseWindow();
404  fCurrent->GetDecorFrame()->GetTitleBar()->SetTitleBarColors(fForeCurrent,
405  fBackCurrent,
406  fFontCurrent);
407  if (fCurrent->GetDecorFrame()->IsMaximized() && fMenuBar)
408  fMenuBar->ShowFrames(fCurrent->GetDecorFrame()->GetTitleBar()->GetWinIcon(),
409  fCurrent->GetDecorFrame()->GetTitleBar()->GetButtons());
410 
411  } else if (fChildren) {
412  SetCurrent(fChildren);
413  }
414 }
415 
416 ////////////////////////////////////////////////////////////////////////////////
417 /// Send the highest window to the bottom.
418 
419 void TGMdiMainFrame::CirculateDown()
420 {
421  if (fCurrent) {
422  fCurrent->GetDecorFrame()->LowerWindow();
423  fCurrent->GetDecorFrame()->GetTitleBar()->SetTitleBarColors(fForeNotCurrent,
424  fBackNotCurrent,
425  fFontNotCurrent);
426 
427  fCurrent = fCurrent->GetCyclePrev(); // do not call SetCurrent in order
428  // to not to alter the stacking order
429  fCurrent->GetDecorFrame()->RaiseWindow();
430  fCurrent->GetDecorFrame()->GetTitleBar()->SetTitleBarColors(fForeCurrent,
431  fBackCurrent,
432  fFontCurrent);
433  if (fCurrent->GetDecorFrame()->IsMaximized() && fMenuBar)
434  fMenuBar->ShowFrames(fCurrent->GetDecorFrame()->GetTitleBar()->GetWinIcon(),
435  fCurrent->GetDecorFrame()->GetTitleBar()->GetButtons());
436  } else if (fChildren) {
437  SetCurrent(fChildren);
438  }
439 }
440 
441 ////////////////////////////////////////////////////////////////////////////////
442 /// Return decor frame of MDI child window (by frame pointer).
443 
444 TGMdiDecorFrame *TGMdiMainFrame::GetDecorFrame(TGMdiFrame *frame) const
445 {
446  TGMdiFrameList *travel = fChildren;
447  while (travel && (travel->GetDecorFrame()->GetMdiFrame() != frame))
448  travel = travel->GetNext();
449  if (!travel) return 0;
450  return travel->GetDecorFrame();
451 }
452 
453 ////////////////////////////////////////////////////////////////////////////////
454 /// Return decor frame of MDI child window (by id).
455 
456 TGMdiDecorFrame *TGMdiMainFrame::GetDecorFrame(UInt_t id) const
457 {
458  TGMdiFrameList *travel = fChildren;
459  while (travel && (travel->GetDecorFrame()->GetId() != id)) travel = travel->GetNext();
460  if (!travel) return 0;
461  return travel->GetDecorFrame();
462 }
463 
464 ////////////////////////////////////////////////////////////////////////////////
465 /// Return frame of MDI child window (by id).
466 
467 TGMdiFrame *TGMdiMainFrame::GetMdiFrame(UInt_t id) const
468 {
469  TGMdiDecorFrame *frame = GetDecorFrame(id);
470  if (!frame) return 0;
471  return frame->GetMdiFrame();
472 }
473 
474 ////////////////////////////////////////////////////////////////////////////////
475 /// Return resizing box (rectangle) for current MDI child.
476 
477 TGRectangle TGMdiMainFrame::GetBBox() const
478 {
479  if (fCurrent && fCurrent->GetDecorFrame()->IsMaximized()) {
480  return TGRectangle(0, 0, fWidth - 2 * fBorderWidth, fHeight - 2 * fBorderWidth);
481  } else {
482  TGRectangle rect;
483  TGMdiFrameList *travel;
484 
485  for (travel = fChildren; travel; travel = travel->GetNext()) {
486  Int_t x = travel->GetDecorFrame()->GetX();
487  Int_t y = travel->GetDecorFrame()->GetY();
488  UInt_t w = travel->GetDecorFrame()->GetWidth();
489  UInt_t h = travel->GetDecorFrame()->GetHeight();
490  TGRectangle wrect(x, y, w, h);
491  rect.Merge(wrect);
492  }
493  return rect;
494  }
495 }
496 
497 ////////////////////////////////////////////////////////////////////////////////
498 /// Return minimized box (rectangle) for current MDI child.
499 
500 TGRectangle TGMdiMainFrame::GetMinimizedBBox() const
501 {
502  TGRectangle rect;
503  TGMdiFrameList *travel;
504  Int_t first = kTRUE;
505 
506  for (travel = fChildren; travel; travel = travel->GetNext()) {
507  if (travel->GetDecorFrame()->IsMinimized()) {
508  TGRectangle wrect(travel->GetDecorFrame()->GetX(), travel->GetDecorFrame()->GetY(),
509  travel->GetDecorFrame()->GetWidth(), travel->GetDecorFrame()->GetHeight());
510  if (first) rect = wrect;
511  else rect.Merge(wrect);
512  first = kFALSE;
513  }
514  }
515  return rect;
516 }
517 
518 ////////////////////////////////////////////////////////////////////////////////
519 /// Update MDI menu entries with current list of MDI child windows.
520 
521 void TGMdiMainFrame::UpdateWinListMenu()
522 {
523  TString buf;
524  char scut;
525  TGMdiFrameList *travel;
526  const TGPicture *pic;
527 
528  TGMenuEntry *e;
529  TIter fNext(fWinListMenu->GetListOfEntries());
530  while ((e = (TGMenuEntry*)fNext())) {
531  fWinListMenu->DeleteEntry(e);
532  }
533  scut = '0';
534 
535  if (!fChildren) {
536  fWinListMenu->AddEntry(new TGHotString("(None)"), 1000);
537  fWinListMenu->DisableEntry(1000);
538  return;
539  }
540 
541  for (travel = fChildren; travel; travel = travel->GetNext()) {
542  scut++;
543  if (scut == ('9' + 1)) scut = 'A';
544  buf = TString::Format("&%c. %s", scut, travel->GetDecorFrame()->GetWindowName());
545  if (travel->GetDecorFrame()->GetMdiButtons() & kMdiMenu)
546  pic = travel->GetDecorFrame()->GetWindowIcon();
547  else
548  pic = 0;
549  fWinListMenu->AddEntry(new TGHotString(buf.Data()), travel->GetDecorFrame()->GetId(), 0, pic);
550  }
551 
552  if (fCurrent)
553  fWinListMenu->RCheckEntry(fCurrent->GetDecorFrame()->GetId(), 0, kMaxInt);
554 }
555 
556 ////////////////////////////////////////////////////////////////////////////////
557 /// Recalculates the postion and the size of all MDI child windows.
558 
559 void TGMdiMainFrame::Layout()
560 {
561  TGCanvas::Layout();
562  if (fCurrent && fCurrent->GetDecorFrame()->IsMaximized())
563  fCurrent->GetDecorFrame()->MoveResize(0, 0, fWidth - 2 *fBorderWidth, fHeight -
564  2 * fBorderWidth);
565 }
566 
567 ////////////////////////////////////////////////////////////////////////////////
568 /// Update the status of MDI buttons in the decor frame of all children.
569 
570 void TGMdiMainFrame::UpdateMdiButtons()
571 {
572  static Bool_t done = kFALSE;
573  TGMdiFrameList *travel;
574  if (done) return;
575  for (travel = fChildren; travel; travel = travel->GetNext()) {
576  if (!travel->GetDecorFrame()->IsMaximized() &&
577  !travel->GetDecorFrame()->IsMinimized()) {
578  travel->GetDecorFrame()->SetMdiButtons(travel->GetDecorFrame()->GetMdiButtons());
579  }
580  }
581  done = kTRUE;
582 }
583 
584 ////////////////////////////////////////////////////////////////////////////////
585 /// Automatic repositionning and resizing of every MDI child window.
586 /// depending on mode : tile horizontal, tile vertical, or cascade.
587 
588 void TGMdiMainFrame::ArrangeFrames(Int_t mode)
589 {
590  Int_t factor_x = 0;
591  Int_t factor_y = 0;
592  Int_t num_mapped = 0;
593  Int_t x = 0;
594  Int_t y = 0;
595  Int_t w = fWidth - 2 * fBorderWidth; //GetContainer()->GetWidth();
596  Int_t h = fHeight - 2 * fBorderWidth; //GetContainer()->GetHeight();
597 
598  fArrangementMode = mode;
599 
600  TGMdiFrameList *tmp, *travel;
601 
602  for (travel = fChildren; travel; travel = travel->GetNext()) {
603  if (travel->GetDecorFrame()->IsMaximized())
604  Restore(travel->GetDecorFrame()->GetMdiFrame());
605  if (!travel->GetDecorFrame()->IsMinimized())
606  ++num_mapped;
607  }
608 
609  // must also restore view to 0,0
610  GetViewPort()->SetHPos(0);
611  GetViewPort()->SetVPos(0);
612 
613  ArrangeMinimized();
614 
615  travel = fChildren;
616 
617  if (num_mapped == 0) return;
618 
619  TGRectangle irect = GetMinimizedBBox();
620  h -= irect.fH;
621 
622  switch (mode) {
623  case kMdiTileHorizontal:
624  factor_y = h / num_mapped;
625  for (travel = fChildren; travel; travel = travel->GetNext()) {
626  if (!travel->GetDecorFrame()->IsMinimized()) {
627  travel->GetDecorFrame()->MoveResize(x, y, w, factor_y);
628  y = y + factor_y;
629  }
630  }
631  break;
632 
633  case kMdiTileVertical:
634  factor_x = w / num_mapped;
635  for (travel = fChildren; travel; travel = travel->GetNext()) {
636  if (!travel->GetDecorFrame()->IsMinimized()) {
637  travel->GetDecorFrame()->MoveResize(x, y, factor_x, h);
638  x = x + factor_x;
639  }
640  }
641  break;
642 
643  case kMdiCascade:
644  y = travel->GetDecorFrame()->GetTitleBar()->GetX() +
645  travel->GetDecorFrame()->GetTitleBar()->GetHeight();
646  x = y;
647  factor_y = (h * 2) / 3;
648  factor_x = (w * 2) / 3;
649 
650  travel = fCurrent;
651  if (!travel) travel = fChildren;
652  tmp = travel;
653  if (travel) {
654  do {
655  travel = travel->GetCycleNext();
656  if (!travel->GetDecorFrame()->IsMinimized()) {
657  travel->GetDecorFrame()->MoveResize(x - y, x - y, factor_x, factor_y);
658  x += y;
659  }
660  } while (travel != tmp);
661  }
662  break;
663  }
664 
665  FramesArranged(mode);
666 
667  Layout();
668 }
669 
670 ////////////////////////////////////////////////////////////////////////////////
671 /// This is an attempt to an "smart" minimized window re-arrangement.
672 
673 void TGMdiMainFrame::ArrangeMinimized()
674 {
675  TGMdiFrameList *travel, *closest;
676  Int_t x, y, w, h;
677 
678  Bool_t arranged = kTRUE;
679 
680  for (travel = fChildren; travel && arranged; travel = travel->GetNext())
681  if (travel->GetDecorFrame()->IsMinimized()) arranged = kFALSE;
682 
683  // return if there is nothing to do
684 
685  if (arranged || !fChildren) return;
686 
687  h = fChildren->GetDecorFrame()->GetTitleBar()->GetDefaultHeight() +
688  fChildren->GetDecorFrame()->GetBorderWidth();
689  w = kMinimizedWidth * h + fChildren->GetDecorFrame()->GetBorderWidth();
690 
691  x = 0;
692  y = GetViewPort()->GetHeight() - h;
693 
694  // we'll use the _minimizedUserPlacement variable as a "not arranged" flag
695 
696  for (travel = fChildren; travel; travel = travel->GetNext())
697  travel->GetDecorFrame()->SetMinUserPlacement();
698 
699  do {
700  closest = 0;
701  Int_t cdist = 0;
702  for (travel = fChildren; travel; travel = travel->GetNext()) {
703  if (travel->GetDecorFrame()->IsMinimized()) {
704  if (travel->GetDecorFrame()->GetMinUserPlacement()) {
705  Int_t dx = travel->GetDecorFrame()->GetX() - x;
706  Int_t dy = y - travel->GetDecorFrame()->GetY();
707  Int_t dist = dx * dx + dy * dy;
708  if (!closest || (dist < cdist)) {
709  closest = travel;
710  cdist = dist;
711  }
712  }
713  }
714  }
715 
716  if (closest) {
717  closest->GetDecorFrame()->SetMinimizedX(x);
718  closest->GetDecorFrame()->SetMinimizedY(y);
719  closest->GetDecorFrame()->MoveResize(x, y, w, h);
720  closest->GetDecorFrame()->SetMinUserPlacement(kFALSE);
721 
722  x += w;
723  if (x + w > (Int_t)GetViewPort()->GetWidth()) {
724  x = 0;
725  y -= h;
726  }
727  }
728 
729  } while (closest);
730 
731  // reset the fMinimizedUserPlacement settings for all windows
732 
733  for (travel = fChildren; travel; travel = travel->GetNext())
734  travel->GetDecorFrame()->SetMinUserPlacement(kFALSE);
735 }
736 
737 ////////////////////////////////////////////////////////////////////////////////
738 /// Process messages MDI main frame.
739 
740 Bool_t TGMdiMainFrame::ProcessMessage(Long_t msg, Long_t parm1, Long_t parm2)
741 {
742  switch (GET_MSG(msg)) {
743  case kC_MDI:
744  SetCurrent(parm1);
745  switch (GET_SUBMSG(msg)) {
746 
747  case kMDI_MINIMIZE:
748  Minimize(GetCurrent());
749  break;
750 
751  case kMDI_MAXIMIZE:
752  Maximize(GetCurrent());
753  break;
754 
755  case kMDI_RESTORE:
756  Restore(GetCurrent());
757  break;
758 
759  case kMDI_CLOSE:
760  Close(GetCurrent());
761  break;
762 
763  case kMDI_MOVE:
764  FreeMove(GetCurrent());
765  break;
766 
767  case kMDI_SIZE:
768  FreeSize(GetCurrent());
769  break;
770 
771  case kMDI_HELP:
772  ContextHelp(GetCurrent());
773  break;
774  }
775  break;
776 
777  default:
778  return TGCanvas::ProcessMessage(msg, parm1, parm2);
779  }
780 
781  return kTRUE;
782 }
783 
784 ////////////////////////////////////////////////////////////////////////////////
785 /// Maximize MDI child window mdiframe.
786 
787 void TGMdiMainFrame::Maximize(TGMdiFrame *mdiframe)
788 {
789  TGMdiDecorFrame *frame = GetDecorFrame(mdiframe);
790 
791  if (!frame) return;
792 
793  if (frame->IsMaximized()) return;
794 
795  if (frame->IsMinimized()) Restore(mdiframe);
796 
797  frame->SetDecorBorderWidth(0);
798  frame->SetPreResizeX(frame->GetX());
799  frame->SetPreResizeY(frame->GetY());
800  frame->SetPreResizeWidth(frame->GetWidth());
801  frame->SetPreResizeHeight(frame->GetHeight());
802  frame->GetUpperHR()->UnmapWindow();
803  frame->GetLowerHR()->UnmapWindow();
804  frame->GetLeftVR()->UnmapWindow();
805  frame->GetRightVR()->UnmapWindow();
806  frame->GetUpperLeftCR()->UnmapWindow();
807  frame->GetUpperRightCR()->UnmapWindow();
808  frame->GetLowerLeftCR()->UnmapWindow();
809  frame->GetLowerRightCR()->UnmapWindow();
810 
811  frame->MoveResize(fBorderWidth, fBorderWidth, fWidth - 2 *fBorderWidth,
812  fHeight - 2 * fBorderWidth);
813  frame->Maximize();
814  frame->GetTitleBar()->LayoutButtons(frame->GetMdiButtons(), frame->IsMinimized(),
815  frame->IsMaximized());
816  frame->GetTitleBar()->RemoveFrames(frame->GetTitleBar()->GetWinIcon(),
817  frame->GetTitleBar()->GetButtons());
818  frame->HideFrame(frame->GetTitleBar());
819 
820  if (fMenuBar) {
821  frame->GetTitleBar()->GetWinIcon()->SetBackgroundColor(GetDefaultFrameBackground());
822  frame->GetTitleBar()->GetButtons()->SetBackgroundColor(GetDefaultFrameBackground());
823  fMenuBar->AddFrames(frame->GetTitleBar()->GetWinIcon(),
824  frame->GetTitleBar()->GetButtons());
825  fMenuBar->Layout();
826  }
827 
828  SendMessage(fParent, MK_MSG(kC_MDI, kMDI_MAXIMIZE), frame->GetId(), 0);
829  FrameMaximized(frame->GetId());
830 
831  Layout();
832 }
833 
834 ////////////////////////////////////////////////////////////////////////////////
835 /// Restore size of MDI child window mdiframe.
836 
837 void TGMdiMainFrame::Restore(TGMdiFrame *mdiframe)
838 {
839  TGMdiDecorFrame *frame = GetDecorFrame(mdiframe);
840 
841  if (!frame) return;
842 
843  if (frame->IsMinimized() == kFALSE && frame->IsMaximized() == kFALSE) return;
844 
845  if (frame->IsMinimized()) {
846  frame->SetMinimizedX(frame->GetX());
847  frame->SetMinimizedY(frame->GetY());
848  frame->Minimize(kFALSE);
849  frame->GetTitleBar()->SetTitleBarColors(fForeCurrent,
850  fBackCurrent,
851  fFontCurrent);
852  } else if (frame->IsMaximized()) {
853  frame->SetDecorBorderWidth(TGMdiDecorFrame::kMdiBorderWidth);
854  frame->MapSubwindows();
855 
856  if (fMenuBar) {
857  fMenuBar->RemoveFrames(frame->GetTitleBar()->GetWinIcon(),
858  frame->GetTitleBar()->GetButtons());
859  fMenuBar->Layout();
860  }
861 
862  frame->GetTitleBar()->AddFrames(frame->GetTitleBar()->GetWinIcon(),
863  frame->GetTitleBar()->GetButtons());
864  frame->GetTitleBar()->SetTitleBarColors(fForeCurrent, fBackCurrent,
865  fFontCurrent);
866  frame->ShowFrame(frame->GetTitleBar());
867  }
868  frame->Minimize(kFALSE);
869  frame->Maximize(kFALSE);
870  frame->GetTitleBar()->LayoutButtons(frame->GetMdiButtons(), kFALSE, kFALSE);
871  frame->MoveResize(frame->GetPreResizeX(), frame->GetPreResizeY(),
872  frame->GetPreResizeWidth(), frame->GetPreResizeHeight());
873  SetCurrent(mdiframe);
874  SendMessage(fParent, MK_MSG(kC_MDI, kMDI_RESTORE), frame->GetId(), 0);
875  FrameRestored(frame->GetId());
876 
877  Layout();
878 }
879 
880 ////////////////////////////////////////////////////////////////////////////////
881 /// Minimize MDI child window mdiframe.
882 
883 void TGMdiMainFrame::Minimize(TGMdiFrame *mdiframe)
884 {
885  Int_t x, y, w, h;
886  TGMdiDecorFrame *frame = GetDecorFrame(mdiframe);
887 
888  if (!frame) return;
889 
890  if (frame->IsMinimized()) return;
891 
892  if (frame->IsMaximized()) Restore(mdiframe);
893 
894  frame->SetPreResizeX(frame->GetX());
895  frame->SetPreResizeY(frame->GetY());
896  frame->SetPreResizeWidth(frame->GetWidth());
897  frame->SetPreResizeHeight(frame->GetHeight());
898 
899  h = frame->GetTitleBar()->GetDefaultHeight() + frame->GetBorderWidth();
900  w = kMinimizedWidth * h + frame->GetBorderWidth();
901 
902  if (!frame->GetMinUserPlacement()) {
903 
904  x = 0;
905  y = GetViewPort()->GetHeight() - h;
906 
907  while (1) {
908  TGMdiFrameList *travel;
909  Bool_t taken = kFALSE;
910 
911  // find an empty spot...
912  for (travel = fChildren; travel; travel = travel->GetNext()) {
913  if (travel->GetDecorFrame()->IsMinimized()) {
914  TGPosition p(travel->GetDecorFrame()->GetX(),
915  travel->GetDecorFrame()->GetY());
916  TGDimension s(travel->GetDecorFrame()->GetWidth(),
917  travel->GetDecorFrame()->GetHeight());
918  if ((x <= p.fX + (Int_t) s.fWidth - 1) && (x + w - 1 >= p.fX) &&
919  (y <= p.fY + (Int_t) s.fHeight - 1) && (y + h - 1 >= p.fY)) {
920  taken = kTRUE;
921  break;
922  }
923  }
924  }
925  if (!taken) break;
926 
927  x += w;
928  if (x + w > (Int_t)GetViewPort()->GetWidth()) {
929  x = 0;
930  y -= h;
931  }
932  }
933 
934  frame->SetMinimizedX(x);
935  frame->SetMinimizedY(y);
936  }
937 
938  frame->Minimize();
939 
940  frame->MoveResize(frame->GetMinimizedX(), frame->GetMinimizedY(), w, h);
941  frame->LowerWindow();
942  frame->GetTitleBar()->LayoutButtons(frame->GetMdiButtons(),
943  frame->IsMinimized(),
944  frame->IsMaximized());
945  frame->Layout();
946 
947  SendMessage(fParent, MK_MSG(kC_MDI, kMDI_MINIMIZE), frame->GetId(), 0);
948  FrameMinimized(frame->GetId());
949 
950  Layout();
951 }
952 
953 ////////////////////////////////////////////////////////////////////////////////
954 /// Close MDI child window mdiframe.
955 
956 Int_t TGMdiMainFrame::Close(TGMdiFrame *mdiframe)
957 {
958  if (!mdiframe) return kFALSE;
959 
960  TGMdiDecorFrame *frame = GetDecorFrame(mdiframe);
961  Restore(mdiframe);
962  mdiframe->Emit("CloseWindow()");
963  if (frame && mdiframe->TestBit(kNotDeleted) && !mdiframe->TestBit(TGMdiFrame::kDontCallClose))
964  return frame->CloseWindow();
965  return kTRUE;
966 }
967 
968 ////////////////////////////////////////////////////////////////////////////////
969 /// Allow to move MDI child window mdiframe.
970 
971 void TGMdiMainFrame::FreeMove(TGMdiFrame *mdiframe)
972 {
973  TGMdiDecorFrame *frame = GetDecorFrame(mdiframe);
974  if (!frame) return;
975 
976  Int_t x = frame->GetTitleBar()->GetWidth() / 2;
977  Int_t y = frame->GetTitleBar()->GetHeight() - 1;
978 
979  gVirtualX->Warp(x, y, frame->GetTitleBar()->GetId());
980 
981  frame->GetTitleBar()->SetLeftButPressed();
982  frame->GetTitleBar()->SetX0(x);
983  frame->GetTitleBar()->SetY0(y);
984  Cursor_t cursor = gVirtualX->CreateCursor(kMove);
985  gVirtualX->SetCursor(frame->GetTitleBar()->GetId(), cursor);
986 
987  gVirtualX->GrabPointer(frame->GetTitleBar()->GetId(),
988  kButtonReleaseMask | kPointerMotionMask,
989  kNone, cursor, kTRUE, kFALSE);
990 }
991 
992 ////////////////////////////////////////////////////////////////////////////////
993 /// Allow to resize MDI child window mdiframe.
994 
995 void TGMdiMainFrame::FreeSize(TGMdiFrame *mdiframe)
996 {
997  TGMdiDecorFrame *frame = GetDecorFrame(mdiframe);
998  if (!frame) return;
999 
1000  Int_t x = frame->GetLowerRightCR()->GetWidth() - 5;
1001  Int_t y = frame->GetLowerRightCR()->GetHeight() - 5;
1002 
1003  Int_t xroot, yroot;
1004  Window_t win;
1005 
1006  gVirtualX->TranslateCoordinates(frame->GetLowerRightCR()->GetId(),
1007  fClient->GetDefaultRoot()->GetId(), x, y, xroot, yroot, win);
1008 
1009  gVirtualX->Warp(x, y, frame->GetLowerRightCR()->GetId());
1010 
1011  Event_t event;
1012 
1013  event.fType = kButtonPress;
1014  event.fWindow = frame->GetLowerRightCR()->GetId();
1015  event.fCode = kButton1;
1016  event.fX = x;
1017  event.fY = y;
1018  event.fXRoot = xroot;
1019  event.fYRoot = yroot;
1020 
1021  Cursor_t cursor = gVirtualX->CreateCursor(kBottomRight);
1022  gVirtualX->SetCursor(frame->GetLowerRightCR()->GetId(), cursor);
1023 
1024  gVirtualX->GrabPointer(frame->GetLowerRightCR()->GetId(),
1025  kButtonReleaseMask | kPointerMotionMask,
1026  kNone, cursor, kTRUE, kFALSE);
1027 
1028  frame->GetLowerRightCR()->HandleButton(&event);
1029 }
1030 
1031 ////////////////////////////////////////////////////////////////////////////////
1032 /// Calls Help() method of MDI child window mdiframe.
1033 
1034 Int_t TGMdiMainFrame::ContextHelp(TGMdiFrame *mdiframe)
1035 {
1036  if (mdiframe)
1037  return mdiframe->Help();
1038  else
1039  return kFALSE;
1040 }
1041 
1042 ////////////////////////////////////////////////////////////////////////////////
1043 /// Return pointer on current (active) MDI child window.
1044 
1045 TGMdiFrame *TGMdiMainFrame::GetCurrent() const
1046 {
1047  if (fCurrent)
1048  return fCurrent->GetDecorFrame()->GetMdiFrame();
1049  else
1050  return 0;
1051 }
1052 
1053 ////////////////////////////////////////////////////////////////////////////////
1054 /// Get MDI geometry of MDI child window f.
1055 
1056 TGMdiGeometry TGMdiMainFrame::GetWindowGeometry(TGMdiFrame *f) const
1057 {
1058  TGMdiGeometry geom;
1059 
1060  geom.fValueMask = 0;
1061 
1062  const TGMdiDecorFrame *frame = GetDecorFrame(f);
1063  if (frame) {
1064  Int_t th = frame->GetTitleBar()->GetDefaultHeight();
1065  Int_t bw = frame->GetBorderWidth();
1066 
1067  if (frame->IsMinimized() || frame->IsMaximized()) {
1068  geom.fDecoration = TGRectangle(frame->GetPreResizeX(),
1069  frame->GetPreResizeY(),
1070  (unsigned) frame->GetPreResizeWidth(),
1071  (unsigned) frame->GetPreResizeHeight());
1072  } else {
1073  geom.fDecoration = TGRectangle(frame->GetX(),
1074  frame->GetY(),
1075  (unsigned) frame->GetWidth(),
1076  (unsigned) frame->GetHeight());
1077  }
1078  geom.fValueMask |= kMdiDecorGeometry;
1079 
1080  geom.fClient = TGRectangle(geom.fDecoration.fX + bw,
1081  geom.fDecoration.fY + bw + th,
1082  (unsigned) (geom.fDecoration.fW - 2 * bw),
1083  (unsigned) (geom.fDecoration.fH - 2 * bw - th));
1084  geom.fValueMask |= kMdiClientGeometry;
1085 
1086  if (frame->GetMinUserPlacement()) {
1087  Int_t mh = th + 2 * bw;
1088  Int_t mw = kMinimizedWidth * mh;
1089 
1090  geom.fIcon = TGRectangle(frame->GetMinimizedX(),
1091  frame->GetMinimizedY(),
1092  (unsigned) mw,
1093  (unsigned) mh);
1094  geom.fValueMask |= kMdiIconGeometry;
1095  }
1096 
1097  }
1098 
1099  return geom;
1100 }
1101 
1102 ////////////////////////////////////////////////////////////////////////////////
1103 /// Set MDI geometry for MDI child window f.
1104 
1105 void TGMdiMainFrame::ConfigureWindow(TGMdiFrame *f, TGMdiGeometry &geom)
1106 {
1107  TGMdiDecorFrame *frame = GetDecorFrame(f);
1108  if (frame) {
1109  if (geom.fValueMask & kMdiDecorGeometry) {
1110  if (frame->IsMinimized() || frame->IsMaximized()) {
1111  frame->SetPreResizeX(geom.fDecoration.fX);
1112  frame->SetPreResizeY(geom.fDecoration.fY);
1113  frame->SetPreResizeWidth(geom.fDecoration.fW);
1114  frame->SetPreResizeHeight(geom.fDecoration.fH);
1115  } else {
1116  frame->MoveResize(geom.fDecoration.fX, geom.fDecoration.fY,
1117  geom.fDecoration.fW, geom.fDecoration.fH);
1118  }
1119  } else if (geom.fValueMask & kMdiClientGeometry) {
1120 
1121  }
1122  if (geom.fValueMask & kMdiIconGeometry) {
1123  frame->SetMinimizedX(geom.fIcon.fX);
1124  frame->SetMinimizedY(geom.fIcon.fY);
1125  frame->SetMinUserPlacement();
1126  if (frame->IsMinimized())
1127  frame->Move(frame->GetMinimizedX(), frame->GetMinimizedY());
1128  }
1129  Layout();
1130  }
1131 }
1132 
1133 ////////////////////////////////////////////////////////////////////////////////
1134 /// Close all MDI child windows.
1135 
1136 void TGMdiMainFrame::CloseAll()
1137 {
1138  TGMdiFrameList *tmp, *travel = fChildren;
1139 
1140  while (travel) {
1141  tmp = travel->GetNext();
1142  SetCurrent(travel);
1143  Close(GetCurrent());
1144  travel = tmp;
1145  }
1146 }
1147 
1148 ////////////////////////////////////////////////////////////////////////////////
1149 /// Check if MDI child window f is maximized;
1150 
1151 Bool_t TGMdiMainFrame::IsMaximized(TGMdiFrame *f)
1152 {
1153  TGMdiDecorFrame *frame = GetDecorFrame(f);
1154  if (frame) return frame->IsMaximized();
1155  return kFALSE;
1156 }
1157 
1158 ////////////////////////////////////////////////////////////////////////////////
1159 /// Check if MDI child window f is minimized;
1160 
1161 Bool_t TGMdiMainFrame::IsMinimized(TGMdiFrame *f)
1162 {
1163  TGMdiDecorFrame *frame = GetDecorFrame(f);
1164  if (frame) return frame->IsMinimized();
1165  return kFALSE;
1166 }
1167 
1168 ////////////////////////////////////////////////////////////////////////////////
1169 /// TGMdiContainer constructor.
1170 
1171 TGMdiContainer::TGMdiContainer(const TGMdiMainFrame *p, Int_t w, Int_t h,
1172  UInt_t options, ULong_t back) :
1173  TGFrame(p->GetViewPort(), w, h, options, back)
1174 {
1175  fMain = p;
1176  AddInput(kStructureNotifyMask);
1177 }
1178 
1179 ////////////////////////////////////////////////////////////////////////////////
1180 /// Return dimension of MDI container.
1181 
1182 TGDimension TGMdiContainer::GetDefaultSize() const
1183 {
1184  TGRectangle rect = fMain->GetBBox();
1185 
1186  Int_t xpos = -fMain->GetViewPort()->GetHPos() - rect.LeftTop().fX;
1187  Int_t ypos = -fMain->GetViewPort()->GetVPos() - rect.LeftTop().fY;
1188 
1189  return TGDimension(TMath::Max(Int_t(xpos + fWidth), rect.RightBottom().fX + 1),
1190  TMath::Max(Int_t(ypos + fHeight), rect.RightBottom().fY + 1));
1191 }
1192 
1193 ////////////////////////////////////////////////////////////////////////////////
1194 /// Handle configure notify events for MDI container.
1195 
1196 Bool_t TGMdiContainer::HandleConfigureNotify(Event_t *event)
1197 {
1198  if (event->fWindow != fId) {
1199  TGRectangle rect = fMain->GetBBox();
1200 
1201  Int_t vw = fMain->GetViewPort()->GetWidth();
1202  Int_t vh = fMain->GetViewPort()->GetHeight();
1203 
1204  Int_t w = TMath::Max(vw, rect.RightBottom().fX + 1);
1205  Int_t h = TMath::Max(vh, rect.RightBottom().fY + 1);
1206 
1207  if ((w != (Int_t)fWidth) || (h != (Int_t)fHeight)) {
1208  ((TGMdiMainFrame*)fMain)->Layout();
1209  return kTRUE;
1210  }
1211  }
1212  return kFALSE;
1213 }
1214 
1215 ////////////////////////////////////////////////////////////////////////////////
1216 /// Save a MDI main frame as a C++ statement(s) on output stream out
1217 
1218 void TGMdiMainFrame::SavePrimitive(std::ostream &out, Option_t *option /*= ""*/)
1219 {
1220  if (fBackground != GetDefaultFrameBackground()) SaveUserColor(out, option);
1221 
1222  out << std::endl << " // MDI main frame" << std::endl;
1223  out << " TGMdiMainFrame *";
1224  out << GetName() << " = new TGMdiMainFrame(" << fParent->GetName()
1225  << "," << GetMenu()->GetName() << "," << GetWidth() << "," << GetHeight();
1226 
1227  if (fBackground == GetDefaultFrameBackground()) {
1228  if (!GetOptions()) {
1229  out << ");" << std::endl;
1230  } else {
1231  out << "," << GetOptionString() <<");" << std::endl;
1232  }
1233  } else {
1234  out << "," << GetOptionString() << ",ucolor);" << std::endl;
1235  }
1236  if (option && strstr(option, "keep_names"))
1237  out << " " << GetName() << "->SetName(\"" << GetName() << "\");" << std::endl;
1238 
1239  TGMdiFrameList *travel=fChildren;
1240  travel->SetCycleNext(travel);
1241  for (travel = fChildren; travel; travel = travel->GetNext()) {
1242  TGMdiFrame *mf = travel->GetDecorFrame()->GetMdiFrame();
1243  if (mf) mf->SavePrimitive(out, option);
1244  }
1245  if (fArrangementMode) {
1246  out << " " << GetName() << "->ArrangeFrames(";
1247  switch (fArrangementMode) {
1248 
1249  case kMdiTileHorizontal:
1250  out << "kMdiTileHorizontal);" << std::endl;
1251  break;
1252 
1253  case kMdiTileVertical:
1254  out << "kMdiTileVertical);" << std::endl;
1255  break;
1256 
1257  case kMdiCascade:
1258  out << "kMdiCascade);" << std::endl;
1259  break;
1260  }
1261  }
1262  if (fResizeMode != kMdiOpaque)
1263  out << " " << GetName() << "->SetResizeMode(kMdiNonOpaque);" << std::endl;
1264 
1265  if (fCurrent)
1266  out << " " << GetName() << "->SetCurrent(" << GetCurrent()->GetName()
1267  << ");" << std::endl;
1268 }
1269 
1270