Logo ROOT  
Reference Guide
TGPicture.cxx
Go to the documentation of this file.
1 // @(#)root/gui:$Id$
2 // Author: Fons Rademakers 01/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 TGPicture
25  \ingroup guiwidgets
26 
27 
28 The TGPicture class implements pictures and icons used in the
29 different GUI elements and widgets. The TGPicturePool class
30 implements a TGPicture cache. TGPictures are created, managed and
31 destroyed by the TGPicturePool.
32 
33 */
34 
35 
36 #include "TGPicture.h"
37 #include "TGResourcePool.h"
38 #include "THashTable.h"
39 #include "TSystem.h"
40 #include "TGWindow.h"
41 #include "TVirtualX.h"
42 #include "TImage.h"
43 #include "TROOT.h"
44 #include <cstdlib>
45 
47 
51 
52 
53 ////////////////////////////////////////////////////////////////////////////////
54 ///copy constructor
55 
57  TObject(pp),
58  fClient(pp.fClient),
59  fPath(pp.fPath),
60  fPicList(pp.fPicList)
61 {
62 }
63 
64 ////////////////////////////////////////////////////////////////////////////////
65 ///assignment operator
66 
68 {
69  if(this!=&pp) {
71  fClient=pp.fClient;
72  fPath=pp.fPath;
73  fPicList=pp.fPicList;
74  }
75  return *this;
76 }
77 
78 ////////////////////////////////////////////////////////////////////////////////
79 /// Get a picture from the picture pool. Picture must be freed using
80 /// TGPicturePool::FreePicture(). If picture is not found 0 is returned.
81 
83 {
84  if (!fPicList)
85  fPicList = new THashTable(50);
86 
87  TString pname = name;
88  pname.Strip();
89  TString ext = strrchr(pname, '.');
90  ext.ToLower();
91 
92  if (ext.Length()) { // ".xpm", ".gif" etc
93  pname = gSystem->UnixPathName(pname);
94  gSystem->ExpandPathName(pname);
95  }
96 
97  TGPicture *pic = (TGPicture *)fPicList->FindObject(pname);
98  if (pic && !pic->IsScaled()) {
99  if (pic->fPic == kNone)
100  return 0;
101  pic->AddReference();
102  return pic;
103  }
104 
105  char *picnam = gSystem->Which(fPath, pname, kReadPermission);
106  if (!picnam) {
107  pic = new TGPicture(pname);
109  pic->fAttributes.fCloseness = 40000; // Allow for "similar" colors
111  fPicList->Add(pic);
112  return 0;
113  }
114 
115  TImage *img = TImage::Open(picnam);
116  if (!img) {
117  pic = new TGPicture(pname);
119  pic->fAttributes.fCloseness = 40000; // Allow for "similar" colors
121  fPicList->Add(pic);
122  delete [] picnam;
123  return 0;
124  }
125 
126  pic = new TGPicture(pname, img->GetPixmap(), img->GetMask());
127  delete [] picnam;
128  delete img;
129  fPicList->Add(pic);
130  return pic;
131 }
132 
133 ////////////////////////////////////////////////////////////////////////////////
134 /// Get picture with specified size from pool (picture will be scaled if
135 /// necessary). Picture must be freed using TGPicturePool::FreePicture(). If
136 /// picture is not found 0 is returned.
137 
139  UInt_t new_width, UInt_t new_height)
140 {
141  if (!fPicList)
142  fPicList = new THashTable(50);
143 
144  TString pname = name;
145  pname.Strip();
146  TString ext = strrchr(pname, '.');
147  ext.ToLower();
148 
149  if (ext.Length()) { // ".xpm", ".gif" etc
150  pname = gSystem->UnixPathName(pname);
151  gSystem->ExpandPathName(pname);
152  }
153 
154  const char *hname = TGPicture::HashName(pname, new_width, new_height);
155  TGPicture *pic = (TGPicture *)fPicList->FindObject(hname);
156  if (pic && pic->GetWidth() == new_width && pic->GetHeight() == new_height) {
157  if (pic->fPic == kNone)
158  return 0;
159  pic->AddReference();
160  return pic;
161  }
162 
163  char *picnam = gSystem->Which(fPath, pname, kReadPermission);
164  if (!picnam) {
165  pic = new TGPicture(hname, kTRUE);
167  pic->fAttributes.fCloseness = 40000; // Allow for "similar" colors
169  pic->fAttributes.fWidth = new_width;
170  pic->fAttributes.fHeight = new_height;
171  fPicList->Add(pic);
172  return 0;
173  }
174 
175  TImage *img = TImage::Open(picnam);
176  if (!img) {
177  pic = new TGPicture(hname, kTRUE);
179  pic->fAttributes.fCloseness = 40000; // Allow for "similar" colors
181  pic->fAttributes.fWidth = new_width;
182  pic->fAttributes.fHeight = new_height;
183  fPicList->Add(pic);
184  delete [] picnam;
185  return 0;
186  }
187 
188  img->Scale(new_width, new_height);
189 
190  pic = new TGPicture(hname, img->GetPixmap(), img->GetMask());
191  delete [] picnam;
192  delete img;
193  fPicList->Add(pic);
194  return pic;
195 }
196 
197 ////////////////////////////////////////////////////////////////////////////////
198 /// Get picture with specified pixmap and mask from pool.
199 /// Picture must be freed using TGPicturePool::FreePicture().
200 /// If picture is not found 0 is returned.
201 
203  Pixmap_t mask)
204 {
205  if (!fPicList)
206  fPicList = new THashTable(50);
207 
208  Int_t xy;
209  UInt_t w, h;
210 
211  gVirtualX->GetWindowSize(pxmap, xy, xy, w, h);
212 
213  const char *hname = TGPicture::HashName(name, w, h);
214  TGPicture *pic = (TGPicture *)fPicList->FindObject(hname);
215 
216  if (pic) {
217  pic->AddReference();
218  return pic;
219  }
220 
221  pic = new TGPicture(hname, pxmap, mask);
222  fPicList->Add(pic);
223 
224  return pic;
225 }
226 
227 ////////////////////////////////////////////////////////////////////////////////
228 /// Create picture from XPM data.
229 /// Picture must be freed using TGPicturePool::FreePicture().
230 /// If picture creation failed 0 is returned.
231 
232 const TGPicture *TGPicturePool::GetPicture(const char *name, char **xpm)
233 {
234  UInt_t w, h;
235 
236  if (!xpm || !*xpm) {
237  return 0;
238  }
239 
240  if (!fPicList) {
241  fPicList = new THashTable(50);
242  }
243  char *ptr = xpm[0];
244  while (isspace((int)*ptr)) ++ptr;
245  w = atoi(ptr);
246 
247  while (isspace((int)*ptr)) ++ptr;
248  h = atoi(ptr);
249 
250  const char *hname = TGPicture::HashName(name, w, h);
251  TGPicture *pic = (TGPicture *)fPicList->FindObject(hname);
252  if (pic) {
253  pic->AddReference();
254  return pic;
255  }
256 
257  TImage *img = TImage::Open(xpm);
258  if (!img) {
259  pic = new TGPicture(hname, kTRUE);
261  pic->fAttributes.fCloseness = 40000; // Allow for "similar" colors
263  pic->fAttributes.fWidth = w;
264  pic->fAttributes.fHeight = h;
265  fPicList->Add(pic);
266  return 0;
267  }
268 
269  pic = new TGPicture(hname, img->GetPixmap(), img->GetMask());
270  delete img;
271  return pic;
272 }
273 
274 ////////////////////////////////////////////////////////////////////////////////
275 /// Remove picture from cache if nobody is using it anymore.
276 
278 {
279  if (!fPicList) return;
280 
281  TGPicture *pic = (TGPicture *)fPicList->FindObject(fpic);
282  if (pic) {
283  if (pic->RemoveReference() == 0) {
284  fPicList->Remove(pic);
285  delete pic;
286  }
287  }
288 }
289 
290 ////////////////////////////////////////////////////////////////////////////////
291 /// Delete picture cache.
292 
294 {
295  if (fPicList) {
296  fPicList->Delete();
297  delete fPicList;
298  }
299 
300  // Required since we overload TObject::Hash.
302 }
303 
304 ////////////////////////////////////////////////////////////////////////////////
305 /// List all pictures in the pool.
306 
308 {
309  if (fPicList)
310  fPicList->Print();
311  else
312  Info("Print", "no pictures in picture pool");
313 }
314 
315 ////////////////////////////////////////////////////////////////////////////////
316 /// ctor. Important: both pixmaps pxmap and mask must be unique (not shared)
317 
318 TGPicture::TGPicture(const char *name, Pixmap_t pxmap, Pixmap_t mask)
319 {
320  fName = name;
321  fScaled = kFALSE;
322  fPic = pxmap;
323  fMask = mask;
324  Int_t xy;
325 
326  fAttributes.fColormap = gClient->GetDefaultColormap();
327  fAttributes.fCloseness = 40000; // Allow for "similar" colors
329  fAttributes.fPixels = 0;
330  fAttributes.fDepth = 0;
331  fAttributes.fNpixels = 0;
334 
335  gVirtualX->GetWindowSize(fPic, xy, xy, fAttributes.fWidth, fAttributes.fHeight);
336  SetRefCount(1);
337 }
338 
339 ////////////////////////////////////////////////////////////////////////////////
340 /// Draw a picture.
341 
343 {
344  GCValues_t gcv;
345 
347  gcv.fClipMask = fMask;
348  gcv.fClipXOrigin = x;
349  gcv.fClipYOrigin = y;
350  gVirtualX->ChangeGC(gc, &gcv);
351  gVirtualX->CopyArea(fPic, id, gc, 0, 0, fAttributes.fWidth, fAttributes.fHeight,
352  x, y);
353  gcv.fMask = kGCClipMask;
354  gcv.fClipMask = kNone;
355  gVirtualX->ChangeGC(gc, &gcv);
356 }
357 
358 ////////////////////////////////////////////////////////////////////////////////
359 /// Delete picture object.
360 
362 {
363  if (fPic != kNone)
364  gVirtualX->DeletePixmap(fPic);
365  if (fMask != kNone)
366  gVirtualX->DeletePixmap(fMask);
367  if (fAttributes.fPixels)
368  delete [] fAttributes.fPixels;
369 }
370 
371 ////////////////////////////////////////////////////////////////////////////////
372 /// Static function returning a unique name used to look up a picture.
373 /// The unique name has the form "name__widthxheight".
374 
375 const char *TGPicture::HashName(const char *name, Int_t width, Int_t height)
376 {
377  static TString hashName;
378 
379  hashName.Form("%s__%dx%d", name, width, height);
380  return hashName.Data();
381 }
382 
383 ////////////////////////////////////////////////////////////////////////////////
384 /// Print picture info.
385 
387 {
388  Printf("TGPicture: %s,%sref cnt = %u %lx", GetName(),
389  fScaled ? " scaled, " : " ", References(), fPic);
390 }
391 
392 
393 ////////////////////////////////////////////////////////////////////////////////
394 /// Create a "selected" looking picture based on the original TGPicture.
395 
397  TGPicture("")
398 {
399  GCValues_t gcv;
400  UInt_t w, h;
401 
402  fClient = client;
403  Window_t root = fClient->GetDefaultRoot()->GetId();
404 
405  w = p->GetWidth();
406  h = p->GetHeight();
407 
408  fPic = gVirtualX->CreatePixmap(root, w, h);
409  fMask = p->GetMask();
410 
411  fAttributes.fWidth = w;
413 
414  gVirtualX->CopyArea(p->GetPicture(), fPic, GetSelectedGC()(), 0, 0, w, h, 0, 0);
415 
417  gcv.fClipMask = p->GetMask();
418  gcv.fClipXOrigin = 0;
419  gcv.fClipYOrigin = 0;
421 
422  gVirtualX->FillRectangle(fPic, GetSelectedGC()(), 0, 0, w, h);
423 
425 }
426 
427 ////////////////////////////////////////////////////////////////////////////////
428 /// Delete selected picture.
429 
431 {
432  // fMask was borrowed so should not be deleted by ~TGPicture.
433  fMask = kNone;
434 }
435 
436 ////////////////////////////////////////////////////////////////////////////////
437 /// Return selection graphics context in use.
438 
440 {
441  if (!fgSelectedGC) {
442  fgSelectedGC = new TGGC(*gClient->GetResourcePool()->GetFrameGC());
443  fgSelectedGC->SetForeground(gClient->GetResourcePool()->GetSelectedBgndColor());
444  fgSelectedGC->SetBackground(gClient->GetResourcePool()->GetBlackColor());
446  fgSelectedGC->SetStipple(gClient->GetResourcePool()->GetCheckeredBitmap());
447  }
448  return *fgSelectedGC;
449 }
TGClient::GetDefaultRoot
const TGWindow * GetDefaultRoot() const
Returns the root (i.e.
Definition: TGClient.cxx:236
TGPicture::fName
TString fName
Definition: TGPicture.h:30
TGPicture::TGPicture
TGPicture(const char *name, Bool_t scaled=kFALSE)
Definition: TGPicture.h:36
kTRUE
const Bool_t kTRUE
Definition: RtypesCore.h:95
Pixmap_t
Handle_t Pixmap_t
Pixmap handle.
Definition: GuiTypes.h:30
TGPicture
The TGPicture class implements pictures and icons used in the different GUI elements and widgets.
Definition: TGPicture.h:25
PictureAttributes_t::fPixels
ULong_t * fPixels
list of used color pixels (if set use delete[])
Definition: GuiTypes.h:330
TRefCnt::SetRefCount
void SetRefCount(UInt_t r)
Definition: TRefCnt.h:39
Option_t
const char Option_t
Definition: RtypesCore.h:66
TGPicture::HashName
static const char * HashName(const char *name, Int_t width, Int_t height)
Static function returning a unique name used to look up a picture.
Definition: TGPicture.cxx:375
TRefCnt::References
UInt_t References() const
Definition: TRefCnt.h:38
TGPicture::GetWidth
UInt_t GetWidth() const
Definition: TGPicture.h:52
THashTable::Add
void Add(TObject *obj)
Add object to the hash table.
Definition: THashTable.cxx:92
PictureAttributes_t::fWidth
UInt_t fWidth
width of picture
Definition: GuiTypes.h:326
TString::Strip
TSubString Strip(EStripType s=kTrailing, char c=' ') const
Return a substring of self stripped at beginning and/or end.
Definition: TString.cxx:1128
TGSelectedPicture::~TGSelectedPicture
virtual ~TGSelectedPicture()
Delete selected picture.
Definition: TGPicture.cxx:430
gVirtualX
#define gVirtualX
Definition: TVirtualX.h:338
TString::Data
const char * Data() const
Definition: TString.h:369
kFillStippled
@ kFillStippled
Definition: GuiTypes.h:51
TSystem::Which
virtual char * Which(const char *search, const char *file, EAccessMode mode=kFileExists)
Find location of file in a search path.
Definition: TSystem.cxx:1544
ClassImp
#define ClassImp(name)
Definition: Rtypes.h:364
TGPicture.h
GCValues_t::fClipXOrigin
Int_t fClipXOrigin
origin for clipping
Definition: GuiTypes.h:245
kGCClipMask
const Mask_t kGCClipMask
Definition: GuiTypes.h:305
TObject::Info
virtual void Info(const char *method, const char *msgfmt,...) const
Issue info message.
Definition: TObject.cxx:867
TGPicture::GetMask
Pixmap_t GetMask() const
Definition: TGPicture.h:55
GCValues_t
Graphics context structure.
Definition: GuiTypes.h:224
TGGC::SetFillStyle
void SetFillStyle(Int_t v)
Set fill style (kFillSolid, kFillTiled, kFillStippled, kFillOpaeueStippled).
Definition: TGGC.cxx:345
width
include TDocParser_001 C image html pict1_TDocParser_001 png width
Definition: TDocParser.cxx:121
TGGC::SetAttributes
void SetAttributes(GCValues_t *values)
Set attributes as specified in the values structure.
Definition: TGGC.cxx:235
TImage
An abstract interface to image processing library.
Definition: TImage.h:29
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
TGSelectedPicture
Definition: TGPicture.h:67
TVirtualX.h
TGPicture::IsScaled
Bool_t IsScaled() const
Definition: TGPicture.h:56
TImage::Open
static TImage * Open(const char *file, EImageFileTypes type=kUnknown)
Open a specified image file.
Definition: TImage.cxx:118
TGPicture::fScaled
Bool_t fScaled
Definition: TGPicture.h:31
TString
Basic string class.
Definition: TString.h:136
kPAColormap
const Mask_t kPAColormap
Definition: GuiTypes.h:337
TGObject::GetId
Handle_t GetId() const
Definition: TGObject.h:37
THashTable::Delete
void Delete(Option_t *option="")
Remove all objects from the table AND delete all heap based objects.
Definition: THashTable.cxx:220
PictureAttributes_t::fYHotspot
UInt_t fYHotspot
picture y hotspot coordinate
Definition: GuiTypes.h:329
TGSelectedPicture::TGSelectedPicture
TGSelectedPicture(const TGSelectedPicture &gp)
Definition: TGPicture.h:75
TGWindow.h
TGPicturePool::fPicList
THashTable * fPicList
Definition: TGPicture.h:94
PictureAttributes_t::fDepth
Int_t fDepth
depth of window
Definition: GuiTypes.h:325
TImage.h
xy
XPoint xy[kMAXMK]
Definition: TGX11.cxx:123
TROOT.h
GContext_t
Handle_t GContext_t
Graphics context handle.
Definition: GuiTypes.h:38
gClient
#define gClient
Definition: TGClient.h:157
TRefCnt::AddReference
void AddReference()
Definition: TRefCnt.h:40
kNone
const Handle_t kNone
Definition: GuiTypes.h:88
TString::Form
void Form(const char *fmt,...)
Formats a string using a printf style format descriptor.
Definition: TString.cxx:2311
TGPicturePool::TGPicturePool
TGPicturePool(const TGPicturePool &)
copy constructor
Definition: TGPicture.cxx:56
TGPicturePool::GetPicture
const TGPicture * GetPicture(const char *name)
Get a picture from the picture pool.
Definition: TGPicture.cxx:82
TGPicture::Print
void Print(Option_t *option="") const
Print picture info.
Definition: TGPicture.cxx:386
TSystem.h
THashTable
THashTable implements a hash table to store TObject's.
Definition: THashTable.h:35
TGSelectedPicture::GetSelectedGC
static TGGC & GetSelectedGC()
Return selection graphics context in use.
Definition: TGPicture.cxx:439
h
#define h(i)
Definition: RSha256.hxx:106
TGSelectedPicture::fgSelectedGC
static TGGC * fgSelectedGC
Definition: TGPicture.h:72
TImage::Scale
virtual void Scale(UInt_t, UInt_t)
Definition: TImage.h:141
TGGC
Encapsulate a graphics context used in the low level graphics.
Definition: TGGC.h:22
kPASize
const Mask_t kPASize
width and height
Definition: GuiTypes.h:339
THashTable::FindObject
TObject * FindObject(const char *name) const
Find object using its name.
Definition: THashTable.cxx:238
kFALSE
const Bool_t kFALSE
Definition: RtypesCore.h:96
TGClient::GetDefaultColormap
Colormap_t GetDefaultColormap() const
Definition: TGClient.h:145
TGPicturePool::fClient
const TGClient * fClient
Definition: TGPicture.h:92
TImage::GetMask
virtual Pixmap_t GetMask()
Definition: TImage.h:236
TGGC::SetClipMask
void SetClipMask(Pixmap_t v)
Bitmap for clipping.
Definition: TGGC.cxx:466
TGPicturePool
Definition: TGPicture.h:89
Window_t
Handle_t Window_t
Window handle.
Definition: GuiTypes.h:29
PictureAttributes_t::fXHotspot
UInt_t fXHotspot
picture x hotspot coordinate
Definition: GuiTypes.h:328
y
Double_t y[n]
Definition: legend1.C:17
PictureAttributes_t::fCloseness
UInt_t fCloseness
allowable RGB deviation
Definition: GuiTypes.h:332
TSystem::ExpandPathName
virtual Bool_t ExpandPathName(TString &path)
Expand a pathname getting rid of special shell characters like ~.
Definition: TSystem.cxx:1272
TGPicture::fPic
Pixmap_t fPic
Definition: TGPicture.h:32
TGPicture::fMask
Pixmap_t fMask
Definition: TGPicture.h:33
GCValues_t::fClipYOrigin
Int_t fClipYOrigin
Definition: GuiTypes.h:246
TGPicturePool::operator=
TGPicturePool & operator=(const TGPicturePool &)
assignment operator
Definition: TGPicture.cxx:67
unsigned int
TGPicturePool::~TGPicturePool
virtual ~TGPicturePool()
Delete picture cache.
Definition: TGPicture.cxx:293
PictureAttributes_t::fColormap
Colormap_t fColormap
colormap to use
Definition: GuiTypes.h:324
Printf
void Printf(const char *fmt,...)
gSystem
R__EXTERN TSystem * gSystem
Definition: TSystem.h:559
THashTable::Remove
TObject * Remove(TObject *obj)
Remove object from the hashtable.
Definition: THashTable.cxx:417
TGPicture::fAttributes
PictureAttributes_t fAttributes
Definition: TGPicture.h:34
kPACloseness
const Mask_t kPACloseness
Definition: GuiTypes.h:342
TObject::operator=
TObject & operator=(const TObject &rhs)
TObject assignment operator.
Definition: TObject.h:283
TSystem::UnixPathName
virtual const char * UnixPathName(const char *unixpathname)
Convert from a local pathname to a Unix pathname.
Definition: TSystem.cxx:1061
TRefCnt::RemoveReference
UInt_t RemoveReference()
Definition: TRefCnt.h:41
kGCClipXOrigin
const Mask_t kGCClipXOrigin
Definition: GuiTypes.h:303
GCValues_t::fMask
Mask_t fMask
bit mask specifying which fields are valid
Definition: GuiTypes.h:251
kGCClipYOrigin
const Mask_t kGCClipYOrigin
Definition: GuiTypes.h:304
TGPicture::GetPicture
Pixmap_t GetPicture() const
Definition: TGPicture.h:54
PictureAttributes_t::fMask
Mask_t fMask
mask specifying which attributes are defined
Definition: GuiTypes.h:333
TGGC::SetBackground
void SetBackground(Pixel_t v)
Set background color.
Definition: TGGC.cxx:289
TGGC::SetForeground
void SetForeground(Pixel_t v)
Set foreground color.
Definition: TGGC.cxx:278
GCValues_t::fClipMask
Pixmap_t fClipMask
bitmap clipping; other calls for rects
Definition: GuiTypes.h:247
TObject
Mother of all ROOT objects.
Definition: TObject.h:37
Handle_t
ULong_t Handle_t
Generic resource handle.
Definition: GuiTypes.h:26
TImage::GetPixmap
virtual Pixmap_t GetPixmap()
Definition: TImage.h:235
name
char name[80]
Definition: TGX11.cxx:110
TGPicture::GetName
const char * GetName() const
Returns name of object.
Definition: TGPicture.h:51
TGSelectedPicture::fClient
const TGClient * fClient
Definition: TGPicture.h:70
TGPicture::~TGPicture
virtual ~TGPicture()
Delete picture object.
Definition: TGPicture.cxx:361
THashTable::Print
void Print(Option_t *option, Int_t recurse) const
Print the collection header and its elements.
Definition: THashTable.cxx:328
PictureAttributes_t::fNpixels
UInt_t fNpixels
number of used color pixels
Definition: GuiTypes.h:331
TGResourcePool.h
ROOT::CallRecursiveRemoveIfNeeded
void CallRecursiveRemoveIfNeeded(TObject &obj)
call RecursiveRemove for obj if gROOT is valid and obj.TestBit(kMustCleanup) is true.
Definition: TROOT.h:395
TString::ToLower
void ToLower()
Change string to lower-case.
Definition: TString.cxx:1147
kReadPermission
@ kReadPermission
Definition: TSystem.h:47
TGPicturePool::FreePicture
void FreePicture(const TGPicture *pic)
Remove picture from cache if nobody is using it anymore.
Definition: TGPicture.cxx:277
TGPicture::GetHeight
UInt_t GetHeight() const
Definition: TGPicture.h:53
TGClient
Window client.
Definition: TGClient.h:37
TGPicturePool::fPath
TString fPath
Definition: TGPicture.h:93
PictureAttributes_t::fHeight
UInt_t fHeight
height of picture
Definition: GuiTypes.h:327
TGPicturePool::Print
void Print(Option_t *option="") const
List all pictures in the pool.
Definition: TGPicture.cxx:307
int
TGGC::SetStipple
void SetStipple(Pixmap_t v)
Set 1 plane pixmap for stippling.
Definition: TGGC.cxx:378
THashTable.h