Logo ROOT  

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