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