ROOT  6.06/09
Reference Guide
TGuiBldHintsEditor.cxx
Go to the documentation of this file.
1 // @(#)root/guibuilder:$Id$
2 // Author: Valeriy Onuchin 12/09/04
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 #include "TGuiBldHintsEditor.h"
13 #include "TGuiBldHintsButton.h"
14 #include "TGNumberEntry.h"
15 #include "TGuiBldEditor.h"
16 #include "TGLabel.h"
17 #include "TG3DLine.h"
18 #include "TGuiBldNameFrame.h"
19 #include "TGuiBldGeometryFrame.h"
20 #include "TRootGuiBuilder.h"
21 #include "TGTableLayout.h"
22 
23 //_____________________________________________________________________________
24 //
25 // TGuiBldHintsEditor
26 //
27 // Editor of widget's layout hints used by the ROOT GUI builder.
28 //_____________________________________________________________________________
29 
30 ClassImp(TGuiBldHintsEditor)
31 
32 ////////////////////////////////////////////////////////////////////////////////
33 class TGuiBldHintsManager : public TGVerticalFrame {
34 
35 public:
36  TGuiBldEditor *fEditor;
37  TGNumberEntry *fColumns;
38  TGNumberEntry *fRows;
39  TGuiBldHintsEditor *fHints;
40  TGMatrixLayout *fMatrix;
41 
42  UInt_t fPadTop; // save values
43  UInt_t fPadBottom; //
44  UInt_t fPadLeft; //
45  UInt_t fPadRight; //
46 
47 public:
48  TGuiBldHintsManager(const TGWindow *p, TGuiBldEditor *editor, TGuiBldHintsEditor *hints);
49  virtual ~TGuiBldHintsManager() { }
50  void ChangeSelected(TGFrame *frame);
51 };
52 
53 ////////////////////////////////////////////////////////////////////////////////
54 /// Constructor.
55 
56 TGuiBldHintsManager::TGuiBldHintsManager(const TGWindow *p, TGuiBldEditor *e,
57  TGuiBldHintsEditor *hints) :
58  TGVerticalFrame(p, 1, 1), fEditor(e), fHints(hints)
59 {
60  fEditDisabled = kEditDisable;
61  SetCleanup(kDeepCleanup);
62  fRows = 0;
63  fColumns = 0;
64 
65  //-----check button to layout subframes was moved to HintsEditor to be generalized ------
66 
67  // "Matrix layout" group frame
68  TGGroupFrame *fGroupFrame4066 = new TGGroupFrame(this, "Matrix layout");
69  TGHorizontalFrame *f = new TGHorizontalFrame(fGroupFrame4066);
70 
71  f->AddFrame(new TGLabel(f," Cols "), new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 2, 2, 2, 2));
72  fColumns = new TGNumberEntry(f,0.0,4,-1,(TGNumberFormat::EStyle)5);
73  f->AddFrame(fColumns, new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 2, 2, 2, 2));
74 
75  f->AddFrame(new TGLabel(f," Rows "), new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 2, 2, 2, 2));
76  fRows = new TGNumberEntry(f,0.0,4,-1,(TGNumberFormat::EStyle)5);
77  f->AddFrame(fRows, new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 2, 2, 2, 2));
78 
79  fGroupFrame4066->AddFrame(f, new TGLayoutHints(kLHintsExpandX | kLHintsCenterY, 2, 2, 2, 2));
80 
81  TGTextButton *fAppButton = new TGTextButton(fGroupFrame4066, " Apply ");
82  fGroupFrame4066->AddFrame(fAppButton, new TGLayoutHints(kLHintsExpandX | kLHintsCenterY, 5, 5, 2, 2));
83 
84  AddFrame(fGroupFrame4066, new TGLayoutHints(kLHintsTop | kLHintsExpandX));
85 
86  fAppButton->Connect("Clicked()", "TGuiBldHintsEditor", fHints, "MatrixLayout()");
87  //fRows->Connect("ValueSet(Long_t)", "TGuiBldHintsEditor", fHints, "MatrixLayout()");
88  //fColumns->Connect("ValueSet(Long_t)", "TGuiBldHintsEditor", fHints, "MatrixLayout()");
89  fRows->GetNumberEntry()->Connect("ReturnPressed()", "TGuiBldHintsEditor", fHints, "MatrixLayout()");
90  fColumns->GetNumberEntry()->Connect("ReturnPressed()", "TGuiBldHintsEditor", fHints, "MatrixLayout()");
91  fRows->SetLimits(TGNumberFormat::kNELLimitMin, 1);
92  fColumns->SetLimits(TGNumberFormat::kNELLimitMin, 1);
93 
94  fPadTop = 2;
95  fPadBottom = 2;
96  fPadLeft = 2;
97  fPadRight = 2;
98 
99  MapSubwindows();
100  Resize();
101  MapWindow();
102 }
103 
104 ////////////////////////////////////////////////////////////////////////////////
105 /// action whne selcted/grabbed frame was changed
106 
107 void TGuiBldHintsManager::ChangeSelected(TGFrame *frame)
108 {
109  fMatrix = 0;
110 
111  if (!frame) {
112  UnmapWindow();
113  fHints->fLayButton->SetEnabled(kFALSE);
114  fHints->fLayButton->SetDown(kFALSE);
115  fRows->SetNumber(0);
116  fColumns->SetNumber(0);
117  return;
118  }
119 
120  Bool_t enable = frame->InheritsFrom(TGCompositeFrame::Class()) &&
121  !(frame->GetEditDisabled() & kEditDisableLayout);
122 
123  if (!enable) {
124  UnmapWindow();
125  fHints->fLayButton->SetEnabled(kFALSE);
126  fHints->fLayButton->SetDown(kFALSE);
127  fRows->SetNumber(0);
128  fColumns->SetNumber(0);
129  } else {
130  TGCompositeFrame *comp = (TGCompositeFrame*)frame;
131  TGLayoutManager *lm = comp->GetLayoutManager();
132 
133  if (!lm) {
134  return;
135  }
136  Int_t n = comp->GetList()->GetEntries();
137 
138  MapWindow();
139  fHints->fLayButton->SetEnabled(kTRUE);
140  fHints->fLayButton->SetDown(kFALSE);
141 
142  if (lm->IsA() == TGVerticalLayout::Class()) {
143  fRows->SetNumber(n);
144  fColumns->SetNumber(1);
145  } else if (lm->IsA() == TGHorizontalLayout::Class()) {
146  fColumns->SetNumber(n);
147  fRows->SetNumber(1);
148  } else if (lm->IsA() == TGMatrixLayout::Class()) {
149  fMatrix = (TGMatrixLayout*)lm;
150 
151  fColumns->SetNumber(fMatrix->fColumns);
152  fRows->SetNumber(fMatrix->fRows);
153  }
154  }
155  DoRedraw();
156 }
157 
158 ///////////////////////////////////////////////////////////////////////////////
159 ////////////////////////////////////////////////////////////////////////////////
160 /// ctor.
161 
162 TGuiBldHintsEditor::TGuiBldHintsEditor(const TGWindow *p, TGuiBldEditor *e) :
163  TGVerticalFrame(p, 1, 1), fEditor(e)
164 {
165  SetCleanup(kDeepCleanup);
166 
167  fBuilder = (TRootGuiBuilder*)TRootGuiBuilder::Instance();
168 
169  TGVerticalFrame *frame3 = new TGVerticalFrame(this,262,18,kVerticalFrame);
170 
171  // horizontal frame - layout subframes (token from matrix layout)
172  TGHorizontalFrame *framez399 = new TGHorizontalFrame(frame3,123,40,kHorizontalFrame);
173  fLayButton = new TGCheckButton(framez399,"");
174  framez399->AddFrame(fLayButton, new TGLayoutHints(kLHintsLeft | kLHintsTop,0,1,2,2));
175  TGLabel *framez401 = new TGLabel(framez399,"Layout subframes");
176  framez399->AddFrame(framez401, new TGLayoutHints(kLHintsLeft | kLHintsCenterX | kLHintsTop,1,1,2,2));
177 
178  frame3->AddFrame(framez399, new TGLayoutHints(kLHintsLeft | kLHintsCenterX | kLHintsTop,1,1,1,1));
179 
180  fLayButton->Connect("Toggled(Bool_t)", "TGuiBldHintsEditor", this, "LayoutSubframes(Bool_t)");
181 
182  //--------layout hints in new layout---------------------------------------
183 
184  // "Padding" group frame
185  fPaddingFrame = new TGGroupFrame(frame3, "Padding");
186  fPaddingFrame->SetLayoutManager(new TGTableLayout(fPaddingFrame, 2, 4));
187 
188  fPaddingFrame->AddFrame(new TGLabel(fPaddingFrame,"Top "),
189  new TGTableLayoutHints(0, 1, 0, 1,
190  kLHintsRight | kLHintsCenterY, 0, 2, 2, 2));
191  fPadTop = new TGNumberEntry(fPaddingFrame,0.0,4,-1,(TGNumberFormat::EStyle) 5);
192  fPaddingFrame->AddFrame(fPadTop, new TGTableLayoutHints(1, 2, 0, 1,
193  kLHintsLeft | kLHintsCenterY, 0, 0, 2, 2));
194 
195  fPaddingFrame->AddFrame(new TGLabel(fPaddingFrame," Left "),
196  new TGTableLayoutHints(2, 3, 0, 1,
197  kLHintsRight | kLHintsCenterY, 2, 2, 2, 2));
198  fPadLeft = new TGNumberEntry(fPaddingFrame,0.0,4,-1,(TGNumberFormat::EStyle) 5);
199  fPaddingFrame->AddFrame(fPadLeft, new TGTableLayoutHints(3, 4, 0, 1,
200  kLHintsLeft | kLHintsCenterY, 0, 0, 2, 2));
201 
202  fPaddingFrame->AddFrame(new TGLabel(fPaddingFrame,"Bottom "),
203  new TGTableLayoutHints(0, 1, 1, 2,
204  kLHintsRight | kLHintsCenterY, 0, 2, 2, 2));
205  fPadBottom = new TGNumberEntry(fPaddingFrame,0.0,4,-1,(TGNumberFormat::EStyle) 5);
206  fPaddingFrame->AddFrame(fPadBottom, new TGTableLayoutHints(1, 2, 1, 2,
207  kLHintsLeft | kLHintsCenterY, 0, 0, 2, 2));
208 
209  fPaddingFrame->AddFrame(new TGLabel(fPaddingFrame," Right "),
210  new TGTableLayoutHints(2, 3, 1, 2,
211  kLHintsRight | kLHintsCenterY, 2, 2, 2, 2));
212  fPadRight = new TGNumberEntry(fPaddingFrame,0.0,4,-1,(TGNumberFormat::EStyle) 5);
213  fPaddingFrame->AddFrame(fPadRight, new TGTableLayoutHints(3, 4, 1, 2,
214  kLHintsLeft | kLHintsCenterY, 0, 0, 2, 2));
215 
216  frame3->AddFrame(fPaddingFrame, new TGLayoutHints(kLHintsTop | kLHintsExpandX, 2, 2, 2, 2));
217 
218  // "Layout" group frame
219  fHintsFrame = new TGGroupFrame(frame3,"Layout");
220 
221  fHintsFrame->SetLayoutManager(new TGTableLayout(fHintsFrame, 4, 2));
222 
223  fCbTop = new TGCheckButton(fHintsFrame, "Top");
224  fHintsFrame->AddFrame(fCbTop, new TGTableLayoutHints(0, 1, 0, 1,
225  kLHintsLeft | kLHintsCenterY, 5, 2, 2, 2));
226 
227  fCbBottom = new TGCheckButton(fHintsFrame, "Bottom");
228  fHintsFrame->AddFrame(fCbBottom, new TGTableLayoutHints(0, 1, 1, 2,
229  kLHintsLeft | kLHintsCenterY, 5, 2, 2, 2));
230 
231  fCbLeft = new TGCheckButton(fHintsFrame, "Left");
232  fHintsFrame->AddFrame(fCbLeft, new TGTableLayoutHints(0, 1, 2, 3,
233  kLHintsLeft | kLHintsCenterY, 5, 2, 2, 2));
234 
235  fCbRight = new TGCheckButton(fHintsFrame, "Right");
236  fHintsFrame->AddFrame(fCbRight, new TGTableLayoutHints(0, 1, 3, 4,
237  kLHintsLeft | kLHintsCenterY, 5, 2, 2, 2));
238 
239  fCbCenterX = new TGCheckButton(fHintsFrame, "Center in X");
240  fHintsFrame->AddFrame(fCbCenterX, new TGTableLayoutHints(1, 2, 0, 1,
241  kLHintsLeft | kLHintsCenterY, 9, 2, 2, 2));
242 
243  fCbCenterY = new TGCheckButton(fHintsFrame, "Center in Y");
244  fHintsFrame->AddFrame(fCbCenterY, new TGTableLayoutHints(1, 2, 1, 2,
245  kLHintsLeft | kLHintsCenterY, 9, 2, 2, 2));
246 
247  fCbExpandX = new TGCheckButton(fHintsFrame, "Expand in X");
248  fHintsFrame->AddFrame(fCbExpandX, new TGTableLayoutHints(1, 2, 2, 3,
249  kLHintsLeft | kLHintsCenterY, 9, 2, 2, 2));
250 
251  fCbExpandY = new TGCheckButton(fHintsFrame, "Expand in Y");
252  fHintsFrame->AddFrame(fCbExpandY, new TGTableLayoutHints(1, 2, 3, 4,
253  kLHintsLeft | kLHintsCenterY, 9, 2, 2, 2));
254 
255  frame3->AddFrame(fHintsFrame, new TGLayoutHints(kLHintsTop | kLHintsExpandX, 2, 2, 2, 2));
256 
257  fHintsManager = new TGuiBldHintsManager(frame3, e, this);
258  frame3->AddFrame(fHintsManager, new TGLayoutHints(kLHintsBottom | kLHintsExpandX,2,2,2,2));
259  fHintsManager->UnmapWindow();
260  AddFrame(frame3);
261 
262  SetEditDisabled(1);
263  Resize();
264  MapSubwindows();
265  MapWindow();
266 
267  fCbTop->Connect("Clicked()", "TGButton", fCbBottom, "SetDown(=kFALSE)");
268  fCbBottom->Connect("Clicked()", "TGButton", fCbTop, "SetDown(=kFALSE)");
269  fCbRight->Connect("Clicked()", "TGButton", fCbLeft, "SetDown(=kFALSE)");
270  fCbLeft->Connect("Clicked()", "TGButton", fCbRight, "SetDown(=kFALSE)");
271 
272  fCbTop->Connect("Clicked()", "TGuiBldHintsEditor", this, "UpdateState()");
273  fCbBottom->Connect("Clicked()", "TGuiBldHintsEditor", this, "UpdateState()");
274  fCbRight->Connect("Clicked()", "TGuiBldHintsEditor", this, "UpdateState()");
275  fCbLeft->Connect("Clicked()", "TGuiBldHintsEditor", this, "UpdateState()");
276  fCbExpandX->Connect("Clicked()", "TGuiBldHintsEditor", this, "UpdateState()");
277  fCbCenterX->Connect("Clicked()", "TGuiBldHintsEditor", this, "UpdateState()");
278  fCbExpandY->Connect("Clicked()", "TGuiBldHintsEditor", this, "UpdateState()");
279  fCbCenterY->Connect("Clicked()", "TGuiBldHintsEditor", this, "UpdateState()");
280 
281  fPadTop->Connect("ValueSet(Long_t)", "TGuiBldHintsEditor", this, "UpdateState()");
282  fPadLeft->Connect("ValueSet(Long_t)", "TGuiBldHintsEditor", this, "UpdateState()");
283  fPadRight->Connect("ValueSet(Long_t)", "TGuiBldHintsEditor", this, "UpdateState()");
284  fPadBottom->Connect("ValueSet(Long_t)", "TGuiBldHintsEditor", this, "UpdateState()");
285 
286  fPadTop->GetNumberEntry()->Connect("ReturnPressed()", "TGuiBldHintsEditor", this, "UpdateState()");
287  fPadLeft->GetNumberEntry()->Connect("ReturnPressed()", "TGuiBldHintsEditor", this, "UpdateState()");
288  fPadRight->GetNumberEntry()->Connect("ReturnPressed()", "TGuiBldHintsEditor", this, "UpdateState()");
289  fPadBottom->GetNumberEntry()->Connect("ReturnPressed()", "TGuiBldHintsEditor", this, "UpdateState()");
290 }
291 
292 
293 ////////////////////////////////////////////////////////////////////////////////
294 /// Change selected
295 
296 void TGuiBldHintsEditor::ChangeSelected(TGFrame *frame)
297 {
298  if (!frame) {
299  return;
300  }
301  TGFrameElement *fe = frame->GetFrameElement();
302 
303  if (!fe) {
304  return;
305  }
306 
307  fHintsManager->ChangeSelected(frame);
308 
309  ULong_t lh = fe->fLayout->GetLayoutHints();
310 
311  fCbCenterX->SetEnabled(kTRUE);
312  fCbCenterY->SetEnabled(kTRUE);
313  fCbExpandX->SetEnabled(!(frame->GetEditDisabled() & kEditDisableWidth));
314  fCbExpandY->SetEnabled(!(frame->GetEditDisabled() & kEditDisableHeight));
315  fClient->NeedRedraw(fCbExpandX);
316  fClient->NeedRedraw(fCbExpandY);
317 
318  fCbTop->SetEnabled(kTRUE);
319  fCbRight->SetEnabled(kTRUE);
320  fCbLeft->SetEnabled(kTRUE);
321  fCbBottom->SetEnabled(kTRUE);
322 
323  fCbCenterX->SetDown(lh & kLHintsCenterX);
324  fCbCenterY->SetDown(lh & kLHintsCenterY);
325  fCbExpandX->SetDown(lh & kLHintsExpandX);
326  fCbExpandY->SetDown(lh & kLHintsExpandY);
327 
328  fCbTop->SetDown(lh & kLHintsTop);
329  fCbRight->SetDown(lh & kLHintsRight);
330  fCbLeft->SetDown(lh & kLHintsLeft);
331  fCbBottom->SetDown(lh & kLHintsBottom);
332 
333  fPadTop->SetIntNumber(fe->fLayout->GetPadTop());
334  fPadLeft->SetIntNumber(fe->fLayout->GetPadLeft());
335  fPadRight->SetIntNumber(fe->fLayout->GetPadRight());
336  fPadBottom->SetIntNumber(fe->fLayout->GetPadBottom());
337 }
338 
339 ////////////////////////////////////////////////////////////////////////////////
340 /// Update state
341 
342 void TGuiBldHintsEditor::UpdateState()
343 {
344  TGFrame *frame = fEditor->GetSelected();
345 
346  if (!frame) {
347  return;
348  }
349 
350  TGFrameElement *fe = frame->GetFrameElement();
351 
352  if (!fe) {
353  return;
354  }
355 
356  if (fLayButton->IsDown() &&
357  ((gTQSender == fPadTop) || (gTQSender == fPadBottom) ||
358  (gTQSender == fPadLeft) || (gTQSender == fPadRight))) {
359  SetMatrixSep();
360  return;
361  }
362 
363  ULong_t lh = fe->fLayout->GetLayoutHints();
364 
365  if (fCbCenterX->IsDown()) {
366  lh |= kLHintsCenterX;
367  } else {
368  lh &= ~kLHintsCenterX;
369  }
370 
371  if (fCbCenterY->IsDown()) {
372  lh |= kLHintsCenterY;
373  } else {
374  lh &= ~kLHintsCenterY;
375  }
376 
377  if (fCbExpandX->IsDown()) {
378  lh |= kLHintsExpandX;
379  } else {
380  lh &= ~kLHintsExpandX;
381  }
382 
383  if (fCbExpandY->IsDown()) {
384  lh |= kLHintsExpandY;
385  } else {
386  lh &= ~kLHintsExpandY;
387  }
388 
389  if (fCbTop->IsDown()) {
390  lh |= kLHintsTop;
391  lh &= ~kLHintsBottom;
392  } else {
393  lh &= ~kLHintsTop;
394  }
395 
396  if (fCbBottom->IsDown()) {
397  lh |= kLHintsBottom;
398  lh &= ~kLHintsTop;
399  } else {
400  lh &= ~kLHintsBottom;
401  }
402 
403  if (fCbRight->IsDown()) {
404  lh |= kLHintsRight;
405  lh &= ~kLHintsLeft;
406  } else {
407  lh &= ~kLHintsRight;
408  }
409 
410  if (fCbLeft->IsDown()) {
411  lh |= kLHintsLeft;
412  lh &= ~kLHintsRight;
413  } else {
414  lh &= ~kLHintsLeft;
415  }
416 
417  if (fPadLeft->GetIntNumber() >=0) {
418  fe->fLayout->SetPadLeft(fPadLeft->GetIntNumber());
419  }
420  if (fPadRight->GetIntNumber() >=0) {
421  fe->fLayout->SetPadRight(fPadRight->GetIntNumber());
422  }
423  if (fPadTop->GetIntNumber() >=0) {
424  fe->fLayout->SetPadTop(fPadTop->GetIntNumber());
425  }
426  if (fPadBottom->GetIntNumber() >=0) {
427  fe->fLayout->SetPadBottom(fPadBottom->GetIntNumber());
428  }
429 
430  if (fe->fLayout->References() > 1) {
431  TGLayoutHints *lh2 = new TGLayoutHints(*fe->fLayout);
432  fe->fLayout->RemoveReference();
433  lh2->AddReference();
434  fe->fLayout = lh2;
435  } else {
436  fe->fLayout->SetLayoutHints(lh);
437  }
438 
439  fEditor->UpdateSelected(frame);
440 }
441 
442 ////////////////////////////////////////////////////////////////////////////////
443 /// Set the position of selected frame when adjusted by the right panel input.
444 
445 void TGuiBldHintsEditor::SetPosition()
446 {
447  if (!fEditor) {
448  return;
449  }
450  TGFrame *frame = fEditor->GetSelected();
451 
452  if (!frame) {
453  //fNameFrame->Reset();
454  return;
455  }
456 
457  if ((fEditor->GetXPos() >= 0) && (fEditor->GetYPos() >= 0)) {
458  frame->MoveResize(fEditor->GetXPos(), fEditor->GetYPos(),
459  frame->GetWidth(), frame->GetHeight());
460  fClient->NeedRedraw(frame, kTRUE);
461  TGWindow *root = (TGWindow*)fClient->GetRoot();
462  fClient->NeedRedraw(root, kTRUE);
463  if (fBuilder) {
464  fClient->NeedRedraw(fBuilder, kTRUE);
465  }
466  } else {
467  fEditor->SetYPos(frame->GetY());
468  fEditor->SetXPos(frame->GetX());
469  }
470 }
471 
472 
473 ////////////////////////////////////////////////////////////////////////////////
474 /// Layout subframes.
475 
476 void TGuiBldHintsEditor::LayoutSubframes(Bool_t on)
477 {
478  if (!fEditor) {
479  return;
480  }
481  TGFrame *frame = fEditor->GetSelected();
482 
483  if (!frame) {
484  //fNameFrame->Reset();
485  return;
486  }
487 
488  TGFrameElement *fe = frame->GetFrameElement();
489 
490  if (!fe) {
491  //fNameFrame->Reset();
492  return;
493  }
494 
495  Bool_t enable = frame->InheritsFrom(TGCompositeFrame::Class()) &&
496  !(frame->GetEditDisabled() & kEditDisableLayout);
497 
498  if (!on) {
499  fPadTop->SetIntNumber(fHintsManager->fPadTop);
500  fPadBottom->SetIntNumber(fHintsManager->fPadBottom);
501  fPadLeft->SetIntNumber(fHintsManager->fPadLeft);
502  fPadRight->SetIntNumber(fHintsManager->fPadRight);
503 
504  ChangeSelected(frame);
505  return;
506  }
507  if (!enable) {
508  return;
509  }
510 
511  TGCompositeFrame *comp = (TGCompositeFrame*)frame;
512  fHintsManager->fRows->SetState(kTRUE);
513  fHintsManager->fColumns->SetState(kTRUE);
514  comp->SetLayoutBroken(kFALSE);
515 
516  if (!fHintsManager->fMatrix) {
517  if (!(frame->GetParent()->GetEditDisabled() & kEditDisableLayout)) {
518  //comp->Resize();
519  comp->Layout();
520  } else {
521  if (comp->GetLayoutManager()) {
522  comp->GetLayoutManager()->Layout();
523  } else {
524  comp->Layout();
525  }
526  }
527  return;
528  }
529 
530  MatrixLayout();
531 
532 }
533 
534 ////////////////////////////////////////////////////////////////////////////////
535 /// Set matrix layout separator.
536 
537 void TGuiBldHintsEditor::SetMatrixSep()
538 {
539  TGFrame *frame = fEditor->GetSelected();
540 
541  if (!frame) {
542  //fNameFrame->Reset();
543  return;
544  }
545 
546  TGFrameElement *fe = frame->GetFrameElement();
547 
548  if (!fe) {
549  //fNameFrame->Reset();
550  return;
551  }
552 
553  Bool_t enable = frame->InheritsFrom(TGCompositeFrame::Class()) &&
554  !(frame->GetEditDisabled() & kEditDisableLayout) &&
555  ((TGCompositeFrame*)frame)->GetLayoutManager() &&
556  ((TGCompositeFrame*)frame)->GetLayoutManager()->InheritsFrom(TGMatrixLayout::Class());
557 
558  if (!enable) {
559  return;
560  }
561 
562  TGNumberEntry *ne = (TGNumberEntry*)gTQSender;
563  UInt_t sep = ne->GetIntNumber();
564 
565  fPadTop->SetIntNumber(sep);
566  fPadLeft->SetIntNumber(sep);
567  fPadRight->SetIntNumber(sep);
568  fPadBottom->SetIntNumber(sep);
569  fLayButton->SetDown(kTRUE);
570 
571  fHintsManager->fMatrix->fSep = sep;
572  frame->SetLayoutBroken(kFALSE);
573 
574  if (!(frame->GetParent()->GetEditDisabled() & kEditDisableLayout)) {
575  frame->Resize();
576  } else {
577  fHintsManager->fMatrix->Layout();
578  }
579  fClient->NeedRedraw(frame, kTRUE);
580 }
581 
582 ////////////////////////////////////////////////////////////////////////////////
583 /// Apply matrix layout.
584 
585 void TGuiBldHintsEditor::MatrixLayout()
586 {
587  TGFrame *frame = fEditor->GetSelected();
588 
589  if (!frame) {
590  //fNameFrame->Reset();
591  return;
592  }
593 
594  TGFrameElement *fe = frame->GetFrameElement();
595 
596  if (!fe) {
597  //fNameFrame->Reset();
598  return;
599  }
600 
601  Bool_t enable = frame->InheritsFrom(TGCompositeFrame::Class()) &&
602  !(frame->GetEditDisabled() & kEditDisableLayout);
603 
604  if (!enable) {
605  return;
606  }
607 
608  TGCompositeFrame *comp = (TGCompositeFrame*)frame;
609 
610  UInt_t rows = fHintsManager->fRows->GetIntNumber();
611  UInt_t cols = fHintsManager->fColumns->GetIntNumber();
612  UInt_t sep = fPadTop->GetIntNumber();
613 
614  fCbCenterX->SetEnabled(kFALSE);
615  fCbCenterY->SetEnabled(kFALSE);
616  fCbExpandX->SetEnabled(kFALSE);
617  fCbExpandY->SetEnabled(kFALSE);
618 
619  fCbTop->SetEnabled(kFALSE);
620  fCbRight->SetEnabled(kFALSE);
621  fCbLeft->SetEnabled(kFALSE);
622  fCbBottom->SetEnabled(kFALSE);
623 
624  fHintsManager->fPadTop = fPadTop->GetIntNumber();
625  fHintsManager->fPadBottom = fPadBottom->GetIntNumber();
626  fHintsManager->fPadLeft = fPadLeft->GetIntNumber();
627  fHintsManager->fPadRight = fPadRight->GetIntNumber();
628 
629  fPadTop->SetIntNumber(sep);
630  fPadLeft->SetIntNumber(sep);
631  fPadRight->SetIntNumber(sep);
632  fPadBottom->SetIntNumber(sep);
633 
634  fHintsManager->fRows->SetState(kTRUE);
635  fHintsManager->fColumns->SetState(kTRUE);
636 
637  comp->SetLayoutBroken(kFALSE);
638 
639  fHintsManager->fMatrix = new TGMatrixLayout(comp, rows, cols, sep, 0);
640  comp->SetLayoutManager(fHintsManager->fMatrix);
641 
642  if (!(comp->GetParent()->GetEditDisabled() & kEditDisableLayout)) {
643  comp->Layout(); //resize?
644  } else {
645  fHintsManager->fMatrix->Layout();
646  }
647  fClient->NeedRedraw(comp, kTRUE);
648 }
TGLayoutHints::GetPadTop
Int_t GetPadTop() const
Definition: TGLayout.h:96
fEditor
TGuiBldEditor * fEditor
Definition: TGuiBldEditor.cxx:41
fPadBottom
UInt_t fPadBottom
Definition: TGuiBldHintsEditor.cxx:43
TCollection::GetEntries
virtual Int_t GetEntries() const
Definition: TCollection.h:92
TGFrame::Resize
virtual void Resize(UInt_t w=0, UInt_t h=0)
Resize the frame.
Definition: TGFrame.cxx:587
TGuiBldEditor::GetSelected
TGFrame * GetSelected() const
Definition: TGuiBldEditor.h:73
TGLayoutHints::SetPadBottom
virtual void SetPadBottom(Int_t v)
Definition: TGLayout.h:103
TGuiBldHintsEditor::fCbBottom
TGCheckButton * fCbBottom
Definition: TGuiBldHintsEditor.h:52
fHints
TGuiBldHintsEditor * fHints
Definition: TGuiBldHintsEditor.cxx:39
TGFrame::MapSubwindows
virtual void MapSubwindows()
Definition: TGFrame.h:263
TGuiBldHintsEditor::fLayButton
TGCheckButton * fLayButton
Definition: TGuiBldHintsEditor.h:63
TGFrame::MoveResize
virtual void MoveResize(Int_t x, Int_t y, UInt_t w=0, UInt_t h=0)
Move and/or resize the frame.
Definition: TGFrame.cxx:611
TGuiBldHintsEditor::fPadBottom
TGNumberEntry * fPadBottom
Definition: TGuiBldHintsEditor.h:59
TObject::InheritsFrom
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
Definition: TObject.cxx:487
TGWindow::GetParent
const TGWindow * GetParent() const
Definition: TGWindow.h:87
TGuiBldHintsEditor::fHintsFrame
TGGroupFrame * fHintsFrame
Definition: TGuiBldHintsEditor.h:42
TGuiBldHintsEditor::ChangeSelected
void ChangeSelected(TGFrame *)
Change selected.
Definition: TGuiBldHintsEditor.cxx:296
TRefCnt::References
UInt_t References() const
Definition: TRefCnt.h:40
gTQSender
R__EXTERN void * gTQSender
Definition: TQObject.h:49
fPadTop
UInt_t fPadTop
Definition: TGuiBldHintsEditor.cxx:42
TGLayoutHints::GetPadRight
Int_t GetPadRight() const
Definition: TGLayout.h:99
TGClient::GetRoot
const TGWindow * GetRoot() const
Returns current root (i.e.
Definition: TGClient.cxx:222
TGFrame::GetWidth
UInt_t GetWidth() const
Definition: TGFrame.h:287
TGuiBldHintsEditor::MatrixLayout
void MatrixLayout()
Apply matrix layout.
Definition: TGuiBldHintsEditor.cxx:585
TGNumberEntry::SetNumber
virtual void SetNumber(Double_t val)
Definition: TGNumberEntry.h:192
TGMatrixLayout::fColumns
UInt_t fColumns
Definition: TGLayout.h:262
TGCheckButton::IsDown
virtual Bool_t IsDown() const
Definition: TGButton.h:316
TGMatrixLayout::fRows
UInt_t fRows
Definition: TGLayout.h:261
TGCompositeFrame::GetList
virtual TList * GetList() const
Definition: TGFrame.h:385
TGCompositeFrame::SetLayoutManager
virtual void SetLayoutManager(TGLayoutManager *l)
Set the layout manager for the composite frame.
Definition: TGFrame.cxx:982
TGuiBldHintsEditor::fPaddingFrame
TGGroupFrame * fPaddingFrame
Definition: TGuiBldHintsEditor.h:43
Int_t
int Int_t
Definition: RtypesCore.h:41
Bool_t
bool Bool_t
Definition: RtypesCore.h:59
kFALSE
const Bool_t kFALSE
Definition: Rtypes.h:92
TGNumberEntry::SetLimits
virtual void SetLimits(ELimit limits=TGNumberFormat::kNELNoLimits, Double_t min=0, Double_t max=1)
Definition: TGNumberEntry.h:234
TGFrame::GetY
Int_t GetY() const
Definition: TGFrame.h:295
fRows
TGNumberEntry * fRows
Definition: TGuiBldHintsEditor.cxx:38
TGFrame::GetHeight
UInt_t GetHeight() const
Definition: TGFrame.h:288
TGLayoutHints::GetPadLeft
Int_t GetPadLeft() const
Definition: TGLayout.h:98
TGuiBldHintsEditor::fPadTop
TGNumberEntry * fPadTop
Definition: TGuiBldHintsEditor.h:58
TGCompositeFrame::Layout
virtual void Layout()
Layout the elements of the composite frame.
Definition: TGFrame.cxx:1239
TGFrameElement::fLayout
TGLayoutHints * fLayout
Definition: TGLayout.h:127
~TGuiBldHintsManager
virtual ~TGuiBldHintsManager()
Definition: TGuiBldHintsEditor.cxx:49
TGuiBldEditor::SetYPos
void SetYPos(Int_t pos)
Definition: TGuiBldEditor.h:71
TGNumberEntry::GetNumberEntry
TGNumberEntryField * GetNumberEntry() const
Definition: TGNumberEntry.h:274
Class
void Class()
Definition: Class.C:29
TGFrame::GetFrameElement
TGFrameElement * GetFrameElement() const
Definition: TGFrame.h:298
TGuiBldEditor::GetYPos
Int_t GetYPos() const
Definition: TGuiBldEditor.h:69
TGuiBldEditor::SetXPos
void SetXPos(Int_t pos)
Definition: TGuiBldEditor.h:70
TGLayoutHints::GetLayoutHints
ULong_t GetLayoutHints() const
Definition: TGLayout.h:95
TGuiBldHintsEditor::TGuiBldHintsEditor
TGuiBldHintsEditor(const TGWindow *p, TGuiBldEditor *e)
ctor.
Definition: TGuiBldHintsEditor.cxx:162
fPadRight
UInt_t fPadRight
Definition: TGuiBldHintsEditor.cxx:45
TGWindow::GetEditDisabled
virtual UInt_t GetEditDisabled() const
Definition: TGWindow.h:118
TQObject::Connect
Bool_t Connect(const char *signal, const char *receiver_class, void *receiver, const char *slot)
Non-static method is used to connect from the signal of this object to the receiver slot...
Definition: TQObject.cxx:1135
TGLayoutHints::SetPadRight
virtual void SetPadRight(Int_t v)
Definition: TGLayout.h:105
ChangeSelected
void ChangeSelected(TGFrame *frame)
TGCompositeFrame::SetLayoutBroken
virtual void SetLayoutBroken(Bool_t on=kTRUE)
Set broken layout. No Layout method is called.
Definition: TGFrame.cxx:994
TGuiBldHintsEditor::LayoutSubframes
void LayoutSubframes(Bool_t on=kTRUE)
Layout subframes.
Definition: TGuiBldHintsEditor.cxx:476
UInt_t
unsigned int UInt_t
Definition: RtypesCore.h:42
TGuiBldHintsManager
TGuiBldHintsManager(const TGWindow *p, TGuiBldEditor *editor, TGuiBldHintsEditor *hints)
Constructor.
Definition: TGuiBldHintsEditor.cxx:56
fColumns
ClassImp(TGuiBldHintsEditor) class TGuiBldHintsManager TGNumberEntry * fColumns
Definition: TGuiBldHintsEditor.cxx:30
TGVerticalFrame::TGVerticalFrame
TGVerticalFrame(const TGWindow *p=0, UInt_t w=1, UInt_t h=1, UInt_t options=kChildFrame, Pixel_t back=GetDefaultFrameBackground())
Definition: TGFrame.h:452
TGNumberEntry::SetIntNumber
virtual void SetIntNumber(Long_t val)
Definition: TGNumberEntry.h:195
TGuiBldHintsEditor::fCbExpandX
TGCheckButton * fCbExpandX
Definition: TGuiBldHintsEditor.h:53
TGLayoutHints::GetPadBottom
Int_t GetPadBottom() const
Definition: TGLayout.h:97
TGuiBldHintsEditor::fPadLeft
TGNumberEntry * fPadLeft
Definition: TGuiBldHintsEditor.h:60
ClassImp
#define ClassImp(name)
Definition: Rtypes.h:279
f
double f(double x)
Definition: testIntegration.cxx:12
TGCompositeFrame::SetEditDisabled
virtual void SetEditDisabled(UInt_t on=1)
Set edit disable flag for this frame and subframes.
Definition: TGFrame.cxx:1004
TGLayoutHints::SetLayoutHints
virtual void SetLayoutHints(ULong_t lh)
Definition: TGLayout.h:101
TRefCnt::RemoveReference
UInt_t RemoveReference()
Definition: TRefCnt.h:43
TGCompositeFrame::SetCleanup
virtual void SetCleanup(Int_t mode=kLocalCleanup)
Turn on automatic cleanup of child frames in dtor.
Definition: TGFrame.cxx:1054
TGButton::SetEnabled
virtual void SetEnabled(Bool_t e=kTRUE)
Set enabled or disabled state of button.
Definition: TGButton.cxx:409
TGuiBldHintsEditor::SetMatrixSep
void SetMatrixSep()
Set matrix layout separator.
Definition: TGuiBldHintsEditor.cxx:537
TGuiBldHintsEditor::SetPosition
void SetPosition()
Set the position of selected frame when adjusted by the right panel input.
Definition: TGuiBldHintsEditor.cxx:445
ULong_t
unsigned long ULong_t
Definition: RtypesCore.h:51
TGuiBldHintsEditor::fEditor
TGuiBldEditor * fEditor
Definition: TGuiBldHintsEditor.h:39
TGuiBldHintsEditor::fPadRight
TGNumberEntry * fPadRight
Definition: TGuiBldHintsEditor.h:61
TGFrame::SetCleanup
virtual void SetCleanup(Int_t=kLocalCleanup)
Definition: TGFrame.h:280
TGuiBldHintsEditor::UpdateState
void UpdateState()
Update state.
Definition: TGuiBldHintsEditor.cxx:342
TGCompositeFrame::AddFrame
virtual void AddFrame(TGFrame *f, TGLayoutHints *l=0)
Add frame to the composite frame using the specified layout hints.
Definition: TGFrame.cxx:1099
TGFrame::GetX
Int_t GetX() const
Definition: TGFrame.h:294
TGCompositeFrame::MapSubwindows
virtual void MapSubwindows()
Map all sub windows that are part of the composite frame.
Definition: TGFrame.cxx:1146
TGuiBldHintsEditor::fBuilder
TRootGuiBuilder * fBuilder
Definition: TGuiBldHintsEditor.h:65
TGuiBldEditor::UpdateSelected
void UpdateSelected(TGFrame *=0)
Update selected frame.
Definition: TGuiBldEditor.cxx:420
TGFrame::UnmapWindow
virtual void UnmapWindow()
Definition: TGFrame.h:269
TGLayoutHints::SetPadTop
virtual void SetPadTop(Int_t v)
Definition: TGLayout.h:102
TGuiBldHintsEditor::fHintsManager
TGuiBldHintsManager * fHintsManager
Definition: TGuiBldHintsEditor.h:41
TGButton::SetDown
virtual void SetDown(Bool_t on=kTRUE, Bool_t emit=kFALSE)
Definition: TGButton.cxx:260
TGuiBldDragManager::DoRedraw
void DoRedraw()
Redraw the editted window.
Definition: TGuiBldDragManager.cxx:1151
TRefCnt::AddReference
void AddReference()
Definition: TRefCnt.h:42
TGuiBuilder::Instance
static TGuiBuilder * Instance()
return an instance of TGuiBuilder object
Definition: TGuiBuilder.cxx:148
TGFrame::SetLayoutBroken
virtual void SetLayoutBroken(Bool_t=kTRUE)
Definition: TGFrame.h:278
TGFrame::MapWindow
virtual void MapWindow()
Definition: TGFrame.h:267
TGObject::fClient
TGClient * fClient
Definition: TGObject.h:41
TGLayoutManager::Layout
virtual void Layout()=0
TGClient::NeedRedraw
void NeedRedraw(TGWindow *w, Bool_t force=kFALSE)
Set redraw flags.
Definition: TGClient.cxx:370
fPadLeft
UInt_t fPadLeft
Definition: TGuiBldHintsEditor.cxx:44
TGWindow::fEditDisabled
UInt_t fEditDisabled
Definition: TGWindow.h:47
TGuiBldHintsEditor::fCbTop
TGCheckButton * fCbTop
Definition: TGuiBldHintsEditor.h:51
TGNumberEntry::GetIntNumber
virtual Long_t GetIntNumber() const
Definition: TGNumberEntry.h:215
TGuiBldHintsEditor::fCbCenterX
TGCheckButton * fCbCenterX
Definition: TGuiBldHintsEditor.h:55
fMatrix
TGMatrixLayout * fMatrix
Definition: TGuiBldHintsEditor.cxx:40
TGLayoutHints::SetPadLeft
virtual void SetPadLeft(Int_t v)
Definition: TGLayout.h:104
kTRUE
const Bool_t kTRUE
Definition: Rtypes.h:91
TGuiBldHintsEditor::fCbExpandY
TGCheckButton * fCbExpandY
Definition: TGuiBldHintsEditor.h:54
TGuiBldEditor::GetXPos
Int_t GetXPos() const
Definition: TGuiBldEditor.h:68
TGCompositeFrame::GetLayoutManager
virtual TGLayoutManager * GetLayoutManager() const
Definition: TGFrame.h:413
TGuiBldHintsEditor::fCbCenterY
TGCheckButton * fCbCenterY
Definition: TGuiBldHintsEditor.h:56
TGuiBldHintsEditor::fCbRight
TGCheckButton * fCbRight
Definition: TGuiBldHintsEditor.h:50
TGuiBldHintsEditor::fCbLeft
TGCheckButton * fCbLeft
Definition: TGuiBldHintsEditor.h:49