Logo ROOT   6.30.04
Reference Guide
 All Namespaces Files Pages
TGMdiDecorFrame.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 // TGMdiDecorFrame, TGMdiTitleBar, TGMdiButtons, TGMdiTitleIcon, //
36 // TGMdiWinResizer, TGMdiVerticalWinResizer, TGMdiHorizontalWinResizer, //
37 // and TGMdiCornerWinResizer. //
38 // //
39 // This file contains all different MDI frame decoration classes. //
40 // //
41 //////////////////////////////////////////////////////////////////////////
42 
43 #include <stdio.h>
44 #include <stdlib.h>
45 
46 #include "TROOT.h"
47 #include "KeySymbols.h"
48 #include "TGResourcePool.h"
49 #include "TGDimension.h"
50 #include "WidgetMessageTypes.h"
51 #include "TGMdiFrame.h"
52 #include "TGMdiDecorFrame.h"
53 #include "TGMdiMainFrame.h"
54 
55 ClassImp(TGMdiDecorFrame);
56 ClassImp(TGMdiTitleBar);
57 ClassImp(TGMdiButtons);
58 ClassImp(TGMdiTitleIcon);
59 ClassImp(TGMdiWinResizer);
60 ClassImp(TGMdiVerticalWinResizer);
61 ClassImp(TGMdiHorizontalWinResizer);
62 ClassImp(TGMdiCornerWinResizer);
63 
64 ////////////////////////////////////////////////////////////////////////////////
65 /// TGMdiDecorFrame constructor.
66 /// The TGMdiDecorFrame is the frame containing MDI decorations like
67 /// title bar, minimize, maximize, restore and close buttons, and resizers.
68 
69 TGMdiDecorFrame::TGMdiDecorFrame(TGMdiMainFrame *main, TGMdiFrame *frame,
70  Int_t w, Int_t h, const TGGC *boxGC,
71  UInt_t options, Pixel_t back) :
72  TGCompositeFrame(main->GetContainer(), w, h,
73  options | kOwnBackground | kVerticalFrame | kFixedSize, back)
74 {
75 
76  fMdiMainFrame = main;
77  fEditDisabled = 1;
78  fFrame = frame;
79  fIsMinimized = fIsMaximized = kFALSE;
80  fMinimizedX = fMinimizedY = 0;
81  fMinimizedUserPlacement = kFALSE;
82  fButtonMask = kMdiDefaultHints;
83  SetCleanup(kDeepCleanup);
84 
85  SetDecorBorderWidth(kMdiBorderWidth);
86 
87  fTitlebar = new TGMdiTitleBar(this, fMdiMainFrame);
88 
89  fLHint = new TGLayoutHints(kLHintsExpandX);
90  fExpandHint = new TGLayoutHints(kLHintsExpandX | kLHintsExpandY);
91 
92  AddFrame(fTitlebar, fLHint);
93  fTitlebar->LayoutButtons(fButtonMask, kFALSE, kFALSE);
94 
95  fUpperHR = new TGMdiVerticalWinResizer(this, main, kMdiResizerTop,
96  boxGC, kMdiBorderWidth);
97  fLowerHR = new TGMdiVerticalWinResizer(this, main, kMdiResizerBottom,
98  boxGC, kMdiBorderWidth);
99  fLeftVR = new TGMdiHorizontalWinResizer(this, main, kMdiResizerLeft,
100  boxGC, kMdiBorderWidth);
101  fRightVR = new TGMdiHorizontalWinResizer(this, main, kMdiResizerRight,
102  boxGC, kMdiBorderWidth);
103 
104  fUpperLeftCR = new TGMdiCornerWinResizer(this, main,
105  kMdiResizerTop | kMdiResizerLeft,
106  boxGC, kMdiBorderWidth);
107  fLowerLeftCR = new TGMdiCornerWinResizer(this, main,
108  kMdiResizerBottom | kMdiResizerLeft,
109  boxGC, kMdiBorderWidth);
110  fUpperRightCR = new TGMdiCornerWinResizer(this, main,
111  kMdiResizerTop | kMdiResizerRight,
112  boxGC, kMdiBorderWidth);
113  fLowerRightCR = new TGMdiCornerWinResizer(this, main,
114  kMdiResizerBottom | kMdiResizerRight,
115  boxGC, kMdiBorderWidth);
116 
117  fUpperHR->SetMinSize(50, fTitlebar->GetDefaultHeight() + 2 * fBorderWidth);
118  fLowerHR->SetMinSize(50, fTitlebar->GetDefaultHeight() + 2 * fBorderWidth);
119  fLeftVR->SetMinSize(50, fTitlebar->GetDefaultHeight() + 2 * fBorderWidth);
120  fRightVR->SetMinSize(50, fTitlebar->GetDefaultHeight() + 2 * fBorderWidth);
121  fUpperLeftCR->SetMinSize(50, fTitlebar->GetDefaultHeight() + 2 * fBorderWidth);
122  fLowerLeftCR->SetMinSize(50, fTitlebar->GetDefaultHeight() + 2 * fBorderWidth);
123  fUpperRightCR->SetMinSize(50, fTitlebar->GetDefaultHeight() + 2 * fBorderWidth);
124  fLowerRightCR->SetMinSize(50, fTitlebar->GetDefaultHeight() + 2 * fBorderWidth);
125 
126  AddInput(kStructureNotifyMask | kButtonPressMask);
127 
128  fFrame->ReparentWindow(this, fBorderWidth, fTitlebar->GetDefaultHeight());
129  fFrame->fParent = this;
130  AddFrame(fFrame, fExpandHint);
131 
132  MapSubwindows();
133  Resize(GetDefaultSize());
134  Layout();
135 
136  MapWindow();
137  TGFrame::SetWindowName();
138 
139  fFrame->RaiseWindow();
140  fTitlebar->RaiseWindow();
141 }
142 
143 ////////////////////////////////////////////////////////////////////////////////
144 /// TGMdiDecorFrame destructor.
145 
146 TGMdiDecorFrame::~TGMdiDecorFrame()
147 {
148  if (!MustCleanup()) {
149  delete fUpperHR;
150  delete fLowerHR;
151  delete fLeftVR;
152  delete fRightVR;
153  delete fUpperLeftCR;
154  delete fLowerLeftCR;
155  delete fUpperRightCR;
156  delete fLowerRightCR;
157  }
158  DestroyWindow();
159 }
160 
161 ////////////////////////////////////////////////////////////////////////////////
162 /// Set border width of the decor.
163 
164 void TGMdiDecorFrame::SetDecorBorderWidth(Int_t bw)
165 {
166  fBorderWidth = bw;
167 }
168 
169 ////////////////////////////////////////////////////////////////////////////////
170 /// Set-up MDI buttons.
171 
172 void TGMdiDecorFrame::SetMdiButtons(ULong_t buttons)
173 {
174  fButtonMask = buttons;
175  fTitlebar->LayoutButtons(fButtonMask, fIsMinimized, fIsMaximized);
176  if (fButtonMask & kMdiSize) {
177  fUpperHR->Activate(kTRUE);
178  fLowerHR->Activate(kTRUE);
179  fLeftVR->Activate(kTRUE);
180  fRightVR->Activate(kTRUE);
181  fUpperLeftCR->Activate(kTRUE);
182  fLowerLeftCR->Activate(kTRUE);
183  fUpperRightCR->Activate(kTRUE);
184  fLowerRightCR->Activate(kTRUE);
185  } else {
186  fUpperHR->Activate(kFALSE);
187  fLowerHR->Activate(kFALSE);
188  fLeftVR->Activate(kFALSE);
189  fRightVR->Activate(kFALSE);
190  fUpperLeftCR->Activate(kFALSE);
191  fLowerLeftCR->Activate(kFALSE);
192  fUpperRightCR->Activate(kFALSE);
193  fLowerRightCR->Activate(kFALSE);
194  }
195 }
196 
197 ////////////////////////////////////////////////////////////////////////////////
198 /// Set resize mode (opaque or transparent)
199 
200 void TGMdiDecorFrame::SetResizeMode(Int_t mode)
201 {
202  fUpperHR->SetResizeMode(mode);
203  fLowerHR->SetResizeMode(mode);
204  fLeftVR->SetResizeMode(mode);
205  fRightVR->SetResizeMode(mode);
206  fUpperLeftCR->SetResizeMode(mode);
207  fLowerLeftCR->SetResizeMode(mode);
208  fUpperRightCR->SetResizeMode(mode);
209  fLowerRightCR->SetResizeMode(mode);
210 }
211 
212 ////////////////////////////////////////////////////////////////////////////////
213 /// Recalculates the postion and the size of all decor frame components.
214 
215 void TGMdiDecorFrame::Layout()
216 {
217  RemoveInput(kStructureNotifyMask);
218  TGCompositeFrame::Layout();
219  AddInput(kStructureNotifyMask);
220 
221  if (fIsMaximized == kFALSE) {
222  fUpperLeftCR->Move(0, 0);
223  fUpperRightCR->Move(fWidth - fUpperRightCR->GetWidth(), 0);
224  fLowerLeftCR->Move(0, fHeight - fLowerLeftCR->GetHeight());
225  fLowerRightCR->Move(fWidth - fLowerRightCR->GetWidth(),
226  fHeight - fLowerRightCR->GetHeight());
227 
228  fLeftVR->MoveResize(0, fUpperLeftCR->GetHeight(), fLeftVR->GetWidth(),
229  fHeight - fUpperLeftCR->GetHeight() -
230  fLowerLeftCR->GetHeight());
231  fUpperHR->MoveResize(fUpperLeftCR->GetWidth(), 0,
232  fWidth - fUpperRightCR->GetWidth() -
233  fUpperLeftCR->GetWidth(), fUpperHR->GetHeight());
234  fRightVR->MoveResize(fWidth - fRightVR->GetWidth(),
235  fUpperRightCR->GetHeight(), fRightVR->GetWidth(),
236  fHeight - fUpperLeftCR->GetHeight() -
237  fLowerLeftCR->GetHeight());
238  fLowerHR->MoveResize(fLowerLeftCR->GetWidth(), fHeight -
239  fLowerHR->GetHeight(),
240  fWidth - fLowerRightCR->GetWidth() -
241  fLowerLeftCR->GetWidth(), fLowerHR->GetHeight());
242  }
243 }
244 
245 ////////////////////////////////////////////////////////////////////////////////
246 /// Set MDI Window name (appearing in the title bar)
247 
248 void TGMdiDecorFrame::SetWindowName(const char *name)
249 {
250  fTitlebar->GetWinName()->SetText(new TGString(name));
251  fTitlebar->Layout();
252 }
253 
254 ////////////////////////////////////////////////////////////////////////////////
255 /// Set Window icon (appearing in the title bar)
256 
257 void TGMdiDecorFrame::SetWindowIcon(const TGPicture *icon)
258 {
259  fTitlebar->GetWinIcon()->SetPicture(icon);
260  fClient->NeedRedraw(fTitlebar->GetWinIcon());
261 }
262 
263 ////////////////////////////////////////////////////////////////////////////////
264 /// Move the MDI window at position x, y.
265 
266 void TGMdiDecorFrame::Move(Int_t x, Int_t y)
267 {
268  if (x < 0) {
269  fMdiMainFrame->SetHsbPosition(fMdiMainFrame->GetViewPort()->GetWidth());
270  }
271  if (y < 0) {
272  fMdiMainFrame->SetVsbPosition(fMdiMainFrame->GetViewPort()->GetHeight());
273  }
274  TGCompositeFrame::Move(x, y);
275  if (IsMinimized()) fMinimizedUserPlacement = kTRUE;
276  if (IsMapped() && !IsMaximized()) fMdiMainFrame->Layout();
277 }
278 
279 ////////////////////////////////////////////////////////////////////////////////
280 /// Move the MDI window at position x, y and set size to w, h.
281 
282 void TGMdiDecorFrame::MoveResize(Int_t x, Int_t y, UInt_t w, UInt_t h)
283 {
284  if (x < 0) {
285  fMdiMainFrame->SetHsbPosition(fMdiMainFrame->GetViewPort()->GetWidth());
286  }
287  if (y < 0) {
288  fMdiMainFrame->SetVsbPosition(fMdiMainFrame->GetViewPort()->GetHeight());
289  }
290  TGCompositeFrame::MoveResize(x, y, w, h);
291  if (IsMinimized()) fMinimizedUserPlacement = kTRUE;
292  if (IsMapped() && !IsMaximized()) fMdiMainFrame->Layout();
293 }
294 
295 ////////////////////////////////////////////////////////////////////////////////
296 /// Handle configure notify event.
297 
298 Bool_t TGMdiDecorFrame::HandleConfigureNotify(Event_t *event)
299 {
300  if ((event->fX < 0) || (event->fY < 0) ||
301  (event->fX + event->fWidth > fMdiMainFrame->GetViewPort()->GetWidth()) ||
302  (event->fY + event->fHeight > fMdiMainFrame->GetViewPort()->GetHeight())) {
303  fMdiMainFrame->Resize();
304  }
305 
306  if (event->fWindow == fFrame->GetId()) {
307  UInt_t newW = event->fWidth + 2 * fBorderWidth;
308  UInt_t newH = event->fHeight + 2 * fBorderWidth +
309  fTitlebar->GetDefaultHeight();
310 
311  if ((fWidth != newW) || (fHeight != newH)) {
312  Resize(newW, newH);
313  }
314  fMdiMainFrame->Layout();
315  return kTRUE;
316  }
317  fMdiMainFrame->Layout();
318  return kFALSE;
319 }
320 
321 ////////////////////////////////////////////////////////////////////////////////
322 /// Handle mouse button events.
323 
324 Bool_t TGMdiDecorFrame::HandleButton(Event_t *event)
325 {
326  if (event->fType == kButtonPress) {
327  void *ud;
328  fTitlebar->GetWinIcon()->GetPopup()->EndMenu(ud);
329  SendMessage(fMdiMainFrame, MK_MSG(kC_MDI, kMDI_CURRENT), fId, 0);
330  }
331  return kTRUE;
332 }
333 
334 
335 ////////////////////////////////////////////////////////////////////////////////
336 /// TGMdiTitleBar constructor.
337 /// the TGMdiTitleBar is the frame containing a title (window name)
338 /// an icon and MDI picture buttons as minimize, maximize, restore,
339 /// close and help.
340 
341 TGMdiTitleBar::TGMdiTitleBar(const TGWindow *p, const TGWindow *mdiwin,
342  const char *name) :
343  TGCompositeFrame(p, 10, 10, kOwnBackground | kHorizontalFrame)
344 {
345  fMdiWin = mdiwin;
346  fEditDisabled = kTRUE;
347  fWinName = 0;
348  fMidButPressed = fLeftButPressed = fRightButPressed = kFALSE;
349 
350  AddInput(kButtonPressMask | kButtonReleaseMask | kButtonMotionMask);
351 
352  fLHint = new TGLayoutHints(kLHintsNormal);
353  fLeftHint = new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 3, 1, 1, 1);
354  //fMiddleHint = new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 1, 1, 1, 1);
355  fMiddleHint = new TGLayoutHints(kLHintsLeft | kLHintsCenterY | kLHintsExpandX, 1, 1, 1, 1);
356  fRightHint = new TGLayoutHints(kLHintsRight | kLHintsCenterY, 1, 2, 1, 1);
357 
358  fLFrame = new TGCompositeFrame(this, 10, 10, kHorizontalFrame);
359  fMFrame = new TGCompositeFrame(this, 10, 10, kHorizontalFrame);
360  fRFrame = new TGCompositeFrame(this, 10, 10, kHorizontalFrame);
361  AddFrame(fLFrame, fLeftHint);
362  AddFrame(fMFrame, fMiddleHint);
363  AddFrame(fRFrame, fRightHint);
364 
365  fWinIcon = new TGMdiTitleIcon(fLFrame, this,
366  fClient->GetPicture("mdi_default.xpm"),
367  16, 16);
368  fLFrame->AddFrame(fWinIcon, fLHint);
369 
370  fWinName = new TGLabel(fMFrame, new TGString(name));
371  fWinName->SetTextJustify(kTextLeft);
372  fMFrame->AddFrame(fWinName, fLHint);
373 
374  fButtons = new TGMdiButtons(fRFrame, this);
375  fRFrame->AddFrame(fButtons, fLHint);
376 
377  MapWindow();
378  MapSubwindows();
379  Layout();
380  SetWindowName();
381 }
382 
383 ////////////////////////////////////////////////////////////////////////////////
384 /// TGMdiTitleBar destructor.
385 
386 TGMdiTitleBar::~TGMdiTitleBar()
387 {
388  if (!MustCleanup()) {
389  delete fLHint;
390  delete fLeftHint;
391  delete fMiddleHint;
392  delete fRightHint;
393  }
394 }
395 
396 ////////////////////////////////////////////////////////////////////////////////
397 /// Recalculates the position of every enabled (displayed) buttons.
398 
399 void TGMdiTitleBar::LayoutButtons(UInt_t buttonmask,Bool_t isMinimized,
400  Bool_t isMaximized)
401 {
402  fWinIcon->GetPopup()->EnableEntry(kMdiMove);
403 
404  if (buttonmask & kMdiSize) {
405  fWinIcon->GetPopup()->EnableEntry(kMdiSize);
406  } else {
407  fWinIcon->GetPopup()->DisableEntry(kMdiSize);
408  }
409 
410  if (buttonmask & kMdiMenu) {
411  fLFrame->ShowFrame(fWinIcon);
412  } else {
413  fLFrame->HideFrame(fWinIcon);
414  }
415 
416  if (buttonmask & kMdiClose) {
417  fButtons->ShowFrame(fButtons->GetButton(4));
418  fWinIcon->GetPopup()->EnableEntry(kMdiClose);
419  } else {
420  fButtons->HideFrame(fButtons->GetButton(4));
421  fWinIcon->GetPopup()->DisableEntry(kMdiClose);
422  }
423 
424  if (buttonmask & kMdiHelp) {
425  fButtons->ShowFrame(fButtons->GetButton(3));
426  } else {
427  fButtons->HideFrame(fButtons->GetButton(3));
428  }
429 
430  if ((buttonmask & kMdiMaximize) && (!isMaximized)) {
431  fButtons->ShowFrame(fButtons->GetButton(2));
432  fWinIcon->GetPopup()->EnableEntry(kMdiMaximize);
433  } else {
434  fButtons->HideFrame(fButtons->GetButton(2));
435  fWinIcon->GetPopup()->DisableEntry(kMdiMaximize);
436  }
437 
438  if (isMinimized | isMaximized) {
439  fButtons->ShowFrame(fButtons->GetButton(1));
440  fWinIcon->GetPopup()->EnableEntry(kMdiRestore);
441  fWinIcon->GetPopup()->DisableEntry(kMdiSize);
442  if (isMaximized) fWinIcon->GetPopup()->DisableEntry(kMdiMove);
443  } else {
444  fButtons->HideFrame(fButtons->GetButton(1));
445  fWinIcon->GetPopup()->DisableEntry(kMdiRestore);
446  }
447 
448  if ((buttonmask & kMdiMinimize) && (!isMinimized)) {
449  fButtons->ShowFrame(fButtons->GetButton(0));
450  fWinIcon->GetPopup()->EnableEntry(kMdiMinimize);
451  } else {
452  fButtons->HideFrame(fButtons->GetButton(0));
453  fWinIcon->GetPopup()->DisableEntry(kMdiMinimize);
454  }
455 
456  Layout();
457 }
458 
459 ////////////////////////////////////////////////////////////////////////////////
460 /// Set title bar color (blue or grey, depends on active state).
461 
462 void TGMdiTitleBar::SetTitleBarColors(UInt_t fore, UInt_t back, TGFont *font)
463 {
464  SetBackgroundColor(back);
465 
466  fClient->GetFont(font->GetName());
467  fWinName->SetTextFont(font);
468  fWinName->SetTextColor(fore, kFALSE);
469  fMFrame->SetBackgroundColor(back);
470  fWinName->SetBackgroundColor(back);
471  fWinIcon->SetBackgroundColor(back);
472  fButtons->SetBackgroundColor(back);
473  Layout();
474  fClient->NeedRedraw(this);
475  fClient->NeedRedraw(fWinName);
476  fClient->NeedRedraw(fMFrame);
477  fClient->NeedRedraw(fButtons);
478  fClient->NeedRedraw(fWinIcon);
479  fWinIcon->DoRedraw();
480 }
481 
482 ////////////////////////////////////////////////////////////////////////////////
483 /// Handle double click in title bar (maximize window)
484 
485 Bool_t TGMdiTitleBar::HandleDoubleClick(Event_t *event)
486 {
487  if ((event->fType == kButtonPress) && (event->fCode == kButton1)) {
488  SendMessage(fMdiWin, MK_MSG(kC_MDI, kMDI_MAXIMIZE), fParent->GetId(), 0);
489  }
490  return kTRUE;
491 }
492 
493 ////////////////////////////////////////////////////////////////////////////////
494 /// Handle mouse click on title bar.
495 
496 Bool_t TGMdiTitleBar::HandleButton(Event_t *event)
497 {
498  if (event->fType == kButtonPress) {
499  void *ud;
500  GetWinIcon()->GetPopup()->EndMenu(ud);
501  gVirtualX->SetCursor(fId, gVirtualX->CreateCursor(kMove));
502  switch (event->fCode) {
503  case kButton1:
504  fX0 = event->fX;
505  fY0 = event->fY;
506  fLeftButPressed = kTRUE;
507  SendMessage(fMdiWin, MK_MSG(kC_MDI, kMDI_CURRENT), fParent->GetId(), 0);
508  break;
509 
510  case kButton2:
511  fMidButPressed = kTRUE;
512  break;
513 
514  case kButton3:
515  gVirtualX->LowerWindow(fParent->GetId());
516  fRightButPressed = kTRUE;
517  break;
518  }
519  } else {
520  gVirtualX->GrabPointer(0, 0, 0, 0, kFALSE);
521  gVirtualX->SetCursor(fId, gVirtualX->CreateCursor(kPointer));
522  switch (event->fCode) {
523 
524  case kButton1:
525  //if (!fClient->IsEditable()) ((TGMainFrame *)((TGMdiMainFrame *)fMdiWin)->GetMainFrame())->Layout();
526  fLeftButPressed = kFALSE;
527  break;
528 
529  case kButton2:
530  fMidButPressed = kFALSE;
531  break;
532 
533  case kButton3:
534  fRightButPressed = kFALSE;
535  break;
536  }
537 
538  TGFrame *f = GetFrameFromPoint(event->fX, event->fY);
539  if (f && (f != this)) {
540  TranslateCoordinates(f, event->fX, event->fY, event->fX, event->fY);
541  f->HandleButton(event);
542  }
543  }
544  return kTRUE;
545 }
546 
547 ////////////////////////////////////////////////////////////////////////////////
548 /// Process messages for title bar.
549 
550 Bool_t TGMdiTitleBar::ProcessMessage(Long_t msg, Long_t parm1, Long_t parm2)
551 {
552  switch (GET_MSG(msg)) {
553  case kC_COMMAND:
554  switch (GET_SUBMSG(msg)) {
555  case kCM_BUTTON:
556  case kCM_MENU:
557  SendMessage(fMdiWin, MK_MSG(kC_MDI, (EWidgetMessageTypes)parm1),
558  fParent->GetId(), parm2);
559  break;
560  }
561  break;
562  }
563  return kTRUE;
564 }
565 
566 ////////////////////////////////////////////////////////////////////////////////
567 /// Handle mouse motion events in title bar (used to move MDI window).
568 
569 Bool_t TGMdiTitleBar::HandleMotion(Event_t *event)
570 {
571  if (event->fWindow != fId) return kTRUE;
572  if (!fLeftButPressed) return kTRUE;
573 
574  Int_t x = ((TGFrame *)fParent)->GetX();
575  Int_t y = ((TGFrame *)fParent)->GetY();
576  ((TGFrame *)fParent)->Move(x + event->fX - fX0, y + event->fY - fY0);
577 
578  return kTRUE;
579 }
580 
581 
582 ////////////////////////////////////////////////////////////////////////////////
583 /// This is called from TGMdiMainFrame on Restore().
584 
585 void TGMdiTitleBar::AddFrames(TGMdiTitleIcon *icon, TGMdiButtons *buttons)
586 {
587  icon->ReparentWindow(fLFrame);
588  buttons->ReparentWindow(fRFrame);
589  fLFrame->AddFrame(icon, fLHint);
590  fLFrame->ShowFrame(icon);
591  fRFrame->AddFrame(buttons, fLHint);
592  fRFrame->ShowFrame(buttons);
593 }
594 
595 
596 ////////////////////////////////////////////////////////////////////////////////
597 /// This is called from TGMdiMainFrame on Maximize().
598 
599 void TGMdiTitleBar::RemoveFrames(TGMdiTitleIcon *icon, TGMdiButtons *buttons)
600 {
601  fLFrame->RemoveFrame(icon);
602  fRFrame->RemoveFrame(buttons);
603 }
604 
605 
606 ////////////////////////////////////////////////////////////////////////////////
607 /// TGMdiButtons constructor.
608 /// the TGMdiButtons is the frame containing MDI picture buttons like
609 /// minimize, maximize, restore, close and help.
610 
611 TGMdiButtons::TGMdiButtons(const TGWindow *p, const TGWindow *titlebar) :
612  TGCompositeFrame(p, 10, 10, kHorizontalFrame)
613 {
614  fDefaultHint = new TGLayoutHints(kLHintsNormal, 0, 0, 1, 0);
615  fCloseHint = new TGLayoutHints(kLHintsNormal, 2, 0, 1, 0);
616  fEditDisabled = kTRUE;
617  fMsgWindow = 0;
618 
619  //--- Minimize button
620 
621  fButton[0] = new TGPictureButton(this,
622  fClient->GetPicture("mdi_minimize.xpm"),
623  kMdiMinimize);
624  fButton[0]->SetToolTipText("Minimize");
625  AddFrame(fButton[0], fDefaultHint);
626  fButton[0]->SetBackgroundColor(GetDefaultFrameBackground());
627  fButton[0]->Associate(titlebar);
628 
629  //--- Restore button
630 
631  fButton[1] = new TGPictureButton(this,
632  fClient->GetPicture("mdi_restore.xpm"),
633  kMdiRestore);
634  fButton[1]->SetToolTipText("Restore");
635  AddFrame(fButton[1], fDefaultHint);
636  fButton[1]->SetBackgroundColor(GetDefaultFrameBackground());
637  fButton[1]->Associate(titlebar);
638 
639  //--- Maximize button
640 
641  fButton[2] = new TGPictureButton(this,
642  fClient->GetPicture("mdi_maximize.xpm"),
643  kMdiMaximize);
644  fButton[2]->SetToolTipText("Maximize");
645  AddFrame(fButton[2], fDefaultHint);
646  fButton[2]->SetBackgroundColor(GetDefaultFrameBackground());
647  fButton[2]->Associate(titlebar);
648 
649  //--- Help button
650 
651  fButton[3] = new TGPictureButton(this,
652  fClient->GetPicture("mdi_help.xpm"),
653  kMdiHelp);
654  fButton[3]->SetToolTipText("Help");
655  AddFrame(fButton[3], fDefaultHint);
656  fButton[3]->SetBackgroundColor(GetDefaultFrameBackground());
657  fButton[3]->Associate(titlebar);
658 
659  //--- Close button
660 
661  fButton[4] = new TGPictureButton(this,
662  fClient->GetPicture("mdi_close.xpm"),
663  kMdiClose);
664  fButton[4]->SetToolTipText("Close");
665  AddFrame(fButton[4], fCloseHint);
666  fButton[4]->SetBackgroundColor(GetDefaultFrameBackground());
667  fButton[4]->Associate(titlebar);
668  SetWindowName();
669 }
670 
671 ////////////////////////////////////////////////////////////////////////////////
672 /// TGMdiButtons destructor.
673 
674 TGMdiButtons::~TGMdiButtons()
675 {
676  if (!MustCleanup()) {
677  delete fDefaultHint;
678  delete fCloseHint;
679  }
680 }
681 
682 ////////////////////////////////////////////////////////////////////////////////
683 /// TGMdiTitleIcon constructor.
684 /// the TGMdiTitleIcon is the left icon used also for the MDI
685 /// popup menu allowing access to MDI commands as : restore,
686 /// move, size, minimize and close.
687 
688 TGMdiTitleIcon::TGMdiTitleIcon(const TGWindow *p, const TGWindow *titlebar,
689  const TGPicture *pic, Int_t w, Int_t h) :
690  TGIcon(p, pic, w, h)
691 {
692  fMsgWindow = titlebar;
693  fEditDisabled = kTRUE;
694 
695  //--- MDI system menu
696 
697  fPopup = new TGPopupMenu(fClient->GetDefaultRoot());// fClient->GetRoot());
698  fPopup->AddEntry(new TGHotString("&Restore"), kMdiRestore);
699  fPopup->AddEntry(new TGHotString("&Move"), kMdiMove);
700  fPopup->AddEntry(new TGHotString("&Size"), kMdiSize);
701  fPopup->AddEntry(new TGHotString("Mi&nimize"), kMdiMinimize);
702  fPopup->AddEntry(new TGHotString("Ma&ximize"), kMdiMaximize);
703  fPopup->AddSeparator();
704  fPopup->AddEntry(new TGHotString("&Close Ctrl+F4"), kMdiClose);
705  fPopup->DisableEntry(kMdiRestore);
706  fPopup->Associate(titlebar);
707 
708  AddInput(kButtonPressMask | kButtonReleaseMask);
709  SetWindowName();
710 }
711 
712 ////////////////////////////////////////////////////////////////////////////////
713 /// TGMdiTitleIcon destructor.
714 
715 TGMdiTitleIcon::~TGMdiTitleIcon()
716 {
717  delete fPopup;
718 }
719 
720 ////////////////////////////////////////////////////////////////////////////////
721 /// Redraw icon.
722 
723 void TGMdiTitleIcon::DoRedraw()
724 {
725  gVirtualX->ClearArea(fId, 0, 0, fWidth, fHeight);
726  TGIcon::DoRedraw();
727 }
728 
729 ////////////////////////////////////////////////////////////////////////////////
730 /// Handle double click event on MDI icon (close the window)
731 
732 Bool_t TGMdiTitleIcon::HandleDoubleClick(Event_t *event)
733 {
734  if (event->fCode == kButton1) {
735  void *ud;
736  fPopup->EndMenu(ud);
737  gVirtualX->GrabPointer(0, 0, 0, 0, kFALSE);
738  SendMessage(fMsgWindow, MK_MSG(kC_COMMAND, kCM_MENU), kMDI_CLOSE, 0);
739  }
740  return kTRUE;
741 }
742 
743 ////////////////////////////////////////////////////////////////////////////////
744 /// Handle button event on MDI icon (popup menu)
745 
746 Bool_t TGMdiTitleIcon::HandleButton(Event_t *event)
747 {
748  SendMessage(fMsgWindow, MK_MSG(kC_COMMAND, kCM_MENU), kMDI_CURRENT, 0);
749 
750  if (event->fType == kButtonPress) {
751  fPopup->PlaceMenu(event->fXRoot - event->fX,
752  event->fYRoot + (fHeight - event->fY),
753  kTRUE, kTRUE);
754  }
755  return kTRUE;
756 }
757 
758 
759 ////////////////////////////////////////////////////////////////////////////////
760 /// TGMdiWinResizer constructor.
761 /// The TGMdiWinResizer is a frame allowing to resize MDI window.
762 /// Could be horizontal, vertical or corner resizer (see derived classes
763 /// TGMdiVerticalWinResizer, TGMdiHorizontalWinResizer, and
764 /// TGMdiCornerWinResizer).
765 
766 TGMdiWinResizer::TGMdiWinResizer(const TGWindow *p, const TGWindow *mdiwin,
767  Int_t pos, const TGGC *boxgc, Int_t linew,
768  Int_t mdioptions, Int_t w, Int_t h, UInt_t options) :
769  TGFrame(p, w, h, options)
770 {
771  fWinX = fWinY = fWinW = fWinH = fOldX = fOldY = fOldW = fOldH = 0;
772  fNewX = fNewY = fNewW = fNewH = fX0 = fY0 = 0;
773 
774  fWidgetFlags = kWidgetIsEnabled;
775 
776  fMdiWin = mdiwin;
777  fMdiOptions = mdioptions;
778  fPos = pos;
779 
780  fBoxGC = boxgc;
781  fLineW = linew;
782 
783  fMinW = 50;
784  fMinH = 20;
785 
786  fMidButPressed = fLeftButPressed = fRightButPressed = kFALSE;
787 
788  gVirtualX->GrabButton(fId, kButton1, kAnyModifier,
789  kButtonPressMask | kButtonReleaseMask | kButtonMotionMask,
790  kNone, kNone);
791  SetWindowName();
792 }
793 
794 ////////////////////////////////////////////////////////////////////////////////
795 /// Handle button events in resizer (grab button and resize).
796 
797 Bool_t TGMdiWinResizer::HandleButton(Event_t *event)
798 {
799  if (!IsEnabled()) return kTRUE;
800 
801  if (event->fType == kButtonPress) {
802  void *ud;
803  ((TGMdiDecorFrame *)fParent)->GetTitleBar()->GetWinIcon()->GetPopup()->EndMenu(ud);
804  switch (event->fCode) {
805  case kButton1:
806  SendMessage(fMdiWin, MK_MSG(kC_MDI, kMDI_CURRENT), fParent->GetId(), 0);
807  fNewX = fOldX = fWinX = ((TGFrame *)fParent)->GetX();
808  fNewY = fOldY = fWinY = ((TGFrame *)fParent)->GetY();
809  fWinW = ((TGFrame *)fParent)->GetWidth();
810  fWinH = ((TGFrame *)fParent)->GetHeight();
811  fX0 = event->fXRoot;
812  fY0 = event->fYRoot;
813  fNewW = fWinW;
814  fNewH = fWinH;
815  if (fMdiOptions != kMdiOpaque) {
816  DrawBox(fNewX, fNewY, fNewW, fNewH);
817  }
818  fLeftButPressed = kTRUE;
819  gVirtualX->GrabPointer(fId, kButtonReleaseMask | kPointerMotionMask,
820  kNone, kNone, kTRUE, kFALSE);
821  break;
822 
823  case kButton2:
824  fMidButPressed = kTRUE;
825  break;
826 
827  case kButton3:
828  fRightButPressed = kTRUE;
829  break;
830  }
831  } else {
832  gVirtualX->GrabPointer(0, 0, 0, 0, kFALSE);
833  switch (event->fCode) {
834  case kButton1:
835  if (fMdiOptions != kMdiOpaque) {
836  DrawBox(fNewX, fNewY, fNewW, fNewH);
837  ((TGFrame *)fParent)->MoveResize(fNewX, fNewY, fNewW, fNewH);
838  }
839  //if (!fClient->IsEditable()) ((TGMainFrame *)((TGMdiMainFrame *)fMdiWin)->GetMainFrame())->Layout();
840  fLeftButPressed = kFALSE;
841  break;
842 
843  case kButton2:
844  fMidButPressed = kFALSE;
845  break;
846 
847  case kButton3:
848  fRightButPressed = kFALSE;
849  break;
850  }
851  }
852  return kTRUE;
853 }
854 
855 ////////////////////////////////////////////////////////////////////////////////
856 /// Draw resize box (rectangle).
857 
858 void TGMdiWinResizer::DrawBox(Int_t x, Int_t y, UInt_t width, UInt_t height)
859 {
860  TGMdiMainFrame *m = (TGMdiMainFrame *) fMdiWin;
861 
862  gVirtualX->DrawRectangle(m->GetContainer()->GetId(), fBoxGC->GetGC(),
863  x + fLineW / 2, y + fLineW / 2, width - fLineW, height - fLineW);
864 }
865 
866 ////////////////////////////////////////////////////////////////////////////////
867 /// Move (resize) parent MDI window.
868 
869 void TGMdiWinResizer::MoveResizeIt()
870 {
871  if (fMdiOptions == kMdiOpaque) {
872  ((TGFrame *)fParent)->MoveResize(fNewX, fNewY, fNewW, fNewH);
873  } else {
874  DrawBox(fOldX, fOldY, fOldW, fOldH);
875  DrawBox(fNewX, fNewY, fNewW, fNewH);
876  }
877 }
878 
879 
880 ////////////////////////////////////////////////////////////////////////////////
881 /// TGMdiVerticalWinResizer constructor.
882 
883 TGMdiVerticalWinResizer::TGMdiVerticalWinResizer(const TGWindow *p,
884  const TGWindow *mdiwin, Int_t pos, const TGGC *boxGC, Int_t linew,
885  Int_t mdioptions, Int_t w, Int_t h) :
886  TGMdiWinResizer(p, mdiwin, pos, boxGC, linew, mdioptions,
887  w, h, kFixedHeight | kOwnBackground)
888 {
889  gVirtualX->SetCursor(fId, gVirtualX->CreateCursor(kArrowVer));
890 }
891 
892 ////////////////////////////////////////////////////////////////////////////////
893 /// Handle motion events in resizer (resize associated MDI window).
894 
895 Bool_t TGMdiVerticalWinResizer::HandleMotion(Event_t *event)
896 {
897  if (((TGMdiDecorFrame *)fParent)->IsMinimized()) return kTRUE;
898 
899  fOldX = fNewX;
900  fOldY = fNewY;
901  fOldW = fNewW;
902  fOldH = fNewH;
903 
904  Int_t dy = event->fYRoot - fY0;
905 
906  if (!fLeftButPressed) return kTRUE;
907 
908  switch (fPos) {
909  case kMdiResizerTop:
910  if (fWinH - dy < fMinH) dy = fWinH - fMinH;
911  fNewY = fWinY + dy;
912  fNewH = fWinH - dy;
913  break;
914 
915  case kMdiResizerBottom:
916  if (fWinH + dy < fMinH) dy = fMinH - fWinH;
917  fNewY = fWinY;
918  fNewH = fWinH + dy;
919  break;
920  }
921 
922  MoveResizeIt();
923 
924  return kTRUE;
925 }
926 
927 ////////////////////////////////////////////////////////////////////////////////
928 /// Draw vertical resizer frame border.
929 
930 void TGMdiVerticalWinResizer::DrawBorder()
931 {
932  gVirtualX->ClearArea(fId, 0, 0, fWidth, fHeight);
933  if (fPos == kMdiResizerTop) {
934  gVirtualX->DrawLine(fId, GetHilightGC()(), 0, 1, fWidth - 1, 1);
935  } else {
936  gVirtualX->DrawLine(fId, GetShadowGC()(), 0, fHeight - 2, fWidth - 1,
937  fHeight - 2);
938  gVirtualX->DrawLine(fId, GetBlackGC()(), 0, fHeight - 1, fWidth - 1,
939  fHeight - 1);
940  }
941 }
942 
943 
944 ////////////////////////////////////////////////////////////////////////////////
945 /// TGMdiCornerWinResizer constructor.
946 
947 TGMdiCornerWinResizer::TGMdiCornerWinResizer(const TGWindow *p,
948  const TGWindow *mdiwin, Int_t pos, const TGGC *boxGC, Int_t linew,
949  Int_t mdioptions, Int_t w, Int_t h) :
950  TGMdiWinResizer(p, mdiwin, pos, boxGC, linew, mdioptions,
951  w, h, kFixedSize | kOwnBackground)
952 {
953  Cursor_t defaultCursor = kNone;
954  fEditDisabled = kTRUE;
955 
956  switch (fPos) {
957  case (kMdiResizerTop | kMdiResizerLeft):
958  defaultCursor = gVirtualX->CreateCursor(kTopLeft);
959  break;
960 
961  case (kMdiResizerBottom | kMdiResizerLeft):
962  defaultCursor = gVirtualX->CreateCursor(kBottomLeft);
963  break;
964 
965  case (kMdiResizerTop | kMdiResizerRight):
966  defaultCursor = gVirtualX->CreateCursor(kTopRight);
967  break;
968 
969  case (kMdiResizerBottom | kMdiResizerRight):
970  defaultCursor = gVirtualX->CreateCursor(kBottomRight);
971  break;
972  }
973  gVirtualX->SetCursor(fId, defaultCursor);
974 }
975 
976 ////////////////////////////////////////////////////////////////////////////////
977 /// Handle motion events in resizer (resize associated MDI window).
978 
979 Bool_t TGMdiCornerWinResizer::HandleMotion(Event_t *event)
980 {
981  if (((TGMdiDecorFrame *)fParent)->IsMinimized()) return kTRUE;
982 
983  fOldX = fNewX;
984  fOldY = fNewY;
985  fOldW = fNewW;
986  fOldH = fNewH;
987 
988  Int_t dx = event->fXRoot - fX0;
989  Int_t dy = event->fYRoot - fY0;
990 
991  if (!fLeftButPressed) return kTRUE;
992 
993  switch (fPos) {
994  case (kMdiResizerTop | kMdiResizerLeft):
995  if (fWinW - dx < fMinW) dx = fWinW - fMinW;
996  if (fWinH - dy < fMinH) dy = fWinH - fMinH;
997  fNewX = fWinX + dx;
998  fNewW = fWinW - dx;
999  fNewY = fWinY + dy;
1000  fNewH = fWinH - dy;
1001  break;
1002 
1003  case (kMdiResizerBottom | kMdiResizerLeft):
1004  if (fWinW - dx < fMinW) dx = fWinW - fMinW;
1005  if (fWinH + dy < fMinH) dy = fMinH - fWinH;
1006  fNewX = fWinX + dx;
1007  fNewW = fWinW - dx;
1008  fNewY = fWinY;
1009  fNewH = fWinH + dy;
1010  break;
1011 
1012  case (kMdiResizerTop | kMdiResizerRight):
1013  if (fWinW + dx < fMinW) dx = fMinW - fWinW;
1014  if (fWinH - dy < fMinH) dy = fWinH - fMinH;
1015  fNewX = fWinX;
1016  fNewW = fWinW + dx;
1017  fNewY = fWinY + dy;
1018  fNewH = fWinH - dy;
1019  break;
1020 
1021  case (kMdiResizerBottom | kMdiResizerRight):
1022  if (fWinW + dx < fMinW) dx = fMinW - fWinW;
1023  if (fWinH + dy < fMinH) dy = fMinH - fWinH;
1024  fNewX = fWinX;
1025  fNewW = fWinW + dx;
1026  fNewY = fWinY;
1027  fNewH = fWinH + dy;
1028  break;
1029  }
1030 
1031  MoveResizeIt();
1032 
1033  return kTRUE;
1034 }
1035 
1036 ////////////////////////////////////////////////////////////////////////////////
1037 /// Draw corner resizer frame border.
1038 
1039 void TGMdiCornerWinResizer::DrawBorder()
1040 {
1041  gVirtualX->ClearArea(fId, 0, 0, fWidth, fHeight);
1042 
1043  switch (fPos) {
1044  case (kMdiResizerTop | kMdiResizerLeft):
1045  gVirtualX->DrawLine(fId, GetHilightGC()(), 1, 1, fWidth - 1, 1);
1046  gVirtualX->DrawLine(fId, GetHilightGC()(), 1, 1, 1, fHeight - 1);
1047  break;
1048 
1049  case (kMdiResizerBottom | kMdiResizerLeft):
1050  gVirtualX->DrawLine(fId, GetHilightGC()(), 1, 0, 1, fHeight - 1);
1051  gVirtualX->DrawLine(fId, GetShadowGC()(), 1, fHeight - 2,
1052  fWidth - 1, fHeight - 2);
1053  gVirtualX->DrawLine(fId, GetBlackGC()(), 0, fHeight - 1,
1054  fWidth - 1, fHeight - 1);
1055  break;
1056 
1057  case (kMdiResizerTop | kMdiResizerRight):
1058  gVirtualX->DrawLine(fId, GetHilightGC()(), 0, 1, fWidth - 1, 1);
1059  gVirtualX->DrawLine(fId, GetShadowGC()(), fWidth - 2, 1,
1060  fWidth - 2, fHeight - 1);
1061  gVirtualX->DrawLine(fId, GetBlackGC()(), fWidth - 1, 0,
1062  fWidth - 1, fHeight - 1);
1063  break;
1064 
1065  case (kMdiResizerBottom | kMdiResizerRight):
1066  gVirtualX->DrawLine(fId, GetShadowGC()(), fWidth - 2, 0,
1067  fWidth - 2, fHeight - 2);
1068  gVirtualX->DrawLine(fId, GetShadowGC()(), 0, fHeight - 2,
1069  fWidth - 1, fHeight - 2);
1070  gVirtualX->DrawLine(fId, GetBlackGC()(), fWidth - 1, 0,
1071  fWidth - 1, fHeight - 1);
1072  gVirtualX->DrawLine(fId, GetBlackGC()(), 0, fHeight - 1,
1073  fWidth - 1, fHeight - 1);
1074  break;
1075  }
1076 }
1077 
1078 
1079 ////////////////////////////////////////////////////////////////////////////////
1080 /// TGMdiHorizontalWinResizer constructor.
1081 
1082 TGMdiHorizontalWinResizer::TGMdiHorizontalWinResizer(const TGWindow *p,
1083  const TGWindow *mdiwin, Int_t pos, const TGGC *boxGC, Int_t linew,
1084  Int_t mdioptions, Int_t w, Int_t h) :
1085  TGMdiWinResizer(p, mdiwin, pos, boxGC, linew, mdioptions,
1086  w, h, kFixedWidth | kOwnBackground)
1087 {
1088  fEditDisabled = kTRUE;
1089  gVirtualX->SetCursor(fId, gVirtualX->CreateCursor(kArrowHor));
1090  SetWindowName();
1091 }
1092 
1093 ////////////////////////////////////////////////////////////////////////////////
1094 /// Handle motion events in resizer (resize associated MDI window).
1095 
1096 Bool_t TGMdiHorizontalWinResizer::HandleMotion(Event_t *event)
1097 {
1098  if (((TGMdiDecorFrame *)fParent)->IsMinimized()) return kTRUE;
1099 
1100  fOldX = fNewX;
1101  fOldY = fNewY;
1102  fOldW = fNewW;
1103  fOldH = fNewH;
1104 
1105  Int_t dx = event->fXRoot - fX0;
1106 
1107  if (!fLeftButPressed) return kTRUE;
1108 
1109  switch (fPos) {
1110  case (kMdiResizerLeft):
1111  if (fWinW - dx < fMinW) dx = fWinW - fMinW;
1112  fNewX = fWinX + dx;
1113  fNewW = fWinW - dx;
1114  break;
1115 
1116  case (kMdiResizerRight):
1117  if (fWinW + dx < fMinW) dx = fMinW - fWinW;
1118  fNewX = fWinX;
1119  fNewW = fWinW + dx;
1120  break;
1121  }
1122 
1123  MoveResizeIt();
1124 
1125  return kTRUE;
1126 }
1127 
1128 ////////////////////////////////////////////////////////////////////////////////
1129 /// Draw horizontal resizer frame border.
1130 
1131 void TGMdiHorizontalWinResizer::DrawBorder()
1132 {
1133  gVirtualX->ClearArea(fId, 0, 0, fWidth, fHeight);
1134  if (fPos == kMdiResizerLeft) {
1135  gVirtualX->DrawLine(fId, GetHilightGC()(), 1, 0, 1, fHeight - 1);
1136  } else {
1137  gVirtualX->DrawLine(fId, GetShadowGC()(), fWidth - 2, 0, fWidth - 2, fHeight - 1);
1138  gVirtualX->DrawLine(fId, GetBlackGC()(), fWidth - 1, 0, fWidth - 1, fHeight - 1);
1139  }
1140 }