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
28The TGPicture class implements pictures and icons used in the
29different GUI elements and widgets. The TGPicturePool class
30implements a TGPicture cache. TGPictures are created, managed and
31destroyed 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) {
72 fPath=pp.fPath;
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
232const 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
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
334
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);
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
375const 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;
404
405 w = p->GetWidth();
406 h = p->GetHeight();
407
408 fPic = gVirtualX->CreatePixmap(root, w, h);
409 fMask = p->GetMask();
410
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}
const Mask_t kGCClipXOrigin
Definition: GuiTypes.h:303
const Mask_t kPACloseness
Definition: GuiTypes.h:342
Handle_t Pixmap_t
Pixmap handle.
Definition: GuiTypes.h:30
const Handle_t kNone
Definition: GuiTypes.h:88
@ kFillStippled
Definition: GuiTypes.h:51
const Mask_t kPAColormap
Definition: GuiTypes.h:337
Handle_t GContext_t
Graphics context handle.
Definition: GuiTypes.h:38
const Mask_t kGCClipYOrigin
Definition: GuiTypes.h:304
const Mask_t kPASize
width and height
Definition: GuiTypes.h:339
const Mask_t kGCClipMask
Definition: GuiTypes.h:305
Handle_t Window_t
Window handle.
Definition: GuiTypes.h:29
ULongptr_t Handle_t
Generic resource handle.
Definition: GuiTypes.h:26
#define h(i)
Definition: RSha256.hxx:106
int Int_t
Definition: RtypesCore.h:45
unsigned int UInt_t
Definition: RtypesCore.h:46
const Bool_t kFALSE
Definition: RtypesCore.h:101
const Bool_t kTRUE
Definition: RtypesCore.h:100
const char Option_t
Definition: RtypesCore.h:66
#define ClassImp(name)
Definition: Rtypes.h:364
include TDocParser_001 C image html pict1_TDocParser_001 png width
Definition: TDocParser.cxx:121
#define gClient
Definition: TGClient.h:157
char name[80]
Definition: TGX11.cxx:110
XPoint xy[kMAXMK]
Definition: TGX11.cxx:123
void Printf(const char *fmt,...)
@ kReadPermission
Definition: TSystem.h:47
R__EXTERN TSystem * gSystem
Definition: TSystem.h:559
#define gVirtualX
Definition: TVirtualX.h:338
Window client.
Definition: TGClient.h:37
const TGWindow * GetDefaultRoot() const
Returns the root (i.e.
Definition: TGClient.cxx:236
Colormap_t GetDefaultColormap() const
Definition: TGClient.h:145
Encapsulate a graphics context used in the low level graphics.
Definition: TGGC.h:22
void SetFillStyle(Int_t v)
Set fill style (kFillSolid, kFillTiled, kFillStippled, kFillOpaeueStippled).
Definition: TGGC.cxx:345
void SetForeground(Pixel_t v)
Set foreground color.
Definition: TGGC.cxx:278
void SetClipMask(Pixmap_t v)
Bitmap for clipping.
Definition: TGGC.cxx:466
void SetAttributes(GCValues_t *values)
Set attributes as specified in the values structure.
Definition: TGGC.cxx:235
void SetBackground(Pixel_t v)
Set background color.
Definition: TGGC.cxx:289
void SetStipple(Pixmap_t v)
Set 1 plane pixmap for stippling.
Definition: TGGC.cxx:378
Handle_t GetId() const
Definition: TGObject.h:37
virtual ~TGPicturePool()
Delete picture cache.
Definition: TGPicture.cxx:293
TString fPath
icon search path
Definition: TGPicture.h:93
THashTable * fPicList
hash table containing the icons
Definition: TGPicture.h:94
void Print(Option_t *option="") const
List all pictures in the pool.
Definition: TGPicture.cxx:307
TGPicturePool(const TGPicturePool &)
copy constructor
Definition: TGPicture.cxx:56
void FreePicture(const TGPicture *pic)
Remove picture from cache if nobody is using it anymore.
Definition: TGPicture.cxx:277
const TGClient * fClient
client for which we keep icon pool
Definition: TGPicture.h:92
const TGPicture * GetPicture(const char *name)
Get a picture from the picture pool.
Definition: TGPicture.cxx:82
TGPicturePool & operator=(const TGPicturePool &)
assignment operator
Definition: TGPicture.cxx:67
The TGPicture class implements pictures and icons used in the different GUI elements and widgets.
Definition: TGPicture.h:25
Pixmap_t fPic
picture pixmap
Definition: TGPicture.h:32
PictureAttributes_t fAttributes
picture attributes
Definition: TGPicture.h:34
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
Pixmap_t fMask
picture mask pixmap
Definition: TGPicture.h:33
Pixmap_t GetMask() const
Definition: TGPicture.h:55
Bool_t IsScaled() const
Definition: TGPicture.h:56
const char * GetName() const
Returns name of object.
Definition: TGPicture.h:51
TGPicture(const char *name, Bool_t scaled=kFALSE)
Definition: TGPicture.h:36
UInt_t GetHeight() const
Definition: TGPicture.h:53
void Draw(Option_t *="")
Default Draw method for all objects.
Definition: TGPicture.h:46
Pixmap_t GetPicture() const
Definition: TGPicture.h:54
virtual ~TGPicture()
Delete picture object.
Definition: TGPicture.cxx:361
Bool_t fScaled
kTRUE if picture is scaled
Definition: TGPicture.h:31
void Print(Option_t *option="") const
Print picture info.
Definition: TGPicture.cxx:386
TString fName
name of picture
Definition: TGPicture.h:30
UInt_t GetWidth() const
Definition: TGPicture.h:52
static TGGC & GetSelectedGC()
Return selection graphics context in use.
Definition: TGPicture.cxx:439
static TGGC * fgSelectedGC
Definition: TGPicture.h:72
TGSelectedPicture(const TGSelectedPicture &gp)
Definition: TGPicture.h:75
virtual ~TGSelectedPicture()
Delete selected picture.
Definition: TGPicture.cxx:430
const TGClient * fClient
Definition: TGPicture.h:70
THashTable implements a hash table to store TObject's.
Definition: THashTable.h:35
TObject * Remove(TObject *obj)
Remove object from the hashtable.
Definition: THashTable.cxx:417
void Add(TObject *obj)
Add object to the hash table.
Definition: THashTable.cxx:92
void Print(Option_t *option, Int_t recurse) const
Print the collection header and its elements.
Definition: THashTable.cxx:328
TObject * FindObject(const char *name) const
Find object using its name.
Definition: THashTable.cxx:238
void Delete(Option_t *option="")
Remove all objects from the table AND delete all heap based objects.
Definition: THashTable.cxx:220
An abstract interface to image processing library.
Definition: TImage.h:29
static TImage * Open(const char *file, EImageFileTypes type=kUnknown)
Open a specified image file.
Definition: TImage.cxx:118
virtual void Scale(UInt_t, UInt_t)
Definition: TImage.h:141
virtual Pixmap_t GetPixmap()
Definition: TImage.h:235
virtual Pixmap_t GetMask()
Definition: TImage.h:236
Mother of all ROOT objects.
Definition: TObject.h:37
TObject & operator=(const TObject &rhs)
TObject assignment operator.
Definition: TObject.h:283
virtual void Info(const char *method, const char *msgfmt,...) const
Issue info message.
Definition: TObject.cxx:867
void AddReference()
Definition: TRefCnt.h:40
void SetRefCount(UInt_t r)
Definition: TRefCnt.h:39
UInt_t RemoveReference()
Definition: TRefCnt.h:41
UInt_t References() const
Definition: TRefCnt.h:38
Basic string class.
Definition: TString.h:136
Ssiz_t Length() const
Definition: TString.h:410
void ToLower()
Change string to lower-case.
Definition: TString.cxx:1150
TSubString Strip(EStripType s=kTrailing, char c=' ') const
Return a substring of self stripped at beginning and/or end.
Definition: TString.cxx:1131
const char * Data() const
Definition: TString.h:369
void Form(const char *fmt,...)
Formats a string using a printf style format descriptor.
Definition: TString.cxx:2314
virtual Bool_t ExpandPathName(TString &path)
Expand a pathname getting rid of special shell characters like ~.
Definition: TSystem.cxx:1274
virtual const char * UnixPathName(const char *unixpathname)
Convert from a local pathname to a Unix pathname.
Definition: TSystem.cxx:1063
virtual char * Which(const char *search, const char *file, EAccessMode mode=kFileExists)
Find location of file in a search path.
Definition: TSystem.cxx:1546
Double_t y[n]
Definition: legend1.C:17
Double_t x[n]
Definition: legend1.C:17
void CallRecursiveRemoveIfNeeded(TObject &obj)
call RecursiveRemove for obj if gROOT is valid and obj.TestBit(kMustCleanup) is true.
Definition: TROOT.h:393
Graphics context structure.
Definition: GuiTypes.h:224
Pixmap_t fClipMask
bitmap clipping; other calls for rects
Definition: GuiTypes.h:247
Int_t fClipYOrigin
Definition: GuiTypes.h:246
Int_t fClipXOrigin
origin for clipping
Definition: GuiTypes.h:245
Mask_t fMask
bit mask specifying which fields are valid
Definition: GuiTypes.h:251
UInt_t fHeight
height of picture
Definition: GuiTypes.h:327
Mask_t fMask
mask specifying which attributes are defined
Definition: GuiTypes.h:333
ULong_t * fPixels
list of used color pixels (if set use delete[])
Definition: GuiTypes.h:330
Colormap_t fColormap
colormap to use
Definition: GuiTypes.h:324
UInt_t fCloseness
allowable RGB deviation
Definition: GuiTypes.h:332
Int_t fDepth
depth of window
Definition: GuiTypes.h:325
UInt_t fNpixels
number of used color pixels
Definition: GuiTypes.h:331
UInt_t fYHotspot
picture y hotspot coordinate
Definition: GuiTypes.h:329
UInt_t fXHotspot
picture x hotspot coordinate
Definition: GuiTypes.h:328
UInt_t fWidth
width of picture
Definition: GuiTypes.h:326