Fixed poor handling of RCS logs by last CVS checkin
[dyninst.git] / paradyn / src / UIthread / shgPhases.C
1 /*
2  * Copyright (c) 1996-1998 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * This license is for research uses.  For such uses, there is no
12  * charge. We define "research use" to mean you may freely use it
13  * inside your organization for whatever purposes you see fit. But you
14  * may not re-distribute Paradyn or parts of Paradyn, in any form
15  * source or binary (including derivatives), electronic or otherwise,
16  * to any other organization or entity without our permission.
17  * 
18  * (for other uses, please contact us at paradyn@cs.wisc.edu)
19  * 
20  * All warranties, including without limitation, any warranty of
21  * merchantability or fitness for a particular purpose, are hereby
22  * excluded.
23  * 
24  * By your use of Paradyn, you understand and agree that we (or any
25  * other person or entity with proprietary rights in Paradyn) are
26  * under no obligation to provide either maintenance services,
27  * update services, notices of latent defects, or correction of
28  * defects for Paradyn.
29  * 
30  * Even if advised of the possibility of such damages, under no
31  * circumstances shall we (or any other person or entity with
32  * proprietary rights in the software licensed hereunder) be liable
33  * to you or any third party for direct, indirect, or consequential
34  * damages of any character regardless of type of action, including,
35  * without limitation, loss of profits, loss of use, loss of good
36  * will, or computer failure or malfunction.  You agree to indemnify
37  * us (and any other person or entity with proprietary rights in the
38  * software licensed hereunder) for any and all liability it may
39  * incur to third parties resulting from your use of Paradyn.
40  */
41
42 // shgPhases.C
43 // Ariel Tamches
44 // Analagous to "abstractions.h" for the where axis; this class
45 // basically manages several "shg"'s, as defined in shgPhases.h
46
47 /* $Log: shgPhases.C,v $
48 /* Revision 1.25  1999/03/12 22:59:31  pcroth
49 /* Fixed poor handling of RCS logs by last CVS checkin
50 /*
51  * Revision 1.24  1999/03/03 18:16:10  pcroth
52  * Updated to support Windows NT as a front-end platform
53  * Changes made to X code, to use Tcl analogues when appropriate
54  * Also changed in response to modifications in thread library and igen output.
55  *
56  * Revision 1.23  1996/11/26 16:06:57  naim
57  * Fixing asserts - naim
58  *
59  * Revision 1.22  1996/08/16 21:07:15  tamches
60  * updated copyright for release 1.1
61  *
62  * Revision 1.21  1996/05/30 21:54:55  tamches
63  * removed uses of string::quote
64  *
65  * Revision 1.20  1996/05/01 20:56:35  tamches
66  * added inactivateEntireSearch
67  * altered use of configNode to correspond w/ new shg syntax
68  *
69  * Revision 1.19  1996/05/01 14:08:01  naim
70  * Multiples changes in UI to make call to requestNodeInfoCallback async.
71  * (UI<->PC) - naim
72  *
73  * Revision 1.18  1996/04/24  21:58:07  tamches
74  * We now do a yview -pickplace end on the "status window" area when changing
75  * phases.
76  *
77  * Revision 1.17  1996/04/16 18:37:36  karavan
78  * fine-tunification of UI-PC batching code, plus addification of some
79  * Ari-like verbification commentification.
80  *
81  * Revision 1.16  1996/04/13 04:39:42  karavan
82  * better implementation of batching for edge requests
83  *
84  * Revision 1.15  1996/04/09 19:25:15  karavan
85  * added batch mode to cut down on shg redraw time.
86  *
87  */
88
89 #include <limits.h>
90 #include "util/h/headers.h"
91 #include "tkTools.h" // myTclEval()
92 #include "shgPhases.h"
93
94 #ifdef PARADYN
95 #include "paradyn/src/TCthread/tunableConst.h"
96 #include "performanceConsultant.thread.CLNT.h"
97 extern performanceConsultantUser *perfConsult;
98 #endif
99
100 shgPhases::shgPhases(const string &iMenuName,
101                      const string &iHorizSBName, const string &iVertSBName,
102                      const string &iCurrItemLabelName,
103                      const string &iMsgTextWindowName,
104                      const string &iSearchButtonName,
105                      const string &iPauseButtonName,
106                      const string &iCurrPhaseLabelName,
107                      Tcl_Interp *iInterp, Tk_Window iTkWindow) :
108                         menuName(iMenuName), horizSBName(iHorizSBName),
109                         vertSBName(iVertSBName),
110                         currItemLabelName(iCurrItemLabelName),
111                         msgTextWindowName(iMsgTextWindowName),
112                         searchButtonName(iSearchButtonName),
113                         pauseButtonName(iPauseButtonName),
114                         currPhaseLabelName(iCurrPhaseLabelName)
115 {
116    currShgPhaseIndex = UINT_MAX;
117
118    interp = iInterp;
119    theTkWindow = iTkWindow;
120
121    currInstalledAltMoveHandler=false;
122    ignoreNextShgAltMove=false;
123
124 #ifdef PARADYN
125    // grab initial values from the appropriate tunable constants
126    hideTrueNodes = tunableConstantRegistry::findBoolTunableConstant("hideShgTrueNodes").getValue();
127    hideFalseNodes = tunableConstantRegistry::findBoolTunableConstant("hideShgFalseNodes").getValue();
128    hideUnknownNodes = tunableConstantRegistry::findBoolTunableConstant("hideShgUnknownNodes").getValue();
129    hideNeverSeenNodes = tunableConstantRegistry::findBoolTunableConstant("hideShgNeverSeenNodes").getValue();
130    hideActiveNodes = tunableConstantRegistry::findBoolTunableConstant("hideShgActiveNodes").getValue();
131    hideInactiveNodes = tunableConstantRegistry::findBoolTunableConstant("hideShgInactiveNodes").getValue();
132    hideShadowNodes = tunableConstantRegistry::findBoolTunableConstant("hideShgShadowNodes").getValue();
133 #else
134    hideTrueNodes = hideFalseNodes = hideUnknownNodes = hideNeverSeenNodes = false;
135    hideActiveNodes = hideInactiveNodes = hideShadowNodes = false;
136 #endif
137 }
138
139 shgPhases::~shgPhases() {
140    for (unsigned i=0; i < theShgPhases.size(); i++)
141       delete theShgPhases[i].theShg;
142
143    currShgPhaseIndex = UINT_MAX;
144 }
145
146 shgPhases::shgStruct &shgPhases::getByIDLL(int phaseID) {
147    for (unsigned i=0; i < theShgPhases.size(); i++) {
148       if (theShgPhases[i].getPhaseId() == phaseID)
149          return theShgPhases[i];
150    }
151
152    cerr << "shgPhases: phase id " << phaseID << " doesn't exist." << endl;
153    assert(false);
154    return theShgPhases[0];      // placate compiler
155 }
156
157 shg &shgPhases::getByID(int phaseID) {
158    return *(getByIDLL(phaseID).theShg);
159 }
160
161 int shgPhases::name2id(const string &phaseName) const {
162    // returns -1 if not found
163    for (unsigned i=0; i < theShgPhases.size(); i++)
164       if (phaseName == theShgPhases[i].phaseName)
165          return theShgPhases[i].getPhaseId();
166
167    return -1;
168 }
169
170 const string &shgPhases::id2name(int id) const {
171    for (unsigned lcv=0; lcv < theShgPhases.size(); lcv++)
172       if (theShgPhases[lcv].getPhaseId() == id)
173          return theShgPhases[lcv].phaseName;
174    assert(false);
175    return NULL; // placate compiler
176 }
177
178 bool shgPhases::changeLL(unsigned newIndex) {
179    // returns true iff any changes, in which case you should redraw
180    // NOTE: Like currShgPhaseIndex, the param newIndex is an index into
181    //       the low-level array theShgPhases; it is not a dagid/phaseid!
182    if (newIndex == currShgPhaseIndex)
183       return false;
184
185    if (existsCurrent()) {
186       // Save current scrollbar values
187       shgStruct &theShgStruct=theShgPhases[currShgPhaseIndex];
188
189       string commandStr = horizSBName + " get";
190       myTclEval(interp, commandStr);
191       bool aflag;
192       aflag=(2==sscanf(interp->result, "%f %f", &theShgStruct.horizSBfirst,
193                        &theShgStruct.horizSBlast));
194       assert(aflag);
195
196       commandStr = vertSBName + " get";
197       myTclEval(interp, commandStr);
198       aflag=(2==sscanf(interp->result, "%f %f", &theShgStruct.vertSBfirst,
199                        &theShgStruct.vertSBlast));
200       assert(aflag);
201    }
202
203    // Set new scrollbar values:
204    shgStruct &theNewShgStruct=theShgPhases[currShgPhaseIndex = newIndex];
205
206    string commandStr = horizSBName + " set " +
207                        string(theNewShgStruct.horizSBfirst) + " " +
208                        string(theNewShgStruct.horizSBlast);
209    myTclEval(interp, commandStr);
210
211    commandStr = vertSBName + " set " + string(theNewShgStruct.vertSBfirst) + " " +
212                 string(theNewShgStruct.vertSBlast);
213    myTclEval(interp, commandStr);
214
215    // Set the Search(Resume) and Pause buttons:
216    if (!theNewShgStruct.everSearched) {
217       commandStr = searchButtonName + " config -text \"Search\" -state normal";
218       myTclEval(interp, commandStr);
219
220       commandStr = pauseButtonName + " config -state disabled";
221       myTclEval(interp, commandStr);
222    }
223    else if (theNewShgStruct.currSearching) {
224       commandStr = searchButtonName + " config -text \"Resume\" -state disabled";
225       myTclEval(interp, commandStr);
226
227       commandStr = pauseButtonName + " config -state normal";
228       myTclEval(interp, commandStr);
229    }
230    else {
231       // we are currently paused
232       commandStr = searchButtonName + " config -text \"Resume\" -state normal";
233       myTclEval(interp, commandStr);
234
235       commandStr = pauseButtonName + " config -state disabled";
236       myTclEval(interp, commandStr);
237    }
238
239    // This should update the menu:
240    Tcl_SetVar(interp, "currShgPhase",
241               (char*)string(theNewShgStruct.getPhaseId()).string_of(), TCL_GLOBAL_ONLY);
242
243    // Update the label containing the current phase name:
244    commandStr = currPhaseLabelName + " config -text \"" +
245                 theNewShgStruct.phaseName + "\"";
246    myTclEval(interp, commandStr);
247
248    // Update the message text:
249    commandStr = msgTextWindowName + " delete 1.0 end";
250       // this says 'delete from char 0 of line 1' (tk decrees that line 1 is the first line)
251    myTclEval(interp, commandStr);
252
253    commandStr = msgTextWindowName + " insert end \"" + theNewShgStruct.msgText + "\"";
254    myTclEval(interp, commandStr);
255
256    commandStr = msgTextWindowName + " yview -pickplace end";
257    myTclEval(interp, commandStr);
258
259    // We must resize, since newly displayed shg had been set aside (is this right?)
260    theNewShgStruct.theShg->resize(true);
261    
262    return true;
263 }
264
265 bool shgPhases::changeByPhaseId(int id) {
266    // returns true iff changes were made, in which case you should redraw
267    for (unsigned i=0; i < theShgPhases.size(); i++) {
268       shgStruct &theShgStruct = theShgPhases[i];
269       if (theShgStruct.getPhaseId() == id)
270          return changeLL(i);
271    }
272
273    cout << "shgPhases::changeByPhaseId(): phase id " << id << " doesn't exist" << endl;
274    return false; // could not find any phase with that name
275 }
276
277 bool shgPhases::change(const string &newPhaseName) {
278    // returns true iff successful, in which case you should redraw
279    for (unsigned i=0; i < theShgPhases.size(); i++) {
280       shgStruct &theShgStruct = theShgPhases[i];
281       if (theShgStruct.phaseName == newPhaseName)
282          return changeLL(i);
283    }
284
285    return false; // could not find any phase with that name
286 }
287
288 shg &shgPhases::getCurrent() {
289    assert(existsCurrent());
290    assert(theShgPhases[currShgPhaseIndex].theShg);
291    return *(theShgPhases[currShgPhaseIndex].theShg);
292 }
293
294 bool shgPhases::existsById(int id) const {
295    for (unsigned lcv=0; lcv < theShgPhases.size(); lcv++) {
296       const shgStruct &theStruct = theShgPhases[lcv];
297
298       if (theStruct.getPhaseId() == id)
299          return true;
300    }
301
302    return false;
303 }
304
305 const shg &shgPhases::getCurrent() const {
306    assert(existsCurrent());
307    assert(theShgPhases[currShgPhaseIndex].theShg);
308    return *(theShgPhases[currShgPhaseIndex].theShg);
309 }
310
311 void shgPhases::resizeEverything() {
312    if (!existsCurrent())
313       return;
314
315    for (unsigned i=0; i < theShgPhases.size(); i++) {
316       theShgPhases[i].theShg->recursiveRethinkLayout();
317       theShgPhases[i].theShg->resize(i==currShgPhaseIndex);
318    }
319 }   
320
321 /* ************************************************************ */
322
323 void shgPhases::draw(bool doubleBuffer, bool isXsynchOn) const {
324    if (existsCurrent())
325       getCurrent().draw(doubleBuffer, isXsynchOn);
326 }
327
328 bool shgPhases::resize() {
329    // returns true if a redraw is called for
330    const bool ec = existsCurrent();
331    if (ec)
332       getCurrent().resize(true); // true --> we are curr shg
333    return ec;
334 }
335
336 void shgPhases::processSingleClick(int x, int y) {
337    if (existsCurrent())
338       getCurrent().processSingleClick(x, y);
339 }
340
341 void shgPhases::processMiddleClick(int x, int y) {
342    if (existsCurrent())
343       getCurrent().processMiddleClick(x, y);
344 }
345
346 bool shgPhases::processDoubleClick(int x, int y) {
347    // returns true if a redraw is called for
348    const bool ec = existsCurrent();
349    if (ec)
350       getCurrent().processDoubleClick(x, y);
351    return ec;
352 }
353
354 bool shgPhases::newVertScrollPosition(int argc, char **argv) {
355    if (!existsCurrent())
356       return false;
357
358    float newFirst;
359    bool anyChanges = processScrollCallback(interp, argc, argv,
360                                            getVertSBName(),
361                                            getCurrent().getVertSBOffset(), // <= 0
362                                            getCurrent().getTotalVertPixUsed(),
363                                            getCurrent().getVisibleVertPix(),
364                                            newFirst);
365    if (anyChanges)
366       anyChanges = getCurrent().adjustVertSBOffset(newFirst);
367
368    return anyChanges;
369 }
370
371 bool shgPhases::newHorizScrollPosition(int argc, char **argv) {
372    if (!existsCurrent())
373       return false;
374
375    float newFirst;
376    bool anyChanges = processScrollCallback(interp, argc, argv,
377                                            getHorizSBName(),
378                                            getCurrent().getHorizSBOffset(), // <= 0
379                                            getCurrent().getTotalHorizPixUsed(),
380                                            getCurrent().getVisibleHorizPix(),
381                                            newFirst);
382    if (anyChanges)
383       anyChanges = getCurrent().adjustHorizSBOffset(newFirst);
384
385    return anyChanges;
386 }
387
388 bool shgPhases::altPress(int x, int y) {
389    // returns true if a redraw is called for (in which case a scroll
390    // is done as well as an XWarpPointer)
391    if (!existsCurrent())
392       return false;
393
394    if (currInstalledAltMoveHandler) {
395       if (ignoreNextShgAltMove) {
396          ignoreNextShgAltMove = false;
397          return false;
398       }
399
400       int deltax = x - shgAltAnchorX;
401       int deltay = y - shgAltAnchorY;
402
403       // add some extra speedup juice as an incentive to use alt-mousemove scrolling
404       deltax *= 4;
405       deltay *= 4;
406
407       getCurrent().adjustHorizSBOffsetFromDeltaPix(deltax);
408       getCurrent().adjustVertSBOffsetFromDeltaPix(deltay);
409
410 #if !defined(i386_unknown_nt4_0)
411       XWarpPointer(Tk_Display(theTkWindow),
412                    Tk_WindowId(theTkWindow),
413                    Tk_WindowId(theTkWindow),
414                    0, 0, 0, 0,
415                    shgAltAnchorX, shgAltAnchorY);
416 #else // !defined(i386_unknown_nt4_0)
417         // TODO - implement warping support
418 #endif // !defined(i386_unknown_nt4_0)
419
420       ignoreNextShgAltMove = true;
421          
422       return true;
423    }
424    else {
425       shgAltAnchorX = x;
426       shgAltAnchorY = y;
427
428       currInstalledAltMoveHandler = true;
429       return false;
430    }
431 }
432
433 void shgPhases::altRelease() {
434    if (currInstalledAltMoveHandler)
435       currInstalledAltMoveHandler = false;
436 }
437
438 /* ************************************************************ */
439
440 bool shgPhases::defineNewSearch(int phaseId, const string &phaseName) {
441    assert(!existsById(phaseId));
442
443    shgStruct theStruct(phaseId, phaseName,
444                        interp, theTkWindow,
445                        horizSBName, vertSBName,
446                        currItemLabelName,
447                        hideTrueNodes, hideFalseNodes, hideUnknownNodes,
448                        hideNeverSeenNodes, hideActiveNodes, hideInactiveNodes,
449                        hideShadowNodes);
450
451    bool result = false; // so far, nothing has changed
452
453    // possibly pull off the last phase...
454    if (theShgPhases.size() > 1) // never touch the "Global Search"
455       if (!theShgPhases[theShgPhases.size()-1].everSearched) {
456          shgStruct &victimStruct = theShgPhases[theShgPhases.size()-1];
457          
458 //         cout << "shgPhases: throwing out never-searched phase id " << victimStruct.getPhaseId() << " " << victimStruct.phaseName << endl;
459          string commandStr = menuName + " delete " + string(theShgPhases.size());
460          myTclEval(interp, commandStr);
461
462          victimStruct.fryDag();
463
464          theShgPhases.resize(theShgPhases.size()-1);
465             // destructor for shgStruct will fry the shg
466
467          if (currShgPhaseIndex == theShgPhases.size()) {
468             // uh oh.  We fried the current search.  We need to make
469             // someone else the current search.  But who?  We'll just
470             // make it the previous search index.  One will always exist,
471             // since we'll never fry the global phase search.
472             assert(theShgPhases.size() > 0);
473             changeLL(theShgPhases.size()-1);
474             result = true;
475          }
476       }
477
478    theShgPhases += theStruct;
479
480    string commandStr = menuName + " add radiobutton -label " +
481                        "\"" + phaseName + "\"" +
482                        " -command " + "\"" + "shgChangePhase " +
483                        string(phaseId) + "\"" +
484                        " -variable currShgPhase -value " +
485                        string(phaseId);
486    myTclEval(interp, commandStr);
487
488    const bool changeTo = (theShgPhases.size()==1);
489    if (changeTo)
490       if (change(phaseName))
491          result = true; // indicates a redraw is called for
492
493    return result;
494 }
495
496 bool shgPhases::activateCurrSearch() {
497    // returns true iff successfully activated
498    if (!existsCurrent())
499       return false;
500
501    int phaseId = getCurrentId();
502    shgStruct &theStruct = getByIDLL(phaseId); // slow...
503
504    assert(!theStruct.currSearching);
505
506    // make the igen call to do the actual search:
507 #ifdef PARADYN
508    perfConsult->activateSearch(phaseId);
509 #endif
510
511    theStruct.everSearched = true;
512    theStruct.currSearching = true;
513
514    return true;
515 }
516
517 bool shgPhases::pauseCurrSearch() {
518    // returns true iff successfully paused
519    if (!existsCurrent())
520       return false;
521
522    int phaseId = getCurrentId();
523    shgStruct &theStruct = getByIDLL(phaseId); // slow...
524
525    assert(theStruct.everSearched);
526    assert(theStruct.currSearching);
527
528    // make the igen call to do the actual pausing:
529 #ifdef PARADYN
530    perfConsult->pauseSearch(phaseId);
531 #endif
532
533    theStruct.currSearching = false;
534
535    return true;
536 }
537
538 bool shgPhases::resumeCurrSearch() {
539    // returns true iff successfully resumed
540    if (!existsCurrent())
541       return false;
542
543    int phaseId = getCurrentId();
544    shgStruct &theStruct = getByIDLL(phaseId); // slow...
545
546    assert(theStruct.everSearched);
547    assert(theStruct.currSearching);
548
549    // make the igen call to do the actual resuming:
550 #ifdef PARADYN
551    perfConsult->activateSearch(phaseId);
552 #endif
553
554    theStruct.currSearching = true;
555
556    return true;
557 }
558
559 bool shgPhases::changeHiddenNodes(bool newHideTrue, bool newHideFalse,
560                                   bool newHideUnknown, bool newHideNeverSeen,
561                                   bool newHideActive, bool newHideInactive,
562                                   bool newHideShadow) {
563    if (hideTrueNodes == newHideTrue && hideFalseNodes == newHideFalse &&
564        hideUnknownNodes == newHideUnknown && hideNeverSeenNodes == newHideNeverSeen &&
565        hideActiveNodes == newHideActive && hideInactiveNodes == newHideInactive &&
566        hideShadowNodes == newHideShadow)
567       return false; // nothing changed
568
569    bool anyChanges = false; // so far
570    for (unsigned shgindex=0; shgindex < theShgPhases.size(); shgindex++) {
571       shgStruct &theShgStruct = theShgPhases[shgindex];
572       shg *theShg = theShgStruct.theShg;
573
574       if (theShg->changeHiddenNodes(newHideTrue, newHideFalse, newHideUnknown,
575                                     newHideNeverSeen, newHideActive, newHideInactive,
576                                     newHideShadow,
577                                     shgindex == currShgPhaseIndex))
578          anyChanges = true;
579    }
580
581    return anyChanges;
582 }
583 bool shgPhases::changeHiddenNodes(shg::changeType ct, bool hide) {
584    switch (ct) {
585       case shg::ct_true:
586          if (hideTrueNodes == hide) return false;
587          hideTrueNodes = hide;
588          break;
589        case shg::ct_false:
590          if (hideFalseNodes == hide) return false;
591          hideFalseNodes = hide;
592          break;
593        case shg::ct_unknown:
594          if (hideUnknownNodes == hide) return false;
595          hideUnknownNodes = hide;
596          break;
597        case shg::ct_never:
598          if (hideNeverSeenNodes == hide) return false;
599          hideNeverSeenNodes = hide;
600          break;
601        case shg::ct_active:
602          if (hideActiveNodes == hide) return false;
603          hideActiveNodes = hide;
604          break;
605        case shg::ct_inactive:
606          if (hideInactiveNodes == hide) return false;
607          hideInactiveNodes = hide;
608          break;
609        case shg::ct_shadow:
610          if (hideShadowNodes == hide) return false;
611          hideShadowNodes = hide;
612          break;
613        default:
614          assert(false);
615    }
616
617    bool anyChanges = false; // so far
618    for (unsigned shgindex = 0; shgindex < theShgPhases.size(); shgindex++) {
619       shgStruct &theShgStruct = theShgPhases[shgindex];
620       shg *theShg = theShgStruct.theShg;
621       if (theShg->changeHiddenNodes(ct, hide, currShgPhaseIndex == shgindex))
622          anyChanges = true;
623    }
624
625    return anyChanges;
626 }
627
628 bool shgPhases::addNode(int phaseId, unsigned nodeId,
629                         bool active,
630                         shgRootNode::evaluationState es,
631                         const string &label, const string &fullInfo,
632                         bool rootNodeFlag) {
633    // returns true iff a redraw should take place
634    shg &theShg = getByID(phaseId);
635    const bool isCurrShg = (getCurrentId() == phaseId);
636
637    theShg.addNode(nodeId, active, es, label, fullInfo, rootNodeFlag, isCurrShg);
638
639    return isCurrShg;
640 }
641
642 bool shgPhases::addEdge(int phaseId, unsigned fromId, unsigned toId,
643                         shgRootNode::refinement theRefinement,
644                         const char *label, // used only for shadow nodes, else NULL
645                         bool rethinkFlag) {
646    // The evaluationState param decides whether to explicitly expand
647    // the "to" node.  Rethinks the entire layout of the shg
648    // Returns true iff a redraw should take place
649    shg &theShg = getByID(phaseId);
650    const bool isCurrShg = (getCurrentId() == phaseId);
651    theShg.addEdge(fromId, toId, theRefinement, label, isCurrShg, rethinkFlag);
652
653    return isCurrShg;
654 }
655
656 bool shgPhases::configNode(int phaseId, unsigned nodeId,
657                            bool active, shgRootNode::evaluationState es) {
658    // returns true iff a redraw should take place
659    shg &theShg = getByID(phaseId);
660    const bool isCurrShg = (getCurrentId() == phaseId);
661
662    const shg::configNodeResult changes =
663       theShg.configNode(nodeId, active, es, isCurrShg, true);
664          // true --> rethink if needed
665
666    return isCurrShg && (changes != shg::noChanges);
667 }
668
669 bool shgPhases::inactivateEntireSearch(int phaseId) {
670    // returns true iff a redraw should take place
671    shg &theShg = getByID(phaseId);
672    const bool isCurrShg = (getCurrentId() == phaseId);
673    const bool anyChanges = theShg.inactivateAll(isCurrShg);
674
675    return isCurrShg && anyChanges;
676 }
677
678 void shgPhases::addToStatusDisplay(int phaseId, const string &iMsg) {
679    // currently, we do _not_ add a \n to the message for you.
680    if (!existsCurrent()) {
681       cerr << "addToStatusDisplay: no current phase to display msg:" << endl;
682       cerr << iMsg << endl;
683       return;
684    }
685
686    if (!existsById(phaseId)) {
687       //cerr << "addToStatusDisplay: no phase id " << phaseId << " exists to display msg:" << endl;
688       //cerr << "\"" << iMsg << "\"" << endl;
689       return;
690    }
691
692    const bool isCurrShg = (getCurrentId() == phaseId);
693    shgStruct &theShgStruct = getByIDLL(phaseId);
694
695    theShgStruct.msgText += iMsg;
696
697    if (isCurrShg) {
698       string commandStr = msgTextWindowName + " insert end {" + iMsg + "}";
699       myTclEval(interp, commandStr);
700
701       commandStr = msgTextWindowName + " yview -pickplace end";
702       myTclEval(interp, commandStr);
703    }
704 }
705
706 #ifdef PARADYN
707 void shgPhases::nodeInformation(int phaseId, int nodeId,
708                                 const shg_node_info &theNodeInfo) {
709    // in response to a middle-mouse-click...
710    shg &theShg = getByID(phaseId);
711    theShg.nodeInformation(nodeId, theNodeInfo);
712 }
713 #endif