1 |
dashley |
25 |
/* $Header: /cvsroot/esrg/sfesrg/esrgpcpj/shared/tk_base/tkwinbutton.c,v 1.1.1.1 2001/06/13 05:11:56 dtashley Exp $ */
|
2 |
|
|
|
3 |
|
|
/*
|
4 |
|
|
* tkWinButton.c --
|
5 |
|
|
*
|
6 |
|
|
* This file implements the Windows specific portion of the button
|
7 |
|
|
* widgets.
|
8 |
|
|
*
|
9 |
|
|
* Copyright (c) 1996-1998 by Sun Microsystems, Inc.
|
10 |
|
|
*
|
11 |
|
|
* See the file "license.terms" for information on usage and redistribution
|
12 |
|
|
* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
|
13 |
|
|
*
|
14 |
|
|
* RCS: @(#) $Id: tkwinbutton.c,v 1.1.1.1 2001/06/13 05:11:56 dtashley Exp $
|
15 |
|
|
*/
|
16 |
|
|
|
17 |
|
|
#define OEMRESOURCE
|
18 |
|
|
#include "tkWinInt.h"
|
19 |
|
|
#include "tkButton.h"
|
20 |
|
|
|
21 |
|
|
#include "resource.h"
|
22 |
|
|
/* Necessary to load the TK_BUTTONS.
|
23 |
|
|
*/
|
24 |
|
|
|
25 |
|
|
/*
|
26 |
|
|
* These macros define the base style flags for the different button types.
|
27 |
|
|
*/
|
28 |
|
|
|
29 |
|
|
#define LABEL_STYLE (BS_OWNERDRAW | WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS)
|
30 |
|
|
#define PUSH_STYLE (BS_OWNERDRAW | BS_PUSHBUTTON | WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS)
|
31 |
|
|
#define CHECK_STYLE (BS_OWNERDRAW | BS_CHECKBOX | WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS)
|
32 |
|
|
#define RADIO_STYLE (BS_OWNERDRAW | BS_RADIOBUTTON | WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS)
|
33 |
|
|
|
34 |
|
|
static DWORD buttonStyles[] = {
|
35 |
|
|
LABEL_STYLE, PUSH_STYLE, CHECK_STYLE, RADIO_STYLE
|
36 |
|
|
};
|
37 |
|
|
|
38 |
|
|
/*
|
39 |
|
|
* Declaration of Windows specific button structure.
|
40 |
|
|
*/
|
41 |
|
|
|
42 |
|
|
typedef struct WinButton {
|
43 |
|
|
TkButton info; /* Generic button info. */
|
44 |
|
|
WNDPROC oldProc; /* Old window procedure. */
|
45 |
|
|
HWND hwnd; /* Current window handle. */
|
46 |
|
|
Pixmap pixmap; /* Bitmap for rendering the button. */
|
47 |
|
|
DWORD style; /* Window style flags. */
|
48 |
|
|
} WinButton;
|
49 |
|
|
|
50 |
|
|
|
51 |
|
|
/*
|
52 |
|
|
* The following macro reverses the order of RGB bytes to convert
|
53 |
|
|
* between RGBQUAD and COLORREF values.
|
54 |
|
|
*/
|
55 |
|
|
|
56 |
|
|
#define FlipColor(rgb) (RGB(GetBValue(rgb),GetGValue(rgb),GetRValue(rgb)))
|
57 |
|
|
|
58 |
|
|
/*
|
59 |
|
|
* The following enumeration defines the meaning of the palette entries
|
60 |
|
|
* in the "buttons" image used to draw checkbox and radiobutton indicators.
|
61 |
|
|
*/
|
62 |
|
|
|
63 |
|
|
enum {
|
64 |
|
|
PAL_CHECK = 0,
|
65 |
|
|
PAL_TOP_OUTER = 1,
|
66 |
|
|
PAL_BOTTOM_OUTER = 2,
|
67 |
|
|
PAL_BOTTOM_INNER = 3,
|
68 |
|
|
PAL_INTERIOR = 4,
|
69 |
|
|
PAL_TOP_INNER = 5,
|
70 |
|
|
PAL_BACKGROUND = 6
|
71 |
|
|
};
|
72 |
|
|
|
73 |
|
|
/*
|
74 |
|
|
* Cached information about the boxes bitmap, and the default border
|
75 |
|
|
* width for a button in string form for use in Tk_OptionSpec for
|
76 |
|
|
* the various button widget classes.
|
77 |
|
|
*/
|
78 |
|
|
|
79 |
|
|
typedef struct ThreadSpecificData {
|
80 |
|
|
BITMAPINFOHEADER *boxesPtr; /* Information about the bitmap. */
|
81 |
|
|
DWORD *boxesPalette; /* Pointer to color palette. */
|
82 |
|
|
LPSTR boxesBits; /* Pointer to bitmap data. */
|
83 |
|
|
DWORD boxHeight; /* Height of each sub-image. */
|
84 |
|
|
DWORD boxWidth ; /* Width of each sub-image. */
|
85 |
|
|
char defWidth[TCL_INTEGER_SPACE];
|
86 |
|
|
} ThreadSpecificData;
|
87 |
|
|
static Tcl_ThreadDataKey dataKey;
|
88 |
|
|
|
89 |
|
|
/*
|
90 |
|
|
* Declarations for functions defined in this file.
|
91 |
|
|
*/
|
92 |
|
|
|
93 |
|
|
static int ButtonBindProc _ANSI_ARGS_((ClientData clientData,
|
94 |
|
|
Tcl_Interp *interp, XEvent *eventPtr,
|
95 |
|
|
Tk_Window tkwin, KeySym keySym));
|
96 |
|
|
static LRESULT CALLBACK ButtonProc _ANSI_ARGS_((HWND hwnd, UINT message,
|
97 |
|
|
WPARAM wParam, LPARAM lParam));
|
98 |
|
|
static DWORD ComputeStyle _ANSI_ARGS_((WinButton* butPtr));
|
99 |
|
|
static Window CreateProc _ANSI_ARGS_((Tk_Window tkwin,
|
100 |
|
|
Window parent, ClientData instanceData));
|
101 |
|
|
static void InitBoxes _ANSI_ARGS_((void));
|
102 |
|
|
|
103 |
|
|
/*
|
104 |
|
|
* The class procedure table for the button widgets.
|
105 |
|
|
*/
|
106 |
|
|
|
107 |
|
|
TkClassProcs tkpButtonProcs = {
|
108 |
|
|
CreateProc, /* createProc. */
|
109 |
|
|
TkButtonWorldChanged, /* geometryProc. */
|
110 |
|
|
NULL /* modalProc. */
|
111 |
|
|
};
|
112 |
|
|
|
113 |
|
|
|
114 |
|
|
/*
|
115 |
|
|
*----------------------------------------------------------------------
|
116 |
|
|
*
|
117 |
|
|
* InitBoxes --
|
118 |
|
|
*
|
119 |
|
|
* This function load the Tk 3d button bitmap. "buttons" is a 16
|
120 |
|
|
* color bitmap that is laid out such that the top row contains
|
121 |
|
|
* the 4 checkbox images, and the bottom row contains the radio
|
122 |
|
|
* button images. Note that the bitmap is stored in bottom-up
|
123 |
|
|
* format. Also, the first seven palette entries are used to
|
124 |
|
|
* identify the different parts of the bitmaps so we can do the
|
125 |
|
|
* appropriate color mappings based on the current button colors.
|
126 |
|
|
*
|
127 |
|
|
* Results:
|
128 |
|
|
* None.
|
129 |
|
|
*
|
130 |
|
|
* Side effects:
|
131 |
|
|
* Loads the "buttons" resource.
|
132 |
|
|
*
|
133 |
|
|
*----------------------------------------------------------------------
|
134 |
|
|
*/
|
135 |
|
|
|
136 |
|
|
static void
|
137 |
|
|
InitBoxes()
|
138 |
|
|
{
|
139 |
|
|
/*
|
140 |
|
|
* For DLLs like Tk, the HINSTANCE is the same as the HMODULE.
|
141 |
|
|
*/
|
142 |
|
|
|
143 |
|
|
HMODULE module = (HINSTANCE) Tk_GetHINSTANCE();
|
144 |
|
|
HRSRC hrsrc;
|
145 |
|
|
HGLOBAL hblk;
|
146 |
|
|
LPBITMAPINFOHEADER newBitmap;
|
147 |
|
|
DWORD size;
|
148 |
|
|
ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
|
149 |
|
|
Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
|
150 |
|
|
|
151 |
|
|
hrsrc = FindResource(module, (const char *)TK_BUTTONS, RT_BITMAP);
|
152 |
|
|
/* Found experimentally that using the constant defined in
|
153 |
|
|
** RESOURCE.H in the call above works as per Microsoft
|
154 |
|
|
** documentation. Old line was:
|
155 |
|
|
** hrsrc = FindResource(module, "buttons", RT_BITMAP);
|
156 |
|
|
** Didn't work reliably with GUI build after code ported.
|
157 |
|
|
** Believe the call above accesses the resource correctly.
|
158 |
|
|
*/
|
159 |
|
|
|
160 |
|
|
if (hrsrc) {
|
161 |
|
|
hblk = LoadResource(module, hrsrc);
|
162 |
|
|
tsdPtr->boxesPtr = (LPBITMAPINFOHEADER)LockResource(hblk);
|
163 |
|
|
}
|
164 |
|
|
|
165 |
|
|
/*
|
166 |
|
|
* Copy the DIBitmap into writable memory.
|
167 |
|
|
*/
|
168 |
|
|
|
169 |
|
|
if (tsdPtr->boxesPtr != NULL && !(tsdPtr->boxesPtr->biWidth % 4)
|
170 |
|
|
&& !(tsdPtr->boxesPtr->biHeight % 2)) {
|
171 |
|
|
size = tsdPtr->boxesPtr->biSize + (1 << tsdPtr->boxesPtr->biBitCount)
|
172 |
|
|
* sizeof(RGBQUAD) + tsdPtr->boxesPtr->biSizeImage;
|
173 |
|
|
newBitmap = (LPBITMAPINFOHEADER) ckalloc(size);
|
174 |
|
|
memcpy(newBitmap, tsdPtr->boxesPtr, size);
|
175 |
|
|
tsdPtr->boxesPtr = newBitmap;
|
176 |
|
|
tsdPtr->boxWidth = tsdPtr->boxesPtr->biWidth / 4;
|
177 |
|
|
tsdPtr->boxHeight = tsdPtr->boxesPtr->biHeight / 2;
|
178 |
|
|
tsdPtr->boxesPalette = (DWORD*) (((LPSTR) tsdPtr->boxesPtr)
|
179 |
|
|
+ tsdPtr->boxesPtr->biSize);
|
180 |
|
|
tsdPtr->boxesBits = ((LPSTR) tsdPtr->boxesPalette)
|
181 |
|
|
+ ((1 << tsdPtr->boxesPtr->biBitCount) * sizeof(RGBQUAD));
|
182 |
|
|
} else {
|
183 |
|
|
tsdPtr->boxesPtr = NULL;
|
184 |
|
|
}
|
185 |
|
|
}
|
186 |
|
|
|
187 |
|
|
/*
|
188 |
|
|
*----------------------------------------------------------------------
|
189 |
|
|
*
|
190 |
|
|
* TkpButtonSetDefaults --
|
191 |
|
|
*
|
192 |
|
|
* This procedure is invoked before option tables are created for
|
193 |
|
|
* buttons. It modifies some of the default values to match the
|
194 |
|
|
* current values defined for this platform.
|
195 |
|
|
*
|
196 |
|
|
* Results:
|
197 |
|
|
* Some of the default values in *specPtr are modified.
|
198 |
|
|
*
|
199 |
|
|
* Side effects:
|
200 |
|
|
* Updates some of.
|
201 |
|
|
*
|
202 |
|
|
*----------------------------------------------------------------------
|
203 |
|
|
*/
|
204 |
|
|
|
205 |
|
|
void
|
206 |
|
|
TkpButtonSetDefaults(specPtr)
|
207 |
|
|
Tk_OptionSpec *specPtr; /* Points to an array of option specs,
|
208 |
|
|
* terminated by one with type
|
209 |
|
|
* TK_OPTION_END. */
|
210 |
|
|
{
|
211 |
|
|
int width;
|
212 |
|
|
ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
|
213 |
|
|
Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
|
214 |
|
|
|
215 |
|
|
if (tsdPtr->defWidth[0] == 0) {
|
216 |
|
|
width = GetSystemMetrics(SM_CXEDGE);
|
217 |
|
|
if (width == 0) {
|
218 |
|
|
width = 1;
|
219 |
|
|
}
|
220 |
|
|
sprintf(tsdPtr->defWidth, "%d", width);
|
221 |
|
|
}
|
222 |
|
|
for ( ; specPtr->type != TK_OPTION_END; specPtr++) {
|
223 |
|
|
if (specPtr->internalOffset == Tk_Offset(TkButton, borderWidth)) {
|
224 |
|
|
specPtr->defValue = tsdPtr->defWidth;
|
225 |
|
|
}
|
226 |
|
|
}
|
227 |
|
|
}
|
228 |
|
|
|
229 |
|
|
/*
|
230 |
|
|
*----------------------------------------------------------------------
|
231 |
|
|
*
|
232 |
|
|
* TkpCreateButton --
|
233 |
|
|
*
|
234 |
|
|
* Allocate a new TkButton structure.
|
235 |
|
|
*
|
236 |
|
|
* Results:
|
237 |
|
|
* Returns a newly allocated TkButton structure.
|
238 |
|
|
*
|
239 |
|
|
* Side effects:
|
240 |
|
|
* Registers an event handler for the widget.
|
241 |
|
|
*
|
242 |
|
|
*----------------------------------------------------------------------
|
243 |
|
|
*/
|
244 |
|
|
|
245 |
|
|
TkButton *
|
246 |
|
|
TkpCreateButton(tkwin)
|
247 |
|
|
Tk_Window tkwin;
|
248 |
|
|
{
|
249 |
|
|
WinButton *butPtr;
|
250 |
|
|
|
251 |
|
|
butPtr = (WinButton *)ckalloc(sizeof(WinButton));
|
252 |
|
|
butPtr->hwnd = NULL;
|
253 |
|
|
return (TkButton *) butPtr;
|
254 |
|
|
}
|
255 |
|
|
|
256 |
|
|
/*
|
257 |
|
|
*----------------------------------------------------------------------
|
258 |
|
|
*
|
259 |
|
|
* CreateProc --
|
260 |
|
|
*
|
261 |
|
|
* This function creates a new Button control, subclasses
|
262 |
|
|
* the instance, and generates a new Window object.
|
263 |
|
|
*
|
264 |
|
|
* Results:
|
265 |
|
|
* Returns the newly allocated Window object, or None on failure.
|
266 |
|
|
*
|
267 |
|
|
* Side effects:
|
268 |
|
|
* Causes a new Button control to come into existence.
|
269 |
|
|
*
|
270 |
|
|
*----------------------------------------------------------------------
|
271 |
|
|
*/
|
272 |
|
|
|
273 |
|
|
static Window
|
274 |
|
|
CreateProc(tkwin, parentWin, instanceData)
|
275 |
|
|
Tk_Window tkwin; /* Token for window. */
|
276 |
|
|
Window parentWin; /* Parent of new window. */
|
277 |
|
|
ClientData instanceData; /* Button instance data. */
|
278 |
|
|
{
|
279 |
|
|
Window window;
|
280 |
|
|
HWND parent;
|
281 |
|
|
char *class;
|
282 |
|
|
WinButton *butPtr = (WinButton *)instanceData;
|
283 |
|
|
|
284 |
|
|
parent = Tk_GetHWND(parentWin);
|
285 |
|
|
if (butPtr->info.type == TYPE_LABEL) {
|
286 |
|
|
class = "STATIC";
|
287 |
|
|
butPtr->style = SS_OWNERDRAW | WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS;
|
288 |
|
|
} else {
|
289 |
|
|
class = "BUTTON";
|
290 |
|
|
butPtr->style = BS_OWNERDRAW | WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS;
|
291 |
|
|
}
|
292 |
|
|
butPtr->hwnd = CreateWindow(class, NULL, butPtr->style,
|
293 |
|
|
Tk_X(tkwin), Tk_Y(tkwin), Tk_Width(tkwin), Tk_Height(tkwin),
|
294 |
|
|
parent, NULL, Tk_GetHINSTANCE(), NULL);
|
295 |
|
|
SetWindowPos(butPtr->hwnd, HWND_TOP, 0, 0, 0, 0,
|
296 |
|
|
SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
|
297 |
|
|
butPtr->oldProc = (WNDPROC)SetWindowLong(butPtr->hwnd, GWL_WNDPROC,
|
298 |
|
|
(DWORD) ButtonProc);
|
299 |
|
|
|
300 |
|
|
window = Tk_AttachHWND(tkwin, butPtr->hwnd);
|
301 |
|
|
return window;
|
302 |
|
|
}
|
303 |
|
|
|
304 |
|
|
/*
|
305 |
|
|
*----------------------------------------------------------------------
|
306 |
|
|
*
|
307 |
|
|
* TkpDestroyButton --
|
308 |
|
|
*
|
309 |
|
|
* Free data structures associated with the button control.
|
310 |
|
|
*
|
311 |
|
|
* Results:
|
312 |
|
|
* None.
|
313 |
|
|
*
|
314 |
|
|
* Side effects:
|
315 |
|
|
* Restores the default control state.
|
316 |
|
|
*
|
317 |
|
|
*----------------------------------------------------------------------
|
318 |
|
|
*/
|
319 |
|
|
|
320 |
|
|
void
|
321 |
|
|
TkpDestroyButton(butPtr)
|
322 |
|
|
TkButton *butPtr;
|
323 |
|
|
{
|
324 |
|
|
WinButton *winButPtr = (WinButton *)butPtr;
|
325 |
|
|
HWND hwnd = winButPtr->hwnd;
|
326 |
|
|
if (hwnd) {
|
327 |
|
|
SetWindowLong(hwnd, GWL_WNDPROC, (DWORD) winButPtr->oldProc);
|
328 |
|
|
}
|
329 |
|
|
}
|
330 |
|
|
|
331 |
|
|
/*
|
332 |
|
|
*----------------------------------------------------------------------
|
333 |
|
|
*
|
334 |
|
|
* TkpDisplayButton --
|
335 |
|
|
*
|
336 |
|
|
* This procedure is invoked to display a button widget. It is
|
337 |
|
|
* normally invoked as an idle handler.
|
338 |
|
|
*
|
339 |
|
|
* Results:
|
340 |
|
|
* None.
|
341 |
|
|
*
|
342 |
|
|
* Side effects:
|
343 |
|
|
* Information appears on the screen. The REDRAW_PENDING flag
|
344 |
|
|
* is cleared.
|
345 |
|
|
*
|
346 |
|
|
*----------------------------------------------------------------------
|
347 |
|
|
*/
|
348 |
|
|
|
349 |
|
|
void
|
350 |
|
|
TkpDisplayButton(clientData)
|
351 |
|
|
ClientData clientData; /* Information about widget. */
|
352 |
|
|
{
|
353 |
|
|
TkWinDCState state;
|
354 |
|
|
HDC dc;
|
355 |
|
|
register TkButton *butPtr = (TkButton *) clientData;
|
356 |
|
|
GC gc;
|
357 |
|
|
Tk_3DBorder border;
|
358 |
|
|
Pixmap pixmap;
|
359 |
|
|
int x = 0; /* Initialization only needed to stop
|
360 |
|
|
* compiler warning. */
|
361 |
|
|
int y, relief;
|
362 |
|
|
register Tk_Window tkwin = butPtr->tkwin;
|
363 |
|
|
int width, height;
|
364 |
|
|
int defaultWidth; /* Width of default ring. */
|
365 |
|
|
int offset; /* 0 means this is a label widget. 1 means
|
366 |
|
|
* it is a flavor of button, so we offset
|
367 |
|
|
* the text to make the button appear to
|
368 |
|
|
* move up and down as the relief changes. */
|
369 |
|
|
DWORD *boxesPalette;
|
370 |
|
|
|
371 |
|
|
ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
|
372 |
|
|
Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
|
373 |
|
|
|
374 |
|
|
boxesPalette= tsdPtr->boxesPalette;
|
375 |
|
|
butPtr->flags &= ~REDRAW_PENDING;
|
376 |
|
|
if ((butPtr->tkwin == NULL) || !Tk_IsMapped(tkwin)) {
|
377 |
|
|
return;
|
378 |
|
|
}
|
379 |
|
|
|
380 |
|
|
border = butPtr->normalBorder;
|
381 |
|
|
if ((butPtr->state == STATE_DISABLED) && (butPtr->disabledFg != NULL)) {
|
382 |
|
|
gc = butPtr->disabledGC;
|
383 |
|
|
} else if ((butPtr->state == STATE_ACTIVE)
|
384 |
|
|
&& !Tk_StrictMotif(butPtr->tkwin)) {
|
385 |
|
|
gc = butPtr->activeTextGC;
|
386 |
|
|
border = butPtr->activeBorder;
|
387 |
|
|
} else {
|
388 |
|
|
gc = butPtr->normalTextGC;
|
389 |
|
|
}
|
390 |
|
|
if ((butPtr->flags & SELECTED) && (butPtr->state != STATE_ACTIVE)
|
391 |
|
|
&& (butPtr->selectBorder != NULL) && !butPtr->indicatorOn) {
|
392 |
|
|
border = butPtr->selectBorder;
|
393 |
|
|
}
|
394 |
|
|
|
395 |
|
|
/*
|
396 |
|
|
* Override the relief specified for the button if this is a
|
397 |
|
|
* checkbutton or radiobutton and there's no indicator.
|
398 |
|
|
*/
|
399 |
|
|
|
400 |
|
|
relief = butPtr->relief;
|
401 |
|
|
if ((butPtr->type >= TYPE_CHECK_BUTTON) && !butPtr->indicatorOn) {
|
402 |
|
|
relief = (butPtr->flags & SELECTED) ? TK_RELIEF_SUNKEN
|
403 |
|
|
: TK_RELIEF_RAISED;
|
404 |
|
|
}
|
405 |
|
|
|
406 |
|
|
/*
|
407 |
|
|
* Compute width of default ring and offset for pushed buttons.
|
408 |
|
|
*/
|
409 |
|
|
|
410 |
|
|
if (butPtr->type == TYPE_BUTTON) {
|
411 |
|
|
defaultWidth = ((butPtr->defaultState == DEFAULT_ACTIVE)
|
412 |
|
|
? butPtr->highlightWidth : 0);
|
413 |
|
|
offset = 1;
|
414 |
|
|
} else {
|
415 |
|
|
defaultWidth = 0;
|
416 |
|
|
if ((butPtr->type >= TYPE_CHECK_BUTTON) && !butPtr->indicatorOn) {
|
417 |
|
|
offset = 1;
|
418 |
|
|
} else {
|
419 |
|
|
offset = 0;
|
420 |
|
|
}
|
421 |
|
|
}
|
422 |
|
|
|
423 |
|
|
/*
|
424 |
|
|
* In order to avoid screen flashes, this procedure redraws
|
425 |
|
|
* the button in a pixmap, then copies the pixmap to the
|
426 |
|
|
* screen in a single operation. This means that there's no
|
427 |
|
|
* point in time where the on-sreen image has been cleared.
|
428 |
|
|
*/
|
429 |
|
|
|
430 |
|
|
pixmap = Tk_GetPixmap(butPtr->display, Tk_WindowId(tkwin),
|
431 |
|
|
Tk_Width(tkwin), Tk_Height(tkwin), Tk_Depth(tkwin));
|
432 |
|
|
Tk_Fill3DRectangle(tkwin, pixmap, border, 0, 0, Tk_Width(tkwin),
|
433 |
|
|
Tk_Height(tkwin), 0, TK_RELIEF_FLAT);
|
434 |
|
|
|
435 |
|
|
/*
|
436 |
|
|
* Display image or bitmap or text for button.
|
437 |
|
|
*/
|
438 |
|
|
|
439 |
|
|
if (butPtr->image != None) {
|
440 |
|
|
Tk_SizeOfImage(butPtr->image, &width, &height);
|
441 |
|
|
|
442 |
|
|
imageOrBitmap:
|
443 |
|
|
TkComputeAnchor(butPtr->anchor, tkwin, 0, 0,
|
444 |
|
|
butPtr->indicatorSpace + width, height, &x, &y);
|
445 |
|
|
x += butPtr->indicatorSpace;
|
446 |
|
|
|
447 |
|
|
if (relief == TK_RELIEF_SUNKEN) {
|
448 |
|
|
x += offset;
|
449 |
|
|
y += offset;
|
450 |
|
|
}
|
451 |
|
|
if (butPtr->image != NULL) {
|
452 |
|
|
if ((butPtr->selectImage != NULL) && (butPtr->flags & SELECTED)) {
|
453 |
|
|
Tk_RedrawImage(butPtr->selectImage, 0, 0, width, height,
|
454 |
|
|
pixmap, x, y);
|
455 |
|
|
} else {
|
456 |
|
|
Tk_RedrawImage(butPtr->image, 0, 0, width, height, pixmap,
|
457 |
|
|
x, y);
|
458 |
|
|
}
|
459 |
|
|
} else {
|
460 |
|
|
XSetClipOrigin(butPtr->display, gc, x, y);
|
461 |
|
|
XCopyPlane(butPtr->display, butPtr->bitmap, pixmap, gc, 0, 0,
|
462 |
|
|
(unsigned int) width, (unsigned int) height, x, y, 1);
|
463 |
|
|
XSetClipOrigin(butPtr->display, gc, 0, 0);
|
464 |
|
|
}
|
465 |
|
|
y += height/2;
|
466 |
|
|
} else if (butPtr->bitmap != None) {
|
467 |
|
|
Tk_SizeOfBitmap(butPtr->display, butPtr->bitmap, &width, &height);
|
468 |
|
|
goto imageOrBitmap;
|
469 |
|
|
} else {
|
470 |
|
|
RECT rect;
|
471 |
|
|
TkComputeAnchor(butPtr->anchor, tkwin, butPtr->padX, butPtr->padY,
|
472 |
|
|
butPtr->indicatorSpace + butPtr->textWidth, butPtr->textHeight,
|
473 |
|
|
&x, &y);
|
474 |
|
|
|
475 |
|
|
x += butPtr->indicatorSpace;
|
476 |
|
|
|
477 |
|
|
if (relief == TK_RELIEF_SUNKEN) {
|
478 |
|
|
x += offset;
|
479 |
|
|
y += offset;
|
480 |
|
|
}
|
481 |
|
|
Tk_DrawTextLayout(butPtr->display, pixmap, gc, butPtr->textLayout,
|
482 |
|
|
x, y, 0, -1);
|
483 |
|
|
Tk_UnderlineTextLayout(butPtr->display, pixmap, gc,
|
484 |
|
|
butPtr->textLayout, x, y, butPtr->underline);
|
485 |
|
|
|
486 |
|
|
/*
|
487 |
|
|
* Draw the focus ring. If this is a push button then we need to put
|
488 |
|
|
* it around the inner edge of the border, otherwise we put it around
|
489 |
|
|
* the text.
|
490 |
|
|
*/
|
491 |
|
|
|
492 |
|
|
if (butPtr->flags & GOT_FOCUS && butPtr->type != TYPE_LABEL) {
|
493 |
|
|
dc = TkWinGetDrawableDC(butPtr->display, pixmap, &state);
|
494 |
|
|
if (butPtr->type == TYPE_BUTTON || !butPtr->indicatorOn) {
|
495 |
|
|
rect.top = butPtr->borderWidth + 1 + defaultWidth;
|
496 |
|
|
rect.left = rect.top;
|
497 |
|
|
rect.right = Tk_Width(tkwin) - rect.left;
|
498 |
|
|
rect.bottom = Tk_Height(tkwin) - rect.top;
|
499 |
|
|
} else {
|
500 |
|
|
rect.top = y-2;
|
501 |
|
|
rect.left = x-2;
|
502 |
|
|
rect.right = x+butPtr->textWidth + 1;
|
503 |
|
|
rect.bottom = y+butPtr->textHeight + 1;
|
504 |
|
|
}
|
505 |
|
|
SetTextColor(dc, gc->foreground);
|
506 |
|
|
SetBkColor(dc, gc->background);
|
507 |
|
|
DrawFocusRect(dc, &rect);
|
508 |
|
|
TkWinReleaseDrawableDC(pixmap, dc, &state);
|
509 |
|
|
}
|
510 |
|
|
y += butPtr->textHeight/2;
|
511 |
|
|
}
|
512 |
|
|
|
513 |
|
|
/*
|
514 |
|
|
* Draw the indicator for check buttons and radio buttons. At this
|
515 |
|
|
* point x and y refer to the top-left corner of the text or image
|
516 |
|
|
* or bitmap.
|
517 |
|
|
*/
|
518 |
|
|
|
519 |
|
|
if ((butPtr->type >= TYPE_CHECK_BUTTON) && butPtr->indicatorOn
|
520 |
|
|
&& tsdPtr->boxesPtr) {
|
521 |
|
|
int xSrc, ySrc;
|
522 |
|
|
|
523 |
|
|
x -= butPtr->indicatorSpace;
|
524 |
|
|
y -= butPtr->indicatorDiameter / 2;
|
525 |
|
|
|
526 |
|
|
xSrc = (butPtr->flags & SELECTED) ? tsdPtr->boxWidth : 0;
|
527 |
|
|
if (butPtr->state == STATE_ACTIVE) {
|
528 |
|
|
xSrc += tsdPtr->boxWidth*2;
|
529 |
|
|
}
|
530 |
|
|
ySrc = (butPtr->type == TYPE_RADIO_BUTTON) ? 0 : tsdPtr->boxHeight;
|
531 |
|
|
|
532 |
|
|
/*
|
533 |
|
|
* Update the palette in the boxes bitmap to reflect the current
|
534 |
|
|
* button colors. Note that this code relies on the layout of the
|
535 |
|
|
* bitmap's palette. Also, all of the colors used to draw the
|
536 |
|
|
* bitmap must be in the palette that is selected into the DC of
|
537 |
|
|
* the offscreen pixmap. This requires that the static colors
|
538 |
|
|
* be placed into the palette.
|
539 |
|
|
*/
|
540 |
|
|
|
541 |
|
|
boxesPalette[PAL_CHECK] = FlipColor(gc->foreground);
|
542 |
|
|
boxesPalette[PAL_TOP_OUTER] = FlipColor(TkWinGetBorderPixels(tkwin,
|
543 |
|
|
border, TK_3D_DARK_GC));
|
544 |
|
|
boxesPalette[PAL_TOP_INNER] = FlipColor(TkWinGetBorderPixels(tkwin,
|
545 |
|
|
border, TK_3D_DARK2));
|
546 |
|
|
boxesPalette[PAL_BOTTOM_INNER] = FlipColor(TkWinGetBorderPixels(tkwin,
|
547 |
|
|
border, TK_3D_LIGHT2));
|
548 |
|
|
boxesPalette[PAL_BOTTOM_OUTER] = FlipColor(TkWinGetBorderPixels(tkwin,
|
549 |
|
|
border, TK_3D_LIGHT_GC));
|
550 |
|
|
if (butPtr->state == STATE_DISABLED) {
|
551 |
|
|
boxesPalette[PAL_INTERIOR] = FlipColor(TkWinGetBorderPixels(tkwin,
|
552 |
|
|
border, TK_3D_LIGHT2));
|
553 |
|
|
} else if (butPtr->selectBorder != NULL) {
|
554 |
|
|
boxesPalette[PAL_INTERIOR] = FlipColor(TkWinGetBorderPixels(tkwin,
|
555 |
|
|
butPtr->selectBorder, TK_3D_FLAT_GC));
|
556 |
|
|
} else {
|
557 |
|
|
boxesPalette[PAL_INTERIOR] = FlipColor(GetSysColor(COLOR_WINDOW));
|
558 |
|
|
}
|
559 |
|
|
boxesPalette[PAL_BACKGROUND] = FlipColor(TkWinGetBorderPixels(tkwin,
|
560 |
|
|
border, TK_3D_FLAT_GC));
|
561 |
|
|
|
562 |
|
|
dc = TkWinGetDrawableDC(butPtr->display, pixmap, &state);
|
563 |
|
|
StretchDIBits(dc, x, y, tsdPtr->boxWidth, tsdPtr->boxHeight,
|
564 |
|
|
xSrc, ySrc, tsdPtr->boxWidth, tsdPtr->boxHeight,
|
565 |
|
|
tsdPtr->boxesBits, (LPBITMAPINFO) tsdPtr->boxesPtr,
|
566 |
|
|
DIB_RGB_COLORS, SRCCOPY);
|
567 |
|
|
TkWinReleaseDrawableDC(pixmap, dc, &state);
|
568 |
|
|
}
|
569 |
|
|
|
570 |
|
|
/*
|
571 |
|
|
* If the button is disabled with a stipple rather than a special
|
572 |
|
|
* foreground color, generate the stippled effect. If the widget
|
573 |
|
|
* is selected and we use a different background color when selected,
|
574 |
|
|
* must temporarily modify the GC.
|
575 |
|
|
*/
|
576 |
|
|
|
577 |
|
|
if ((butPtr->state == STATE_DISABLED)
|
578 |
|
|
&& ((butPtr->disabledFg == NULL) || (butPtr->image != NULL))) {
|
579 |
|
|
if ((butPtr->flags & SELECTED) && !butPtr->indicatorOn
|
580 |
|
|
&& (butPtr->selectBorder != NULL)) {
|
581 |
|
|
XSetForeground(butPtr->display, butPtr->disabledGC,
|
582 |
|
|
Tk_3DBorderColor(butPtr->selectBorder)->pixel);
|
583 |
|
|
}
|
584 |
|
|
XFillRectangle(butPtr->display, pixmap, butPtr->disabledGC,
|
585 |
|
|
butPtr->inset, butPtr->inset,
|
586 |
|
|
(unsigned) (Tk_Width(tkwin) - 2*butPtr->inset),
|
587 |
|
|
(unsigned) (Tk_Height(tkwin) - 2*butPtr->inset));
|
588 |
|
|
if ((butPtr->flags & SELECTED) && !butPtr->indicatorOn
|
589 |
|
|
&& (butPtr->selectBorder != NULL)) {
|
590 |
|
|
XSetForeground(butPtr->display, butPtr->disabledGC,
|
591 |
|
|
Tk_3DBorderColor(butPtr->normalBorder)->pixel);
|
592 |
|
|
}
|
593 |
|
|
}
|
594 |
|
|
|
595 |
|
|
/*
|
596 |
|
|
* Draw the border and traversal highlight last. This way, if the
|
597 |
|
|
* button's contents overflow they'll be covered up by the border.
|
598 |
|
|
*/
|
599 |
|
|
|
600 |
|
|
if (relief != TK_RELIEF_FLAT) {
|
601 |
|
|
Tk_Draw3DRectangle(tkwin, pixmap, border,
|
602 |
|
|
defaultWidth, defaultWidth,
|
603 |
|
|
Tk_Width(tkwin) - 2*defaultWidth,
|
604 |
|
|
Tk_Height(tkwin) - 2*defaultWidth,
|
605 |
|
|
butPtr->borderWidth, relief);
|
606 |
|
|
}
|
607 |
|
|
if (defaultWidth != 0) {
|
608 |
|
|
dc = TkWinGetDrawableDC(butPtr->display, pixmap, &state);
|
609 |
|
|
TkWinFillRect(dc, 0, 0, Tk_Width(tkwin), defaultWidth,
|
610 |
|
|
butPtr->highlightColorPtr->pixel);
|
611 |
|
|
TkWinFillRect(dc, 0, 0, defaultWidth, Tk_Height(tkwin),
|
612 |
|
|
butPtr->highlightColorPtr->pixel);
|
613 |
|
|
TkWinFillRect(dc, 0, Tk_Height(tkwin) - defaultWidth,
|
614 |
|
|
Tk_Width(tkwin), defaultWidth,
|
615 |
|
|
butPtr->highlightColorPtr->pixel);
|
616 |
|
|
TkWinFillRect(dc, Tk_Width(tkwin) - defaultWidth, 0,
|
617 |
|
|
defaultWidth, Tk_Height(tkwin),
|
618 |
|
|
butPtr->highlightColorPtr->pixel);
|
619 |
|
|
TkWinReleaseDrawableDC(pixmap, dc, &state);
|
620 |
|
|
}
|
621 |
|
|
|
622 |
|
|
/*
|
623 |
|
|
* Copy the information from the off-screen pixmap onto the screen,
|
624 |
|
|
* then delete the pixmap.
|
625 |
|
|
*/
|
626 |
|
|
|
627 |
|
|
XCopyArea(butPtr->display, pixmap, Tk_WindowId(tkwin),
|
628 |
|
|
butPtr->copyGC, 0, 0, (unsigned) Tk_Width(tkwin),
|
629 |
|
|
(unsigned) Tk_Height(tkwin), 0, 0);
|
630 |
|
|
Tk_FreePixmap(butPtr->display, pixmap);
|
631 |
|
|
}
|
632 |
|
|
|
633 |
|
|
/*
|
634 |
|
|
*----------------------------------------------------------------------
|
635 |
|
|
*
|
636 |
|
|
* TkpComputeButtonGeometry --
|
637 |
|
|
*
|
638 |
|
|
* After changes in a button's text or bitmap, this procedure
|
639 |
|
|
* recomputes the button's geometry and passes this information
|
640 |
|
|
* along to the geometry manager for the window.
|
641 |
|
|
*
|
642 |
|
|
* Results:
|
643 |
|
|
* None.
|
644 |
|
|
*
|
645 |
|
|
* Side effects:
|
646 |
|
|
* The button's window may change size.
|
647 |
|
|
*
|
648 |
|
|
*----------------------------------------------------------------------
|
649 |
|
|
*/
|
650 |
|
|
|
651 |
|
|
void
|
652 |
|
|
TkpComputeButtonGeometry(butPtr)
|
653 |
|
|
register TkButton *butPtr; /* Button whose geometry may have changed. */
|
654 |
|
|
{
|
655 |
|
|
int width, height, avgWidth;
|
656 |
|
|
Tk_FontMetrics fm;
|
657 |
|
|
ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
|
658 |
|
|
Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
|
659 |
|
|
|
660 |
|
|
if (butPtr->highlightWidth < 0) {
|
661 |
|
|
butPtr->highlightWidth = 0;
|
662 |
|
|
}
|
663 |
|
|
butPtr->inset = butPtr->highlightWidth + butPtr->borderWidth;
|
664 |
|
|
butPtr->indicatorSpace = 0;
|
665 |
|
|
|
666 |
|
|
if (!tsdPtr->boxesPtr) {
|
667 |
|
|
InitBoxes();
|
668 |
|
|
}
|
669 |
|
|
|
670 |
|
|
if (butPtr->image != NULL) {
|
671 |
|
|
Tk_SizeOfImage(butPtr->image, &width, &height);
|
672 |
|
|
imageOrBitmap:
|
673 |
|
|
if (butPtr->width > 0) {
|
674 |
|
|
width = butPtr->width;
|
675 |
|
|
}
|
676 |
|
|
if (butPtr->height > 0) {
|
677 |
|
|
height = butPtr->height;
|
678 |
|
|
}
|
679 |
|
|
if ((butPtr->type >= TYPE_CHECK_BUTTON) && butPtr->indicatorOn) {
|
680 |
|
|
butPtr->indicatorSpace = tsdPtr->boxWidth * 2;
|
681 |
|
|
butPtr->indicatorDiameter = tsdPtr->boxHeight;
|
682 |
|
|
}
|
683 |
|
|
} else if (butPtr->bitmap != None) {
|
684 |
|
|
Tk_SizeOfBitmap(butPtr->display, butPtr->bitmap, &width, &height);
|
685 |
|
|
goto imageOrBitmap;
|
686 |
|
|
} else {
|
687 |
|
|
Tk_FreeTextLayout(butPtr->textLayout);
|
688 |
|
|
butPtr->textLayout = Tk_ComputeTextLayout(butPtr->tkfont,
|
689 |
|
|
Tcl_GetString(butPtr->textPtr), -1, butPtr->wrapLength,
|
690 |
|
|
butPtr->justify, 0, &butPtr->textWidth, &butPtr->textHeight);
|
691 |
|
|
|
692 |
|
|
width = butPtr->textWidth;
|
693 |
|
|
height = butPtr->textHeight;
|
694 |
|
|
avgWidth = Tk_TextWidth(butPtr->tkfont, "0", 1);
|
695 |
|
|
Tk_GetFontMetrics(butPtr->tkfont, &fm);
|
696 |
|
|
|
697 |
|
|
if (butPtr->width > 0) {
|
698 |
|
|
width = butPtr->width * avgWidth;
|
699 |
|
|
}
|
700 |
|
|
if (butPtr->height > 0) {
|
701 |
|
|
height = butPtr->height * fm.linespace;
|
702 |
|
|
}
|
703 |
|
|
|
704 |
|
|
if ((butPtr->type >= TYPE_CHECK_BUTTON) && butPtr->indicatorOn) {
|
705 |
|
|
butPtr->indicatorDiameter = tsdPtr->boxHeight;
|
706 |
|
|
butPtr->indicatorSpace = butPtr->indicatorDiameter + avgWidth;
|
707 |
|
|
}
|
708 |
|
|
|
709 |
|
|
/*
|
710 |
|
|
* Increase the inset to allow for the focus ring.
|
711 |
|
|
*/
|
712 |
|
|
|
713 |
|
|
if (butPtr->type != TYPE_LABEL) {
|
714 |
|
|
butPtr->inset += 3;
|
715 |
|
|
}
|
716 |
|
|
}
|
717 |
|
|
|
718 |
|
|
/*
|
719 |
|
|
* When issuing the geometry request, add extra space for the indicator,
|
720 |
|
|
* if any, and for the border and padding, plus an extra pixel so the
|
721 |
|
|
* display can be offset by 1 pixel in either direction for the raised
|
722 |
|
|
* or lowered effect.
|
723 |
|
|
*/
|
724 |
|
|
|
725 |
|
|
if ((butPtr->image == NULL) && (butPtr->bitmap == None)) {
|
726 |
|
|
width += 2*butPtr->padX;
|
727 |
|
|
height += 2*butPtr->padY;
|
728 |
|
|
}
|
729 |
|
|
if ((butPtr->type == TYPE_BUTTON)
|
730 |
|
|
|| ((butPtr->type >= TYPE_CHECK_BUTTON) && !butPtr->indicatorOn)) {
|
731 |
|
|
width += 1;
|
732 |
|
|
height += 1;
|
733 |
|
|
}
|
734 |
|
|
Tk_GeometryRequest(butPtr->tkwin, (int) (width + butPtr->indicatorSpace
|
735 |
|
|
+ 2*butPtr->inset), (int) (height + 2*butPtr->inset));
|
736 |
|
|
Tk_SetInternalBorder(butPtr->tkwin, butPtr->inset);
|
737 |
|
|
}
|
738 |
|
|
|
739 |
|
|
/*
|
740 |
|
|
*----------------------------------------------------------------------
|
741 |
|
|
*
|
742 |
|
|
* ButtonProc --
|
743 |
|
|
*
|
744 |
|
|
* This function is call by Windows whenever an event occurs on
|
745 |
|
|
* a button control created by Tk.
|
746 |
|
|
*
|
747 |
|
|
* Results:
|
748 |
|
|
* Standard Windows return value.
|
749 |
|
|
*
|
750 |
|
|
* Side effects:
|
751 |
|
|
* May generate events.
|
752 |
|
|
*
|
753 |
|
|
*----------------------------------------------------------------------
|
754 |
|
|
*/
|
755 |
|
|
|
756 |
|
|
static LRESULT CALLBACK
|
757 |
|
|
ButtonProc(hwnd, message, wParam, lParam)
|
758 |
|
|
HWND hwnd;
|
759 |
|
|
UINT message;
|
760 |
|
|
WPARAM wParam;
|
761 |
|
|
LPARAM lParam;
|
762 |
|
|
{
|
763 |
|
|
LRESULT result;
|
764 |
|
|
WinButton *butPtr;
|
765 |
|
|
Tk_Window tkwin = Tk_HWNDToWindow(hwnd);
|
766 |
|
|
|
767 |
|
|
if (tkwin == NULL) {
|
768 |
|
|
panic("ButtonProc called on an invalid HWND");
|
769 |
|
|
}
|
770 |
|
|
butPtr = (WinButton *)((TkWindow*)tkwin)->instanceData;
|
771 |
|
|
|
772 |
|
|
switch(message) {
|
773 |
|
|
case WM_ERASEBKGND:
|
774 |
|
|
return 0;
|
775 |
|
|
|
776 |
|
|
case BM_GETCHECK:
|
777 |
|
|
if (((butPtr->info.type == TYPE_CHECK_BUTTON)
|
778 |
|
|
|| (butPtr->info.type == TYPE_RADIO_BUTTON))
|
779 |
|
|
&& butPtr->info.indicatorOn) {
|
780 |
|
|
return (butPtr->info.flags & SELECTED)
|
781 |
|
|
? BST_CHECKED : BST_UNCHECKED;
|
782 |
|
|
}
|
783 |
|
|
return 0;
|
784 |
|
|
|
785 |
|
|
case BM_GETSTATE: {
|
786 |
|
|
DWORD state = 0;
|
787 |
|
|
if (((butPtr->info.type == TYPE_CHECK_BUTTON)
|
788 |
|
|
|| (butPtr->info.type == TYPE_RADIO_BUTTON))
|
789 |
|
|
&& butPtr->info.indicatorOn) {
|
790 |
|
|
state = (butPtr->info.flags & SELECTED)
|
791 |
|
|
? BST_CHECKED : BST_UNCHECKED;
|
792 |
|
|
}
|
793 |
|
|
if (butPtr->info.flags & GOT_FOCUS) {
|
794 |
|
|
state |= BST_FOCUS;
|
795 |
|
|
}
|
796 |
|
|
return state;
|
797 |
|
|
}
|
798 |
|
|
case WM_ENABLE:
|
799 |
|
|
break;
|
800 |
|
|
|
801 |
|
|
case WM_PAINT: {
|
802 |
|
|
PAINTSTRUCT ps;
|
803 |
|
|
BeginPaint(hwnd, &ps);
|
804 |
|
|
EndPaint(hwnd, &ps);
|
805 |
|
|
TkpDisplayButton((ClientData)butPtr);
|
806 |
|
|
|
807 |
|
|
/*
|
808 |
|
|
* Special note: must cancel any existing idle handler
|
809 |
|
|
* for TkpDisplayButton; it's no longer needed, and
|
810 |
|
|
* TkpDisplayButton cleared the REDRAW_PENDING flag.
|
811 |
|
|
*/
|
812 |
|
|
|
813 |
|
|
Tcl_CancelIdleCall(TkpDisplayButton, (ClientData)butPtr);
|
814 |
|
|
return 0;
|
815 |
|
|
}
|
816 |
|
|
case BN_CLICKED: {
|
817 |
|
|
int code;
|
818 |
|
|
Tcl_Interp *interp = butPtr->info.interp;
|
819 |
|
|
if (butPtr->info.state != STATE_DISABLED) {
|
820 |
|
|
Tcl_Preserve((ClientData)interp);
|
821 |
|
|
code = TkInvokeButton((TkButton*)butPtr);
|
822 |
|
|
if (code != TCL_OK && code != TCL_CONTINUE
|
823 |
|
|
&& code != TCL_BREAK) {
|
824 |
|
|
Tcl_AddErrorInfo(interp, "\n (button invoke)");
|
825 |
|
|
Tcl_BackgroundError(interp);
|
826 |
|
|
}
|
827 |
|
|
Tcl_Release((ClientData)interp);
|
828 |
|
|
}
|
829 |
|
|
Tcl_ServiceAll();
|
830 |
|
|
return 0;
|
831 |
|
|
}
|
832 |
|
|
|
833 |
|
|
default:
|
834 |
|
|
if (Tk_TranslateWinEvent(hwnd, message, wParam, lParam, &result)) {
|
835 |
|
|
return result;
|
836 |
|
|
}
|
837 |
|
|
}
|
838 |
|
|
return DefWindowProc(hwnd, message, wParam, lParam);
|
839 |
|
|
}
|
840 |
|
|
|
841 |
|
|
|
842 |
|
|
/* $History: tkWinButton.c $
|
843 |
|
|
*
|
844 |
|
|
* ***************** Version 1 *****************
|
845 |
|
|
* User: Dtashley Date: 1/02/01 Time: 3:10a
|
846 |
|
|
* Created in $/IjuScripter, IjuConsole/Source/Tk Base
|
847 |
|
|
* Initial check-in.
|
848 |
|
|
*/
|
849 |
|
|
|
850 |
|
|
/* End of TKWINBUTTON.C */ |