Changed to eliminate inline cvs logs -> cvs $Id$
[dyninst.git] / paradyn / src / UIthread / rootNode.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 // whereAxisRootNode.C
43 // Ariel Tamches
44
45 /* $Id: rootNode.C,v 1.10 1999/04/27 16:03:45 nash Exp $ */
46
47 #include <assert.h>
48
49 #include "util/h/headers.h"
50 #include "whereAxis.h" // for some of its static vrbles / member functions
51 #include "rootNode.h" // change to whereAxisRootNode.h some day
52
53 int whereAxisRootNode::borderPix = 3;
54 int whereAxisRootNode::horizPad = 3;
55 int whereAxisRootNode::vertPad = 2;
56
57 whereAxisRootNode::whereAxisRootNode(resourceHandle iUniqueId, const string &initStr) :
58                                   name(initStr) {
59    uniqueId = iUniqueId;
60    highlighted = false;
61
62    pixWidthAsRoot = borderPix + horizPad +
63       Tk_TextWidth(whereAxis::getRootItemFontStruct(),
64                    name.string_of(), name.length()) +
65                    horizPad + borderPix;
66
67    Tk_FontMetrics rootItemFontMetrics; // filled in
68    Tk_GetFontMetrics(whereAxis::getRootItemFontStruct(), &rootItemFontMetrics);
69    pixHeightAsRoot = borderPix + vertPad +
70                      rootItemFontMetrics.ascent +
71                      rootItemFontMetrics.descent +
72                      vertPad + borderPix;
73
74    pixWidthAsListboxItem = Tk_TextWidth(whereAxis::getListboxItemFontStruct(),
75                                         name.string_of(), name.length());
76 }
77
78 void whereAxisRootNode::drawAsRoot(Tk_Window theTkWindow,
79                                    int theDrawable, // may be an offscreen pixmap
80                                    int root_middlex, int root_topy) const {
81    // First, some quick & dirty clipping:
82    const int minWindowX = 0;
83    const int maxWindowX = Tk_Width(theTkWindow) - 1;
84    const int minWindowY = 0;
85    const int maxWindowY = Tk_Height(theTkWindow) - 1;
86
87    if (root_topy > maxWindowY)
88       return;
89    if (root_topy + pixHeightAsRoot - 1 < minWindowY)
90       return;
91
92    const int boxLeft = root_middlex - (pixWidthAsRoot / 2);
93
94    if (boxLeft > maxWindowX)
95       return;
96    if (boxLeft + pixWidthAsRoot - 1 < minWindowX)
97       return;
98
99    const int normalRelief = TK_RELIEF_GROOVE;
100    const int highlightedRelief = TK_RELIEF_SUNKEN;
101
102    Tk_Fill3DRectangle(theTkWindow, theDrawable,
103                       whereAxis::getRootItemTk3DBorder(),
104                       boxLeft, root_topy,
105                       pixWidthAsRoot, pixHeightAsRoot,
106                       borderPix,
107                       highlighted ? highlightedRelief : normalRelief);
108
109    // Third, draw the text
110    Tk_FontMetrics rootItemFontMetrics; // filled in
111    Tk_GetFontMetrics(whereAxis::getRootItemFontStruct(), &rootItemFontMetrics);
112    
113    const int textLeft = boxLeft + borderPix + horizPad;
114    const int textBaseLine = root_topy + borderPix + vertPad +
115                             rootItemFontMetrics.ascent - 1;
116
117         Tk_DrawChars(Tk_Display(theTkWindow),
118                 theDrawable,
119                 whereAxis::getRootItemTextGC(),
120                 whereAxis::getRootItemFontStruct(),
121                 name.string_of(), name.length(),
122                 textLeft, textBaseLine );
123 }
124
125 GC whereAxisRootNode::getGCforListboxRay(const whereAxisRootNode &, // parent
126                                          const whereAxisRootNode & // 1st child
127                                          ) {
128    // a static member function
129    return whereAxis::getGCforListboxRay();
130 }
131
132 GC whereAxisRootNode::getGCforNonListboxRay(const whereAxisRootNode &, // parent
133                                             const whereAxisRootNode &  // 1st child
134                                             ) {
135    // a static member function
136    return whereAxis::getGCforNonListboxRay();
137 }
138
139 void whereAxisRootNode::prepareForDrawingListboxItems(Tk_Window theTkWindow,
140                                                       XRectangle &listboxBounds) {
141 #if !defined(i386_unknown_nt4_0)
142    XSetClipRectangles(Tk_Display(theTkWindow), whereAxis::getListboxItemGC(),
143                       0, 0, &listboxBounds, 1, YXBanded);
144 #else // !defined(i386_unknown_nt4_0)
145         // TODO - is this needed?
146 #endif // !defined(i386_unknown_nt4_0)
147 }
148
149 void whereAxisRootNode::doneDrawingListboxItems(Tk_Window theTkWindow) {
150    XSetClipMask(Tk_Display(theTkWindow), whereAxis::getListboxItemGC(), None);
151 }
152
153 void whereAxisRootNode::drawAsListboxItem(Tk_Window theTkWindow,
154                                           int theDrawable,
155                                           int boxLeft, int boxTop,
156                                           int boxWidth, int boxHeight,
157                                           int textLeft, int textBaseline) const {
158    Tk_Fill3DRectangle(theTkWindow, theDrawable,
159                       whereAxis::getListboxItem3DBorder(),
160                          // for a shg-like class, this routine would take in a parameter
161                          // and return a varying border.  But the where axis doesn't need
162                          // such a feature.
163                       boxLeft, boxTop,
164                       boxWidth, boxHeight,
165                       1, // 2 also looks pretty good; 3 doesn't
166                       highlighted ? TK_RELIEF_SUNKEN : TK_RELIEF_RAISED);
167
168         Tk_DrawChars(Tk_Display(theTkWindow),
169                 theDrawable,
170                 whereAxis::getListboxItemGC(),
171                 whereAxis::getRootItemFontStruct(),     // is this correct?
172                 name.string_of(), name.length(),
173                 textLeft, textBaseline );
174 }
175
176
177 int whereAxisRootNode::pointWithinAsRoot(int xpix, int ypix,
178                                          int root_centerx, int root_topy) const {
179    // return values:
180    // 1 -- yes
181    // 2 -- no, point is above the root
182    // 3 -- no, point is below root
183    // 4 -- no, point is to the left of root
184    // 5 -- no, point is to the right of root
185    
186    assert(xpix >= 0 && ypix >= 0);
187    
188    if (ypix < root_topy) return 2;
189
190    const int root_bottomy = root_topy + pixHeightAsRoot - 1;
191    if (ypix > root_bottomy) return 3;
192
193    const int root_leftx = root_centerx - pixWidthAsRoot / 2;
194    if (xpix < root_leftx) return 4;
195
196    const int root_rightx = root_leftx + pixWidthAsRoot - 1;
197    if (xpix > root_rightx) return 5;
198
199    assert(xpix >= root_leftx && xpix <= root_rightx);
200    assert(ypix >= root_topy && ypix <= root_bottomy);
201    return 1; // bingo
202 }