Logo ROOT  
Reference Guide
TGListView.cxx
Go to the documentation of this file.
1 // @(#)root/gui:$Id$
2 // Author: Fons Rademakers 17/01/98
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 /**************************************************************************
12 
13  This source is based on Xclass95, a Win95-looking GUI toolkit.
14  Copyright (C) 1996, 1997 David Barth, Ricky Ralston, Hector Peraza.
15 
16  Xclass95 is free software; you can redistribute it and/or
17  modify it under the terms of the GNU Library General Public
18  License as published by the Free Software Foundation; either
19  version 2 of the License, or (at your option) any later version.
20 
21 **************************************************************************/
22 
23 
24 /** \class TGListView
25  \ingroup guiwidgets
26 
27 A list view is a widget that can contain a number of items
28 arranged in a grid or list. The items can be represented either
29 by a string or by an icon.
30 
31 The TGListView is user callable. The other classes are service
32 classes of the list view.
33 
34 A list view can generate the following events:
35  - kC_CONTAINER, kCT_SELCHANGED, total items, selected items.
36  - kC_CONTAINER, kCT_ITEMCLICK, which button, location (y<<16|x).
37  - kC_CONTAINER, kCT_ITEMDBLCLICK, which button, location (y<<16|x).
38 
39 */
40 
41 
42 #include "TGListView.h"
43 #include "TGPicture.h"
44 #include "TGButton.h"
45 #include "TGScrollBar.h"
46 #include "TGResourcePool.h"
47 #include "TList.h"
48 #include "TSystem.h"
49 #include "TGMimeTypes.h"
50 #include "TObjString.h"
51 #include "TVirtualX.h"
52 
53 #include <iostream>
54 
55 const TGFont *TGLVEntry::fgDefaultFont = nullptr;
56 TGGC *TGLVEntry::fgDefaultGC = nullptr;
57 
58 const TGFont *TGListView::fgDefaultFont = nullptr;
59 TGGC *TGListView::fgDefaultGC = nullptr;
60 
61 
65 
66 ////////////////////////////////////////////////////////////////////////////////
67 /// Create a list view item.
68 
69 TGLVEntry::TGLVEntry(const TGWindow *p, const TGPicture *bigpic,
70  const TGPicture *smallpic, TGString *name,
71  TGString **subnames, EListViewMode viewMode,
72  UInt_t options, ULong_t back) :
73  TGFrame(p, 10, 10, options, back)
74 {
75  fSelPic = 0;
76 
77  fCurrent =
78  fBigPic = bigpic;
79  fSmallPic = smallpic;
80 
81  fCheckMark = fClient->GetPicture("checkmark_t.xpm");
82  fChecked = kFALSE;
83 
84  fItemName = name;
85  fSubnames = subnames;
86  fUserData = 0;
87 
88  fCpos = fJmode = 0;
89  fCtw = nullptr;
90  fActive = kFALSE;
91 
93  fNormGC = GetDefaultGC()();
94 
95  Int_t max_ascent, max_descent;
96  fTWidth = gVirtualX->TextWidth(fFontStruct,
97  fItemName ? fItemName->GetString() : "",
98  fItemName ? fItemName->GetLength() : 0);
99  gVirtualX->GetFontProperties(fFontStruct, max_ascent, max_descent);
100  fTHeight = max_ascent + max_descent;
101 
102  if (fSubnames) {
103  Int_t i;
104  for (i = 0; fSubnames[i] != 0; ++i)
105  ;
106  fCtw = new int[i+1];
107  fCtw[i] = 0;
108  for (i = 0; fSubnames[i] != 0; ++i) {
109  fCtw[i] = gVirtualX->TextWidth(fFontStruct, fSubnames[i]->GetString(),
110  fSubnames[i]->GetLength());
111  }
112  }
113 
114  fViewMode = (EListViewMode)-1;
115  SetViewMode(viewMode);
116 }
117 
118 ////////////////////////////////////////////////////////////////////////////////
119 /// Create a list view item.
120 ///
121 /// name - is name of item.
122 /// cname - is name of icon. In most cases this is class name of object
123 /// associated with this item.
124 
126  const TString& cname, TGString **subnames,
127  UInt_t options, Pixel_t back) :
128  TGFrame(p, 10, 10, options, back)
129 {
130  fSelPic = 0;
131 
132  fCurrent =
134  fCheckMark = fClient->GetPicture("checkmark_t.xpm");
135  fChecked = kFALSE;
136 
137  if (!fBigPic) {
138  fBigPic = fClient->GetPicture("doc_s.xpm");
139  }
141  if (!fSmallPic) {
142  fSmallPic = fClient->GetPicture("doc_t.xpm");
143  }
144 
145  fItemName = new TGString(name);
146  fSubnames = subnames;
147  fUserData = 0;
148 
149  fCpos = fJmode = 0;
150 
151  fCtw = nullptr;
152 
153  fActive = kFALSE;
154 
156  fNormGC = GetDefaultGC()();
157 
158  Int_t max_ascent, max_descent;
160  gVirtualX->GetFontProperties(fFontStruct, max_ascent, max_descent);
161  fTHeight = max_ascent + max_descent;
162 
163  if (fSubnames) {
164  Int_t i;
165  for (i = 0; fSubnames[i] != 0; ++i)
166  ;
167  fCtw = new int[i+1];
168  fCtw[i] = 0;
169  for (i = 0; fSubnames[i] != 0; ++i) {
170  fCtw[i] = gVirtualX->TextWidth(fFontStruct, fSubnames[i]->GetString(),
171  fSubnames[i]->GetLength());
172  }
173  }
174 
175  fViewMode = (EListViewMode)-1;
177 }
178 
179 ////////////////////////////////////////////////////////////////////////////////
180 /// Delete a list view item.
181 
183 {
184  if (fItemName) delete fItemName;
185  if (fSelPic) delete fSelPic;
186  if (fSubnames) {
187  for (Int_t i = 0; fSubnames[i] != 0; ++i) delete fSubnames[i];
188  delete [] fSubnames;
189  fSubnames = nullptr;
190  }
191  if (fCtw) {
192  delete [] fCtw;
193  fCtw = nullptr;
194  }
195 }
196 
197 ////////////////////////////////////////////////////////////////////////////////
198 /// Sets new subnames.
199 
200 void TGLVEntry::SetSubnames(const char* n1,const char* n2,const char* n3,
201  const char* n4,const char* n5,const char* n6,
202  const char* n7,const char* n8,const char* n9,
203  const char* n10,const char* n11,const char* n12)
204 {
205  if (fSubnames) {
206  for (Int_t i = 0; fSubnames[i] != 0; ++i) delete fSubnames[i];
207  delete [] fSubnames;
208  }
209  if (fCtw) {
210  delete [] fCtw;
211  }
212 
213  Int_t ncol = 0;
214  fSubnames = nullptr;
215  fCtw = nullptr;
216 
217  if (n12 && strlen(n12)) ncol=12;
218  else if (n11 && strlen(n11)) ncol=11;
219  else if (n10 && strlen(n10)) ncol=10;
220  else if (n9 && strlen(n9)) ncol=9;
221  else if (n8 && strlen(n8)) ncol=8;
222  else if (n7 && strlen(n7)) ncol=7;
223  else if (n6 && strlen(n6)) ncol=6;
224  else if (n5 && strlen(n5)) ncol=5;
225  else if (n4 && strlen(n4)) ncol=4;
226  else if (n3 && strlen(n3)) ncol=3;
227  else if (n2 && strlen(n2)) ncol=2;
228  else if (n1 && strlen(n1)) ncol=1;
229 
230  if (!ncol) return;
231 
232  fSubnames = new TGString* [ncol+1];
233 
234  if (ncol>11) fSubnames[11] = new TGString(n12);
235  if (ncol>10) fSubnames[10] = new TGString(n11);
236  if (ncol>9) fSubnames[9] = new TGString(n10);
237  if (ncol>8) fSubnames[8] = new TGString(n9);
238  if (ncol>7) fSubnames[7] = new TGString(n8);
239  if (ncol>6) fSubnames[6] = new TGString(n7);
240  if (ncol>5) fSubnames[5] = new TGString(n6);
241  if (ncol>4) fSubnames[4] = new TGString(n5);
242  if (ncol>3) fSubnames[3] = new TGString(n4);
243  if (ncol>2) fSubnames[2] = new TGString(n3);
244  if (ncol>1) fSubnames[1] = new TGString(n2);
245  if (ncol>0) fSubnames[0] = new TGString(n1);
246  fSubnames[ncol] = 0;
247 
248  fCtw = new int[ncol];
249  fCtw[ncol-1] = 0;
250 
251  for (int i = 0; i<ncol; i++) {
252  fCtw[i] = gVirtualX->TextWidth(fFontStruct, fSubnames[i]->GetString(),
253  fSubnames[i]->GetLength());
254  }
255 }
256 
257 ////////////////////////////////////////////////////////////////////////////////
258 /// Make list view item active.
259 
261 {
262  if (fActive == a) return;
263  fActive = a;
264 
265  if (fActive) {
267  } else {
268  if (fSelPic) delete fSelPic;
269  fSelPic = nullptr;
270  }
271  DoRedraw();
272 }
273 
274 ////////////////////////////////////////////////////////////////////////////////
275 /// Set the view mode for this list item.
276 
278 {
279  if (viewMode != fViewMode) {
280  fViewMode = viewMode;
281  if (viewMode == kLVLargeIcons)
282  fCurrent = fBigPic;
283  else
285  if (fActive) {
286  if (fSelPic) delete fSelPic;
288  }
289  gVirtualX->ClearWindow(fId);
291  fClient->NeedRedraw(this);
292  }
293 }
294 
295 ////////////////////////////////////////////////////////////////////////////////
296 /// change pictures
297 
298 void TGLVEntry::SetPictures(const TGPicture *bigpic, const TGPicture *smallpic)
299 {
300  if (!bigpic || !smallpic) return;
301 
302  gVirtualX->ClearWindow(fId);
303 
304  fBigPic = bigpic;
305  fSmallPic = smallpic;
307 
308  if (fSelPic) delete fSelPic;
310 
311  Resize();
312  gVirtualX->ClearWindow(fId);
313 }
314 
315 ////////////////////////////////////////////////////////////////////////////////
316 /// Redraw list view item.
317 /// List view item is placed and laid out in the container frame,
318 /// but is drawn in viewport.
319 
321 {
322  DrawCopy(fId, 0, 0);
323 }
324 
325 ////////////////////////////////////////////////////////////////////////////////
326 /// Draw list view item in other window.
327 /// List view item is placed and layout in the container frame,
328 /// but is drawn in viewport.
329 
331 {
332  Int_t ix, iy, lx, ly;
333  Int_t max_ascent, max_descent;
334 
335  gVirtualX->GetFontProperties(fFontStruct, max_ascent, max_descent);
337  fTHeight = max_ascent + max_descent;
338 
339  if (fViewMode == kLVLargeIcons) {
340  ix = (fWidth - fCurrent->GetWidth()) >> 1;
341  iy = 0;
342  lx = (fWidth - fTWidth) >> 1;
343  ly = fHeight - (fTHeight + 1) - 2;
344  } else {
345  ix = 0;
346  iy = (fHeight - fCurrent->GetHeight()) >> 1;
347  lx = fCurrent->GetWidth() + 2;
348  ly = (fHeight - (fTHeight + 1)) >> 1;
349  }
350 
351  if ((fChecked) && (fCheckMark)) {
352  if (fViewMode == kLVLargeIcons) {
353  fCheckMark->Draw(id, fNormGC, x + ix + 8, y + iy + 8);
354  gVirtualX->SetForeground(fNormGC, fgWhitePixel);
355  gVirtualX->FillRectangle(id, fNormGC, x + lx, y + ly, fTWidth, fTHeight + 1);
356  gVirtualX->SetForeground(fNormGC, fgBlackPixel);
357  }
358  else {
359  fCheckMark->Draw(id, fNormGC, x + ix, y + iy);
360  gVirtualX->SetForeground(fNormGC, fgWhitePixel);
361  gVirtualX->FillRectangle(id, fNormGC, x + lx, y, fWidth-lx, fHeight);
362  gVirtualX->SetForeground(fNormGC, fgBlackPixel);
363  }
364  }
365  // This if tries to print the elements with ... appended at the end if
366  // the width of the string is longer than that of the column
367  if (fViewMode == kLVDetails && fSubnames && fCpos && fJmode && fCtw) {
368  TString tmpString = *fItemName;
369  Int_t ftmpWidth = gVirtualX->TextWidth(fFontStruct, tmpString,
370  tmpString.Length());
371  if ( ftmpWidth > (fCpos[0] - lx) ) {
372  for (Int_t j = fItemName->Length() - 1 ; j > 0; j--) {
373  tmpString = (*fItemName)(0,j) + "...";
374  ftmpWidth = gVirtualX->TextWidth(GetDefaultFontStruct(), tmpString,
375  tmpString.Length());
376  if ( ftmpWidth <= (fCpos[0] - lx) ) {
377  break;
378  }
379  }
380  }
381  if (fActive) {
382  if (fSelPic) fSelPic->Draw(id, fNormGC, x + ix, y + iy);
384  gVirtualX->FillRectangle(id, fNormGC, x + lx, y, fWidth-(lx+4), fHeight);
386  } else {
387  fCurrent->Draw(id, fNormGC, x + ix, y + iy);
388  gVirtualX->SetForeground(fNormGC, fgWhitePixel);
389  gVirtualX->FillRectangle(id, fNormGC, x + lx, y, fWidth-(lx+4), fHeight);
390  gVirtualX->SetForeground(fNormGC, fgBlackPixel);
391  }
392 
393  TGString tmpTGString(tmpString);
394  tmpTGString.Draw(id, fNormGC, x+lx, y+ly + max_ascent);
395  } else if (fViewMode == kLVLargeIcons) {
396  if (fActive) {
397  if (fSelPic) fSelPic->Draw(id, fNormGC, x + ix, y + iy);
399  gVirtualX->FillRectangle(id, fNormGC, x + lx, y + ly, fTWidth, fTHeight + 1);
401  } else {
402  fCurrent->Draw(id, fNormGC, x + ix, y + iy);
403  gVirtualX->SetForeground(fNormGC, fgWhitePixel);
404  gVirtualX->FillRectangle(id, fNormGC, x + lx, y + ly, fTWidth, fTHeight + 1);
405  gVirtualX->SetForeground(fNormGC, fgBlackPixel);
406  }
407  fItemName->Draw(id, fNormGC, x+lx, y+ly + max_ascent);
408  } else {
409  if (fActive) {
411  gVirtualX->FillRectangle(id, fNormGC, x + lx, y, fWidth-lx, fHeight);
413  if (fSelPic) fSelPic->Draw(id, fNormGC, x + ix, y + iy);
414  } else {
415  gVirtualX->SetForeground(fNormGC, fgWhitePixel);
416  gVirtualX->FillRectangle(id, fNormGC, x + lx, y, fWidth-lx, fHeight);
417  gVirtualX->SetForeground(fNormGC, fgBlackPixel);
418  fCurrent->Draw(id, fNormGC, x + ix, y + iy);
419  }
420  fItemName->Draw(id, fNormGC, x+lx, y+ly + max_ascent);
421  }
422 
423  if (fViewMode == kLVDetails) {
424  if (fSubnames && fCpos && fJmode && fCtw) {
425  int i;
426 
427  if (fActive) {
429  } else {
430  gVirtualX->SetForeground(fNormGC, fgBlackPixel);
431  }
432  // Again fixes the size of the strings
433  for (i = 0; fSubnames[i] != 0; ++i) {
434  TString tmpString = *fSubnames[i];
435  Int_t ftmpWidth = gVirtualX->TextWidth(fFontStruct, tmpString,
436  tmpString.Length());
437  if ( ftmpWidth > (fCpos[i+1] - fCpos[i]) ) {
438  for (int j = fSubnames[i]->Length() - 1 ; j > 0; j--) {
439  tmpString = (*fSubnames[i])(0,j) + "...";
440  ftmpWidth = gVirtualX->TextWidth(GetDefaultFontStruct(),
441  tmpString,
442  tmpString.Length());
443  if ( ftmpWidth <= (fCpos[i+1] - fCpos[i]) ) {
444  break;
445  }
446  }
447  }
448  if (fCpos[i] == 0)
449  break;
450  if (fJmode[i] == kTextRight)
451  lx = fCpos[i+1] - ftmpWidth - 2;
452  else if (fJmode[i] == kTextCenterX)
453  lx = (fCpos[i] + fCpos[i+1] - ftmpWidth) >> 1;
454  else // default to TEXT_LEFT
455  lx = fCpos[i] + 2;
456 
457  //if (x + lx < 0) continue; // out of left boundary or mess in name
458  TGString tmpTGString(tmpString);
459  tmpTGString.Draw(id, fNormGC, x + lx, y + ly + max_ascent);
460  }
461  }
462  }
463  gVirtualX->SetForeground(fNormGC, fgBlackPixel);
464 }
465 
466 ////////////////////////////////////////////////////////////////////////////////
467 /// Get default size of list item.
468 
470 {
472  TGDimension isize(fCurrent ? fCurrent->GetWidth() : 0,
473  fCurrent ? fCurrent->GetHeight() : 0);
474  TGDimension lsize(fTWidth, fTHeight+1);
475 
476  switch (fViewMode) {
477  default:
478  case kLVLargeIcons:
479  size.fWidth = TMath::Max(isize.fWidth, lsize.fWidth);
480  size.fHeight = isize.fHeight + lsize.fHeight + 6;
481  break;
482 
483  case kLVSmallIcons:
484  case kLVList:
485  case kLVDetails:
486  size.fWidth = isize.fWidth + lsize.fWidth + 4;
487  size.fHeight = TMath::Max(isize.fHeight, lsize.fHeight);
488  break;
489  }
490  return size;
491 }
492 
493 ////////////////////////////////////////////////////////////////////////////////
494 /// Return the default font structure in use.
495 
497 {
498  if (!fgDefaultFont)
499  fgDefaultFont = gClient->GetResourcePool()->GetIconFont();
500  return fgDefaultFont->GetFontStruct();
501 }
502 
503 ////////////////////////////////////////////////////////////////////////////////
504 /// Return the default graphics context in use.
505 
507 {
508  if (!fgDefaultGC) {
509  fgDefaultGC = new TGGC(*gClient->GetResourcePool()->GetFrameGC());
511  }
512  return *fgDefaultGC;
513 }
514 
515 
516 ////////////////////////////////////////////////////////////////////////////////
517 /// Create a list view container. This is the (large) frame that contains
518 /// all the list items. It will be shown through a TGViewPort (which is
519 /// created by the TGCanvas derived TGListView).
520 
522  UInt_t options, ULong_t back) :
523  TGContainer(p, w, h, options, back)
524 {
525  fListView = 0;
526  fLastActive = 0;
527  fCpos = fJmode = 0;
529 
532 
533  SetLayoutManager(new TGTileLayout(this, 8));
534 }
535 
536 ////////////////////////////////////////////////////////////////////////////////
537 /// Create a list view container. This is the (large) frame that contains
538 /// all the list items. It will be shown through a TGViewPort (which is
539 /// created by the TGCanvas derived TGListView).
540 
542  TGContainer(p,options, back)
543 {
544  fListView = 0;
545  fLastActive = 0;
546  fCpos = fJmode = 0;
548 
551 
552  SetLayoutManager(new TGTileLayout(this, 8));
553 
555 }
556 
557 ////////////////////////////////////////////////////////////////////////////////
558 /// Delete list view container.
559 
561 {
562  if (!MustCleanup()) {
563  RemoveAll();
564  delete fItemLayout;
565  }
566 }
567 
568 ////////////////////////////////////////////////////////////////////////////////
569 /// set columns headers
570 
571 void TGLVContainer::SetColHeaders(const char* n1,const char* n2,const char* n3,
572  const char* n4,const char* n5,const char* n6,
573  const char* n7,const char* n8,const char* n9,
574  const char* n10,const char* n11,const char* n12)
575 {
576  if (!fListView) return;
577 
578  Int_t ncol = -1;
579  if (n12 && strlen(n12)) ncol=12;
580  else if (n11 && strlen(n11)) ncol=11;
581  else if (n10 && strlen(n10)) ncol=10;
582  else if (n9 && strlen(n9)) ncol=9;
583  else if (n8 && strlen(n8)) ncol=8;
584  else if (n7 && strlen(n7)) ncol=7;
585  else if (n6 && strlen(n6)) ncol=6;
586  else if (n5 && strlen(n5)) ncol=5;
587  else if (n4 && strlen(n4)) ncol=4;
588  else if (n3 && strlen(n3)) ncol=3;
589  else if (n2 && strlen(n2)) ncol=2;
590  else if (n1 && strlen(n1)) ncol=1;
591 
592  if (ncol<0) return;
593 
594  fListView->SetHeaders(ncol);
595  if (ncol>0) fListView->SetHeader(n1, kTextCenterX, kTextLeft , 0);
596  if (ncol>1) fListView->SetHeader(n2, kTextCenterX, kTextLeft , 1);
597  if (ncol>2) fListView->SetHeader(n3, kTextCenterX, kTextLeft , 2);
598  if (ncol>3) fListView->SetHeader(n4, kTextCenterX, kTextLeft , 3);
599  if (ncol>4) fListView->SetHeader(n5, kTextCenterX, kTextLeft , 4);
600  if (ncol>5) fListView->SetHeader(n6, kTextCenterX, kTextLeft , 5);
601  if (ncol>6) fListView->SetHeader(n7, kTextCenterX, kTextLeft , 6);
602  if (ncol>7) fListView->SetHeader(n8, kTextCenterX, kTextLeft , 7);
603  if (ncol>8) fListView->SetHeader(n9, kTextCenterX, kTextLeft , 8);
604  if (ncol>9) fListView->SetHeader(n10, kTextCenterX, kTextLeft , 9);
605  if (ncol>10) fListView->SetHeader(n11, kTextCenterX, kTextLeft , 10);
606  if (ncol>11) fListView->SetHeader(n12, kTextCenterX, kTextLeft , 11);
607 
608  fListView->Layout();
609 }
610 
611 ////////////////////////////////////////////////////////////////////////////////
612 /// Set list view mode for container.
613 
615 {
616  if (fViewMode != viewMode) {
617  TGLayoutHints *oldLayout = fItemLayout;
618 
619  EListViewMode old = fViewMode;
620  fViewMode = viewMode;
621  if (fListView) fListView->SetViewMode(viewMode);
622 
623  if (viewMode == kLVLargeIcons)
625  else
627 
628  TGFrameElement *el;
629  TIter next(fList);
630  while ((el = (TGFrameElement *) next())) {
631  el->fLayout = fItemLayout;
632  ((TGLVEntry *) el->fFrame)->SetViewMode(viewMode);
633  }
634  delete oldLayout;
635 
636  switch (viewMode) {
637  default:
638  case kLVLargeIcons:
639  SetLayoutManager(new TGTileLayout(this, 8));
640  break;
641 
642  case kLVSmallIcons:
643  SetLayoutManager(new TGTileLayout(this, 2));
644  break;
645 
646  case kLVList:
647  SetLayoutManager(new TGListLayout(this, 2));
648  break;
649 
650  case kLVDetails:
652  break;
653  }
654 
655  TGCanvas *canvas = (TGCanvas *) this->GetParent()->GetParent();
656 
657  // layout and adjust position after layout
658  UInt_t height = fHeight;
659  UInt_t width = fWidth;
660  TGPosition pos = GetPagePosition();
661  canvas->Layout();
662  pos.fX = (pos.fX*fWidth)/width;
663  pos.fY = (pos.fY*fHeight)/height;
664 
665  if (old == kLVList) { // switch x <-> y
666  SetVsbPosition(pos.fX);
667  SetHsbPosition(0);
668  } else if (fViewMode == kLVList) {
669  SetHsbPosition(pos.fY);
670  } else {
671  SetVsbPosition(pos.fY);
672  SetHsbPosition(pos.fX);
673  }
674  }
675 }
676 
677 ////////////////////////////////////////////////////////////////////////////////
678 /// Set column information for list items.
679 
681 {
682  fCpos = cpos;
683  fJmode = jmode;
684 
685  TGFrameElement *el;
686  TIter next(fList);
687  while ((el = (TGFrameElement *) next())) {
688  ((TGLVEntry *) el->fFrame)->SetColumns(fCpos, fJmode);
689  }
690  Layout();
691 }
692 
693 ////////////////////////////////////////////////////////////////////////////////
694 /// Get size of largest item in container.
695 
697 {
698  TGDimension csize, maxsize(0,0);
699 
700  TGFrameElement *el;
701  TIter next(fList);
702  while ((el = (TGFrameElement *) next())) {
703  csize = el->fFrame->GetDefaultSize();
704  maxsize.fWidth = TMath::Max(maxsize.fWidth, csize.fWidth);
705  maxsize.fHeight = TMath::Max(maxsize.fHeight, csize.fHeight);
706  }
707  if (fViewMode == kLVLargeIcons) {
708  maxsize.fWidth += 8;
709  maxsize.fHeight += 8;
710  } else {
711  maxsize.fWidth += 2;
712  maxsize.fHeight += 2;
713  }
714  return maxsize;
715 }
716 
717 ////////////////////////////////////////////////////////////////////////////////
718 /// Get width of largest subname in container.
719 
721 {
722  if (idx == 0) {
723  return GetMaxItemSize().fWidth;
724  }
725 
726  Int_t width, maxwidth = 0;
727 
728  TGFrameElement *el;
729  TIter next(fList);
730  while ((el = (TGFrameElement *) next())) {
731  TGLVEntry *entry = (TGLVEntry *) el->fFrame;
732  width = entry->GetSubnameWidth(idx-1);
733  maxwidth = TMath::Max(maxwidth, width);
734  }
735  return maxwidth;
736 }
737 
738 ////////////////////////////////////////////////////////////////////////////////
739 /// Remove item with fUserData == userData from container.
740 
742 {
743  TGFrameElement *el;
744  TIter next(fList);
745  while ((el = (TGFrameElement *) next())) {
746  TGLVEntry *f = (TGLVEntry *) el->fFrame;
747  if (f->GetUserData() == userData) {
748  RemoveItem(f);
749  break;
750  }
751  }
752 }
753 
754 ////////////////////////////////////////////////////////////////////////////////
755 /// Select/activate item.
756 
758 {
760  fLastActive = (TGLVEntry*)el->fFrame;
761 }
762 
763 ////////////////////////////////////////////////////////////////////////////////
764 /// Unselect/deactivate item.
765 
767 {
769  fLastActive = (TGLVEntry*)el->fFrame;
770 }
771 
772 ////////////////////////////////////////////////////////////////////////////////
773 /// Handle mouse button event in container.
774 
776 {
777  if ( !fMultiSelect ) {
779  }
780 
781  Int_t total = 0, selected = fSelected, page = 0;
782 
783  TGPosition pos = GetPagePosition();
785  Int_t newpos;
786  page = dim.fHeight/4;
787 
788  if (event->fCode == kButton4) {
789  //scroll up
790  newpos = pos.fY - page;
791  if (newpos < 0) newpos = 0;
792  fCanvas->SetVsbPosition(newpos);
793  return kTRUE;
794  }
795  if (event->fCode == kButton5) {
796  // scroll down
797  newpos = fCanvas->GetVsbPosition() + page;
798  fCanvas->SetVsbPosition(newpos);
799  return kTRUE;
800  }
801 
802  Int_t xx = pos.fX + event->fX; // translate coordinates
803  Int_t yy = pos.fY + event->fY;
804 
805  if (event->fType == kButtonPress) {
806  gVirtualX->SetInputFocus(fId);
807 
808  fXp = pos.fX + event->fX;
809  fYp = pos.fY + event->fY;
810 
811  TGFrameElement *el;
812  TIter next(fList);
813  Bool_t select_frame = kFALSE;
814 
815  if (event->fState & kKeyShiftMask) {
816  Bool_t inSelection = kFALSE;
817  TGLVEntry* last = fLastActive;
818 
819  while ((el = (TGFrameElement *) next())) {
820  select_frame = kFALSE;
821 
822  if (!fMapSubwindows) {
823  if ((Int_t(el->fFrame->GetY()) + (Int_t)el->fFrame->GetHeight() > yy ) &&
824  (Int_t(el->fFrame->GetX()) + (Int_t)el->fFrame->GetWidth() > xx ) &&
825  (Int_t(el->fFrame->GetY()) < yy) &&
826  (Int_t(el->fFrame->GetX()) < xx)) {
827  select_frame = kTRUE;
828  }
829  } else {
830  if (el->fFrame->GetId() == (Window_t)event->fUser[0]) {
831  select_frame = kTRUE;
832  }
833  }
834 
835  if (select_frame || last==el->fFrame)
836  inSelection = !inSelection;
837  if (inSelection || select_frame) {
838  if ( !el->fFrame->IsActive() ) {
839  selected++;
840  ActivateItem(el);
841  }
842  Clicked(el->fFrame, event->fCode);
843  Clicked(el->fFrame, event->fCode, event->fXRoot, event->fYRoot);
844  }
845  total++;
846  }
847  } else if (event->fState & kKeyControlMask) {
848  // DO NOTHING!
849  } else {
850  UnSelectAll();
851  total = selected = 0;
852  }
853 
854  while ((el = (TGFrameElement *) next())) {
855  select_frame = kFALSE;
856 
857  if (!fMapSubwindows) {
858  if ((Int_t(el->fFrame->GetY()) + (Int_t)el->fFrame->GetHeight() > yy ) &&
859  (Int_t(el->fFrame->GetX()) + (Int_t)el->fFrame->GetWidth() > xx ) &&
860  (Int_t(el->fFrame->GetY()) < yy) &&
861  (Int_t(el->fFrame->GetX()) < xx)) {
862  select_frame = kTRUE;
863  }
864  } else {
865  if (el->fFrame->GetId() == (Window_t)event->fUser[0]) {
866  select_frame = kTRUE;
867  }
868  }
869 
870  if (select_frame) {
871  if ( el->fFrame->IsActive() ) {
872  selected--;
873  DeActivateItem(el);
874  } else {
875  selected++;
876  ActivateItem(el);
877  }
878  Clicked(el->fFrame, event->fCode);
879  Clicked(el->fFrame, event->fCode, event->fXRoot, event->fYRoot);
880  }
881  total++;
882  }
883 
884  if (fTotal != total || fSelected != selected) {
885  fTotal = total;
886  fSelected = selected;
888  fTotal, fSelected);
889  }
890 
891  if ( selected == 0 ) {
892  fDragging = kTRUE;
893  fX0 = fXf = fXp;
894  fY0 = fYf = fYp;
895  //if (fMapSubwindows)
896  gVirtualX->DrawRectangle(fId, GetLineGC()(), fX0, fY0, fXf-fX0,
897  fYf-fY0);
898  }
899  }
900 
901  if (event->fType == kButtonRelease) {
902  gVirtualX->SetInputFocus(fId);
903 
904  if (fDragging) {
905  fDragging = kFALSE;
906  fScrolling = kFALSE;
907 
909  //if (fMapSubwindows)
910  gVirtualX->DrawRectangle(fId, GetLineGC()(), fX0, fY0, fXf-fX0,
911  fYf-fY0);
912  } else {
914  event->fCode, (event->fYRoot << 16) | event->fXRoot);
915  }
916  }
917  fClient->NeedRedraw(this);
918  return kTRUE;
919 }
920 
921 ////////////////////////////////////////////////////////////////////////////////
922 /// Get list of selected items in container.
923 /// Returned TList object should be deleted by the user
924 
926 {
927  TGFrameElement *el;
928  TIter next(fList);
929  TList *ret = new TList();
930 
931  while ((el = (TGFrameElement *) next())) {
932  if (el->fFrame->IsActive()) {
933  ret->Add((TGLVEntry *)el->fFrame);
934  }
935  }
936  return ret;
937 }
938 
939 ////////////////////////////////////////////////////////////////////////////////
940 /// Get list of selected items in container.
941 /// Returned TList object and its content should be deleted
942 // lst->Delete(); delete lst;
943 
945 {
946  TGFrameElement *el;
947  TIter next(fList);
948  TList *ret = new TList();
949 
950  while ((el = (TGFrameElement *) next())) {
951  if (el->fFrame->IsActive()) {
952  ret->Add(new TObjString(((TGLVEntry*)el->fFrame)->GetItemName()->GetString()));
953  }
954  }
955  return ret;
956 }
957 
958 ////////////////////////////////////////////////////////////////////////////////
959 /// Move current position one column left.
960 
962 {
963  // in details mode just move one line up
964  if (fViewMode == kLVDetails) return LineUp(select);
965 
966  TGPosition pos = GetPagePosition();
968 
970  if (!fe) return; // empty list
971 
973 
974  if (fViewMode == kLVSmallIcons && fe == old) return;
975 
976  if (old) DeActivateItem(old); //
977  else fLastActiveEl = fe;
978 
980  Int_t dx = ms.fWidth;
981  Int_t dy = ms.fHeight;
982 
984  Int_t x = fLastActiveEl->fFrame->GetX() - dx + 2;
985 
986  Int_t hw = pos.fX + dim.fWidth;
987 
988  TGHScrollBar *hb = GetHScrollbar();
989  if (hb && hb->IsMapped()) {
990  Int_t pg = (hb->GetPageSize()*GetWidth())/fViewPort->GetWidth();
991  hw += pg;
992  }
993  if (x <= 0) { // move one line up
994  x = hw;
995  y = y - dy;
996  }
997 
998  fe = FindFrame(x, y);
999  if (fe && fe->fFrame->GetY() > fLastActiveEl->fFrame->GetY()) {
1000  // cannot go down with the left key
1001  x = hw;
1002  y = y - dy;
1003  fe = FindFrame(x, y);
1004  }
1005  if (fViewMode == kLVList) {
1006  if (fe && fe->fFrame->GetY() <= fLastActiveEl->fFrame->GetY() - (2 * dy)) {
1007  // avoid jumping more than one line up
1008  x = fe->fFrame->GetX() - dx;
1009  fe = FindFrame(x, y);
1010  }
1011  // cannot go down and/or right with the left key
1012  if (fe && fe->fFrame->GetY() >= fLastActiveEl->fFrame->GetY() &&
1013  fe->fFrame->GetX() >= fLastActiveEl->fFrame->GetX())
1014  fe = fLastActiveEl;
1015  }
1016  if (!fe || fe->fFrame->GetY() > fLastActiveEl->fFrame->GetY())
1017  fe = (TGFrameElement*)fList->First();
1018  if (!select) fSelected=1;
1019 
1020  ActivateItem(fe);
1021  AdjustPosition();
1022 }
1023 
1024 ////////////////////////////////////////////////////////////////////////////////
1025 /// Move current position one column right.
1026 
1028 {
1029  // in details mode just move one line down
1030  if (fViewMode == kLVDetails) return LineDown(select);
1031 
1032  TGPosition pos = GetPagePosition();
1033  TGDimension dim = GetPageDimension();
1034 
1036  if (!fe) return;
1037 
1039 
1040  if (fViewMode == kLVSmallIcons && fe == old) return;
1041 
1042  if (old) DeActivateItem(old);
1044 
1046  Int_t dx = ms.fWidth;
1047  Int_t dy = ms.fHeight;
1048 
1050  Int_t x = fLastActiveEl->fFrame->GetX() + dx - 2;
1051 
1052  Int_t hw = pos.fX + dim.fWidth - dx;
1053 
1054  TGHScrollBar *hb = GetHScrollbar();
1055  if (x > hw && (hb && !hb->IsMapped())) { // move one line down
1056  x = 0;
1057  y = y + dy;
1058  }
1059 
1060  fe = FindFrame(x, y);
1061  if (fe && fe->fFrame->GetY() < fLastActiveEl->fFrame->GetY()) {
1062  // cannot go up with the right key
1063  x = 0;
1064  y = y + dy;
1065  fe = FindFrame(x, y);
1066  }
1067  if (fViewMode == kLVList) {
1068  // cannot go up and/or left with the right key
1069  if (fe && fe->fFrame->GetY() <= fLastActiveEl->fFrame->GetY() &&
1070  fe->fFrame->GetX() <= fLastActiveEl->fFrame->GetX())
1071  fe = fLastActiveEl;
1072  }
1073  if (!fe || fe->fFrame->GetY() < fLastActiveEl->fFrame->GetY())
1074  fe = (TGFrameElement*)fList->Last();
1075  if (!select) fSelected = 1;
1076 
1077  ActivateItem(fe);
1078  AdjustPosition();
1079 }
1080 
1081 ////////////////////////////////////////////////////////////////////////////////
1082 /// Make current position first line in window by scrolling up.
1083 
1085 {
1087  if (!fe) return;
1088 
1090 
1091  if (old) {
1092  DeActivateItem(old);
1093  } else {
1095  }
1096 
1098  Int_t dy = ms.fHeight;
1099 
1100  Int_t y = fLastActiveEl->fFrame->GetY() - dy;
1102 
1103  fe = FindFrame(x, y);
1104  if (!fe) fe = (TGFrameElement*)fList->First();
1105  if (fe->fFrame->GetY() > fLastActiveEl->fFrame->GetY()) fe = fLastActiveEl;
1106  if (!select) fSelected = 1;
1107 
1108  ActivateItem(fe);
1109  AdjustPosition();
1110 }
1111 
1112 ////////////////////////////////////////////////////////////////////////////////
1113 /// Move one line down.
1114 
1116 {
1118  if (!fe) return;
1119 
1121 
1122  if (old) DeActivateItem(old);
1124 
1126  Int_t dy = ms.fHeight;
1127 
1128  Int_t y = fLastActiveEl->fFrame->GetY() + dy;
1130 
1131  fe = FindFrame(x, y);
1132  if (!fe) fe = (TGFrameElement*)fList->Last();
1133  if (fe->fFrame->GetY() < fLastActiveEl->fFrame->GetY()) fe = fLastActiveEl;
1134  if (!select) fSelected = 1;
1135 
1136  ActivateItem(fe);
1137  AdjustPosition();
1138 }
1139 
1140 
1141 ////////////////////////////////////////////////////////////////////////////////
1142 /// Returns page dimension.
1143 
1145 {
1146  TGDimension ret;
1147  if (!fViewPort) return ret;
1148 
1149  ret.fWidth = fViewPort->GetWidth();
1150  ret.fHeight = fViewPort->GetHeight();
1151  return ret;
1152 }
1153 
1154 ////////////////////////////////////////////////////////////////////////////////
1155 /// Select the TGLVEntry given as argument and de-select the previous one if
1156 /// the container is not in multi-selection mode.
1157 
1159 {
1160  // select (activate) the item passed as argument and deactivate the currently
1161  // active one if not in multi-select mode
1162 
1163  if ( !fMultiSelect ) {
1165  if (old)
1166  DeActivateItem(old);
1167  }
1168  ActivateItem(item->GetFrameElement());
1169 }
1170 
1171 ////////////////////////////////////////////////////////////////////////////////
1172 /// Create a list view widget.
1173 
1175  UInt_t options, ULong_t back) :
1176  TGCanvas(p, w, h, options, back)
1177 {
1179  fNColumns = 0;
1180  fColumns = 0;
1181  fJmode = 0;
1182  fColHeader = 0;
1183  fColNames = 0;
1184  fSplitHeader = 0;
1185  fJustChanged = kFALSE;
1186  fMinColumnSize = 25;
1188  fNormGC = GetDefaultGC()();
1189  if (fHScrollbar)
1190  fHScrollbar->Connect("PositionChanged(Int_t)", "TGListView",
1191  this, "ScrollHeader(Int_t)");
1193 
1195 }
1196 
1197 ////////////////////////////////////////////////////////////////////////////////
1198 /// Delete a list view widget.
1199 
1201 {
1202  if (fNColumns) {
1203  delete [] fColumns;
1204  delete [] fJmode;
1205  for (int i = 0; i < fNColumns; i++) {
1206  delete fColHeader[i];
1207  delete fSplitHeader[i];
1208  }
1209  delete [] fColHeader;
1210  delete [] fColNames;
1211  delete [] fSplitHeader;
1212  delete fHeader;
1213  }
1214 }
1215 
1216 ////////////////////////////////////////////////////////////////////////////////
1217 /// Scroll header buttons with horizontal scrollbar
1218 
1220 {
1221  Int_t i, xl = - pos;
1222  if (fViewMode == kLVDetails) {
1223  for (i = 0; i < fNColumns-1; ++i) {
1224  fColHeader[i]->Move(xl, 0);
1225  xl += fColHeader[i]->GetWidth();
1226  fSplitHeader[i]->Move(xl,fSplitHeader[i]->GetHeight());
1227  }
1228  fColHeader[i]->Move(xl, 0);
1229  xl += fColHeader[i]->GetWidth();
1230  fSplitHeader[i]->Move(xl,fSplitHeader[i]->GetHeight());
1231  }
1232 }
1233 
1234 ////////////////////////////////////////////////////////////////////////////////
1235 /// Set number of headers, i.e. columns that will be shown in detailed view.
1236 /// This method must be followed by exactly ncolumns SetHeader() calls,
1237 /// making sure that every header (i.e. idx) is set (for and example see
1238 /// SetDefaultHeaders()).
1239 
1241 {
1242  if (ncolumns <= 0) {
1243  Error("SetHeaders", "number of columns must be > 0");
1244  return;
1245  }
1246 
1247  if (fNColumns) {
1248  delete [] fColumns;
1249  delete [] fJmode;
1250  for (int i = 0; i < fNColumns; i++) {
1251  if (fColHeader[i]) fColHeader[i]->DestroyWindow();
1252  delete fColHeader[i];
1253  delete fSplitHeader[i];
1254  }
1255  delete [] fColHeader;
1256  delete [] fSplitHeader;
1257  delete [] fColNames;
1258  }
1259 
1260  fNColumns = ncolumns+1; // one extra for the blank filler header
1261  fColumns = new int[fNColumns];
1262  fJmode = new int[fNColumns];
1264  fColNames = new TString [fNColumns];
1266 
1267  for (int i = 0; i < fNColumns; i++) {
1268  fColHeader[i] = 0;
1269  fJmode[i] = kTextLeft;
1270  fSplitHeader[i] = new TGVFileSplitter(fHeader, 10);
1271  fSplitHeader[i]->Connect("LayoutListView()", "TGListView",
1272  this, "Layout()");
1273  fSplitHeader[i]->Connect("LayoutHeader(TGFrame *)", "TGListView",
1274  this, "LayoutHeader(TGFrame *)");
1275  fSplitHeader[i]->Connect("DoubleClicked(TGVFileSplitter*)", "TGListView",
1276  this, "SetDefaultColumnWidth(TGVFileSplitter*)");
1277  }
1278 
1279  // create blank filler header
1280  fColNames[fNColumns-1] = "";
1281  fColHeader[fNColumns-1] = new TGTextButton(fHeader, new TGHotString(""), -1,
1284  fColHeader[fNColumns-1]->Associate(this);
1287  fColHeader[fNColumns-1]->SetStyle(gClient->GetStyle());
1289  fColumns[fNColumns-1] = 0;
1292  fJustChanged = kTRUE;
1293 }
1294 
1295 ////////////////////////////////////////////////////////////////////////////////
1296 /// Set header button idx [0-fNColumns>, hmode is the x text alignmode
1297 /// (ETextJustification) for the header text and cmode is the x text
1298 /// alignmode for the item text.
1299 
1300 void TGListView::SetHeader(const char *s, Int_t hmode, Int_t cmode, Int_t idx)
1301 {
1302  if (idx < 0 || idx >= fNColumns-1) {
1303  Error("SetHeader", "header index must be [0 - %d>", fNColumns-1);
1304  return;
1305  }
1306  delete fColHeader[idx];
1307 
1308  fColNames[idx] = s;
1309  fColHeader[idx] = new TGTextButton(fHeader, new TGHotString(s), idx,
1312  TString txt = s;
1313  txt.ToLower();
1314  if (txt.Contains("modified")) txt += " date";
1315  if (txt.Contains("attributes")) txt = "type";
1316  fColHeader[idx]->SetToolTipText(Form("Click to sort by %s", txt.Data()));
1317  fColHeader[idx]->Associate(this);
1318  fColHeader[idx]->SetTextJustify(hmode | kTextCenterY);
1319  fSplitHeader[idx]->SetFrame(fColHeader[idx], kTRUE);
1320 
1321  fColHeader[idx]->SetStyle(gClient->GetStyle());
1322 
1323  // fJmode and fColumns contain values for columns idx > 0. idx==0 is
1324  // the small icon with the object name
1325  if (idx > 0)
1326  fJmode[idx-1] = cmode;
1327 
1328  if (!fColHeader[0]) return;
1329  int xl = fColHeader[0]->GetDefaultWidth() + 10 + fSplitHeader[0]->GetDefaultWidth();
1330  for (int i = 1; i < fNColumns; i++) {
1331  fColumns[i-1] = xl;
1332  if (!fColHeader[i]) break;
1334  }
1335 }
1336 
1337 ////////////////////////////////////////////////////////////////////////////////
1338 /// Returns name of header idx. If illegal idx or header not set for idx
1339 /// 0 is returned.
1340 
1341 const char *TGListView::GetHeader(Int_t idx) const
1342 {
1343  if (idx >= 0 && idx < fNColumns-1 && fColHeader[idx])
1344  return (const char*) fColNames[idx];
1345  return 0;
1346 }
1347 
1348 ////////////////////////////////////////////////////////////////////////////////
1349 /// Default headers are: Name, Attributes, Size, Owner, Group, Modified.
1350 /// The default is good for file system items.
1351 
1353 {
1354  SetHeaders(6);
1355  SetHeader("Name", kTextLeft, kTextLeft, 0);
1356  SetHeader("Attributes", kTextCenterX, kTextCenterX, 1);
1357  SetHeader("Size", kTextRight, kTextRight, 2);
1358  SetHeader("Owner", kTextCenterX, kTextCenterX, 3);
1359  SetHeader("Group", kTextCenterX, kTextCenterX, 4);
1360  SetHeader("Modified", kTextCenterX, kTextCenterX, 5);
1361 }
1362 
1363 ////////////////////////////////////////////////////////////////////////////////
1364 /// Set list view mode.
1365 
1367 {
1368  TGLVContainer *container;
1369 
1370  if (fViewMode != viewMode) {
1371  fJustChanged = kTRUE;
1372  fViewMode = viewMode;
1373  container = (TGLVContainer *) fVport->GetContainer();
1374  if (container) container->SetViewMode(viewMode);
1375  Layout();
1376  }
1377 }
1378 
1379 ////////////////////////////////////////////////////////////////////////////////
1380 /// Set list view container. Container must be at least of type
1381 /// TGLVContainer.
1382 
1384 {
1385  if (f->InheritsFrom(TGLVContainer::Class())) {
1387  ((TGLVContainer *) f)->SetColumns(fColumns, fJmode);
1388  ((TGLVContainer *) f)->SetListView(this);
1389  } else
1390  Error("SetContainer", "frame must inherit from TGLVContainer");
1391 }
1392 
1393 ////////////////////////////////////////////////////////////////////////////////
1394 /// Set horizontal and vertical scrollbar increments.
1395 
1397 {
1400 }
1401 
1402 ////////////////////////////////////////////////////////////////////////////////
1403 /// Set default column width of the columns headers.
1404 
1406 {
1407  TGLVContainer *container = (TGLVContainer *) fVport->GetContainer();
1408 
1409  if (!container) {
1410  Error("SetDefaultColumnWidth", "no listview container set yet");
1411  return;
1412  }
1413  container->ClearViewPort();
1414 
1415  for (int i = 0; i < fNColumns; ++i) {
1416  if ( fSplitHeader[i] == splitter ) {
1417  TString dt = fColHeader[i]->GetString();
1418  UInt_t bsize = gVirtualX->TextWidth(fColHeader[i]->GetFontStruct(),
1419  dt.Data(), dt.Length());
1420  UInt_t w = TMath::Max(fColHeader[i]->GetDefaultWidth(), bsize + 20);
1421  if (i == 0) w = TMath::Max(fMaxSize.fWidth + 10, w);
1422  if (i > 0) w = TMath::Max(container->GetMaxSubnameWidth(i) + 40, (Int_t)w);
1423  fColHeader[i]->Resize(w, fColHeader[i]->GetHeight());
1424  Layout();
1425  }
1426  }
1427 }
1428 
1429 ////////////////////////////////////////////////////////////////////////////////
1430 /// Resize column headers to show whole item names.
1431 
1433 {
1434  for (int i = 0; i < fNColumns; ++i) {
1435  TGLVContainer *container = (TGLVContainer *) fVport->GetContainer();
1436  if (!container) {
1437  Error("ResizeColumns", "no listview container set yet");
1438  return;
1439  }
1440  fMaxSize = container->GetMaxItemSize();
1442  }
1443 }
1444 
1445 ////////////////////////////////////////////////////////////////////////////////
1446 /// Layout list view components (container and contents of container).
1447 
1449 {
1450  Int_t i, xl = 0;
1451  UInt_t w, h = 0;
1452 
1453  TGLVContainer *container = (TGLVContainer *) fVport->GetContainer();
1454 
1455  if (!container) {
1456  Error("Layout", "no listview container set yet");
1457  return;
1458  }
1459 
1460  fMaxSize = container->GetMaxItemSize();
1461 
1462  if (fViewMode == kLVDetails) {
1463  h = fColHeader[0]->GetDefaultHeight()-4;
1464  fHeader->MoveResize(0, 0, fWidth, h);
1465  fHeader->MapWindow();
1466  for (i = 0; i < fNColumns-1; ++i) {
1467  fColHeader[i]->SetText(fColNames[i]);
1468 
1469  if ( fJustChanged ) {
1471  if (w < fMinColumnSize) w = fColHeader[i]->GetDefaultWidth();
1472  if (i == 0) w = TMath::Max(fMaxSize.fWidth + 10, w);
1473  if (i > 0) w = TMath::Max(container->GetMaxSubnameWidth(i) + 40, (Int_t)w);
1474  } else {
1475  w = fColHeader[i]->GetWidth();
1476  }
1477  w = TMath::Max(fMinColumnSize, w);
1478  if ( fColHeader[i]->GetDefaultWidth() > w ) {
1479  for (int j = fColNames[i].Length() - 1 ; j > 0; j--) {
1480  fColHeader[i]->SetText( fColNames[i](0,j) + "..." );
1481  if ( fColHeader[i]->GetDefaultWidth() < w )
1482  break;
1483  }
1484  }
1485 
1486  fColHeader[i]->MoveResize(xl, 0, w, h);
1487  fColHeader[i]->MapWindow();
1488  xl += w;
1489  fSplitHeader[i]->Move(xl, 0);
1490  fSplitHeader[i]->MapWindow();
1491  fColumns[i] = xl-2; // -2 is fSep in the layout routine
1492  }
1493  fColHeader[i]->MoveResize(xl, 0, fVport->GetWidth()-xl, h);
1494  fColHeader[i]->MapWindow();
1496  fSplitHeader[i]->MapWindow();
1498 
1499  container->SetColumns(fColumns, fJmode);
1500 
1501  } else {
1502  for (i = 0; i < fNColumns; ++i) {
1503  fColHeader[i]->UnmapWindow();
1504  fSplitHeader[i]->UnmapWindow();
1505  }
1506  fHeader->UnmapWindow();
1507  }
1508  // coverity[returned_null]
1509  // coverity[dereference]
1510  TGLayoutManager *lm = container->GetLayoutManager();
1511  lm->SetDefaultWidth(xl);
1512  TGCanvas::Layout();
1513 
1514  if (fViewMode == kLVDetails) {
1515  container->Resize(container->GetWidth(), container->GetHeight()+h);
1516  fVScrollbar->SetRange((Int_t)container->GetHeight(),
1517  (Int_t)fVport->GetHeight());
1518  if (fJustChanged) {
1520  fVport->GetHeight());
1521  container->Move(0, h);
1522  } else {
1523  container->DrawRegion(0, 0, fVport->GetWidth(), fVport->GetHeight());
1524  }
1525  fColHeader[i]->MoveResize(xl, 0, fVport->GetWidth()-xl, h);
1526  fColHeader[i]->MapWindow();
1527  } else {
1529  fVport->GetHeight());
1530  container->Move(0, 0);
1531  }
1532 
1533  fJustChanged = kFALSE;
1534 }
1535 
1536 ////////////////////////////////////////////////////////////////////////////////
1537 /// Layout list view components (container and contents of container).
1538 
1540 {
1541  Int_t i, xl = 0;
1542  UInt_t w, h = 0;
1543  static Int_t oldPos = 0;
1544  if (head == 0) oldPos = 0;
1545 
1546  TGLVContainer *container = (TGLVContainer *) fVport->GetContainer();
1547 
1548  if (!container) {
1549  Error("Layout", "no listview container set yet");
1550  return;
1551  }
1552  fMaxSize = container->GetMaxItemSize();
1553  Int_t posx = container->GetPagePosition().fX;
1554 
1555  if (fViewMode == kLVDetails) {
1556  h = fColHeader[0]->GetDefaultHeight()-4;
1557  fHeader->MoveResize(0, 0, fWidth, h);
1558  fHeader->MapWindow();
1559  for (i = 0; i < fNColumns-1; ++i) {
1560  fColHeader[i]->SetText(fColNames[i]);
1561 
1562  if ( fJustChanged ) {
1564  if (w < fMinColumnSize) w = fColHeader[i]->GetDefaultWidth();
1565  if (i == 0) w = TMath::Max(fMaxSize.fWidth + 10, w);
1566  if (i > 0) w = TMath::Max(container->GetMaxSubnameWidth(i) + 40, (Int_t)w);
1567  } else {
1568  w = fColHeader[i]->GetWidth();
1569  }
1570  w = TMath::Max(fMinColumnSize, w);
1571  if ( fColHeader[i]->GetDefaultWidth() > w ) {
1572  for (int j = fColNames[i].Length() - 1 ; j > 0; j--) {
1573  fColHeader[i]->SetText( fColNames[i](0,j) + "..." );
1574  if ( fColHeader[i]->GetDefaultWidth() < w )
1575  break;
1576  }
1577  }
1578 
1579  if ((TGFrame *)fColHeader[i] == head) {
1580  if (oldPos > 0) {
1581  gVirtualX->DrawLine(container->GetId(), container->GetLineGC()(),
1582  oldPos - posx, 0, oldPos - posx, fVport->GetHeight());
1583  }
1584  gVirtualX->DrawLine(container->GetId(), container->GetLineGC()(),
1585  xl + w - posx, 0, xl + w - posx, fVport->GetHeight());
1586  oldPos = xl + w;
1587  }
1588 
1589  fColHeader[i]->MoveResize(xl - posx, 0, w, h);
1590  fColHeader[i]->MapWindow();
1591  xl += w;
1592  fSplitHeader[i]->Move(xl, 0);
1593  fSplitHeader[i]->MapWindow();
1594  fColumns[i] = xl-2; // -2 is fSep in the layout routine
1595  }
1596  fColHeader[i]->MoveResize(xl - posx, 0, fVport->GetWidth()-xl, h);
1597  fColHeader[i]->MapWindow();
1599  fSplitHeader[i]->MapWindow();
1601  }
1602  fJustChanged = kFALSE;
1603 }
1604 
1605 ////////////////////////////////////////////////////////////////////////////////
1606 /// Handle messages generated by the list view components.
1607 
1609 {
1611 
1612  const TGLVEntry *entry;
1613  void *p = 0;
1614 
1615  entry = (TGLVEntry *) cnt->GetNextSelected(&p);
1616 
1617  switch (GET_SUBMSG(msg)) {
1618  case kCT_ITEMCLICK:
1619  if ((cnt->NumSelected() == 1) && (entry != 0)) {
1620  Int_t x = (Int_t)(parm2 & 0xffff);
1621  Int_t y = (Int_t)((parm2 >> 16) & 0xffff);
1622  Clicked((TGLVEntry*)entry, (Int_t)parm1);
1623  Clicked((TGLVEntry*)entry, (Int_t)parm1, x, y);
1624  }
1625  break;
1626  case kCT_ITEMDBLCLICK:
1627  if ((cnt->NumSelected() == 1) && (entry!=0)) {
1628  Int_t x = (Int_t)(parm2 & 0xffff);
1629  Int_t y = (Int_t)((parm2 >> 16) & 0xffff);
1630  DoubleClicked((TGLVEntry*)entry, (Int_t)parm1);
1631  DoubleClicked((TGLVEntry*)entry, (Int_t)parm1, x, y);
1632  }
1633  break;
1634  case kCT_SELCHANGED:
1635  SelectionChanged();
1636  break;
1637  default:
1638  break;
1639  }
1640  return TGCanvas::ProcessMessage(msg, parm1, parm2);
1641 }
1642 
1643 ////////////////////////////////////////////////////////////////////////////////
1644 /// Emit Clicked() signal.
1645 
1647 {
1648  Long_t args[2];
1649 
1650  args[0] = (Long_t)entry;
1651  args[1] = btn;
1652 
1653  Emit("Clicked(TGLVEntry*,Int_t)", args);
1654 }
1655 
1656 ////////////////////////////////////////////////////////////////////////////////
1657 /// Emit Clicked() signal.
1658 
1660 {
1661  Long_t args[4];
1662 
1663  args[0] = (Long_t)entry;
1664  args[1] = btn;
1665  args[2] = x;
1666  args[3] = y;
1667 
1668  Emit("Clicked(TGLVEntry*,Int_t,Int_t,Int_t)", args);
1669 }
1670 
1671 ////////////////////////////////////////////////////////////////////////////////
1672 /// Emit DoubleClicked() signal.
1673 
1675 {
1676  Long_t args[2];
1677 
1678  args[0] = (Long_t)entry;
1679  args[1] = btn;
1680 
1681  Emit("DoubleClicked(TGLVEntry*,Int_t)", args);
1682 }
1683 
1684 ////////////////////////////////////////////////////////////////////////////////
1685 /// Emit DoubleClicked() signal.
1686 
1688 {
1689  Long_t args[4];
1690 
1691  args[0] = (Long_t)entry;
1692  args[1] = btn;
1693  args[2] = x;
1694  args[3] = y;
1695 
1696  Emit("DoubleClicked(TGLVEntry*,Int_t,Int_t,Int_t)", args);
1697 }
1698 
1699 ////////////////////////////////////////////////////////////////////////////////
1700 /// Return the default font structure in use.
1701 
1703 {
1704  if (!fgDefaultFont)
1705  fgDefaultFont = gClient->GetResourcePool()->GetIconFont();
1706  return fgDefaultFont->GetFontStruct();
1707 }
1708 
1709 ////////////////////////////////////////////////////////////////////////////////
1710 /// Return the default graphics context in use.
1711 
1713 {
1714  if (!fgDefaultGC) {
1715  fgDefaultGC = new TGGC(*gClient->GetResourcePool()->GetFrameGC());
1717  }
1718  return *fgDefaultGC;
1719 }
1720 
1721 ////////////////////////////////////////////////////////////////////////////////
1722 /// Save a list view widget as a C++ statement(s) on output stream out.
1723 
1724 void TGListView::SavePrimitive(std::ostream &out, Option_t *option /*= ""*/)
1725 {
1726  if (fBackground != GetDefaultFrameBackground()) SaveUserColor(out, option);
1727 
1728  out << std::endl << " // list view" << std::endl;
1729  out <<" TGListView *";
1730  out << GetName() << " = new TGListView(" << fParent->GetName()
1731  << "," << GetWidth() << "," << GetHeight();
1732 
1734  if (GetOptions() == (kSunkenFrame | kDoubleBorder)) {
1735  out <<");" << std::endl;
1736  } else {
1737  out << "," << GetOptionString() <<");" << std::endl;
1738  }
1739  } else {
1740  out << "," << GetOptionString() << ",ucolor);" << std::endl;
1741  }
1742  if (option && strstr(option, "keep_names"))
1743  out << " " << GetName() << "->SetName(\"" << GetName() << "\");" << std::endl;
1744 
1745  GetContainer()->SavePrimitive(out, option);
1746 
1747  out << std::endl;
1748  out << " " << GetName() << "->SetContainer(" << GetContainer()->GetName()
1749  << ");" << std::endl;
1750  out << " " << GetName() << "->SetViewMode(";
1751  switch (fViewMode) {
1752  case kLVLargeIcons:
1753  out << "kLVLargeIcons";
1754  break;
1755  case kLVSmallIcons:
1756  out << "kLVSmallIcons";
1757  break;
1758  case kLVList:
1759  out << "kLVList";
1760  break;
1761  case kLVDetails:
1762  out << "kLVDetails";
1763  break;
1764  }
1765  out << ");" << std::endl;
1766 
1767  out << " " << GetContainer()->GetName() << "->Resize();" << std::endl;
1768 
1769  if (fHScrollbar && fHScrollbar->IsMapped()) {
1770  out << " " << GetName() << "->SetHsbPosition(" << GetHsbPosition()
1771  << ");" << std::endl;
1772  }
1773 
1774  if (fVScrollbar && fVScrollbar->IsMapped()) {
1775  out << " " << GetName() << "->SetVsbPosition(" << GetVsbPosition()
1776  << ");" << std::endl;
1777  }
1778 }
1779 
1780 ////////////////////////////////////////////////////////////////////////////////
1781 /// Save a list view container as a C++ statement(s) on output stream out.
1782 
1783 void TGLVContainer::SavePrimitive(std::ostream &out, Option_t *option /*= ""*/)
1784 {
1785  if (fBackground != GetDefaultFrameBackground()) SaveUserColor(out, option);
1786 
1787  out << std::endl << " // list view container" << std::endl;
1788  out << " TGLVContainer *";
1789 
1790  if ((fParent->GetParent())->InheritsFrom(TGCanvas::Class())) {
1791  out << GetName() << " = new TGLVContainer(" << GetCanvas()->GetName();
1792  } else {
1793  out << GetName() << " = new TGLVContainer(" << fParent->GetName();
1794  out << "," << GetWidth() << "," << GetHeight();
1795  }
1797  if (GetOptions() == (kSunkenFrame | kDoubleBorder)) {
1798  out <<");" << std::endl;
1799  } else {
1800  out << "," << GetOptionString() <<");" << std::endl;
1801  }
1802  } else {
1803  out << "," << GetOptionString() << ",ucolor);" << std::endl;
1804  }
1805  if (option && strstr(option, "keep_names"))
1806  out << " " << GetName() << "->SetName(\"" << GetName() << "\");" << std::endl;
1807 }
TGButton::SetToolTipText
virtual void SetToolTipText(const char *text, Long_t delayms=400)
Set tool tip text associated with this button.
Definition: TGButton.cxx:445
TGLVEntry::~TGLVEntry
virtual ~TGLVEntry()
Delete a list view item.
Definition: TGListView.cxx:182
EListViewMode
EListViewMode
Definition: TGListView.h:21
TGLVContainer::SavePrimitive
virtual void SavePrimitive(std::ostream &out, Option_t *option="")
Save a list view container as a C++ statement(s) on output stream out.
Definition: TGListView.cxx:1783
TGContainer::fSelected
Int_t fSelected
number of selected items
Definition: TGCanvas.h:49
TGCanvas::GetHsbPosition
virtual Int_t GetHsbPosition() const
Get position of horizontal scrollbar.
Definition: TGCanvas.cxx:2374
TGCanvas::ProcessMessage
virtual Bool_t ProcessMessage(Long_t msg, Long_t parm1, Long_t parm2)
Handle message generated by the canvas scrollbars.
Definition: TGCanvas.cxx:2344
TGFrame::GetHeight
UInt_t GetHeight() const
Definition: TGFrame.h:225
TGContainer::Clicked
virtual void Clicked(TGFrame *f, Int_t btn)
Emit Clicked() signal.
Definition: TGCanvas.cxx:510
TGVScrollBar::SetRange
virtual void SetRange(Int_t range, Int_t page_size)
Set range of vertical scrollbar.
Definition: TGScrollBar.cxx:892
TGLVEntry::fTWidth
UInt_t fTWidth
width of name
Definition: TGListView.h:48
TGFrameElement::fLayout
TGLayoutHints * fLayout
Definition: TGLayout.h:114
TGLVEntry::SetPictures
virtual void SetPictures(const TGPicture *bigpic=0, const TGPicture *smallpic=0)
change pictures
Definition: TGListView.cxx:298
TGLVEntry::fViewMode
EListViewMode fViewMode
list view viewing mode
Definition: TGListView.h:52
TGWindow
ROOT GUI Window base class.
Definition: TGWindow.h:23
kLHintsCenterX
@ kLHintsCenterX
Definition: TGLayout.h:25
TGPosition::fY
Int_t fY
y position
Definition: TGDimension.h:39
kTRUE
const Bool_t kTRUE
Definition: RtypesCore.h:100
kFixedWidth
@ kFixedWidth
Definition: GuiTypes.h:387
TGLVEntry::fActive
Bool_t fActive
true if item is active
Definition: TGListView.h:50
TGLVEntry::fFontStruct
FontStruct_t fFontStruct
text font
Definition: TGListView.h:59
TGFrame::fgBlackPixel
static Pixel_t fgBlackPixel
Definition: TGFrame.h:104
TGListView::~TGListView
virtual ~TGListView()
Delete a list view widget.
Definition: TGListView.cxx:1200
TGContainer::fCanvas
TGCanvas * fCanvas
pointer to canvas
Definition: TGCanvas.h:41
TGCompositeFrame::GetLayoutManager
virtual TGLayoutManager * GetLayoutManager() const
Definition: TGFrame.h:338
TGPicture
The TGPicture class implements pictures and icons used in the different GUI elements and widgets.
Definition: TGPicture.h:25
f
#define f(i)
Definition: RSha256.hxx:104
TGDimension
Definition: TGDimension.h:18
TGCanvas::fHScrollbar
TGHScrollBar * fHScrollbar
horizontal scrollbar
Definition: TGCanvas.h:196
Option_t
const char Option_t
Definition: RtypesCore.h:66
TMath::Max
Short_t Max(Short_t a, Short_t b)
Definition: TMathBase.h:212
TGListView::fColNames
TString * fColNames
column titles for in detailed mode
Definition: TGListView.h:128
TGScrollBar::GetPageSize
virtual Int_t GetPageSize() const
Definition: TGScrollBar.h:114
TGPicture::GetWidth
UInt_t GetWidth() const
Definition: TGPicture.h:52
TGListView::fColHeader
TGTextButton ** fColHeader
column headers for in detailed mode
Definition: TGListView.h:127
TGLVEntry::fChecked
Bool_t fChecked
true if item is checked
Definition: TGListView.h:51
TGWindow::RaiseWindow
virtual void RaiseWindow()
raise window
Definition: TGWindow.cxx:208
gVirtualX
#define gVirtualX
Definition: TVirtualX.h:338
TGContainer::GetLineGC
static const TGGC & GetLineGC()
Get graphics context for line drawing.
Definition: TGCanvas.cxx:2105
TGLVContainer::SelectEntry
virtual void SelectEntry(TGLVEntry *item)
Select the TGLVEntry given as argument and de-select the previous one if the container is not in mult...
Definition: TGListView.cxx:1158
kLVLargeIcons
@ kLVLargeIcons
Definition: TGListView.h:22
TSystem::RemoveTimer
virtual TTimer * RemoveTimer(TTimer *t)
Remove timer from list of system timers.
Definition: TSystem.cxx:483
TString::Data
const char * Data() const
Definition: TString.h:369
Pixel_t
ULong_t Pixel_t
Pixel value.
Definition: GuiTypes.h:40
TGLVContainer::GetSelectedItems
TList * GetSelectedItems()
Get list of selected items in container.
Definition: TGListView.cxx:944
TGContainer::fScrolling
Bool_t fScrolling
kTRUE - when scrolling is ON
Definition: TGCanvas.h:59
ClassImp
#define ClassImp(name)
Definition: Rtypes.h:364
Form
char * Form(const char *fmt,...)
TGLVContainer::fViewMode
EListViewMode fViewMode
list view viewing mode
Definition: TGListView.h:186
TObjString.h
TGPicture.h
TGFrame::fWidth
UInt_t fWidth
frame width
Definition: TGFrame.h:87
TGContainer::FindFrame
virtual TGFrameElement * FindFrame(Int_t x, Int_t y, Bool_t exclude=kTRUE)
Find frame located int container at position x,y.
Definition: TGCanvas.cxx:1657
TGLVContainer::~TGLVContainer
virtual ~TGLVContainer()
Delete list view container.
Definition: TGListView.cxx:560
TGCanvas::GetContainer
TGFrame * GetContainer() const
Definition: TGCanvas.h:216
FontStruct_t
Handle_t FontStruct_t
Pointer to font structure.
Definition: GuiTypes.h:39
TGHotString
TGHotString is a string with a "hot" character underlined.
Definition: TGString.h:42
TGLVContainer::LineUp
virtual void LineUp(Bool_t select=kFALSE)
Make current position first line in window by scrolling up.
Definition: TGListView.cxx:1084
TObject::Error
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:893
TGListView::fMaxSize
TGDimension fMaxSize
maximum item size
Definition: TGListView.h:126
TGListView::fFontStruct
FontStruct_t fFontStruct
text font
Definition: TGListView.h:131
TGListView::GetDefaultFontStruct
static FontStruct_t GetDefaultFontStruct()
Return the default font structure in use.
Definition: TGListView.cxx:1702
TGFrame::GetDefaultHeight
virtual UInt_t GetDefaultHeight() const
Definition: TGFrame.h:191
kButton4
@ kButton4
Definition: GuiTypes.h:215
TGFrame::SavePrimitive
virtual void SavePrimitive(std::ostream &out, Option_t *option="")
Save a frame widget as a C++ statement(s) on output stream out.
Definition: TGFrame.cxx:3207
TGVSplitter::SetFrame
virtual void SetFrame(TGFrame *frame, Bool_t left)
Set frame to be resized.
Definition: TGSplitter.cxx:143
TGVFileSplitter
Definition: TGSplitter.h:126
TGLVEntry::GetDefaultFontStruct
static FontStruct_t GetDefaultFontStruct()
Return the default font structure in use.
Definition: TGListView.cxx:496
width
include TDocParser_001 C image html pict1_TDocParser_001 png width
Definition: TDocParser.cxx:121
TGTextButton
Yield an action as soon as it is clicked.
Definition: TGButton.h:142
TGListView::fJustChanged
Bool_t fJustChanged
Indicate whether the view mode was just changed to Detail.
Definition: TGListView.h:133
TGLVEntry::GetSubnameWidth
virtual Int_t GetSubnameWidth(Int_t idx) const
Definition: TGListView.h:107
TGeant4Unit::s
static constexpr double s
Definition: TGeant4SystemOfUnits.h:162
TGLVContainer::fJmode
Int_t * fJmode
alignment of sub names
Definition: TGListView.h:188
TGLVEntry
Definition: TGListView.h:36
Int_t
int Int_t
Definition: RtypesCore.h:45
TGLVContainer::LineRight
virtual void LineRight(Bool_t select=kFALSE)
Move current position one column right.
Definition: TGListView.cxx:1027
TGListView::SetHeaders
virtual void SetHeaders(Int_t ncolumns)
Set number of headers, i.e.
Definition: TGListView.cxx:1240
TGListView::ResizeColumns
virtual void ResizeColumns()
Resize column headers to show whole item names.
Definition: TGListView.cxx:1432
TString::Contains
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition: TString.h:624
kCT_SELCHANGED
@ kCT_SELCHANGED
Definition: WidgetMessageTypes.h:56
TGLVContainer::fCpos
Int_t * fCpos
position of sub names
Definition: TGListView.h:187
TGListView::fgDefaultFont
static const TGFont * fgDefaultFont
Definition: TGListView.h:136
kTextCenterX
@ kTextCenterX
Definition: TGWidget.h:25
event
Definition: triangle.c:553
TGPicture::Draw
void Draw(Option_t *="")
Default Draw method for all objects.
Definition: TGPicture.h:46
x
Double_t x[n]
Definition: legend1.C:17
TString::Length
Ssiz_t Length() const
Definition: TString.h:410
TGCanvas::Layout
virtual void Layout()
Create layout for canvas.
Definition: TGCanvas.cxx:2229
TGMimeTypes.h
TGFrame::fgWhitePixel
static Pixel_t fgWhitePixel
Definition: TGFrame.h:103
TList.h
TList::Last
virtual TObject * Last() const
Return the last object in the list. Returns 0 when list is empty.
Definition: TList.cxx:693
TGSelectedPicture
Definition: TGPicture.h:67
Handle_t
ULongptr_t Handle_t
Generic resource handle.
Definition: GuiTypes.h:26
TGFrame::GetDefaultFrameBackground
static Pixel_t GetDefaultFrameBackground()
Get default frame background.
Definition: TGFrame.cxx:683
TGListView::ProcessMessage
virtual Bool_t ProcessMessage(Long_t msg, Long_t parm1, Long_t parm2)
Handle messages generated by the list view components.
Definition: TGListView.cxx:1608
TVirtualX.h
TGLVEntry::fBigPic
const TGPicture * fBigPic
big icon
Definition: TGListView.h:53
kTextCenterY
@ kTextCenterY
Definition: TGWidget.h:28
TGClient::GetResourcePool
const TGResourcePool * GetResourcePool() const
Definition: TGClient.h:124
TGListView::fJmode
Int_t * fJmode
column text alignment
Definition: TGListView.h:124
TGFrame::GetDefaultSize
virtual TGDimension GetDefaultSize() const
std::cout << fWidth << "x" << fHeight << std::endl;
Definition: TGFrame.cxx:584
TString
Basic string class.
Definition: TString.h:136
TGFrame
A subclasses of TGWindow, and is used as base class for some simple widgets (buttons,...
Definition: TGFrame.h:80
TGLVContainer::SetColumns
virtual void SetColumns(Int_t *cpos, Int_t *jmode)
Set column information for list items.
Definition: TGListView.cxx:680
TGObject::GetId
Handle_t GetId() const
Definition: TGObject.h:37
TGTextButton::SetTextJustify
virtual void SetTextJustify(Int_t tmode)
Set text justification.
Definition: TGButton.cxx:695
TGCanvas::GetVsbPosition
virtual Int_t GetVsbPosition() const
Get position of vertical scrollbar.
Definition: TGCanvas.cxx:2384
kDoubleBorder
@ kDoubleBorder
Definition: GuiTypes.h:385
TGListView
A list view is a widget that can contain a number of items arranged in a grid or list.
Definition: TGListView.h:115
kCT_ITEMDBLCLICK
@ kCT_ITEMDBLCLICK
Definition: WidgetMessageTypes.h:55
TObject::InheritsFrom
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
Definition: TObject.cxx:445
TGListView::fgDefaultGC
static TGGC * fgDefaultGC
Definition: TGListView.h:137
TGLVContainer::fLastActive
TGLVEntry * fLastActive
last active item
Definition: TGListView.h:191
TGLVEntry::GetDefaultSize
virtual TGDimension GetDefaultSize() const
Get default size of list item.
Definition: TGListView.cxx:469
TGCanvas::SetVsbPosition
virtual void SetVsbPosition(Int_t newPos)
Set position of vertical scrollbar.
Definition: TGCanvas.cxx:2408
TGFrame::MapWindow
virtual void MapWindow()
map window
Definition: TGFrame.h:204
TGListView::GetMaxItemSize
TGDimension GetMaxItemSize() const
Definition: TGListView.h:166
bool
TGLVContainer::GetMaxSubnameWidth
virtual Int_t GetMaxSubnameWidth(Int_t idx) const
Get width of largest subname in container.
Definition: TGListView.cxx:720
TGFrame::GetWidth
UInt_t GetWidth() const
Definition: TGFrame.h:224
TGContainer::fYp
Int_t fYp
previous pointer position
Definition: TGCanvas.h:44
TGCompositeFrame::fList
TList * fList
container of frame elements
Definition: TGFrame.h:292
TGContainer::AdjustPosition
virtual void AdjustPosition()
Move content to position of highlighted/activated frame.
Definition: TGCanvas.cxx:1793
TGFrameElement::fFrame
TGFrame * fFrame
Definition: TGLayout.h:112
TGFrame::GetOptionString
TString GetOptionString() const
Returns a frame option string - used in SavePrimitive().
Definition: TGFrame.cxx:2480
TGLayoutManager
Frame layout manager.
Definition: TGLayout.h:135
TGListView::TGListView
TGListView(const TGListView &)=delete
TGFrame::GetOptions
virtual UInt_t GetOptions() const
Definition: TGFrame.h:197
TGLVEntry::DrawCopy
virtual void DrawCopy(Handle_t id, Int_t x, Int_t y)
Draw list view item in other window.
Definition: TGListView.cxx:330
TGLVEntry::fTHeight
UInt_t fTHeight
height of name
Definition: TGListView.h:49
TGLayoutManager::SetDefaultWidth
virtual void SetDefaultWidth(UInt_t)
Definition: TGLayout.h:144
TGWindow::DestroyWindow
virtual void DestroyWindow()
destroy window
Definition: TGWindow.cxx:192
TGContainer::RemoveItem
virtual void RemoveItem(TGFrame *item)
Remove item from container.
Definition: TGCanvas.cxx:660
TObjString
Collectable string class.
Definition: TObjString.h:28
TGLVContainer::GetMaxItemSize
virtual TGDimension GetMaxItemSize() const
Get size of largest item in container.
Definition: TGListView.cxx:696
gClient
#define gClient
Definition: TGClient.h:157
kTextLeft
@ kTextLeft
Definition: TGWidget.h:23
TGLVEntry::Activate
virtual void Activate(Bool_t a)
Make list view item active.
Definition: TGListView.cxx:260
TGContainer::fMsgWindow
const TGWindow * fMsgWindow
window handling container messages
Definition: TGCanvas.h:42
TList::First
virtual TObject * First() const
Return the first object in the list. Returns 0 when list is empty.
Definition: TList.cxx:659
total
static unsigned int total
Definition: TGWin32ProxyDefs.h:40
TGListView::fNColumns
Int_t fNColumns
number of columns
Definition: TGListView.h:122
TGString::GetLength
Int_t GetLength() const
Definition: TGString.h:29
TGListView::SetHeader
virtual void SetHeader(const char *s, Int_t hmode, Int_t cmode, Int_t idx)
Set header button idx [0-fNColumns>, hmode is the x text alignmode (ETextJustification) for the heade...
Definition: TGListView.cxx:1300
TGContainer::fY0
Int_t fY0
corner of rubber band box
Definition: TGCanvas.h:45
TGLVContainer::GetPageDimension
virtual TGDimension GetPageDimension() const
Returns page dimension.
Definition: TGListView.cxx:1144
TGLVContainer::GetSelectedEntries
TList * GetSelectedEntries()
Get list of selected items in container.
Definition: TGListView.cxx:925
TGContainer::GetPagePosition
virtual TGPosition GetPagePosition() const
Returns page position.
Definition: TGCanvas.cxx:737
kSunkenFrame
@ kSunkenFrame
Definition: GuiTypes.h:383
TGScrollBar::SetSmallIncrement
virtual void SetSmallIncrement(Int_t increment)
Definition: TGScrollBar.h:134
TGContainer::GetHScrollbar
virtual TGHScrollBar * GetHScrollbar() const
returns pointer to hor. scroll bar
Definition: TGCanvas.cxx:1745
TSystem.h
TGPosition::fX
Int_t fX
x position
Definition: TGDimension.h:38
kLHintsCenterY
@ kLHintsCenterY
Definition: TGLayout.h:28
TGDimension::fHeight
UInt_t fHeight
Definition: TGDimension.h:21
TGLVEntry::fSelPic
TGSelectedPicture * fSelPic
selected icon
Definition: TGListView.h:57
h
#define h(i)
Definition: RSha256.hxx:106
TGTextButton::SetText
virtual void SetText(TGHotString *new_label)
Set new button text.
Definition: TGButton.cxx:644
TGContainer::SetHsbPosition
virtual void SetHsbPosition(Int_t newPos)
set new hor. position
Definition: TGCanvas.cxx:1777
TGContainer::Layout
virtual void Layout()
Layout container entries.
Definition: TGCanvas.cxx:422
size
size_t size(const MatrixT &matrix)
retrieve the size of a square matrix
TGWindow::GetName
virtual const char * GetName() const
Return unique name, used in SavePrimitive methods.
Definition: TGWindow.cxx:336
TGCanvas::fVScrollbar
TGVScrollBar * fVScrollbar
vertical scrollbar
Definition: TGCanvas.h:197
TGLVContainer::fMultiSelect
Bool_t fMultiSelect
true = multiple file selection
Definition: TGListView.h:189
TGContainer::fLastActiveEl
TGFrameElement * fLastActiveEl
last active item
Definition: TGCanvas.h:43
TGGC
Encapsulate a graphics context used in the low level graphics.
Definition: TGGC.h:22
kLVDetails
@ kLVDetails
Definition: TGListView.h:25
TGWidget::Associate
virtual void Associate(const TGWindow *w)
Definition: TGWidget.h:72
TGFrame::Resize
virtual void Resize(UInt_t w=0, UInt_t h=0)
Resize the frame.
Definition: TGFrame.cxx:605
TGHScrollBar
The TGHScrollBar will generate the following event messages: kC_HSCROLL, kSB_SLIDERPOS,...
Definition: TGScrollBar.h:141
TGContainer::fXp
Int_t fXp
Definition: TGCanvas.h:44
TGObject::fId
Handle_t fId
X11/Win32 Window identifier.
Definition: TGObject.h:26
a
auto * a
Definition: textangle.C:12
TGLVContainer::ActivateItem
virtual void ActivateItem(TGFrameElement *el)
Select/activate item.
Definition: TGListView.cxx:757
TGFrame::SendMessage
virtual void SendMessage(const TGWindow *w, Long_t msg, Long_t parm1, Long_t parm2)
Send message (i.e.
Definition: TGFrame.cxx:645
kFALSE
const Bool_t kFALSE
Definition: RtypesCore.h:101
TGListView::SavePrimitive
virtual void SavePrimitive(std::ostream &out, Option_t *option="")
Save a list view widget as a C++ statement(s) on output stream out.
Definition: TGListView.cxx:1724
TGFrame::fBorderWidth
Int_t fBorderWidth
frame border width
Definition: TGFrame.h:93
kButtonPress
@ kButtonPress
Definition: GuiTypes.h:60
Long_t
long Long_t
Definition: RtypesCore.h:54
kLVSmallIcons
@ kLVSmallIcons
Definition: TGListView.h:23
TGFont::GetFontHandle
FontH_t GetFontHandle() const
Definition: TGFont.h:183
TGDimension::fWidth
UInt_t fWidth
Definition: TGDimension.h:20
kButtonRelease
@ kButtonRelease
Definition: GuiTypes.h:60
TGContainer::fScrollTimer
TTimer * fScrollTimer
autoscroll timer
Definition: TGCanvas.h:50
TGHeaderFrame
Horizontal Frame used to contain header buttons and splitters in a list view.
Definition: TGFrame.h:580
TGLayoutHints
This class describes layout hints used by the layout classes.
Definition: TGLayout.h:50
TGLVContainer::fItemLayout
TGLayoutHints * fItemLayout
item layout hints
Definition: TGListView.h:185
TGFrame::SaveUserColor
void SaveUserColor(std::ostream &out, Option_t *)
Save a user color in a C++ macro file - used in SavePrimitive().
Definition: TGFrame.cxx:2453
TGCanvas::fVport
TGViewPort * fVport
viewport through which we look at contents
Definition: TGCanvas.h:195
kC_CONTAINER
@ kC_CONTAINER
Definition: WidgetMessageTypes.h:53
TGClient::GetPicture
const TGPicture * GetPicture(const char *name)
Get picture from the picture pool.
Definition: TGClient.cxx:291
TGLVEntry::fSubnames
TGString ** fSubnames
sub names of item (details)
Definition: TGListView.h:44
TGListView::SetContainer
virtual void SetContainer(TGFrame *f)
Set list view container.
Definition: TGListView.cxx:1383
TGListView::LayoutHeader
virtual void LayoutHeader(TGFrame *head)
Layout list view components (container and contents of container).
Definition: TGListView.cxx:1539
Window_t
Handle_t Window_t
Window handle.
Definition: GuiTypes.h:29
TGContainer::ClearViewPort
virtual void ClearViewPort()
Clear view port and redraw full content.
Definition: TGCanvas.cxx:891
TGListView::SetViewMode
virtual void SetViewMode(EListViewMode viewMode)
Set list view mode.
Definition: TGListView.cxx:1366
TGContainer::GetCanvas
TGCanvas * GetCanvas() const
Definition: TGCanvas.h:99
y
Double_t y[n]
Definition: legend1.C:17
TGLVEntry::fJmode
Int_t * fJmode
alignment for sub names
Definition: TGListView.h:46
ULong_t
unsigned long ULong_t
Definition: RtypesCore.h:55
TGLVEntry::SetViewMode
virtual void SetViewMode(EListViewMode viewMode)
Set the view mode for this list item.
Definition: TGListView.cxx:277
kLHintsExpandY
@ kLHintsExpandY
Definition: TGLayout.h:31
TGFrame::IsActive
virtual Bool_t IsActive() const
Definition: TGFrame.h:211
TGCompositeFrame::MustCleanup
virtual Int_t MustCleanup() const
Definition: TGFrame.h:361
TGContainer::fX0
Int_t fX0
Definition: TGCanvas.h:45
TGLVEntry::TGLVEntry
TGLVEntry(const TGLVEntry &)=delete
TGFrame::GetX
Int_t GetX() const
Definition: TGFrame.h:231
TGListView::Clicked
virtual void Clicked(TGLVEntry *entry, Int_t btn)
Emit Clicked() signal.
Definition: TGListView.cxx:1646
TGListView::fHeader
TGHeaderFrame * fHeader
frame used as container for column headers
Definition: TGListView.h:132
TGContainer::DrawRegion
virtual void DrawRegion(Int_t x, Int_t y, UInt_t w, UInt_t h)
Draw a region of container in viewport.
Definition: TGCanvas.cxx:819
TGContainer::fXf
Int_t fXf
Definition: TGCanvas.h:46
TGListView::fSplitHeader
TGVFileSplitter ** fSplitHeader
column splitters
Definition: TGListView.h:129
TGLVContainer::LineLeft
virtual void LineLeft(Bool_t select=kFALSE)
Move current position one column left.
Definition: TGListView.cxx:961
TGLVContainer::RemoveItemWithData
virtual void RemoveItemWithData(void *userData)
Remove item with fUserData == userData from container.
Definition: TGListView.cxx:741
TGCompositeFrame::SetLayoutManager
virtual void SetLayoutManager(TGLayoutManager *l)
Set the layout manager for the composite frame.
Definition: TGFrame.cxx:1000
kRaisedFrame
@ kRaisedFrame
Definition: GuiTypes.h:384
TGTileLayout
This is a layout manager for the TGListView widget.
Definition: TGLayout.h:303
TMath::Min
Short_t Min(Short_t a, Short_t b)
Definition: TMathBase.h:180
TGButton::SetStyle
virtual void SetStyle(UInt_t newstyle)
Set the button style (modern or classic).
Definition: TGButton.cxx:271
TGLVContainer::LineDown
virtual void LineDown(Bool_t select=kFALSE)
Move one line down.
Definition: TGListView.cxx:1115
unsigned int
TGListView::fViewMode
EListViewMode fViewMode
view mode if list view widget
Definition: TGListView.h:125
TGButton::SetState
virtual void SetState(EButtonState state, Bool_t emit=kFALSE)
Set button state.
Definition: TGButton.cxx:235
TGClient::GetMimeTypeList
TGMimeTypes * GetMimeTypeList() const
Definition: TGClient.h:146
TGLVEntry::fgDefaultGC
static TGGC * fgDefaultGC
Definition: TGListView.h:63
TGViewPort::GetContainer
TGFrame * GetContainer() const
Definition: TGCanvas.h:173
gSystem
R__EXTERN TSystem * gSystem
Definition: TSystem.h:559
kKeyControlMask
const Mask_t kKeyControlMask
Definition: GuiTypes.h:197
TGContainer::UnSelectAll
virtual void UnSelectAll()
Unselect all items in the container.
Definition: TGCanvas.cxx:589
TGLVContainer::DeActivateItem
virtual void DeActivateItem(TGFrameElement *el)
Unselect/deactivate item.
Definition: TGListView.cxx:766
TGCompositeFrame::fMapSubwindows
Bool_t fMapSubwindows
kTRUE - map subwindows
Definition: TGFrame.h:295
TGListView::SetDefaultHeaders
virtual void SetDefaultHeaders()
Default headers are: Name, Attributes, Size, Owner, Group, Modified.
Definition: TGListView.cxx:1352
TGWindow::GetParent
const TGWindow * GetParent() const
Definition: TGWindow.h:76
TGLVContainer::GetViewMode
EListViewMode GetViewMode() const
Definition: TGListView.h:214
TGClient::NeedRedraw
void NeedRedraw(TGWindow *w, Bool_t force=kFALSE)
Set redraw flags.
Definition: TGClient.cxx:374
TGListView::Layout
virtual void Layout()
Layout list view components (container and contents of container).
Definition: TGListView.cxx:1448
TGLVContainer::fListView
TGListView * fListView
listview which contains this container
Definition: TGListView.h:190
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
TGContainer
Manages a content area.
Definition: TGCanvas.h:31
TGFrame::UnmapWindow
virtual void UnmapWindow()
unmap window
Definition: TGFrame.h:206
TGLVContainer
Definition: TGListView.h:178
TGLVContainer::SetColHeaders
virtual void SetColHeaders(const char *n1="", const char *n2="", const char *n3="", const char *n4="", const char *n5="", const char *n6="", const char *n7="", const char *n8="", const char *n9="", const char *n10="", const char *n11="", const char *n12="")
set columns headers
Definition: TGListView.cxx:571
TGObject::fClient
TGClient * fClient
Connection to display server.
Definition: TGObject.h:27
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:629
TGListView::SetDefaultColumnWidth
virtual void SetDefaultColumnWidth(TGVFileSplitter *splitter)
Set default column width of the columns headers.
Definition: TGListView.cxx:1405
TGListView::fColumns
Int_t * fColumns
column width
Definition: TGListView.h:123
TGFrame::Move
virtual void Move(Int_t x, Int_t y)
Move frame.
Definition: TGFrame.cxx:593
TList::Add
virtual void Add(TObject *obj)
Definition: TList.h:87
TGContainer::DeActivateItem
virtual void DeActivateItem(TGFrameElement *el)
DeActivate item.
Definition: TGCanvas.cxx:724
TGLVContainer::SetViewMode
virtual void SetViewMode(EListViewMode viewMode)
Set list view mode for container.
Definition: TGListView.cxx:614
TGLVEntry::SetSubnames
virtual void SetSubnames(const char *n1="", const char *n2="", const char *n3="", const char *n4="", const char *n5="", const char *n6="", const char *n7="", const char *n8="", const char *n9="", const char *n10="", const char *n11="", const char *n12="")
Sets new subnames.
Definition: TGListView.cxx:200
TGButton.h
TGContainer::ActivateItem
virtual void ActivateItem(TGFrameElement *el)
Activate item.
Definition: TGCanvas.cxx:701
Event_t
Event structure.
Definition: GuiTypes.h:174
TGListView::fNormGC
GContext_t fNormGC
drawing graphics context
Definition: TGListView.h:130
GET_SUBMSG
Int_t GET_SUBMSG(Long_t val)
Definition: WidgetMessageTypes.h:111
TGLVEntry::fCheckMark
const TGPicture * fCheckMark
checkmark
Definition: TGListView.h:56
TGLVContainer::TGLVContainer
TGLVContainer(const TGLVContainer &)=delete
name
char name[80]
Definition: TGX11.cxx:110
TGLVEntry::fUserData
void * fUserData
pointer to user data structure
Definition: TGListView.h:60
kButton5
@ kButton5
Definition: GuiTypes.h:215
TGString::Draw
virtual void Draw(Drawable_t id, GContext_t gc, Int_t x, Int_t y)
Draw string.
Definition: TGString.cxx:56
TGHeaderFrame::SetColumnsInfo
void SetColumnsInfo(Int_t nColumns, TGTextButton **colHeader, TGVFileSplitter **splitHeader)
Set columns information in the header frame.
Definition: TGFrame.cxx:2353
TGCanvas::SetContainer
virtual void SetContainer(TGFrame *f)
Definition: TGCanvas.h:222
TGContainer::fDragging
Bool_t fDragging
true if in dragging mode
Definition: TGCanvas.h:47
TGListView::GetHeader
virtual const char * GetHeader(Int_t idx) const
Returns name of header idx.
Definition: TGListView.cxx:1341
TGFrameElement
Definition: TGLayout.h:105
TGFrame::GetY
Int_t GetY() const
Definition: TGFrame.h:232
TGContainer::fViewPort
TGViewPort * fViewPort
container viewport
Definition: TGCanvas.h:40
TGString::GetString
const char * GetString() const
Definition: TGString.h:30
TGListView::GetDefaultGC
static const TGGC & GetDefaultGC()
Return the default graphics context in use.
Definition: TGListView.cxx:1712
TIter
Definition: TCollection.h:233
kCT_ITEMCLICK
@ kCT_ITEMCLICK
Definition: WidgetMessageTypes.h:54
TGLVEntry::fCtw
Int_t * fCtw
width of sub names
Definition: TGListView.h:47
TGLVContainer::HandleButton
virtual Bool_t HandleButton(Event_t *event)
Handle mouse button event in container.
Definition: TGListView.cxx:775
kLHintsExpandX
@ kLHintsExpandX
Definition: TGLayout.h:30
TGResourcePool.h
TGFont::GetFontStruct
FontStruct_t GetFontStruct() const
Definition: TGFont.h:184
TGeant4Unit::ms
static constexpr double ms
Definition: TGeant4SystemOfUnits.h:163
kTextRight
@ kTextRight
Definition: TGWidget.h:24
TGFrame::fHeight
UInt_t fHeight
frame height
Definition: TGFrame.h:88
TGListView::DoubleClicked
virtual void DoubleClicked(TGLVEntry *entry, Int_t btn)
Emit DoubleClicked() signal.
Definition: TGListView.cxx:1674
xmlio::cnt
const char * cnt
Definition: TXMLSetup.cxx:75
TGLVEntry::fCurrent
const TGPicture * fCurrent
current icon
Definition: TGListView.h:55
TGFrame::fBackground
Pixel_t fBackground
frame background color
Definition: TGFrame.h:95
TGListDetailsLayout
This is a layout manager for the TGListView widget.
Definition: TGLayout.h:355
TGContainer::SetVsbPosition
virtual void SetVsbPosition(Int_t newPos)
Set position of vertical scrollbar.
Definition: TGCanvas.cxx:1761
TGFont
Encapsulate fonts used in the GUI system.
Definition: TGFont.h:140
TGFrame::fgDefaultSelectedBackground
static Pixel_t fgDefaultSelectedBackground
Definition: TGFrame.h:102
Class
void Class()
Definition: Class.C:29
TString::ToLower
void ToLower()
Change string to lower-case.
Definition: TString.cxx:1150
TGListView::SelectionChanged
virtual void SelectionChanged()
Definition: TGListView.h:168
TGPosition
Definition: TGDimension.h:36
TGListView.h
kLVList
@ kLVList
Definition: TGListView.h:24
TGCanvas
A frame containing two scrollbars (a horizontal and a vertical) and a viewport.
Definition: TGCanvas.h:192
TGPicture::GetHeight
UInt_t GetHeight() const
Definition: TGPicture.h:53
TGContainer::RemoveAll
virtual void RemoveAll()
Remove all items from the container.
Definition: TGCanvas.cxx:641
TGContainer::fTotal
Int_t fTotal
total items
Definition: TGCanvas.h:48
TGListView::SetIncrements
virtual void SetIncrements(Int_t hInc, Int_t vInc)
Set horizontal and vertical scrollbar increments.
Definition: TGListView.cxx:1396
TGListView::ScrollHeader
virtual void ScrollHeader(Int_t pos)
Scroll header buttons with horizontal scrollbar.
Definition: TGListView.cxx:1219
TGLVEntry::fItemName
TGString * fItemName
name of item
Definition: TGListView.h:43
splitter
REAL splitter
Definition: triangle.c:617
TGFrame::GetDefaultWidth
virtual UInt_t GetDefaultWidth() const
Definition: TGFrame.h:190
TGString
TGString wraps a TString and adds some graphics routines like drawing, size of string on screen depen...
Definition: TGString.h:20
TGScrollBar.h
TGLVEntry::fNormGC
GContext_t fNormGC
drawing graphics context
Definition: TGListView.h:58
TGContainer::HandleButton
virtual Bool_t HandleButton(Event_t *event)
Handle mouse button event in container.
Definition: TGCanvas.cxx:929
TGGC::SetFont
void SetFont(FontH_t v)
Set font.
Definition: TGGC.cxx:411
TGResourcePool::GetSelectedFgndColor
Pixel_t GetSelectedFgndColor() const
Definition: TGResourcePool.h:114
TGLVEntry::fgDefaultFont
static const TGFont * fgDefaultFont
Definition: TGListView.h:62
MK_MSG
Int_t MK_MSG(EWidgetMessageTypes msg, EWidgetMessageTypes submsg)
Definition: WidgetMessageTypes.h:108
TGListLayout
This is a layout manager for the TGListView widget.
Definition: TGLayout.h:335
TGListView::fMinColumnSize
UInt_t fMinColumnSize
Minimun column size.
Definition: TGListView.h:134
TGWindow::fParent
const TGWindow * fParent
Parent window.
Definition: TGWindow.h:28
TGMimeTypes::GetIcon
const TGPicture * GetIcon(const char *filename, Bool_t small_icon)
Return icon belonging to mime type of filename.
Definition: TGMimeTypes.cxx:203
TGTextButton::GetString
TString GetString() const
Definition: TGButton.h:191
kKeyShiftMask
const Mask_t kKeyShiftMask
Definition: GuiTypes.h:195
kButtonDisabled
@ kButtonDisabled
Definition: TGButton.h:56
TGLVEntry::DoRedraw
virtual void DoRedraw()
Redraw list view item.
Definition: TGListView.cxx:320
TList
A doubly linked list.
Definition: TList.h:44
TGContainer::fYf
Int_t fYf
other corner of rubber band box
Definition: TGCanvas.h:46
TQObject::Emit
void Emit(const char *signal, const T &arg)
Activate signal with single parameter.
Definition: TQObject.h:164
TGLVEntry::GetDefaultGC
static const TGGC & GetDefaultGC()
Return the default graphics context in use.
Definition: TGListView.cxx:506
TGLVEntry::fCpos
Int_t * fCpos
position of sub names
Definition: TGListView.h:45
TGFrame::GetFrameElement
TGFrameElement * GetFrameElement() const
Definition: TGFrame.h:235
kChildFrame
@ kChildFrame
Definition: GuiTypes.h:379
int
TGLVEntry::fSmallPic
const TGPicture * fSmallPic
small icon
Definition: TGListView.h:54
TGWindow::IsMapped
virtual Bool_t IsMapped()
Returns kTRUE if window is mapped on screen, kFALSE otherwise.
Definition: TGWindow.cxx:295