1 | /* ======================================================================== *\
|
---|
2 | !
|
---|
3 | ! *
|
---|
4 | ! * This file is part of MARS, the MAGIC Analysis and Reconstruction
|
---|
5 | ! * Software. It is distributed to you in the hope that it can be a useful
|
---|
6 | ! * and timesaving tool in analysing Data of imaging Cerenkov telescopes.
|
---|
7 | ! * It is distributed WITHOUT ANY WARRANTY.
|
---|
8 | ! *
|
---|
9 | ! * Permission to use, copy, modify and distribute this software and its
|
---|
10 | ! * documentation for any purpose is hereby granted without fee,
|
---|
11 | ! * provided that the above copyright notice appear in all copies and
|
---|
12 | ! * that both that copyright notice and this permission notice appear
|
---|
13 | ! * in supporting documentation. It is provided "as is" without express
|
---|
14 | ! * or implied warranty.
|
---|
15 | ! *
|
---|
16 | !
|
---|
17 | !
|
---|
18 | ! Author(s): Thomas Bretz, 4/2003 <mailto:tbretz@astro.uni-wuerzburg.de>
|
---|
19 | !
|
---|
20 | ! Copyright: MAGIC Software Development, 2003-2004
|
---|
21 | !
|
---|
22 | !
|
---|
23 | \* ======================================================================== */
|
---|
24 |
|
---|
25 | /////////////////////////////////////////////////////////////////////////////
|
---|
26 | //
|
---|
27 | // MStatusDisplay
|
---|
28 | //
|
---|
29 | // This status display can be used (and is used) to display results in
|
---|
30 | // a tabbed window. The window can be written to and read from a root file
|
---|
31 | // (see Read and Write) or printed as a postscript file (see SaveAsPS).
|
---|
32 | //
|
---|
33 | // To write gif files of C-Macros use SaveAsGif() or SaveAsC().
|
---|
34 | // Direct printing to the default printer (via lpr) can be done by
|
---|
35 | // PrintToLpr().
|
---|
36 | //
|
---|
37 | // It has also to half status lines which can be used to display the status
|
---|
38 | // or something going on. Together with the status lines it has a progress
|
---|
39 | // bar which can display the progress of a job or loop.
|
---|
40 | // Access the progress bar by GetProgressBar()
|
---|
41 | //
|
---|
42 | // To add a new tab and get a pointer to the newly created TCanvas
|
---|
43 | // use AddTab.
|
---|
44 | //
|
---|
45 | // If you have a MStatusDisplay and you are not sure whether it was
|
---|
46 | // destroyed by the user meanwhile use:
|
---|
47 | // gROOT->GetListOfSpecials()->FindObject(pointer);
|
---|
48 | // Each MStatusDisplay is added to list list by its constructor and
|
---|
49 | // removed from the list by the destructor.
|
---|
50 | //
|
---|
51 | // You can redirect an output to a MLog-logstream by calling SetLogStream().
|
---|
52 | // To disable redirction call SetLogStream(NULL)
|
---|
53 | //
|
---|
54 | // Because updates to the tabs are only done/displayed if a tab is active
|
---|
55 | // using the gui doesn't make things slower (<1%) if the first (legend
|
---|
56 | // tab) is displayed. This gives you the possibility to look into
|
---|
57 | // the current progress of a loop without loosing more time than the
|
---|
58 | // single update of the tab.
|
---|
59 | //
|
---|
60 | /////////////////////////////////////////////////////////////////////////////
|
---|
61 | #include "MStatusDisplay.h"
|
---|
62 |
|
---|
63 | #include <fstream> // fstream
|
---|
64 |
|
---|
65 | #include <TLine.h> // TLine
|
---|
66 | #include <TText.h> // TText
|
---|
67 | #include <TFile.h> // gFile
|
---|
68 | #include <TFrame.h> // TFrame
|
---|
69 | #include <TStyle.h> // gStyle
|
---|
70 | #include <TCanvas.h> // TCanvas
|
---|
71 | #include <TSystem.h> // gSystem
|
---|
72 | #include <TDatime.h> // TDatime
|
---|
73 | #include <TRandom.h> // TRandom
|
---|
74 | #include <TThread.h> // TThread::Self()
|
---|
75 | #include <TBrowser.h> // TBrowser
|
---|
76 | #include <TObjArray.h> // TObjArray
|
---|
77 | #include <TPostScript.h> // TPostScript
|
---|
78 | #include <TMethodCall.h> // TMethodCall
|
---|
79 |
|
---|
80 | //#include <TRint.h> // gApplication, TRint::Class()
|
---|
81 | #include <TInterpreter.h> // gInterpreter
|
---|
82 |
|
---|
83 | #include <TGTab.h> // TGTab
|
---|
84 | #include <TGLabel.h> // TGLabel
|
---|
85 | #include <TG3DLine.h> // TGHorizontal3DLine
|
---|
86 | #include <TGButton.h> // TGPictureButton
|
---|
87 | #include <TGTextView.h> // TGTextView
|
---|
88 | #include <TGComboBox.h> // TGComboBox
|
---|
89 | #include <TGStatusBar.h> // TGStatusBar
|
---|
90 | #include <TGFileDialog.h> // TGFileDialog
|
---|
91 | #include <TGProgressBar.h> // TGHProgressBar
|
---|
92 | #include <TRootEmbeddedCanvas.h> // TRootEmbeddedCanvas
|
---|
93 |
|
---|
94 | #include "MLog.h" // MLog
|
---|
95 | #include "MLogManip.h" // inf, warn, err
|
---|
96 |
|
---|
97 | #include "MGList.h" // MGList
|
---|
98 | #include "MGMenu.h" // MGMenu, TGMenu
|
---|
99 | #include "MSearch.h" // MSearch
|
---|
100 | #include "MParContainer.h" // MParContainer::GetDescriptor
|
---|
101 | #include "MStatusArray.h" // MStatusArray
|
---|
102 |
|
---|
103 | #undef DEBUG
|
---|
104 | //#define DEBUG
|
---|
105 |
|
---|
106 | ClassImp(MStatusDisplay);
|
---|
107 |
|
---|
108 | using namespace std;
|
---|
109 |
|
---|
110 | // ------------ Workaround for a non working TGTextView::Search -------------
|
---|
111 | #if ROOT_VERSION_CODE < ROOT_VERSION(3,02,05)
|
---|
112 | class MGTextView : public TGTextView
|
---|
113 | {
|
---|
114 | public:
|
---|
115 | MGTextView(const TGWindow *parent, UInt_t w, UInt_t h, Int_t id = -1,
|
---|
116 | UInt_t sboptions = 0, ULong_t back = GetWhitePixel()) :
|
---|
117 | TGTextView(parent, w, h, id, sboptions, back) {}
|
---|
118 | MGTextView(const TGWindow *parent, UInt_t w, UInt_t h, TGText *text,
|
---|
119 | Int_t id = -1, UInt_t sboptions = 0, ULong_t back = GetWhitePixel()) :
|
---|
120 | TGTextView(parent, w, h, text, id, sboptions, back) {}
|
---|
121 | MGTextView(const TGWindow *parent, UInt_t w, UInt_t h, const char *string,
|
---|
122 | Int_t id = -1, UInt_t sboptions = 0, ULong_t back = GetWhitePixel()) :
|
---|
123 | TGTextView(parent, w, h, string, id, sboptions, back) {}
|
---|
124 |
|
---|
125 | void Mark(Long_t xPos, Long_t yPos) { TGTextView::Mark(xPos, yPos); }
|
---|
126 | void UnMark() { TGTextView::UnMark(); }
|
---|
127 |
|
---|
128 | Bool_t Search(const char *string, Bool_t direction, Bool_t caseSensitive)
|
---|
129 | {
|
---|
130 | // Taken from TGTextView::Search and modified.
|
---|
131 |
|
---|
132 | TGLongPosition pos, pos2;
|
---|
133 | pos2.fX = pos2.fY = 0;
|
---|
134 | if (fIsMarked) {
|
---|
135 | if (!direction)
|
---|
136 | {
|
---|
137 | pos2.fX = fMarkedStart.fX;
|
---|
138 | pos2.fY = fMarkedStart.fY;
|
---|
139 | }
|
---|
140 | else
|
---|
141 | {
|
---|
142 | pos2.fX = fMarkedEnd.fX + 1;
|
---|
143 | pos2.fY = fMarkedEnd.fY;
|
---|
144 | }
|
---|
145 | }
|
---|
146 | if (!fText->Search(&pos, pos2, string, direction, caseSensitive))
|
---|
147 | return kFALSE;
|
---|
148 | UnMark();
|
---|
149 | fIsMarked = kTRUE;
|
---|
150 | fMarkedStart.fY = fMarkedEnd.fY = pos.fY;
|
---|
151 | fMarkedStart.fX = pos.fX;
|
---|
152 | fMarkedEnd.fX = fMarkedStart.fX + strlen(string);
|
---|
153 | pos.fY = ToObjYCoord(fVisible.fY);
|
---|
154 | if ((fMarkedStart.fY < pos.fY) ||
|
---|
155 | (ToScrYCoord(fMarkedStart.fY) >= (Int_t)fCanvas->GetHeight()))
|
---|
156 | pos.fY = fMarkedStart.fY;
|
---|
157 | pos.fX = ToObjXCoord(fVisible.fX, pos.fY);
|
---|
158 | if ((fMarkedStart.fX < pos.fX) ||
|
---|
159 | (ToScrXCoord(fMarkedStart.fX, pos.fY) >= (Int_t)fCanvas->GetWidth()))
|
---|
160 | pos.fX = fMarkedStart.fX;
|
---|
161 |
|
---|
162 | SetVsbPosition((ToScrYCoord(pos.fY) + fVisible.fY)/fScrollVal.fY);
|
---|
163 | SetHsbPosition((ToScrXCoord(pos.fX, pos.fY) + fVisible.fX)/fScrollVal.fX);
|
---|
164 | DrawRegion(0, (Int_t)ToScrYCoord(fMarkedStart.fY), fCanvas->GetWidth(),
|
---|
165 | UInt_t(ToScrYCoord(fMarkedEnd.fY+1) - ToScrYCoord(fMarkedEnd.fY)));
|
---|
166 |
|
---|
167 | return kTRUE;
|
---|
168 | }
|
---|
169 | };
|
---|
170 | #else
|
---|
171 | #define MGTextView TGTextView
|
---|
172 | #endif
|
---|
173 |
|
---|
174 | // --------------------------------------------------------------------------
|
---|
175 |
|
---|
176 | // --------------------------------------------------------------------------
|
---|
177 | //
|
---|
178 | // Add menu bar to the GUI
|
---|
179 | //
|
---|
180 | void MStatusDisplay::AddMenuBar()
|
---|
181 | {
|
---|
182 | //
|
---|
183 | // File Menu
|
---|
184 | //
|
---|
185 | MGPopupMenu *filemenu = new MGPopupMenu(gClient->GetRoot());
|
---|
186 | // filemenu->AddEntry("Save &As...", kFileSaveAs);
|
---|
187 | filemenu->AddEntry("New Can&vas", kFileCanvas);
|
---|
188 | filemenu->AddEntry("New &Browser", kFileBrowser);
|
---|
189 | filemenu->AddSeparator();
|
---|
190 | filemenu->AddEntry("Save As status.&ps", kFileSaveAsPS);
|
---|
191 | filemenu->AddEntry("Save As status.&gif", kFileSaveAsGIF);
|
---|
192 | filemenu->AddEntry("Save As status.&C", kFileSaveAsC);
|
---|
193 | filemenu->AddEntry("Save As status.&root", kFileSaveAsRoot);
|
---|
194 | filemenu->AddSeparator();
|
---|
195 | filemenu->AddEntry("&Open...", kFileOpen);
|
---|
196 | filemenu->AddEntry("Save &As...", kFileSaveAs);
|
---|
197 | filemenu->AddSeparator();
|
---|
198 | filemenu->AddEntry("Re&set", kFileReset);
|
---|
199 | filemenu->AddSeparator();
|
---|
200 | filemenu->AddEntry("Print with &lpr", kFilePrint);
|
---|
201 | //filemenu->AddEntry("Set printer &name", kFilePrinterName);
|
---|
202 | filemenu->AddSeparator();
|
---|
203 | filemenu->AddEntry("C&lose", kFileClose);
|
---|
204 | filemenu->AddEntry("E&xit", kFileExit);
|
---|
205 | filemenu->Associate(this);
|
---|
206 |
|
---|
207 | //
|
---|
208 | // Tab Menu
|
---|
209 | //
|
---|
210 | MGPopupMenu *tabmenu = new MGPopupMenu(gClient->GetRoot());
|
---|
211 | tabmenu->AddEntry("Next [&+]", kTabNext);
|
---|
212 | tabmenu->AddEntry("Previous [&-]", kTabPrevious);
|
---|
213 | tabmenu->AddSeparator();
|
---|
214 | tabmenu->AddEntry("Save As tab-i.&ps", kTabSaveAsPS);
|
---|
215 | tabmenu->AddEntry("Save As tab-i.&gif", kTabSaveAsGIF);
|
---|
216 | tabmenu->AddEntry("Save As tab-i.&C", kTabSaveAsC);
|
---|
217 | tabmenu->AddEntry("Save As tab-i.&root", kTabSaveAsRoot);
|
---|
218 | tabmenu->AddSeparator();
|
---|
219 | tabmenu->AddEntry("Save &As...", kTabSaveAs);
|
---|
220 | tabmenu->AddSeparator();
|
---|
221 | tabmenu->AddEntry("Re&move", kTabRemove);
|
---|
222 | tabmenu->AddSeparator();
|
---|
223 | tabmenu->AddEntry("Print with &lpr", kTabPrint);
|
---|
224 | tabmenu->Associate(this);
|
---|
225 |
|
---|
226 | //
|
---|
227 | // Loop Menu
|
---|
228 | //
|
---|
229 | MGPopupMenu *loopmenu = new MGPopupMenu(gClient->GetRoot());
|
---|
230 | loopmenu->AddEntry("&Stop", kLoopStop);
|
---|
231 | loopmenu->Associate(this);
|
---|
232 |
|
---|
233 | //
|
---|
234 | // Loop Menu
|
---|
235 | //
|
---|
236 | MGPopupMenu *sizemenu = new MGPopupMenu(gClient->GetRoot());
|
---|
237 | sizemenu->AddEntry("Fit to 640x&480", kSize640);
|
---|
238 | sizemenu->AddEntry("Fit to 800x&600", kSize800);
|
---|
239 | sizemenu->AddEntry("Fit to 960x7&20", kSize960);
|
---|
240 | sizemenu->AddEntry("Fit to 1024x&768", kSize1024);
|
---|
241 | sizemenu->AddEntry("Fit to 1280x&1024", kSize1280);
|
---|
242 | sizemenu->Associate(this);
|
---|
243 |
|
---|
244 | //
|
---|
245 | // Log Menu
|
---|
246 | //
|
---|
247 | MGPopupMenu *logmenu = new MGPopupMenu(gClient->GetRoot());
|
---|
248 | logmenu->AddEntry("&Copy Selected", kLogCopy);
|
---|
249 | logmenu->AddEntry("Cl&ear all", kLogClear);
|
---|
250 | logmenu->AddSeparator();
|
---|
251 | logmenu->AddEntry("Select &All", kLogSelect);
|
---|
252 | logmenu->AddSeparator();
|
---|
253 | logmenu->AddEntry("&Find...", kLogFind);
|
---|
254 | logmenu->AddSeparator();
|
---|
255 | logmenu->AddEntry("&Save", kLogSave);
|
---|
256 | logmenu->AddEntry("Save &append", kLogAppend);
|
---|
257 | logmenu->Associate(this);
|
---|
258 |
|
---|
259 | //
|
---|
260 | // Menu Bar
|
---|
261 | //
|
---|
262 | TGLayoutHints *layitem = new TGLayoutHints(kLHintsNormal, 0, 4, 0, 0);
|
---|
263 | fList->Add(layitem);
|
---|
264 |
|
---|
265 | MGMenuBar *menubar = new MGMenuBar(this, 1, 1, kHorizontalFrame);
|
---|
266 | menubar->AddPopup("&File", filemenu, layitem);
|
---|
267 | menubar->AddPopup("Lo&g", logmenu, layitem);
|
---|
268 | menubar->AddPopup("&Size", sizemenu, layitem);
|
---|
269 | menubar->AddPopup("&Tab", tabmenu, layitem);
|
---|
270 | menubar->AddPopup("&Loop", loopmenu, layitem);
|
---|
271 | menubar->BindKeys(this);
|
---|
272 | AddFrame(menubar);
|
---|
273 |
|
---|
274 | //
|
---|
275 | // Line below menu bar
|
---|
276 | //
|
---|
277 | TGLayoutHints *laylinesep = new TGLayoutHints(kLHintsTop|kLHintsExpandX);
|
---|
278 | fList->Add(laylinesep);
|
---|
279 |
|
---|
280 | TGHorizontal3DLine *linesep = new TGHorizontal3DLine(this);
|
---|
281 | AddFrame(linesep, laylinesep);
|
---|
282 |
|
---|
283 | //
|
---|
284 | // Add everything to autodel list
|
---|
285 | //
|
---|
286 | fList->Add(filemenu);
|
---|
287 | fList->Add(loopmenu);
|
---|
288 | fList->Add(sizemenu);
|
---|
289 | fList->Add(menubar);
|
---|
290 | fList->Add(tabmenu);
|
---|
291 | fList->Add(logmenu);
|
---|
292 | fList->Add(linesep);
|
---|
293 | }
|
---|
294 |
|
---|
295 | // --------------------------------------------------------------------------
|
---|
296 | //
|
---|
297 | // Adds an empty TGCompositeFrame which might be filled by the user
|
---|
298 | //
|
---|
299 | void MStatusDisplay::AddUserFrame()
|
---|
300 | {
|
---|
301 | TGLayoutHints *lay=new TGLayoutHints(kLHintsExpandX);
|
---|
302 | fList->Add(lay);
|
---|
303 |
|
---|
304 | fUserFrame = new TGCompositeFrame(this, 1, 1);
|
---|
305 | AddFrame(fUserFrame, lay);
|
---|
306 | fList->Add(fUserFrame);
|
---|
307 | }
|
---|
308 |
|
---|
309 | char *rot128(char *c)
|
---|
310 | {
|
---|
311 | char *rc=c;
|
---|
312 | while (*c) *c++ += 128;
|
---|
313 | return rc;
|
---|
314 | }
|
---|
315 |
|
---|
316 | // --------------------------------------------------------------------------
|
---|
317 | //
|
---|
318 | // Add the title tab
|
---|
319 | //
|
---|
320 | void MStatusDisplay::AddMarsTab()
|
---|
321 | {
|
---|
322 | // Create Tab1
|
---|
323 | TGCompositeFrame *f = fTab->AddTab("-=MARS=-");
|
---|
324 |
|
---|
325 | // Add list of tabs
|
---|
326 |
|
---|
327 | TGComboBox *filter = new TGComboBox(f, kTabs);
|
---|
328 | fList->Add(filter);
|
---|
329 | filter->Associate(this);
|
---|
330 | filter->AddEntry("-=MARS=-", 0);
|
---|
331 | filter->Select(0);
|
---|
332 |
|
---|
333 | TGLayoutHints *lay3 = new TGLayoutHints(kLHintsCenterX|kLHintsTop, 10, 10, 10, 5);
|
---|
334 | fList->Add(lay3);
|
---|
335 | f->AddFrame(filter, lay3);
|
---|
336 |
|
---|
337 | // Add MARS version
|
---|
338 | TGLabel *l = new TGLabel(f, Form("Official Release: V%s", MARSVER));
|
---|
339 | fList->Add(l);
|
---|
340 |
|
---|
341 | filter->SetWidth(l->GetWidth());
|
---|
342 | filter->SetHeight(4*l->GetHeight()/3);
|
---|
343 |
|
---|
344 | TGLayoutHints *layb = new TGLayoutHints(kLHintsCenterX|kLHintsTop, 10, 10, 5, 5);
|
---|
345 | fList->Add(layb);
|
---|
346 | f->AddFrame(l, layb);
|
---|
347 |
|
---|
348 | // Add root version
|
---|
349 | l = new TGLabel(f, Form("Using ROOT v%s", ROOTVER));
|
---|
350 | fList->Add(l);
|
---|
351 |
|
---|
352 | TGLayoutHints *lay = new TGLayoutHints(kLHintsCenterX|kLHintsTop);
|
---|
353 | fList->Add(lay);
|
---|
354 | f->AddFrame(l, lay);
|
---|
355 |
|
---|
356 | // Add Mars logo picture
|
---|
357 | const TGPicture *pic2 = fList->GetPicture("marslogo.xpm");
|
---|
358 | if (pic2)
|
---|
359 | {
|
---|
360 | TGPictureButton *mars = new TGPictureButton(f, pic2, kPicMars);
|
---|
361 | fList->Add(mars);
|
---|
362 | mars->Associate(this);
|
---|
363 |
|
---|
364 | TGLayoutHints *lay2 = new TGLayoutHints(kLHintsCenterX|kLHintsCenterY, 10, 10, 5, 5);
|
---|
365 | fList->Add(lay2);
|
---|
366 | f->AddFrame(mars, lay2);
|
---|
367 | }
|
---|
368 |
|
---|
369 | // Add date and time
|
---|
370 | TDatime d;
|
---|
371 | l = new TGLabel(f, d.AsString());
|
---|
372 | fList->Add(l);
|
---|
373 | f->AddFrame(l, lay);
|
---|
374 |
|
---|
375 | // Add copyright notice
|
---|
376 | l = new TGLabel(f, "(c) MAGIC Software Development, 2000-2004");
|
---|
377 | fList->Add(l);
|
---|
378 | f->AddFrame(l, layb);
|
---|
379 |
|
---|
380 | TGLayoutHints *layc = new TGLayoutHints(kLHintsCenterX|kLHintsTop, 10, 10, 0, 5);
|
---|
381 | fList->Add(layc);
|
---|
382 |
|
---|
383 | char *txt = "<< Thomas Bretz >>";
|
---|
384 | l = new TGLabel(f, txt);
|
---|
385 | fList->Add(l);
|
---|
386 | f->AddFrame(l, layc);
|
---|
387 | }
|
---|
388 |
|
---|
389 | // --------------------------------------------------------------------------
|
---|
390 | //
|
---|
391 | // Adds the logbook tab to the GUI if it was not added previously.
|
---|
392 | //
|
---|
393 | // The logbook is updated four times a second only if the tab is visible.
|
---|
394 | //
|
---|
395 | // You can redirect an output to a MLog-logstream by calling SetLogStream().
|
---|
396 | // To disable redirction call SetLogStream(NULL)
|
---|
397 | //
|
---|
398 | // if enable==kFALSE the stdout is disabled/enabled. Otherwise stdout
|
---|
399 | // is ignored.
|
---|
400 | //
|
---|
401 | void MStatusDisplay::SetLogStream(MLog *log, Bool_t enable)
|
---|
402 | {
|
---|
403 | if (gROOT->IsBatch())
|
---|
404 | return;
|
---|
405 |
|
---|
406 | if (log && fLogBox==NULL)
|
---|
407 | {
|
---|
408 | fLogIdx = fTab->GetNumberOfTabs();
|
---|
409 |
|
---|
410 | // Create Tab1
|
---|
411 | TGCompositeFrame *f = AddRawTab("-Logbook-");//fTab->AddTab("-Logbook-");
|
---|
412 |
|
---|
413 | // Create Text View
|
---|
414 | fLogBox = new MGTextView(f, 1, 1); // , -1, 0, TGFrame::GetDefaultFrameBackground());
|
---|
415 | if (fFont)
|
---|
416 | fLogBox->SetFont(fFont);
|
---|
417 | //fLogBox->Associate(this);
|
---|
418 |
|
---|
419 | // Add List box to the tab
|
---|
420 | TGLayoutHints *lay = new TGLayoutHints(kLHintsNormal|kLHintsExpandX|kLHintsExpandY,2,2,2,2);
|
---|
421 | f->AddFrame(fLogBox, lay);
|
---|
422 |
|
---|
423 | // layout and map tab
|
---|
424 | Layout();
|
---|
425 | MapSubwindows();
|
---|
426 |
|
---|
427 | // make it visible
|
---|
428 | // FIXME: This is a workaround, because TApplication::Run is not
|
---|
429 | // thread safe against ProcessEvents. We assume, that if
|
---|
430 | // we are not in the Main-Thread ProcessEvents() is
|
---|
431 | // called by the TApplication Event Loop...
|
---|
432 | if (!TThread::Self()/*gApplication->InheritsFrom(TRint::Class())*/)
|
---|
433 | gClient->ProcessEventsFor(fTab);
|
---|
434 | }
|
---|
435 |
|
---|
436 | if (log)
|
---|
437 | {
|
---|
438 | fLog = log;
|
---|
439 |
|
---|
440 | log->SetOutputGui(fLogBox, kTRUE);
|
---|
441 | log->EnableOutputDevice(MLog::eGui);
|
---|
442 | if (!enable)
|
---|
443 | log->DisableOutputDevice(MLog::eStdout);
|
---|
444 |
|
---|
445 | fLogTimer.Start();
|
---|
446 | }
|
---|
447 | else
|
---|
448 | {
|
---|
449 | fLogTimer.Stop();
|
---|
450 |
|
---|
451 | fLog->DisableOutputDevice(MLog::eGui);
|
---|
452 | fLog->SetOutputGui(NULL);
|
---|
453 | if (!enable)
|
---|
454 | fLog->EnableOutputDevice(MLog::eStdout);
|
---|
455 |
|
---|
456 | fLog = &gLog;
|
---|
457 | }
|
---|
458 | }
|
---|
459 |
|
---|
460 | // --------------------------------------------------------------------------
|
---|
461 | //
|
---|
462 | // Add the Tabs and the predifined Tabs to the GUI
|
---|
463 | //
|
---|
464 | void MStatusDisplay::AddTabs()
|
---|
465 | {
|
---|
466 | fTab = new TGTab(this, 300, 300);
|
---|
467 |
|
---|
468 | AddMarsTab();
|
---|
469 |
|
---|
470 | // Add fTab to Frame
|
---|
471 | TGLayoutHints *laytabs = new TGLayoutHints(kLHintsNormal|kLHintsExpandX|kLHintsExpandY, 5, 5, 5);
|
---|
472 | AddFrame(fTab, laytabs);
|
---|
473 |
|
---|
474 | fList->Add(fTab);
|
---|
475 | fList->Add(laytabs);
|
---|
476 | }
|
---|
477 |
|
---|
478 | // --------------------------------------------------------------------------
|
---|
479 | //
|
---|
480 | // Add the progress bar to the GUI. The Progress Bar range is set to
|
---|
481 | // (0,1) as default.
|
---|
482 | //
|
---|
483 | void MStatusDisplay::AddProgressBar()
|
---|
484 | {
|
---|
485 | TGLayoutHints *laybar=new TGLayoutHints(kLHintsExpandX, 5, 5, 5, 5);
|
---|
486 | fList->Add(laybar);
|
---|
487 |
|
---|
488 | fBar=new TGHProgressBar(this);
|
---|
489 | fBar->SetRange(0, 1);
|
---|
490 | fBar->ShowPosition();
|
---|
491 | AddFrame(fBar, laybar);
|
---|
492 | fList->Add(fBar);
|
---|
493 | }
|
---|
494 |
|
---|
495 | // --------------------------------------------------------------------------
|
---|
496 | //
|
---|
497 | // Set the progress bar position between 0 and 1. The Progress bar range
|
---|
498 | // is assumed to be (0,1)
|
---|
499 | //
|
---|
500 | void MStatusDisplay::SetProgressBarPosition(Float_t p)
|
---|
501 | {
|
---|
502 | fBar->SetPosition(p);
|
---|
503 | }
|
---|
504 |
|
---|
505 | // --------------------------------------------------------------------------
|
---|
506 | //
|
---|
507 | // Adds the status bar to the GUI
|
---|
508 | //
|
---|
509 | void MStatusDisplay::AddStatusBar()
|
---|
510 | {
|
---|
511 | fStatusBar = new TGStatusBar(this, 1, 1);
|
---|
512 |
|
---|
513 | //
|
---|
514 | // Divide it like the 'Golden Cut' (goldener Schnitt)
|
---|
515 | //
|
---|
516 | // 1-a a
|
---|
517 | // 1: ------|----
|
---|
518 | //
|
---|
519 | // a/(1-a) = (1-a)/1
|
---|
520 | // a^2+a-1 = 0
|
---|
521 | // a = (-1+-sqrt(1+4))/2 = sqrt(5)/2-1/2 = 0.618
|
---|
522 | //
|
---|
523 | Int_t p[2] = {38, 62};
|
---|
524 |
|
---|
525 | fStatusBar->SetParts(p, 2);
|
---|
526 |
|
---|
527 | TGLayoutHints *layb = new TGLayoutHints(kLHintsNormal|kLHintsExpandX, 5, 4, 0, 3);
|
---|
528 | AddFrame(fStatusBar, layb);
|
---|
529 |
|
---|
530 | fList->Add(fStatusBar);
|
---|
531 | fList->Add(layb);
|
---|
532 | }
|
---|
533 |
|
---|
534 | // --------------------------------------------------------------------------
|
---|
535 | //
|
---|
536 | // Change the text in the status line 1
|
---|
537 | //
|
---|
538 | void MStatusDisplay::SetStatusLine1(const char *txt)
|
---|
539 | {
|
---|
540 | if (gROOT->IsBatch())
|
---|
541 | return;
|
---|
542 | fStatusBar->SetText(txt, 0);
|
---|
543 |
|
---|
544 | // FIXME: This is a workaround, because TApplication::Run is not
|
---|
545 | // thread safe against ProcessEvents. We assume, that if
|
---|
546 | // we are not in the Main-Thread ProcessEvents() is
|
---|
547 | // called by the TApplication Event Loop...
|
---|
548 | if (!TThread::Self()/*gApplication->InheritsFrom(TRint::Class())*/)
|
---|
549 | gClient->ProcessEventsFor(fStatusBar);
|
---|
550 | }
|
---|
551 |
|
---|
552 | // --------------------------------------------------------------------------
|
---|
553 | //
|
---|
554 | // Change the text in the status line 2
|
---|
555 | //
|
---|
556 | void MStatusDisplay::SetStatusLine2(const char *txt)
|
---|
557 | {
|
---|
558 | if (gROOT->IsBatch())
|
---|
559 | return;
|
---|
560 |
|
---|
561 | fStatusBar->SetText(txt, 1);
|
---|
562 |
|
---|
563 | // FIXME: This is a workaround, because TApplication::Run is not
|
---|
564 | // thread safe against ProcessEvents. We assume, that if
|
---|
565 | // we are not in the Main-Thread ProcessEvents() is
|
---|
566 | // called by the TApplication Event Loop...
|
---|
567 | if (!TThread::Self()/*gApplication->InheritsFrom(TRint::Class())*/)
|
---|
568 | gClient->ProcessEventsFor(fStatusBar);
|
---|
569 | }
|
---|
570 |
|
---|
571 | // --------------------------------------------------------------------------
|
---|
572 | //
|
---|
573 | // Display information about the name of a container
|
---|
574 | //
|
---|
575 | void MStatusDisplay::SetStatusLine2(const MParContainer &cont)
|
---|
576 | {
|
---|
577 | SetStatusLine2(Form("%s: %s", cont.GetDescriptor(), cont.GetTitle()));
|
---|
578 | }
|
---|
579 |
|
---|
580 | // --------------------------------------------------------------------------
|
---|
581 | //
|
---|
582 | // Default constructor. Opens a window with a progress bar. Get a pointer
|
---|
583 | // to the bar by calling GetBar. This pointer can be used for the
|
---|
584 | // eventloop.
|
---|
585 | //
|
---|
586 | // Be carefull: killing or closing the window while the progress meter
|
---|
587 | // is still in use may cause segmentation faults. Please kill the window
|
---|
588 | // always by deleting the corresponding object.
|
---|
589 | //
|
---|
590 | // Update time default: 10s
|
---|
591 | //
|
---|
592 | MStatusDisplay::MStatusDisplay(Long_t t)
|
---|
593 | : TGMainFrame(NULL, 1, 1), fName("MStatusDisplay"), fLog(&gLog), fTab(NULL), fTimer(this, t, kTRUE), fStatus(kLoopNone), fLogIdx(-1), fLogTimer(this, 250, kTRUE), fLogBox(NULL), fIsLocked(0)
|
---|
594 | {
|
---|
595 | // p==NULL means: Take gClient->GetRoot() if not in batch mode
|
---|
596 | // see TGWindow::TGWindow()
|
---|
597 |
|
---|
598 | //
|
---|
599 | // This is a possibility for the user to check whether this
|
---|
600 | // object has already been deleted. It will be removed
|
---|
601 | // from the list in the destructor.
|
---|
602 | //
|
---|
603 | gROOT->GetListOfSpecials()->Add(this);
|
---|
604 |
|
---|
605 | fFont = gVirtualX->LoadQueryFont("7x13bold");
|
---|
606 | fMutex = new TMutex;
|
---|
607 |
|
---|
608 | //
|
---|
609 | // In case we are in batch mode use a list of canvases
|
---|
610 | // instead of the Root Embedded Canvases in the TGTab
|
---|
611 | //
|
---|
612 | fBatch = new TList;
|
---|
613 | fBatch->SetOwner();
|
---|
614 |
|
---|
615 | //
|
---|
616 | // Create a list handling GUI widgets
|
---|
617 | //
|
---|
618 | fList = new MGList;
|
---|
619 | fList->SetOwner();
|
---|
620 |
|
---|
621 | //
|
---|
622 | // Create the layout hint for the root embedded canavses
|
---|
623 | //
|
---|
624 | fLayCanvas = new TGLayoutHints(kLHintsExpandX|kLHintsExpandY);
|
---|
625 | fList->Add(fLayCanvas);
|
---|
626 |
|
---|
627 | //
|
---|
628 | // Add Widgets (from top to bottom)
|
---|
629 | //
|
---|
630 | if (gClient) // BATCH MODE
|
---|
631 | {
|
---|
632 | AddMenuBar();
|
---|
633 | AddUserFrame();
|
---|
634 | AddTabs();
|
---|
635 | AddProgressBar();
|
---|
636 | AddStatusBar();
|
---|
637 | }
|
---|
638 |
|
---|
639 | //
|
---|
640 | // set the smallest and biggest size of the Main frame
|
---|
641 | // and move it to its appearance position
|
---|
642 | SetWMSizeHints(570, 480, 1280, 980, 1, 1);
|
---|
643 | MoveResize(rand()%100+570, rand()%100+480, 570, 480);
|
---|
644 |
|
---|
645 | //
|
---|
646 | // Now do an automatic layout of the widgets and display the window
|
---|
647 | //
|
---|
648 | Layout();
|
---|
649 | MapSubwindows();
|
---|
650 |
|
---|
651 | SetWindowName("Status Display");
|
---|
652 | SetIconName("Status Display");
|
---|
653 |
|
---|
654 | MapWindow();
|
---|
655 |
|
---|
656 | // FIXME: This is a workaround, because TApplication::Run is not
|
---|
657 | // thread safe against ProcessEvents. We assume, that if
|
---|
658 | // we are not in the Main-Thread ProcessEvents() is
|
---|
659 | // called by the TApplication Event Loop...
|
---|
660 | if (!TThread::Self()/*gApplication->InheritsFrom(TRint::Class())*/)
|
---|
661 | gSystem->ProcessEvents();
|
---|
662 | }
|
---|
663 |
|
---|
664 | // --------------------------------------------------------------------------
|
---|
665 | //
|
---|
666 | // Destruct the window with all its tiles. Also the Progress Bar object
|
---|
667 | // is deleted.
|
---|
668 | //
|
---|
669 | MStatusDisplay::~MStatusDisplay()
|
---|
670 | {
|
---|
671 | #if ROOT_VERSION_CODE < ROOT_VERSION(3,10,01)
|
---|
672 | fTab = NULL; // See HandleEvent
|
---|
673 | #endif
|
---|
674 |
|
---|
675 | //
|
---|
676 | // Delete object from global object table so it cannot
|
---|
677 | // be deleted by chance a second time
|
---|
678 | //
|
---|
679 | gInterpreter->DeleteGlobal(this);
|
---|
680 |
|
---|
681 | //
|
---|
682 | // This is a possibility for the user to check whether this
|
---|
683 | // object has already been deleted. It has been added
|
---|
684 | // to the list in the constructor.
|
---|
685 | //
|
---|
686 | gROOT->GetListOfSpecials()->Remove(this);
|
---|
687 |
|
---|
688 | SetLogStream(NULL);
|
---|
689 |
|
---|
690 | //
|
---|
691 | // Delete the list of objects corresponding to this object
|
---|
692 | //
|
---|
693 | delete fList;
|
---|
694 |
|
---|
695 | //
|
---|
696 | // Delete the list list of canvases used in batch mode
|
---|
697 | // instead of the Root Embedded Canvases in the TGTab
|
---|
698 | //
|
---|
699 | delete fBatch;
|
---|
700 |
|
---|
701 | //
|
---|
702 | // Delete the font used for the logging window
|
---|
703 | //
|
---|
704 | if (fFont)
|
---|
705 | gVirtualX->DeleteFont(fFont);
|
---|
706 |
|
---|
707 | //
|
---|
708 | // Delete mutex
|
---|
709 | //
|
---|
710 | delete fMutex;
|
---|
711 | }
|
---|
712 |
|
---|
713 | // --------------------------------------------------------------------------
|
---|
714 | //
|
---|
715 | // Takes a TGCompositeFrame as argument. Searches for the first
|
---|
716 | // TRootEmbeddedCanvas which is contained by it and returns a pointer
|
---|
717 | // to the corresponding TCanvas. If it isn't found NULL is returned.
|
---|
718 | //
|
---|
719 | TRootEmbeddedCanvas *MStatusDisplay::GetEmbeddedCanvas(TGCompositeFrame *cf) const
|
---|
720 | {
|
---|
721 | TIter Next(cf->GetList());
|
---|
722 |
|
---|
723 | TGFrameElement *f;
|
---|
724 | while ((f=(TGFrameElement*)Next()))
|
---|
725 | if (f->fFrame->InheritsFrom(TRootEmbeddedCanvas::Class()))
|
---|
726 | return (TRootEmbeddedCanvas*)f->fFrame;
|
---|
727 |
|
---|
728 | return NULL;
|
---|
729 | }
|
---|
730 |
|
---|
731 | // --------------------------------------------------------------------------
|
---|
732 | //
|
---|
733 | // Takes a TGCompositeFrame as argument. Searches for the first
|
---|
734 | // TRootEmbeddedCanvas which is contained by it and returns a pointer
|
---|
735 | // to the corresponding TCanvas. If it isn't found NULL is returned.
|
---|
736 | //
|
---|
737 | TCanvas *MStatusDisplay::GetCanvas(TGCompositeFrame *cf) const
|
---|
738 | {
|
---|
739 | TRootEmbeddedCanvas *ec = GetEmbeddedCanvas(cf);
|
---|
740 | return ec ? ec->GetCanvas() : NULL;
|
---|
741 | }
|
---|
742 |
|
---|
743 | // --------------------------------------------------------------------------
|
---|
744 | //
|
---|
745 | // Returns GetCanvas of the i-th Tab.
|
---|
746 | //
|
---|
747 | TCanvas *MStatusDisplay::GetCanvas(int i) const
|
---|
748 | {
|
---|
749 | if (gROOT->IsBatch())
|
---|
750 | return (TCanvas*)fBatch->At(i-1);
|
---|
751 |
|
---|
752 | if (i<0 || i>=fTab->GetNumberOfTabs())
|
---|
753 | {
|
---|
754 | *fLog << warn << "MStatusDisplay::GetCanvas: Out of range." << endl;
|
---|
755 | return NULL;
|
---|
756 | }
|
---|
757 |
|
---|
758 | return GetCanvas(fTab->GetTabContainer(i));
|
---|
759 | }
|
---|
760 |
|
---|
761 | // --------------------------------------------------------------------------
|
---|
762 | //
|
---|
763 | // Searches for a TRootEmbeddedCanvas in the TGCompositeFramme of the
|
---|
764 | // Tab with the name 'name'. Returns the corresponding TCanvas or
|
---|
765 | // NULL if something isn't found.
|
---|
766 | //
|
---|
767 | TCanvas *MStatusDisplay::GetCanvas(const TString &name) const
|
---|
768 | {
|
---|
769 | TGFrameElement *f;
|
---|
770 | TIter Next(fTab->GetList());
|
---|
771 | while ((f=(TGFrameElement*)Next()))
|
---|
772 | {
|
---|
773 | TObject *frame = f->fFrame;
|
---|
774 | if (!frame->InheritsFrom(TGTabElement::Class()))
|
---|
775 | continue;
|
---|
776 |
|
---|
777 | TGTabElement *tab = (TGTabElement*)frame;
|
---|
778 | if (tab->GetString()==name)
|
---|
779 | break;
|
---|
780 | }
|
---|
781 |
|
---|
782 | // Search for the next TGCompositeFrame in the list
|
---|
783 | while ((f=(TGFrameElement*)Next()))
|
---|
784 | {
|
---|
785 | TObject *frame = f->fFrame;
|
---|
786 | if (frame->InheritsFrom(TGCompositeFrame::Class()))
|
---|
787 | return GetCanvas((TGCompositeFrame*)frame);
|
---|
788 | }
|
---|
789 |
|
---|
790 | return NULL;
|
---|
791 | }
|
---|
792 |
|
---|
793 | // --------------------------------------------------------------------------
|
---|
794 | //
|
---|
795 | // Calls TCanvas::cd(), for the canvas returned by GetCanvas.
|
---|
796 | //
|
---|
797 | Bool_t MStatusDisplay::CdCanvas(const TString &name)
|
---|
798 | {
|
---|
799 | TCanvas *c = GetCanvas(name);
|
---|
800 | if (!c)
|
---|
801 | return kFALSE;
|
---|
802 |
|
---|
803 | c->cd();
|
---|
804 | return kTRUE;
|
---|
805 | }
|
---|
806 |
|
---|
807 | TGCompositeFrame *MStatusDisplay::AddRawTab(const char *name)
|
---|
808 | {
|
---|
809 | // Add new tab
|
---|
810 | TGCompositeFrame *f = fTab->AddTab(name);
|
---|
811 |
|
---|
812 | TGComboBox *box = (TGComboBox*)fList->FindWidget(kTabs);
|
---|
813 | box->AddEntry(name, box->GetListBox()->GetNumberOfEntries());
|
---|
814 |
|
---|
815 | // layout and map new tab
|
---|
816 | Layout();
|
---|
817 | MapSubwindows();
|
---|
818 | Layout();
|
---|
819 |
|
---|
820 | // display new tab in the main frame
|
---|
821 | // FIXME: This is a workaround, because TApplication::Run is not
|
---|
822 | // thread safe against ProcessEvents. We assume, that if
|
---|
823 | // we are not in the Main-Thread ProcessEvents() is
|
---|
824 | // called by the TApplication Event Loop...
|
---|
825 | if (!TThread::Self()/*gApplication->InheritsFrom(TRint::Class())*/)
|
---|
826 | gClient->ProcessEventsFor(fTab);
|
---|
827 |
|
---|
828 | *fLog << inf << "Adding Raw Tab '" << name << "' (" << f->GetWidth() << "x";
|
---|
829 | *fLog << f->GetHeight() << ")" << endl;
|
---|
830 |
|
---|
831 | // return pointer to new canvas
|
---|
832 | return f;
|
---|
833 | }
|
---|
834 |
|
---|
835 | // --------------------------------------------------------------------------
|
---|
836 | //
|
---|
837 | // This function was connected to all created canvases. It is used
|
---|
838 | // to redirect GetObjectInfo into our own status bar.
|
---|
839 | //
|
---|
840 | // The 'connection' is done in AddTab
|
---|
841 | //
|
---|
842 | void MStatusDisplay::EventInfo(Int_t event, Int_t px, Int_t py, TObject *selected)
|
---|
843 | {
|
---|
844 | // Writes the event status in the status bar parts
|
---|
845 | if (!selected)
|
---|
846 | return;
|
---|
847 |
|
---|
848 | TCanvas *c = (TCanvas*)gTQSender;
|
---|
849 |
|
---|
850 | TVirtualPad* save=gPad;
|
---|
851 |
|
---|
852 | gPad = c ? c->GetSelectedPad() : NULL;
|
---|
853 |
|
---|
854 | if (gPad)
|
---|
855 | SetStatusLine2(selected->GetObjectInfo(px,py));
|
---|
856 |
|
---|
857 | gPad=save;
|
---|
858 | }
|
---|
859 |
|
---|
860 | // --------------------------------------------------------------------------
|
---|
861 | //
|
---|
862 | // Adds a new tab with the name 'name'. Adds a TRootEmbeddedCanvas to the
|
---|
863 | // tab and returns a reference to the corresponding TCanvas.
|
---|
864 | //
|
---|
865 | TCanvas &MStatusDisplay::AddTab(const char *name)
|
---|
866 | {
|
---|
867 | if (gROOT->IsBatch())
|
---|
868 | {
|
---|
869 | TCanvas *c = new TCanvas(name, name);
|
---|
870 | fBatch->Add(c);
|
---|
871 | return *c;
|
---|
872 | }
|
---|
873 |
|
---|
874 | // Add new tab
|
---|
875 | TGCompositeFrame *f = fTab->AddTab(name);
|
---|
876 |
|
---|
877 | // create root embedded canvas and add it to the tab
|
---|
878 | TRootEmbeddedCanvas *ec = new TRootEmbeddedCanvas(name, f, f->GetWidth(), f->GetHeight(), 0);
|
---|
879 | f->AddFrame(ec, fLayCanvas);
|
---|
880 | fList->Add(ec);
|
---|
881 |
|
---|
882 | // set background and border mode of the canvas
|
---|
883 | TCanvas &c = *ec->GetCanvas();
|
---|
884 |
|
---|
885 | c.SetFillColor(16/*165*//*17*//*203*/);
|
---|
886 | c.SetBorderMode(0);
|
---|
887 |
|
---|
888 | // If kNoContextMenu set set kNoContextMenu of the canvas
|
---|
889 | if (TestBit(kNoContextMenu))
|
---|
890 | c.SetBit(kNoContextMenu);
|
---|
891 |
|
---|
892 | // Connect all TCanvas::ProcessedEvent to this->EventInfo
|
---|
893 | // This means, that after TCanvas has processed an event
|
---|
894 | // EventInfo of this class is called, see TCanvas::HandleInput
|
---|
895 | c.Connect("ProcessedEvent(Int_t,Int_t,Int_t,TObject*)",
|
---|
896 | "MStatusDisplay", this, "EventInfo(Int_t,Int_t,Int_t,TObject*)");
|
---|
897 |
|
---|
898 | TGComboBox *box = (TGComboBox*)fList->FindWidget(kTabs);
|
---|
899 | box->AddEntry(name, box->GetListBox()->GetNumberOfEntries());
|
---|
900 |
|
---|
901 | // layout and map new tab
|
---|
902 | Layout(); // seems to layout the TGCompositeFrame
|
---|
903 | MapSubwindows(); // maps the TGCompositeFrame
|
---|
904 | Layout(); // layout the embedded canvas in the frame
|
---|
905 |
|
---|
906 | // display new tab in the main frame
|
---|
907 | // FIXME: This is a workaround, because TApplication::Run is not
|
---|
908 | // thread safe against ProcessEvents. We assume, that if
|
---|
909 | // we are not in the Main-Thread ProcessEvents() is
|
---|
910 | // called by the TApplication Event Loop...
|
---|
911 | if (!TThread::Self()/*gApplication->InheritsFrom(TRint::Class())*/)
|
---|
912 | gClient->ProcessEventsFor(fTab);
|
---|
913 |
|
---|
914 | *fLog << inf << "Adding Tab '" << name << "' (" << f->GetWidth() << "x";
|
---|
915 | *fLog << f->GetHeight() << ", TCanvas=" << &c << ")" << endl;
|
---|
916 |
|
---|
917 | // return pointer to new canvas
|
---|
918 | return c;
|
---|
919 | }
|
---|
920 |
|
---|
921 | // --------------------------------------------------------------------------
|
---|
922 | //
|
---|
923 | // Update a canvas in a tab, takes the corresponding TGCompositeFrame
|
---|
924 | // as an argument. This is necessary, because not all functions
|
---|
925 | // changing the contents of a canvas or pad can call SetModified()
|
---|
926 | // for the corresponding tab. If this is not called correctly the
|
---|
927 | // tab won't be updated calling TCanvas::Update(). So we simply
|
---|
928 | // redraw it by our own (instead we could recursively call
|
---|
929 | // TPad::Modified() for everything contained by the TCanvas and
|
---|
930 | // call TCanvas::Update() afterwards)
|
---|
931 | //
|
---|
932 | void MStatusDisplay::UpdateTab(TGCompositeFrame *f)
|
---|
933 | {
|
---|
934 | if (!f)
|
---|
935 | return;
|
---|
936 |
|
---|
937 | TCanvas *c=GetCanvas(f);
|
---|
938 | if (!c)
|
---|
939 | return;
|
---|
940 |
|
---|
941 | //
|
---|
942 | // If we are in a multithreaded environment (gThreadXAR) we
|
---|
943 | // have to make sure, that thus function is called from
|
---|
944 | // the main thread.
|
---|
945 | //
|
---|
946 | if (gThreadXAR)
|
---|
947 | {
|
---|
948 | // Tell the X-Requester how to call this method
|
---|
949 | TString str = Form("%d", (ULong_t)f);
|
---|
950 |
|
---|
951 | TMethodCall call(IsA(), "UpdateTab", "NULL");
|
---|
952 | void *arr[4] = { NULL, &call, this, (void*)(const char*)str };
|
---|
953 |
|
---|
954 | // If this is not the main thread return
|
---|
955 | if (((*gThreadXAR)("METH", 4, arr, NULL)))
|
---|
956 | return;
|
---|
957 | }
|
---|
958 |
|
---|
959 | //
|
---|
960 | // Secure calls to update the tabs against itself, at least
|
---|
961 | // c->Paint() or c->Flush() may crash X (bad drawable).
|
---|
962 | // This makes sure, that a X call is not interuppted by
|
---|
963 | // another X-call which was started from an gui interrrupt
|
---|
964 | // in the same thread
|
---|
965 | //
|
---|
966 | if (fMutex->TryLock())
|
---|
967 | return;
|
---|
968 |
|
---|
969 | #if ROOT_VERSION_CODE < ROOT_VERSION(3,10,02)
|
---|
970 | TPad *padsav = (TPad*)gPad;
|
---|
971 | if (!gPad)
|
---|
972 | c->cd();
|
---|
973 | #endif
|
---|
974 |
|
---|
975 | if (!c->IsBatch())
|
---|
976 | c->FeedbackMode(kFALSE); // Goto double buffer mode
|
---|
977 |
|
---|
978 | //
|
---|
979 | // Doing this ourself gives us the possibility to repaint
|
---|
980 | // the canvas in any case (Paint() instead of PaintModified())
|
---|
981 | //
|
---|
982 | c->Paint(); // Repaint all pads
|
---|
983 | c->Flush(); // Copy all pad pixmaps to the screen
|
---|
984 |
|
---|
985 | #if ROOT_VERSION_CODE < ROOT_VERSION(3,10,02)
|
---|
986 | if (padsav)
|
---|
987 | padsav->cd();
|
---|
988 | else
|
---|
989 | gPad=NULL;
|
---|
990 | #endif
|
---|
991 |
|
---|
992 | //c->SetCursor(kCross);
|
---|
993 |
|
---|
994 | // Old version
|
---|
995 | //c->Modified();
|
---|
996 | //c->Update();
|
---|
997 | //c->Paint();
|
---|
998 |
|
---|
999 | fMutex->UnLock();
|
---|
1000 | }
|
---|
1001 |
|
---|
1002 | // --------------------------------------------------------------------------
|
---|
1003 | //
|
---|
1004 | // Saves the given canvas (pad) or all pads (num<0) as a temporary
|
---|
1005 | // postscript file and prints it using 'lpr'. If a printer name is set
|
---|
1006 | // via SetPrinter 'lpr -Pname' is used.
|
---|
1007 | //
|
---|
1008 | Int_t MStatusDisplay::PrintToLpr(Int_t num)
|
---|
1009 | {
|
---|
1010 | TString name = "mars";
|
---|
1011 |
|
---|
1012 | for (int i=0; i<6; i++)
|
---|
1013 | name += (char)(gRandom->Uniform(25)+65);
|
---|
1014 |
|
---|
1015 | name += ".ps";
|
---|
1016 |
|
---|
1017 | const Int_t pages = SaveAsPS(num, name);
|
---|
1018 |
|
---|
1019 | SetStatusLine1("Printing...");
|
---|
1020 | SetStatusLine2("");
|
---|
1021 |
|
---|
1022 | if (!pages)
|
---|
1023 | {
|
---|
1024 | *fLog << warn << "MStatusDisplay::PrintToLpr: Sorry, couldn't save file as temporary postscript!" << endl;
|
---|
1025 | SetStatusLine2("Failed!");
|
---|
1026 | return 0;
|
---|
1027 | }
|
---|
1028 |
|
---|
1029 | TString cmd="lpr ";
|
---|
1030 | if (!fPrinter.IsNull())
|
---|
1031 | {
|
---|
1032 | cmd += "-P";
|
---|
1033 | cmd += fPrinter;
|
---|
1034 | cmd += " ";
|
---|
1035 | }
|
---|
1036 | cmd += name;
|
---|
1037 |
|
---|
1038 | gSystem->Exec(cmd);
|
---|
1039 | gSystem->Unlink(name);
|
---|
1040 |
|
---|
1041 | SetStatusLine2(Form("Done (%dpage(s))", pages));
|
---|
1042 |
|
---|
1043 | return pages;
|
---|
1044 | }
|
---|
1045 |
|
---|
1046 | // --------------------------------------------------------------------------
|
---|
1047 | //
|
---|
1048 | // Remove tab no i if this tab contains a TRootEmbeddedCanvas
|
---|
1049 | //
|
---|
1050 | void MStatusDisplay::RemoveTab(int i)
|
---|
1051 | {
|
---|
1052 | TGCompositeFrame *f = fTab->GetTabContainer(i);
|
---|
1053 | if (!f)
|
---|
1054 | return;
|
---|
1055 |
|
---|
1056 | TRootEmbeddedCanvas *ec = GetEmbeddedCanvas(f);
|
---|
1057 | if (!ec)
|
---|
1058 | return;
|
---|
1059 |
|
---|
1060 | TCanvas *c = ec->GetCanvas();
|
---|
1061 | if (!c)
|
---|
1062 | return;
|
---|
1063 |
|
---|
1064 | const TString name(c->GetName());
|
---|
1065 |
|
---|
1066 | f->RemoveFrame(ec);
|
---|
1067 | delete fList->Remove(ec);
|
---|
1068 |
|
---|
1069 | fTab->RemoveTab(i);
|
---|
1070 | fTab->SetTab(0);
|
---|
1071 |
|
---|
1072 | TGComboBox *box = (TGComboBox*)fList->FindWidget(kTabs);
|
---|
1073 | box->RemoveEntry(i);
|
---|
1074 | for (int j=i; j<box->GetListBox()->GetNumberOfEntries(); j++)
|
---|
1075 | {
|
---|
1076 | TGTextLBEntry *entry = (TGTextLBEntry *)box->GetListBox()->Select(j+1, kFALSE);
|
---|
1077 | box->AddEntry(entry->GetText()->GetString(), j);
|
---|
1078 | box->RemoveEntry(j+1);
|
---|
1079 | }
|
---|
1080 | box->GetListBox()->Select(0);
|
---|
1081 |
|
---|
1082 | // Looks strange...
|
---|
1083 | // const Int_t n = fTab->GetNumberOfTabs();
|
---|
1084 | // fTab->SetTab(i<=n-1 ? i : i-1);
|
---|
1085 |
|
---|
1086 | // layout and map new tab
|
---|
1087 | Layout(); // seems to layout the TGCompositeFrame
|
---|
1088 | MapSubwindows(); // maps the TGCompositeFrame
|
---|
1089 | Layout(); // layout the embedded canvas in the frame
|
---|
1090 |
|
---|
1091 | // display new tab in the main frame
|
---|
1092 | // FIXME: This is a workaround, because TApplication::Run is not
|
---|
1093 | // thread safe against ProcessEvents. We assume, that if
|
---|
1094 | // we are not in the Main-Thread ProcessEvents() is
|
---|
1095 | // called by the TApplication Event Loop...
|
---|
1096 | if (!TThread::Self()/*gApplication->InheritsFrom(TRint::Class())*/)
|
---|
1097 | gClient->ProcessEventsFor(fTab);
|
---|
1098 |
|
---|
1099 | *fLog << inf << "Removed Tab #" << i << " '" << name << "'" << endl;
|
---|
1100 | }
|
---|
1101 |
|
---|
1102 | // --------------------------------------------------------------------------
|
---|
1103 | //
|
---|
1104 | // Use this to check whether the MStatusDisplay still contains the
|
---|
1105 | // TCanvas c. It could be removed meanwhile by menu usage.
|
---|
1106 | //
|
---|
1107 | Bool_t MStatusDisplay::HasCanvas(const TCanvas *c) const
|
---|
1108 | {
|
---|
1109 | if (!c)
|
---|
1110 | return kFALSE;
|
---|
1111 |
|
---|
1112 | if (gROOT->IsBatch())
|
---|
1113 | return (Bool_t)fBatch->FindObject(c);
|
---|
1114 |
|
---|
1115 | for (int i=1; i<fTab->GetNumberOfTabs(); i++)
|
---|
1116 | if (c==GetCanvas(i))
|
---|
1117 | return kTRUE;
|
---|
1118 | return kFALSE;
|
---|
1119 | }
|
---|
1120 |
|
---|
1121 | /*
|
---|
1122 | if (...)
|
---|
1123 | fMenu->AddPopup("&CaOs", fCaOs, NULL);
|
---|
1124 | else
|
---|
1125 | fMenu->RemovePopup("CaOs");
|
---|
1126 | fMenu->Resize(fMenu->GetDefaultSize());
|
---|
1127 | MapSubwindows();
|
---|
1128 | MapWindow();
|
---|
1129 | */
|
---|
1130 |
|
---|
1131 | void MStatusDisplay::Reset()
|
---|
1132 | {
|
---|
1133 | if (gROOT->IsBatch())
|
---|
1134 | {
|
---|
1135 | fBatch->Delete();
|
---|
1136 | return;
|
---|
1137 | }
|
---|
1138 |
|
---|
1139 | for (int i=fTab->GetNumberOfTabs()-1; i>0; i--)
|
---|
1140 | RemoveTab(i);
|
---|
1141 | }
|
---|
1142 |
|
---|
1143 | // --------------------------------------------------------------------------
|
---|
1144 | //
|
---|
1145 | // Process the kC_COMMAND, kCM_MENU messages
|
---|
1146 | //
|
---|
1147 | Bool_t MStatusDisplay::ProcessMessageCommandMenu(Long_t id)
|
---|
1148 | {
|
---|
1149 | switch (id)
|
---|
1150 | {
|
---|
1151 | case kLoopStop:
|
---|
1152 | case kFileClose:
|
---|
1153 | case kFileExit:
|
---|
1154 | if (id==kFileExit || id==kFileClose)
|
---|
1155 | CloseWindow();
|
---|
1156 | fStatus = (Status_t)id;
|
---|
1157 | return kTRUE;
|
---|
1158 |
|
---|
1159 | case kFileCanvas:
|
---|
1160 | new TCanvas;
|
---|
1161 | return kTRUE;
|
---|
1162 |
|
---|
1163 | case kFileBrowser:
|
---|
1164 | new TBrowser;
|
---|
1165 | return kTRUE;
|
---|
1166 |
|
---|
1167 | case kFileReset:
|
---|
1168 | Reset();
|
---|
1169 | return kTRUE;
|
---|
1170 |
|
---|
1171 | case kFileOpen:
|
---|
1172 | Open();
|
---|
1173 | return kTRUE;
|
---|
1174 |
|
---|
1175 | case kFileSaveAs:
|
---|
1176 | SaveAs();
|
---|
1177 | return kTRUE;
|
---|
1178 |
|
---|
1179 | case kFileSaveAsPS:
|
---|
1180 | SaveAsPS();
|
---|
1181 | return kTRUE;
|
---|
1182 |
|
---|
1183 | case kFileSaveAsGIF:
|
---|
1184 | SaveAsGIF();
|
---|
1185 | return kTRUE;
|
---|
1186 |
|
---|
1187 | case kFileSaveAsC:
|
---|
1188 | SaveAsC();
|
---|
1189 | return kTRUE;
|
---|
1190 |
|
---|
1191 | case kFileSaveAsRoot:
|
---|
1192 | SaveAsRoot();
|
---|
1193 | return kTRUE;
|
---|
1194 |
|
---|
1195 | case kFilePrint:
|
---|
1196 | PrintToLpr();
|
---|
1197 | return kTRUE;
|
---|
1198 |
|
---|
1199 | case kTabSaveAs:
|
---|
1200 | SaveAs(fTab->GetCurrent());
|
---|
1201 | return kTRUE;
|
---|
1202 |
|
---|
1203 | case kTabSaveAsPS:
|
---|
1204 | SaveAsPS(fTab->GetCurrent());
|
---|
1205 | return kTRUE;
|
---|
1206 |
|
---|
1207 | case kTabSaveAsGIF:
|
---|
1208 | SaveAsGIF(fTab->GetCurrent());
|
---|
1209 | return kTRUE;
|
---|
1210 |
|
---|
1211 | case kTabSaveAsC:
|
---|
1212 | SaveAsC(fTab->GetCurrent());
|
---|
1213 | return kTRUE;
|
---|
1214 |
|
---|
1215 | case kTabSaveAsRoot:
|
---|
1216 | SaveAsRoot(fTab->GetCurrent());
|
---|
1217 | return kTRUE;
|
---|
1218 |
|
---|
1219 | case kTabPrint:
|
---|
1220 | PrintToLpr(fTab->GetCurrent());
|
---|
1221 | return kTRUE;
|
---|
1222 |
|
---|
1223 | case kTabNext:
|
---|
1224 | fTab->SetTab(fTab->GetCurrent()+1);
|
---|
1225 | return kTRUE;
|
---|
1226 |
|
---|
1227 | case kTabPrevious:
|
---|
1228 | fTab->SetTab(fTab->GetCurrent()-1);
|
---|
1229 | return kTRUE;
|
---|
1230 |
|
---|
1231 | case kTabRemove:
|
---|
1232 | RemoveTab(fTab->GetCurrent());
|
---|
1233 | return kTRUE;
|
---|
1234 |
|
---|
1235 | case kSize640:
|
---|
1236 | Resize(570, 480);
|
---|
1237 | return kTRUE;
|
---|
1238 | case kSize800:
|
---|
1239 | Resize(740, 600);
|
---|
1240 | return kTRUE;
|
---|
1241 | case kSize960:
|
---|
1242 | Resize(880, 700);
|
---|
1243 | return kTRUE;
|
---|
1244 | case kSize1024:
|
---|
1245 | Resize(980, 768);
|
---|
1246 | return kTRUE;
|
---|
1247 | case kSize1280:
|
---|
1248 | Resize(1280, 980);
|
---|
1249 | return kTRUE;
|
---|
1250 |
|
---|
1251 | case kLogClear:
|
---|
1252 | fLogBox->Clear();
|
---|
1253 | return kTRUE;
|
---|
1254 | case kLogCopy:
|
---|
1255 | fLogBox->Copy();
|
---|
1256 | return kTRUE;
|
---|
1257 | case kLogSelect:
|
---|
1258 | fLogBox->SelectAll();
|
---|
1259 | return kTRUE;
|
---|
1260 | case kLogFind:
|
---|
1261 | new MSearch(this);
|
---|
1262 | return kTRUE;
|
---|
1263 | case kLogSave:
|
---|
1264 | SetStatusLine1("Saving log...");
|
---|
1265 | SetStatusLine2("");
|
---|
1266 | *fLog << inf << "Saving log... " << flush;
|
---|
1267 | if (fLogBox->GetText()->Save("statusdisplay.log"))
|
---|
1268 | {
|
---|
1269 | *fLog << "done." << endl;
|
---|
1270 | SetStatusLine2("done.");
|
---|
1271 | }
|
---|
1272 | else
|
---|
1273 | {
|
---|
1274 | *fLog << "failed!" << endl;
|
---|
1275 | SetStatusLine2("Failed!");
|
---|
1276 | }
|
---|
1277 | return kTRUE;
|
---|
1278 |
|
---|
1279 | case kLogAppend:
|
---|
1280 | SetStatusLine1("Appending logg...");
|
---|
1281 | SetStatusLine2("");
|
---|
1282 | *fLog << inf << "Appending log... " << flush;
|
---|
1283 | if (fLogBox->GetText()->Append("statusdisplay.log"))
|
---|
1284 | {
|
---|
1285 | *fLog << "done." << endl;
|
---|
1286 | SetStatusLine2("done.");
|
---|
1287 | }
|
---|
1288 | else
|
---|
1289 | {
|
---|
1290 | *fLog << "failed!" << endl;
|
---|
1291 | SetStatusLine2("Failed!");
|
---|
1292 | }
|
---|
1293 | return kTRUE;
|
---|
1294 | #ifdef DEBUG
|
---|
1295 | default:
|
---|
1296 | cout << "Command-Menu #" << id << endl;
|
---|
1297 | #endif
|
---|
1298 | }
|
---|
1299 | return kTRUE;
|
---|
1300 |
|
---|
1301 | }
|
---|
1302 |
|
---|
1303 | // --------------------------------------------------------------------------
|
---|
1304 | //
|
---|
1305 | // Process the kC_COMMAND messages
|
---|
1306 | //
|
---|
1307 | Bool_t MStatusDisplay::ProcessMessageCommand(Long_t submsg, Long_t mp1, Long_t mp2)
|
---|
1308 | {
|
---|
1309 | switch (submsg)
|
---|
1310 | {
|
---|
1311 | case kCM_MENU: // 1
|
---|
1312 | return ProcessMessageCommandMenu(mp1); // mp2=userdata
|
---|
1313 | case kCM_TAB: // 8
|
---|
1314 | /*
|
---|
1315 | for (int i=0; i<fTab->GetNumberOfTabs(); i++)
|
---|
1316 | fTab->GetTabContainer(i)->UnmapWindow();
|
---|
1317 | */
|
---|
1318 | UpdateTab(fTab->GetTabContainer(mp1));
|
---|
1319 | //fTab->GetTabContainer(mp1)->MapWindow();
|
---|
1320 |
|
---|
1321 | /*
|
---|
1322 | if (mp1>0)
|
---|
1323 | fMenu->AddPopup("&CaOs", fCaOs, NULL);
|
---|
1324 | else
|
---|
1325 | fMenu->RemovePopup("CaOs");
|
---|
1326 | fMenu->Resize(fMenu->GetDefaultSize());
|
---|
1327 | MapSubwindows();
|
---|
1328 | MapWindow();
|
---|
1329 | */
|
---|
1330 | return kTRUE;
|
---|
1331 | case kCM_COMBOBOX: // 7
|
---|
1332 | if (mp1==kTabs)
|
---|
1333 | fTab->SetTab(mp2);
|
---|
1334 | return kTRUE;
|
---|
1335 | #ifdef DEBUG
|
---|
1336 | case kCM_MENUSELECT: // 2
|
---|
1337 | cout << "Command-Menuselect #" << mp1 << " (UserData=" << (void*)mp2 << ")" << endl;
|
---|
1338 | return kTRUE;
|
---|
1339 |
|
---|
1340 | case kCM_BUTTON: // 3
|
---|
1341 | cout << "Command-Button." << endl;
|
---|
1342 | return kTRUE;
|
---|
1343 |
|
---|
1344 | case kCM_CHECKBUTTON: // 4
|
---|
1345 | cout << "Command-CheckButton." << endl;
|
---|
1346 | return kTRUE;
|
---|
1347 |
|
---|
1348 | case kCM_RADIOBUTTON: // 5
|
---|
1349 | cout << "Command-RadioButton." << endl;
|
---|
1350 | return kTRUE;
|
---|
1351 |
|
---|
1352 | case kCM_LISTBOX: // 6
|
---|
1353 | cout << "Command-Listbox #" << mp1 << " (LineId #" << mp2 << ")" << endl;
|
---|
1354 | return kTRUE;
|
---|
1355 | default:
|
---|
1356 | cout << "Command: " << "Submsg:" << submsg << " Mp1=" << mp1 << " Mp2=" << mp2 << endl;
|
---|
1357 | #endif
|
---|
1358 | }
|
---|
1359 | return kTRUE;
|
---|
1360 | }
|
---|
1361 |
|
---|
1362 | // --------------------------------------------------------------------------
|
---|
1363 | //
|
---|
1364 | // Process the kC_TEXTVIEW messages
|
---|
1365 | //
|
---|
1366 | Bool_t MStatusDisplay::ProcessMessageTextview(Long_t submsg, Long_t mp1, Long_t mp2)
|
---|
1367 | {
|
---|
1368 | // kC_TEXTVIEW, kTXT_ISMARKED, widget id, [true|false] //
|
---|
1369 | // kC_TEXTVIEW, kTXT_DATACHANGE, widget id, 0 //
|
---|
1370 | // kC_TEXTVIEW, kTXT_CLICK2, widget id, position (y << 16) | x) //
|
---|
1371 | // kC_TEXTVIEW, kTXT_CLICK3, widget id, position (y << 16) | x) //
|
---|
1372 | // kC_TEXTVIEW, kTXT_F3, widget id, true //
|
---|
1373 | // kC_TEXTVIEW, kTXT_OPEN, widget id, 0 //
|
---|
1374 | // kC_TEXTVIEW, kTXT_CLOSE, widget id, 0 //
|
---|
1375 | // kC_TEXTVIEW, kTXT_SAVE, widget id, 0 //
|
---|
1376 | #ifdef DEBUG
|
---|
1377 | switch (submsg)
|
---|
1378 | {
|
---|
1379 | case kTXT_ISMARKED:
|
---|
1380 | cout << "Textview-IsMarked #" << mp1 << " " << (mp2?"yes":"no") << endl;
|
---|
1381 | return kTRUE;
|
---|
1382 |
|
---|
1383 | case kTXT_DATACHANGE:
|
---|
1384 | cout << "Textview-DataChange #" << mp1 << endl;
|
---|
1385 | return kTRUE;
|
---|
1386 |
|
---|
1387 | case kTXT_CLICK2:
|
---|
1388 | cout << "Textview-Click2 #" << mp1 << " x=" << (mp2&0xffff) << " y= " << (mp2>>16) << endl;
|
---|
1389 | return kTRUE;
|
---|
1390 |
|
---|
1391 | case kTXT_CLICK3:
|
---|
1392 | cout << "Textview-Click3 #" << mp1 << " x=" << (mp2&0xffff) << " y= " << (mp2>>16) << endl;
|
---|
1393 | return kTRUE;
|
---|
1394 |
|
---|
1395 | case kTXT_F3:
|
---|
1396 | cout << "Textview-F3 #" << mp1 << endl;
|
---|
1397 | return kTRUE;
|
---|
1398 |
|
---|
1399 | case kTXT_OPEN:
|
---|
1400 | cout << "Textview-Open #" << mp1 << endl;
|
---|
1401 | return kTRUE;
|
---|
1402 |
|
---|
1403 | case kTXT_CLOSE:
|
---|
1404 | cout << "Textview-Close #" << mp1 << endl;
|
---|
1405 | return kTRUE;
|
---|
1406 |
|
---|
1407 | case kTXT_SAVE:
|
---|
1408 | cout << "Textview-Save #" << mp1 << endl;
|
---|
1409 | return kTRUE;
|
---|
1410 |
|
---|
1411 | default:
|
---|
1412 | cout << "Textview: " << "Submsg:" << submsg << " Mp1=" << mp1 << " Mp2=" << mp2 << endl;
|
---|
1413 | }
|
---|
1414 | #endif
|
---|
1415 | return kTRUE;
|
---|
1416 | }
|
---|
1417 |
|
---|
1418 | // --------------------------------------------------------------------------
|
---|
1419 | //
|
---|
1420 | // Process the kC_USER messages
|
---|
1421 | //
|
---|
1422 | Bool_t MStatusDisplay::ProcessMessageUser(Long_t submsg, Long_t mp1, Long_t mp2)
|
---|
1423 | {
|
---|
1424 | // kS_START, case sensitive | backward<<1, char *txt
|
---|
1425 | switch (submsg)
|
---|
1426 | {
|
---|
1427 | case kS_START:
|
---|
1428 | fLogBox->Search((char*)mp2, !(mp1&2>>1), mp1&1);
|
---|
1429 | return kTRUE;
|
---|
1430 | #ifdef DEBUG
|
---|
1431 | default:
|
---|
1432 | cout << "User: " << "Submsg:" << submsg << " Mp1=" << mp1 << " Mp2=" << mp2 << endl;
|
---|
1433 | #endif
|
---|
1434 | }
|
---|
1435 | return kTRUE;
|
---|
1436 | }
|
---|
1437 |
|
---|
1438 | // --------------------------------------------------------------------------
|
---|
1439 | //
|
---|
1440 | // Process the messages from the GUI
|
---|
1441 | //
|
---|
1442 | Bool_t MStatusDisplay::ProcessMessage(Long_t msg, Long_t mp1, Long_t mp2)
|
---|
1443 | {
|
---|
1444 | // Can be found in WidgetMessageTypes.h
|
---|
1445 | #ifdef DEBUG
|
---|
1446 | cout << "Msg: " << GET_MSG(msg) << " Submsg:" << GET_SUBMSG(msg);
|
---|
1447 | cout << " Mp1=" << mp1 << " Mp2=" << mp2 << endl;
|
---|
1448 | #endif
|
---|
1449 | switch (GET_MSG(msg))
|
---|
1450 | {
|
---|
1451 | case kC_COMMAND: // 1
|
---|
1452 | return ProcessMessageCommand(GET_SUBMSG(msg), mp1, mp2);
|
---|
1453 |
|
---|
1454 | case kC_TEXTVIEW: // 9
|
---|
1455 | return ProcessMessageTextview(GET_SUBMSG(msg), mp1, mp2);
|
---|
1456 |
|
---|
1457 | case kC_USER: // 1001
|
---|
1458 | return ProcessMessageUser(GET_SUBMSG(msg), mp1, mp2);
|
---|
1459 | }
|
---|
1460 | #ifdef DEBUG
|
---|
1461 | cout << "Msg: " << GET_MSG(msg) << " Submsg:" << GET_SUBMSG(msg);
|
---|
1462 | cout << " Mp1=" << mp1 << " Mp2=" << mp2 << endl;
|
---|
1463 | #endif
|
---|
1464 | return kTRUE;
|
---|
1465 | }
|
---|
1466 |
|
---|
1467 | void MStatusDisplay::CloseWindow()
|
---|
1468 | {
|
---|
1469 | // Got close message for this MainFrame. Calls parent CloseWindow()
|
---|
1470 | // (which destroys the window) and terminate the application.
|
---|
1471 | // The close message is generated by the window manager when its close
|
---|
1472 | // window menu item is selected.
|
---|
1473 |
|
---|
1474 | // CloseWindow must be overwritten because otherwise CloseWindow
|
---|
1475 | // and the destructor are calling DestroyWindow which seems to be
|
---|
1476 | // in conflict with the TRootEmbeddedCanvas.
|
---|
1477 |
|
---|
1478 | // FIXME: Make sure that the Status Display is deleted from every
|
---|
1479 | // where (eg Eventloop) first!
|
---|
1480 |
|
---|
1481 | //gLog << dbg << fName << " is on heap: " << (int)IsOnHeap() << endl;
|
---|
1482 |
|
---|
1483 | if (TestBit(kExitLoopOnExit) || TestBit(kExitLoopOnClose))
|
---|
1484 | {
|
---|
1485 | gLog << dbg << "CloseWindow() calling ExitLoop." << endl;
|
---|
1486 | gSystem->ExitLoop();
|
---|
1487 | }
|
---|
1488 |
|
---|
1489 | if (fIsLocked<=0 && IsOnHeap())
|
---|
1490 | {
|
---|
1491 | //gLog << dbg << "delete " << fName << ";" << endl;
|
---|
1492 | delete this;
|
---|
1493 | }
|
---|
1494 | fStatus = kFileExit;
|
---|
1495 | //gLog << dbg << fName << ".fStatus=kFileExit;" << endl;
|
---|
1496 | }
|
---|
1497 |
|
---|
1498 | // --------------------------------------------------------------------------
|
---|
1499 | //
|
---|
1500 | // Calls SetBit(kNoContextMenu) for all TCanvas objects found in the
|
---|
1501 | // Tabs.
|
---|
1502 | //
|
---|
1503 | void MStatusDisplay::SetNoContextMenu(Bool_t flag)
|
---|
1504 | {
|
---|
1505 | if (fIsLocked>1 || gROOT->IsBatch())
|
---|
1506 | return;
|
---|
1507 |
|
---|
1508 | flag ? SetBit(kNoContextMenu) : ResetBit(kNoContextMenu);
|
---|
1509 |
|
---|
1510 | for (int i=1; i<fTab->GetNumberOfTabs(); i++)
|
---|
1511 | {
|
---|
1512 | TCanvas *c = GetCanvas(i);
|
---|
1513 | if (c)
|
---|
1514 | flag ? c->SetBit(kNoContextMenu) : c->ResetBit(kNoContextMenu);
|
---|
1515 | }
|
---|
1516 | }
|
---|
1517 |
|
---|
1518 | // --------------------------------------------------------------------------
|
---|
1519 | //
|
---|
1520 | // Updates the canvas (if existing) in the currenly displayed Tab.
|
---|
1521 | // The update intervall is controlled by StartUpdate and StopUpdate
|
---|
1522 | //
|
---|
1523 | Bool_t MStatusDisplay::HandleTimer(TTimer *timer)
|
---|
1524 | {
|
---|
1525 | if (gROOT->IsBatch())
|
---|
1526 | return kTRUE;
|
---|
1527 |
|
---|
1528 | const Int_t c = fTab->GetCurrent();
|
---|
1529 |
|
---|
1530 | // Skip Legend Tab
|
---|
1531 | if (c==0)
|
---|
1532 | return kTRUE;
|
---|
1533 |
|
---|
1534 | // Update a canvas tab (if visible)
|
---|
1535 | if (timer==&fTimer && c!=fLogIdx)
|
---|
1536 | {
|
---|
1537 | UpdateTab(fTab->GetCurrentContainer());
|
---|
1538 | return kTRUE;
|
---|
1539 | }
|
---|
1540 |
|
---|
1541 | // update the logbook tab (if visible)
|
---|
1542 | if (timer==&fLogTimer && c==fLogIdx)
|
---|
1543 | {
|
---|
1544 | fLog->UpdateGui();
|
---|
1545 |
|
---|
1546 | /*
|
---|
1547 | if (!fLogBox->TestBit(kHasChanged))
|
---|
1548 | return kTRUE;
|
---|
1549 |
|
---|
1550 | fLogBox->ResetBit(kHasChanged);
|
---|
1551 | */
|
---|
1552 | return kTRUE;
|
---|
1553 | }
|
---|
1554 |
|
---|
1555 | return kTRUE;
|
---|
1556 | }
|
---|
1557 |
|
---|
1558 | // --------------------------------------------------------------------------
|
---|
1559 | //
|
---|
1560 | // Draws a clone of a canvas into a new canvas. Taken from TCanvas.
|
---|
1561 | //
|
---|
1562 | void MStatusDisplay::DrawClonePad(TCanvas &newc, const TCanvas &oldc) const
|
---|
1563 | {
|
---|
1564 | //copy pad attributes
|
---|
1565 | newc.Range(oldc.GetX1(),oldc.GetY1(),oldc.GetX2(),oldc.GetY2());
|
---|
1566 | newc.SetTickx(oldc.GetTickx());
|
---|
1567 | newc.SetTicky(oldc.GetTicky());
|
---|
1568 | newc.SetGridx(oldc.GetGridx());
|
---|
1569 | newc.SetGridy(oldc.GetGridy());
|
---|
1570 | newc.SetLogx(oldc.GetLogx());
|
---|
1571 | newc.SetLogy(oldc.GetLogy());
|
---|
1572 | newc.SetLogz(oldc.GetLogz());
|
---|
1573 | newc.SetBorderSize(oldc.GetBorderSize());
|
---|
1574 | newc.SetBorderMode(oldc.GetBorderMode());
|
---|
1575 | ((TAttLine&)oldc).Copy((TAttLine&)newc);
|
---|
1576 | ((TAttFill&)oldc).Copy((TAttFill&)newc);
|
---|
1577 | ((TAttPad&)oldc).Copy((TAttPad&)newc);
|
---|
1578 |
|
---|
1579 | //copy primitives
|
---|
1580 | TObject *obj;
|
---|
1581 | TIter next(oldc.GetListOfPrimitives());
|
---|
1582 | while ((obj=next())) {
|
---|
1583 | gROOT->SetSelectedPad(&newc);
|
---|
1584 | newc.GetListOfPrimitives()->Add(obj->Clone(),obj->GetDrawOption());
|
---|
1585 | }
|
---|
1586 | newc.Modified();
|
---|
1587 | newc.Update();
|
---|
1588 | }
|
---|
1589 |
|
---|
1590 | Bool_t MStatusDisplay::Display(const TObjArray &list)
|
---|
1591 | {
|
---|
1592 | TIter Next(&list);
|
---|
1593 |
|
---|
1594 | TObject *o=Next();
|
---|
1595 | if (!o)
|
---|
1596 | {
|
---|
1597 | *fLog << err << "MStatusDisplay::Display: No entry in TObjArray." << endl;
|
---|
1598 | return kFALSE;
|
---|
1599 | }
|
---|
1600 |
|
---|
1601 | fTitle = o->GetTitle();
|
---|
1602 |
|
---|
1603 | TCanvas *c;
|
---|
1604 | while ((c=(TCanvas*)Next()))
|
---|
1605 | if (!GetCanvas(c->GetName()))
|
---|
1606 | DrawClonePad(AddTab(c->GetName()), *c);
|
---|
1607 |
|
---|
1608 | return kTRUE;
|
---|
1609 | }
|
---|
1610 |
|
---|
1611 | // --------------------------------------------------------------------------
|
---|
1612 | //
|
---|
1613 | // Reads the contents of a saved MStatusDisplay from a file.
|
---|
1614 | //
|
---|
1615 | Int_t MStatusDisplay::Read(const char *name)
|
---|
1616 | {
|
---|
1617 | if (!gFile)
|
---|
1618 | {
|
---|
1619 | *fLog << warn << "MStatusDisplay::Read: No file found. Please create a TFile first." << endl;
|
---|
1620 | return 0;
|
---|
1621 | }
|
---|
1622 |
|
---|
1623 | if (!gFile->IsOpen())
|
---|
1624 | {
|
---|
1625 | *fLog << warn << "MStatusDisplay::Read: File not open. Please open the TFile first." << endl;
|
---|
1626 | return 0;
|
---|
1627 | }
|
---|
1628 |
|
---|
1629 | MStatusArray list;
|
---|
1630 |
|
---|
1631 | const Int_t n = list.Read(name);
|
---|
1632 | if (n==0)
|
---|
1633 | {
|
---|
1634 | *fLog << warn << "MStatusDisplay::Read: No objects read." << endl;
|
---|
1635 | return 0;
|
---|
1636 | }
|
---|
1637 |
|
---|
1638 | if (!Display(list))
|
---|
1639 | {
|
---|
1640 | *fLog << err << "MStatusDisplay::Display: No entry in " << name << "." << endl;
|
---|
1641 | return 0;
|
---|
1642 | }
|
---|
1643 |
|
---|
1644 | *fLog << inf << "MStatusDisplay: Key " << name << " with " << n << " keys read from file." << endl;
|
---|
1645 |
|
---|
1646 | return n;
|
---|
1647 | }
|
---|
1648 |
|
---|
1649 | // --------------------------------------------------------------------------
|
---|
1650 | //
|
---|
1651 | // Writes the contents of a MStatusDisplay to a file.
|
---|
1652 | //
|
---|
1653 | Int_t MStatusDisplay::Write(Int_t num, const char *name, Int_t option, Int_t bufsize)
|
---|
1654 | {
|
---|
1655 | if (!gFile)
|
---|
1656 | {
|
---|
1657 | *fLog << warn << "MStatusDisplay::Write: No file found. Please create a TFile first." << endl;
|
---|
1658 | return 0;
|
---|
1659 | }
|
---|
1660 |
|
---|
1661 | if (!gFile->IsOpen())
|
---|
1662 | {
|
---|
1663 | *fLog << warn << "MStatusDisplay::Write: File not open. Please open the TFile first." << endl;
|
---|
1664 | return 0;
|
---|
1665 | }
|
---|
1666 |
|
---|
1667 | if (!gFile->IsWritable())
|
---|
1668 | {
|
---|
1669 | *fLog << warn << "MStatusDisplay::Write: File not writable." << endl;
|
---|
1670 | return 0;
|
---|
1671 | }
|
---|
1672 |
|
---|
1673 | if (num==0)
|
---|
1674 | {
|
---|
1675 | *fLog << warn << "MStatusDisplay::Write: Tab doesn't contain an embedded Canvas... skipped." << endl;
|
---|
1676 | return 0;
|
---|
1677 | }
|
---|
1678 |
|
---|
1679 | if (!gROOT->IsBatch() && num>=fTab->GetNumberOfTabs())
|
---|
1680 | {
|
---|
1681 | *fLog << warn << "MStatusDisplay::Write: Tab doesn't exist... skipped." << endl;
|
---|
1682 | return 0;
|
---|
1683 | }
|
---|
1684 | if (gROOT->IsBatch() && num>fBatch->GetSize())
|
---|
1685 | {
|
---|
1686 | *fLog << warn << "MStatusDisplay::Write: Tab doesn't exist... skipped." << endl;
|
---|
1687 | return 0;
|
---|
1688 | }
|
---|
1689 |
|
---|
1690 | MStatusArray list;
|
---|
1691 |
|
---|
1692 | TNamed named;
|
---|
1693 | named.SetTitle(fTitle);
|
---|
1694 | list.Add(&named);
|
---|
1695 |
|
---|
1696 | const Int_t max = gROOT->IsBatch() ? fBatch->GetSize()+1 : fTab->GetNumberOfTabs();
|
---|
1697 | const Int_t from = num<0 ? 1 : num;
|
---|
1698 | const Int_t to = num<0 ? max : num+1;
|
---|
1699 |
|
---|
1700 | TCanvas *c;
|
---|
1701 | for (int i=from; i<to; i++)
|
---|
1702 | if ((c = GetCanvas(i)))
|
---|
1703 | list.Add(c);
|
---|
1704 |
|
---|
1705 | const Int_t n = list.Write(name, kSingleKey);
|
---|
1706 |
|
---|
1707 | *fLog << inf << "MStatusDisplay: " << n << " keys written to file as key " << name << "." << endl;
|
---|
1708 |
|
---|
1709 | return n;
|
---|
1710 | }
|
---|
1711 |
|
---|
1712 | // --------------------------------------------------------------------------
|
---|
1713 | //
|
---|
1714 | // Use this to start the synchronous (GUI eventloop driven) tab update.
|
---|
1715 | // Can also be used to change the update intervall. If millisec<0
|
---|
1716 | // the intervall given in SetUpdateTime is used. If the intervall in
|
---|
1717 | // SetUpdateTime is <0 nothing is done. (Call SetUpdateTime(-1) to
|
---|
1718 | // disable the automatic update in a MEventloop.
|
---|
1719 | //
|
---|
1720 | void MStatusDisplay::StartUpdate(Int_t millisec)
|
---|
1721 | {
|
---|
1722 | if (fIsLocked>1)
|
---|
1723 | return;
|
---|
1724 |
|
---|
1725 | if (fTimer.GetTime()<TTime(0))
|
---|
1726 | return;
|
---|
1727 | fTimer.Start(millisec);
|
---|
1728 | }
|
---|
1729 |
|
---|
1730 | // --------------------------------------------------------------------------
|
---|
1731 | //
|
---|
1732 | // Stops the automatic GUI update
|
---|
1733 | //
|
---|
1734 | void MStatusDisplay::StopUpdate()
|
---|
1735 | {
|
---|
1736 | if (fIsLocked>1)
|
---|
1737 | return;
|
---|
1738 |
|
---|
1739 | fTimer.Stop();
|
---|
1740 | }
|
---|
1741 |
|
---|
1742 | // --------------------------------------------------------------------------
|
---|
1743 | //
|
---|
1744 | // Set the update interval for the GUI update, see StartUpdate.
|
---|
1745 | //
|
---|
1746 | void MStatusDisplay::SetUpdateTime(Long_t t)
|
---|
1747 | {
|
---|
1748 | fTimer.SetTime(t);
|
---|
1749 | }
|
---|
1750 |
|
---|
1751 | // --------------------------------------------------------------------------
|
---|
1752 | //
|
---|
1753 | // Set the background color in a canvas
|
---|
1754 | //
|
---|
1755 | void MStatusDisplay::CanvasSetFillColor(TPad &p, Int_t col) const
|
---|
1756 | {
|
---|
1757 | TObject *obj;
|
---|
1758 |
|
---|
1759 | // See also TPad::UseCurrentStyle
|
---|
1760 | TIter Next(p.GetListOfPrimitives());
|
---|
1761 | while ((obj=Next()))
|
---|
1762 | {
|
---|
1763 | if (obj->InheritsFrom(TPad::Class()))
|
---|
1764 | CanvasSetFillColor(*(TPad*)obj, col);
|
---|
1765 | if (obj->InheritsFrom(TFrame::Class()))
|
---|
1766 | ((TFrame*)obj)->SetFillColor(col);
|
---|
1767 | }
|
---|
1768 |
|
---|
1769 | p.SetFillColor(col);
|
---|
1770 | }
|
---|
1771 |
|
---|
1772 | void MStatusDisplay::AddExtension(TString &name, const TString &ext, Int_t num) const
|
---|
1773 | {
|
---|
1774 | if (name.IsNull())
|
---|
1775 | {
|
---|
1776 | name = "status";
|
---|
1777 | if (num>0)
|
---|
1778 | {
|
---|
1779 | name += "-";
|
---|
1780 | name += num;
|
---|
1781 | }
|
---|
1782 | }
|
---|
1783 |
|
---|
1784 | if (name.EndsWith("."+ext))
|
---|
1785 | return;
|
---|
1786 |
|
---|
1787 | name += ".";
|
---|
1788 | name += ext;
|
---|
1789 | }
|
---|
1790 |
|
---|
1791 | Bool_t MStatusDisplay::CheckTabForCanvas(int num) const
|
---|
1792 | {
|
---|
1793 | if (gROOT->IsBatch())
|
---|
1794 | return num>0 && num<=fBatch->GetSize() || num<0;
|
---|
1795 |
|
---|
1796 | if (num>=fTab->GetNumberOfTabs())
|
---|
1797 | {
|
---|
1798 | *fLog << warn << "Tab #" << num << " doesn't exist..." << endl;
|
---|
1799 | return kFALSE;
|
---|
1800 | }
|
---|
1801 | if (num==0)
|
---|
1802 | {
|
---|
1803 | *fLog << warn << "Tab #" << num << " doesn't contain an embedded canvas..." << endl;
|
---|
1804 | return kFALSE;
|
---|
1805 | }
|
---|
1806 | if (fTab->GetNumberOfTabs()<2 || !gPad)
|
---|
1807 | {
|
---|
1808 | *fLog << warn << "Sorry, you must have at least one existing canvas (gPad!=NULL)" << endl;
|
---|
1809 | return kFALSE;
|
---|
1810 | }
|
---|
1811 | return kTRUE;
|
---|
1812 | }
|
---|
1813 |
|
---|
1814 | // --------------------------------------------------------------------------
|
---|
1815 | //
|
---|
1816 | // Insert the following two lines into the postscript header:
|
---|
1817 | //
|
---|
1818 | // %%DocumentPaperSizes: a4
|
---|
1819 | // %%Orientation: Landscape
|
---|
1820 | //
|
---|
1821 | void MStatusDisplay::UpdatePSHeader(const TString &name) const
|
---|
1822 | {
|
---|
1823 | const TString newstr("%%DocumentPaperSizes: a4\n%%Orientation: Landscape\n");
|
---|
1824 |
|
---|
1825 | ifstream fin(name);
|
---|
1826 | ofstream fout(name+".$$$");
|
---|
1827 |
|
---|
1828 | char c;
|
---|
1829 |
|
---|
1830 | TString str;
|
---|
1831 | fin >> str >> c; // Read "%!PS-Adobe-2.0\n"
|
---|
1832 | fout << str << endl << newstr;
|
---|
1833 |
|
---|
1834 | // Doing it in blocks seems not to gain much for small (MB) files
|
---|
1835 | while (fin)
|
---|
1836 | {
|
---|
1837 | fin.read(&c, 1);
|
---|
1838 | fout.write(&c, 1);
|
---|
1839 | }
|
---|
1840 |
|
---|
1841 | gSystem->Unlink(name);
|
---|
1842 | gSystem->Rename(name+".$$$", name);
|
---|
1843 | /*
|
---|
1844 | //
|
---|
1845 | // Old style algorithm. Shifts blocks inside a single file --- SLOW!
|
---|
1846 | //
|
---|
1847 | const Int_t l = newstr.Length();
|
---|
1848 |
|
---|
1849 | Long_t t[4]; // { id, size, flags, modtime }
|
---|
1850 | gSystem->GetPathInfo(name, t, t+1, t+2, t+3);
|
---|
1851 |
|
---|
1852 | char *c[2] = { new char[l], new char[l] };
|
---|
1853 |
|
---|
1854 | fstream f(name, ios::in|ios::out);
|
---|
1855 |
|
---|
1856 | TString str;
|
---|
1857 | f >> str >> c[0][0]; // Read "%!PS-Adobe-2.0\n" (Mini Header)
|
---|
1858 | f.read(c[0], l);
|
---|
1859 | f.seekp(-l, ios::cur);
|
---|
1860 | f.write(newstr, l);
|
---|
1861 |
|
---|
1862 | int i=0;
|
---|
1863 | while (1)
|
---|
1864 | {
|
---|
1865 | f.read(c[(i+1)%2], l);
|
---|
1866 | f.seekp(-l, ios::cur);
|
---|
1867 |
|
---|
1868 | if (f)
|
---|
1869 | {
|
---|
1870 | f.write(c[i%2],l);
|
---|
1871 | i++;
|
---|
1872 | i%=2;
|
---|
1873 | continue;
|
---|
1874 | }
|
---|
1875 |
|
---|
1876 | const Int_t ssz = str.Length()+1; // Length of Mini-Header
|
---|
1877 | const Int_t block = t[1]-ssz; // Length of block to be shifted
|
---|
1878 | const Int_t size = block%l; // Reminder
|
---|
1879 | const Int_t pos = (block/l)*l + ssz + 1; // Position to start writing
|
---|
1880 |
|
---|
1881 | f.clear();
|
---|
1882 | f.seekp(pos);
|
---|
1883 | f.write(c[i%2], l);
|
---|
1884 | f.write(c[(i+1)%2], size);
|
---|
1885 | break;
|
---|
1886 | }
|
---|
1887 |
|
---|
1888 | delete c[1];
|
---|
1889 | delete c[0];
|
---|
1890 | */
|
---|
1891 | }
|
---|
1892 |
|
---|
1893 | // --------------------------------------------------------------------------
|
---|
1894 | //
|
---|
1895 | // In case of num<0 all tabs are written into the PS file. If num>0
|
---|
1896 | // the canvas in the corresponding tab is written to the file.
|
---|
1897 | // Name is the name of the file (with or without extension).
|
---|
1898 | //
|
---|
1899 | // Returns the number of pages written.
|
---|
1900 | //
|
---|
1901 | // To write all tabs you can also use SaveAsPS(name)
|
---|
1902 | //
|
---|
1903 | // If the third argument is given a bottom line is drawn with the text
|
---|
1904 | // under it. If no argument is given a bottom line is drawn if
|
---|
1905 | // fTitle (SetTitle) is not empty.
|
---|
1906 | //
|
---|
1907 | Int_t MStatusDisplay::SaveAsPS(Int_t num, TString name, const TString addon)
|
---|
1908 | {
|
---|
1909 | SetStatusLine1("Writing Postscript file...");
|
---|
1910 | SetStatusLine2("");
|
---|
1911 |
|
---|
1912 | if (!CheckTabForCanvas(num))
|
---|
1913 | {
|
---|
1914 | SetStatusLine2("Failed!");
|
---|
1915 | return 0;
|
---|
1916 | }
|
---|
1917 |
|
---|
1918 | AddExtension(name, "ps", num);
|
---|
1919 |
|
---|
1920 | if (num<0)
|
---|
1921 | *fLog << inf << "Open ps-File: " << name << endl;
|
---|
1922 |
|
---|
1923 | TPad *padsav = (TPad*)gPad;
|
---|
1924 | TVirtualPS *psave = gVirtualPS;
|
---|
1925 |
|
---|
1926 | TDatime d;
|
---|
1927 |
|
---|
1928 | TPostScript ps(name, 112);
|
---|
1929 | ps.SetBit(TPad::kPrintingPS);
|
---|
1930 | ps.PrintFast(13, "/nan {1} def ");
|
---|
1931 |
|
---|
1932 | gVirtualPS = &ps;
|
---|
1933 |
|
---|
1934 | //
|
---|
1935 | // Create a list to delete the canvas clones
|
---|
1936 | //
|
---|
1937 | TList l;
|
---|
1938 | l.SetOwner();
|
---|
1939 |
|
---|
1940 | //
|
---|
1941 | // Create some GUI elements for a page legend
|
---|
1942 | //
|
---|
1943 | TLine line;
|
---|
1944 |
|
---|
1945 | int page = 1;
|
---|
1946 |
|
---|
1947 | //
|
---|
1948 | // Maintain tab numbers
|
---|
1949 | //
|
---|
1950 | const Int_t max = gROOT->IsBatch() ? fBatch->GetSize()+1 : fTab->GetNumberOfTabs();
|
---|
1951 | const Int_t from = num<0 ? 1 : num;
|
---|
1952 | const Int_t to = num<0 ? max : num+1;
|
---|
1953 |
|
---|
1954 | for (int i=from; i<to; i++)
|
---|
1955 | {
|
---|
1956 | TCanvas *c;
|
---|
1957 | if (!(c = GetCanvas(i)))
|
---|
1958 | {
|
---|
1959 | if (num<0)
|
---|
1960 | *fLog << inf << " - ";
|
---|
1961 | *fLog << "Tab #" << i << " doesn't contain an embedded Canvas... skipped." << endl;
|
---|
1962 | continue;
|
---|
1963 | }
|
---|
1964 |
|
---|
1965 | SetStatusLine2(Form("Tab #%d", i));
|
---|
1966 |
|
---|
1967 | //
|
---|
1968 | // Init page and page size, make sure, that the canvas in the file
|
---|
1969 | // has the same Aspect Ratio than on the screen.
|
---|
1970 | //
|
---|
1971 | ps.NewPage();
|
---|
1972 |
|
---|
1973 | //
|
---|
1974 | // 28 is used here to scale the canvas into a height of 28,
|
---|
1975 | // such that the page title can be set above the canvas...
|
---|
1976 | //
|
---|
1977 | Float_t psw = 28.0; // A4 - width (29.7)
|
---|
1978 | Float_t psh = 21.0; // A4 - height (21.0)
|
---|
1979 |
|
---|
1980 | const Float_t cw = c->GetWw();
|
---|
1981 | const Float_t ch = c->GetWh();
|
---|
1982 |
|
---|
1983 | if (psw/psh>cw/ch)
|
---|
1984 | psw = cw/ch*psh;
|
---|
1985 | else
|
---|
1986 | psh = ch/cw*psw;
|
---|
1987 |
|
---|
1988 | ps.Range(psw, psh); // A4
|
---|
1989 |
|
---|
1990 | //
|
---|
1991 | // Clone canvas and change background color and schedule for
|
---|
1992 | // deletion
|
---|
1993 | //
|
---|
1994 | TCanvas *n = (TCanvas*)c->Clone();
|
---|
1995 | CanvasSetFillColor(*n, kWhite);
|
---|
1996 | l.Add(n);
|
---|
1997 |
|
---|
1998 | //
|
---|
1999 | // Paint canvas into root file
|
---|
2000 | //
|
---|
2001 | if (num<0)
|
---|
2002 | *fLog << inf << " - ";
|
---|
2003 | *fLog << inf << "Writing Tab #" << i << ": " << c->GetName() << " (" << c << ") ";
|
---|
2004 | if (num>0)
|
---|
2005 | *fLog << "to " << name;
|
---|
2006 | *fLog << "... " << flush;
|
---|
2007 |
|
---|
2008 | n->SetBatch(kTRUE);
|
---|
2009 | n->Paint();
|
---|
2010 |
|
---|
2011 | //
|
---|
2012 | // Use the canvas as coordinate system for the overlaying text
|
---|
2013 | //
|
---|
2014 | gPad = n;
|
---|
2015 | //n->cd();
|
---|
2016 |
|
---|
2017 | //
|
---|
2018 | // Print overlaying text (NDC = %)
|
---|
2019 | //
|
---|
2020 | ps.SetTextColor(kBlack);
|
---|
2021 | ps.SetTextSize(0.015);
|
---|
2022 | ps.SetTextFont(22);
|
---|
2023 | ps.SetTextAlign(11); // left top
|
---|
2024 | ps.TextNDC(0, 1.015, TString(" ")+n->GetName());
|
---|
2025 | ps.SetTextAlign(21); // cent top
|
---|
2026 | ps.TextNDC(0.5, 1.015, TString("MARS - Magic Analysis and Reconstruction Software - ")+d.AsString());
|
---|
2027 | ps.SetTextAlign(31); // right top
|
---|
2028 | ps.TextNDC(1, 1.015, Form("Page No.%i (%i) ", page++, i));
|
---|
2029 | line.PaintLineNDC(0, 1.01, 1, 1.01);
|
---|
2030 |
|
---|
2031 | TString txt(addon.IsNull() ? fTitle : addon);
|
---|
2032 | if (!txt.IsNull())
|
---|
2033 | {
|
---|
2034 | line.PaintLineNDC(0, -0.00, 1, -0.00);
|
---|
2035 | ps.SetTextAlign(11); // left top
|
---|
2036 | ps.TextNDC(0, -0.015, TString(" ")+txt);
|
---|
2037 | ps.SetTextAlign(31); // right top
|
---|
2038 | ps.TextNDC(1, -0.015, "(c) 2000-2004, Thomas Bretz ");
|
---|
2039 | }
|
---|
2040 |
|
---|
2041 | //
|
---|
2042 | // Finish drawing page
|
---|
2043 | //
|
---|
2044 | n->SetBatch(kFALSE);
|
---|
2045 | *fLog << "done." << endl;
|
---|
2046 | }
|
---|
2047 |
|
---|
2048 | gPad = NULL; // Important!
|
---|
2049 | l.Delete();
|
---|
2050 |
|
---|
2051 | ps.Close();
|
---|
2052 |
|
---|
2053 | SetStatusLine2("Updating header of PS file...");
|
---|
2054 |
|
---|
2055 | if (num<0)
|
---|
2056 | *fLog << " - Updating header of PS file... " << flush;
|
---|
2057 | UpdatePSHeader(name);
|
---|
2058 | if (num<0)
|
---|
2059 | *fLog << inf << "done." << endl;
|
---|
2060 |
|
---|
2061 | gVirtualPS = psave;
|
---|
2062 | if (padsav)
|
---|
2063 | padsav->cd();
|
---|
2064 |
|
---|
2065 | if (num<0)
|
---|
2066 | *fLog << inf << "done." << endl;
|
---|
2067 |
|
---|
2068 | SetStatusLine2(Form("Done (%dpages)", page-1));
|
---|
2069 |
|
---|
2070 | return page-1;
|
---|
2071 | }
|
---|
2072 |
|
---|
2073 | Bool_t MStatusDisplay::SaveAsGIF(Int_t num, TString name)
|
---|
2074 | {
|
---|
2075 | if (gROOT->IsBatch())
|
---|
2076 | {
|
---|
2077 | *fLog << warn << "Sorry, writing gif-files is not available in batch mode." << endl;
|
---|
2078 | return 0;
|
---|
2079 | }
|
---|
2080 | SetStatusLine1("Writing GIF file...");
|
---|
2081 | SetStatusLine2("");
|
---|
2082 |
|
---|
2083 | if (!CheckTabForCanvas(num))
|
---|
2084 | {
|
---|
2085 | SetStatusLine2("Failed!");
|
---|
2086 | return 0;
|
---|
2087 | }
|
---|
2088 |
|
---|
2089 | AddExtension(name, "gif", num);
|
---|
2090 |
|
---|
2091 | if (num<0)
|
---|
2092 | *fLog << inf << "Writing gif-Files..." << endl;
|
---|
2093 |
|
---|
2094 | TPad *padsav = (TPad*)gPad;
|
---|
2095 |
|
---|
2096 | int page = 1;
|
---|
2097 |
|
---|
2098 | //
|
---|
2099 | // Maintain tab numbers
|
---|
2100 | //
|
---|
2101 | const Int_t from = num<0 ? 1 : num;
|
---|
2102 | const Int_t to = num<0 ? fTab->GetNumberOfTabs() : num+1;
|
---|
2103 |
|
---|
2104 | for (int i=from; i<to; i++)
|
---|
2105 | {
|
---|
2106 | TCanvas *c;
|
---|
2107 | if (!(c = GetCanvas(i)))
|
---|
2108 | {
|
---|
2109 | if (num<0)
|
---|
2110 | *fLog << inf << " - ";
|
---|
2111 | *fLog << "Tab #" << i << " doesn't contain an embedded Canvas... skipped." << endl;
|
---|
2112 | continue;
|
---|
2113 | }
|
---|
2114 |
|
---|
2115 | SetStatusLine2(Form("Tab #%d", i));
|
---|
2116 |
|
---|
2117 | //
|
---|
2118 | // Clone canvas and change background color and schedule for
|
---|
2119 | // deletion
|
---|
2120 | //
|
---|
2121 | //TCanvas *n = (TCanvas*)c->Clone();
|
---|
2122 | //CanvasSetFillColor(*n, kWhite);
|
---|
2123 |
|
---|
2124 | //
|
---|
2125 | // Paint canvas into root file
|
---|
2126 | //
|
---|
2127 | TString writename = name;
|
---|
2128 | if (num<0)
|
---|
2129 | {
|
---|
2130 | TString numname = "-";
|
---|
2131 | numname += i;
|
---|
2132 | writename.Insert(name.Last('.'), numname);
|
---|
2133 | }
|
---|
2134 | if (num<0)
|
---|
2135 | *fLog << inf << " - ";
|
---|
2136 | *fLog << inf << "Writing Tab #" << i << " to " << writename << ": " << c->GetName() << " (" << c << ") ";
|
---|
2137 | if (num>0)
|
---|
2138 | *fLog << "to " << name;
|
---|
2139 | *fLog << "..." << flush;
|
---|
2140 |
|
---|
2141 | c->Draw();
|
---|
2142 | c->SaveAs(writename);
|
---|
2143 | /*
|
---|
2144 | n->Draw();
|
---|
2145 | n->SaveAs(writename);
|
---|
2146 | delete n;
|
---|
2147 | */
|
---|
2148 |
|
---|
2149 | if (num<0)
|
---|
2150 | *fLog << "done." << endl;
|
---|
2151 | }
|
---|
2152 |
|
---|
2153 | padsav->cd();
|
---|
2154 |
|
---|
2155 | *fLog << inf << "done." << endl;
|
---|
2156 |
|
---|
2157 | SetStatusLine2("Done.");
|
---|
2158 |
|
---|
2159 | return page-1;
|
---|
2160 | }
|
---|
2161 |
|
---|
2162 | Bool_t MStatusDisplay::SaveAsC(Int_t num, TString name)
|
---|
2163 | {
|
---|
2164 | SetStatusLine1("Writing C++ file...");
|
---|
2165 | SetStatusLine2("");
|
---|
2166 |
|
---|
2167 | if (!CheckTabForCanvas(num))
|
---|
2168 | {
|
---|
2169 | SetStatusLine2("Failed!");
|
---|
2170 | return 0;
|
---|
2171 | }
|
---|
2172 |
|
---|
2173 | AddExtension(name, "C", num);
|
---|
2174 |
|
---|
2175 | if (num<0)
|
---|
2176 | *fLog << inf << "Writing C-Files..." << endl;
|
---|
2177 |
|
---|
2178 | TPad *padsav = (TPad*)gPad;
|
---|
2179 |
|
---|
2180 | int page = 1;
|
---|
2181 |
|
---|
2182 | //
|
---|
2183 | // Maintain tab numbers
|
---|
2184 | //
|
---|
2185 | const Int_t from = num<0 ? 1 : num;
|
---|
2186 | const Int_t to = num<0 ? fTab->GetNumberOfTabs() : num+1;
|
---|
2187 |
|
---|
2188 | for (int i=from; i<to; i++)
|
---|
2189 | {
|
---|
2190 | TCanvas *c;
|
---|
2191 | if (!(c = GetCanvas(i)))
|
---|
2192 | {
|
---|
2193 | if (num<0)
|
---|
2194 | *fLog << inf << " - ";
|
---|
2195 | *fLog << "Tab #" << i << " doesn't contain an embedded Canvas... skipped." << endl;
|
---|
2196 | continue;
|
---|
2197 | }
|
---|
2198 |
|
---|
2199 | SetStatusLine2(Form("Tab #%d", i));
|
---|
2200 |
|
---|
2201 | //
|
---|
2202 | // Clone canvas and change background color and schedule for
|
---|
2203 | // deletion
|
---|
2204 | //
|
---|
2205 | TCanvas *n = (TCanvas*)c->Clone();
|
---|
2206 | CanvasSetFillColor(*n, kWhite);
|
---|
2207 |
|
---|
2208 | //
|
---|
2209 | // Paint canvas into root file
|
---|
2210 | //
|
---|
2211 | TString writename = name;
|
---|
2212 | if (num<0)
|
---|
2213 | {
|
---|
2214 | TString numname = "-";
|
---|
2215 | numname += i;
|
---|
2216 | writename.Insert(name.Last('.'), numname);
|
---|
2217 | }
|
---|
2218 | if (num<0)
|
---|
2219 | *fLog << inf << " - ";
|
---|
2220 | *fLog << inf << "Writing Tab #" << i << " to " << writename << ": " << c->GetName() << " (" << n << ") ";
|
---|
2221 | if (num>0)
|
---|
2222 | *fLog << "to " << name;
|
---|
2223 | *fLog << "..." << flush;
|
---|
2224 |
|
---|
2225 | n->SaveSource(writename, "");
|
---|
2226 | delete n;
|
---|
2227 |
|
---|
2228 | if (num<0)
|
---|
2229 | *fLog << "done." << endl;
|
---|
2230 | }
|
---|
2231 |
|
---|
2232 | padsav->cd();
|
---|
2233 |
|
---|
2234 | *fLog << inf << "done." << endl;
|
---|
2235 |
|
---|
2236 | SetStatusLine2("Done.");
|
---|
2237 |
|
---|
2238 | return page-1;
|
---|
2239 | }
|
---|
2240 |
|
---|
2241 | // --------------------------------------------------------------------------
|
---|
2242 | //
|
---|
2243 | // In case of num<0 all tabs are written into the PS file. If num>0
|
---|
2244 | // the canvas in the corresponding tab is written to the file.
|
---|
2245 | // Name is the name of the file (with or without extension).
|
---|
2246 | //
|
---|
2247 | // Returns the number of keys written.
|
---|
2248 | //
|
---|
2249 | // To write all tabs you can also use SaveAsPS(name)
|
---|
2250 | //
|
---|
2251 | Int_t MStatusDisplay::SaveAsRoot(Int_t num, TString name)
|
---|
2252 | {
|
---|
2253 | SetStatusLine1("Writing root file...");
|
---|
2254 | SetStatusLine2("");
|
---|
2255 |
|
---|
2256 | if (!CheckTabForCanvas(num))
|
---|
2257 | {
|
---|
2258 | SetStatusLine2("Failed!");
|
---|
2259 | return 0;
|
---|
2260 | }
|
---|
2261 |
|
---|
2262 | AddExtension(name, "root", num);
|
---|
2263 |
|
---|
2264 | TFile *fsave = gFile;
|
---|
2265 | TFile file(name, "RECREATE", "MARS - Status Window Contents", 9);
|
---|
2266 | const Int_t keys = Write(num);
|
---|
2267 | gFile = fsave;
|
---|
2268 |
|
---|
2269 | SetStatusLine2("Done.");
|
---|
2270 |
|
---|
2271 | return keys;
|
---|
2272 | }
|
---|
2273 |
|
---|
2274 | // --------------------------------------------------------------------------
|
---|
2275 | //
|
---|
2276 | // Opens a save as dialog
|
---|
2277 | //
|
---|
2278 | Int_t MStatusDisplay::SaveAs(Int_t num)
|
---|
2279 | {
|
---|
2280 | static const char *gSaveAsTypes[] =
|
---|
2281 | {
|
---|
2282 | "PostScript", "*.ps",
|
---|
2283 | "Gif files", "*.gif",
|
---|
2284 | "Macro files", "*.C",
|
---|
2285 | "ROOT files", "*.root",
|
---|
2286 | "All files", "*",
|
---|
2287 | NULL, NULL
|
---|
2288 | };
|
---|
2289 |
|
---|
2290 | static TString dir(".");
|
---|
2291 |
|
---|
2292 | TGFileInfo fi; // fFileName and fIniDir deleted in ~TGFileInfo
|
---|
2293 |
|
---|
2294 | fi.fFileTypes = (const char**)gSaveAsTypes;
|
---|
2295 | fi.fIniDir = StrDup(dir);
|
---|
2296 |
|
---|
2297 | new TGFileDialog(fClient->GetRoot(), this, kFDSave, &fi);
|
---|
2298 |
|
---|
2299 | if (!fi.fFilename)
|
---|
2300 | return 0;
|
---|
2301 |
|
---|
2302 | dir = fi.fIniDir;
|
---|
2303 |
|
---|
2304 | const TString name(fi.fFilename);
|
---|
2305 |
|
---|
2306 | if (name.EndsWith(".root")) return SaveAsRoot(num, name);
|
---|
2307 | if (name.EndsWith(".ps")) return SaveAsPS(num, name);
|
---|
2308 | if (name.EndsWith(".gif")) return SaveAsGIF(num, name);
|
---|
2309 | if (name.EndsWith(".C")) return SaveAsC(num, name);
|
---|
2310 |
|
---|
2311 | Warning("MStatusDisplay::SaveAs", "Unknown Extension: %s", fi.fFilename);
|
---|
2312 | return 0;
|
---|
2313 | }
|
---|
2314 |
|
---|
2315 | // --------------------------------------------------------------------------
|
---|
2316 | //
|
---|
2317 | // Open contents of a MStatusDisplay with key name from file fname.
|
---|
2318 | //
|
---|
2319 | Int_t MStatusDisplay::Open(TString fname, const char *name)
|
---|
2320 | {
|
---|
2321 | TFile file(fname, "READ");
|
---|
2322 | if (file.IsZombie())
|
---|
2323 | {
|
---|
2324 | gLog << warn << "WARNING - Cannot open file " << fname << endl;
|
---|
2325 | return 0;
|
---|
2326 | }
|
---|
2327 |
|
---|
2328 | return Read(name);
|
---|
2329 | }
|
---|
2330 |
|
---|
2331 | // --------------------------------------------------------------------------
|
---|
2332 | //
|
---|
2333 | // Opens an open dialog
|
---|
2334 | //
|
---|
2335 | Int_t MStatusDisplay::Open()
|
---|
2336 | {
|
---|
2337 | static const char *gOpenTypes[] =
|
---|
2338 | {
|
---|
2339 | "ROOT files", "*.root",
|
---|
2340 | "All files", "*",
|
---|
2341 | NULL, NULL
|
---|
2342 | };
|
---|
2343 |
|
---|
2344 | static TString dir(".");
|
---|
2345 |
|
---|
2346 | TGFileInfo fi; // fFileName and fIniDir deleted in ~TGFileInfo
|
---|
2347 |
|
---|
2348 | fi.fFileTypes = (const char**)gOpenTypes;
|
---|
2349 | fi.fIniDir = StrDup(dir);
|
---|
2350 |
|
---|
2351 | new TGFileDialog(fClient->GetRoot(), this, kFDSave, &fi);
|
---|
2352 |
|
---|
2353 | if (!fi.fFilename)
|
---|
2354 | return 0;
|
---|
2355 |
|
---|
2356 | dir = fi.fIniDir;
|
---|
2357 |
|
---|
2358 | return Open(fi.fFilename);
|
---|
2359 | }
|
---|
2360 |
|
---|
2361 | Bool_t MStatusDisplay::HandleConfigureNotify(Event_t *evt)
|
---|
2362 | {
|
---|
2363 | //
|
---|
2364 | // The initialization of the GUI is not yet enough finished...
|
---|
2365 | //
|
---|
2366 | if (!fTab)
|
---|
2367 | return kTRUE;
|
---|
2368 |
|
---|
2369 | UInt_t w = evt->fWidth;
|
---|
2370 | UInt_t h = evt->fHeight;
|
---|
2371 |
|
---|
2372 | /*
|
---|
2373 | cout << "Old: " << GetWidth() << " " << GetHeight() << " " << GetBorderWidth() << endl;
|
---|
2374 | cout << "New: " << w << " " << h << " ";
|
---|
2375 | cout << "New: " << GetDefaultWidth() << " " << GetDefaultHeight() << " " << endl;
|
---|
2376 | */
|
---|
2377 |
|
---|
2378 | Bool_t wchanged = w!=GetWidth();
|
---|
2379 | Bool_t hchanged = h!=GetHeight();
|
---|
2380 |
|
---|
2381 | if (!wchanged && !hchanged)
|
---|
2382 | {
|
---|
2383 | Layout();
|
---|
2384 | // FIXME: Make sure that this doesn't result in endless loops.
|
---|
2385 | return kTRUE;
|
---|
2386 | }
|
---|
2387 |
|
---|
2388 |
|
---|
2389 | if (GetWidth()==1 && GetHeight()==1)
|
---|
2390 | return kTRUE;
|
---|
2391 |
|
---|
2392 | // calculate the constant part of the window
|
---|
2393 | const UInt_t cw = GetWidth() -fTab->GetWidth();
|
---|
2394 | const UInt_t ch = GetHeight()-fTab->GetHeight();
|
---|
2395 |
|
---|
2396 | // calculate new size of frame (canvas @ 1:sqrt(2))
|
---|
2397 | if (hchanged)
|
---|
2398 | w = (UInt_t)((h-ch)*sqrt(2.)+.5)+cw;
|
---|
2399 | else
|
---|
2400 | h = (UInt_t)((w-cw)/sqrt(2.)+.5)+ch;
|
---|
2401 |
|
---|
2402 | // resize frame
|
---|
2403 | Resize(w, h);
|
---|
2404 |
|
---|
2405 | return kTRUE;
|
---|
2406 | }
|
---|
2407 |
|
---|
2408 | Bool_t MStatusDisplay::HandleEvent(Event_t *event)
|
---|
2409 | {
|
---|
2410 | Bool_t rc = TGMainFrame::HandleEvent(event);
|
---|
2411 |
|
---|
2412 | //
|
---|
2413 | // This fixes a bug in older root versions which makes
|
---|
2414 | // TCanvas crash if gPad==NULL. So we make sure, that
|
---|
2415 | // gPad!=NULL -- be carfull, this may have other side
|
---|
2416 | // effects.
|
---|
2417 | //
|
---|
2418 | #if ROOT_VERSION_CODE < ROOT_VERSION(3,10,01)
|
---|
2419 | if (!gPad && fTab)
|
---|
2420 | for (int i=0; i<fTab->GetNumberOfTabs(); i++)
|
---|
2421 | {
|
---|
2422 | TCanvas *c = GetCanvas(i);
|
---|
2423 | if (c)
|
---|
2424 | {
|
---|
2425 | c->cd();
|
---|
2426 | gLog << dbg << "MStatusDisplay::HandleEvent - Workaround: gPad=" << gPad << "." << endl;
|
---|
2427 | break;
|
---|
2428 | }
|
---|
2429 | }
|
---|
2430 | #endif
|
---|
2431 |
|
---|
2432 | return rc;
|
---|
2433 | }
|
---|