|
3
|
1 /* $Id: x11window.c,v 1.1.1.1 1997/12/06 05:41:31 darius Exp $ */
|
|
|
2
|
|
|
3
|
|
|
4 /* x11window.c
|
|
|
5 *
|
|
|
6 * Kevin P. Smith 6/11/89
|
|
|
7 * Much modified by Jerry Frain and Joe Young
|
|
|
8 */
|
|
|
9
|
|
|
10 #include <stdio.h>
|
|
|
11 #ifdef __STDC__
|
|
|
12 #include <stdlib.h>
|
|
|
13 #endif
|
|
|
14 #include <X11/Xlib.h>
|
|
|
15 #include <X11/Xutil.h>
|
|
|
16 #ifdef RFCURSORS
|
|
|
17 #include <X11/Xmu/CurUtil.h>
|
|
|
18 #endif
|
|
|
19 #include <X11/cursorfont.h>
|
|
|
20 #include <assert.h>
|
|
|
21 #include <string.h>
|
|
|
22 #include "Wlib.h"
|
|
|
23 #include "defs.h"
|
|
|
24 #include "struct.h"
|
|
|
25 #include "data.h"
|
|
|
26 #include "proto.h"
|
|
|
27
|
|
|
28 #define INVALID_POSITION -10000 /* gotta be a big negative */
|
|
|
29 /* XFIX speedup */
|
|
|
30 #define MAXCACHE 128
|
|
|
31
|
|
|
32 /* changes too good to risk leaving out, by Richard Caley (rjc@cstr.ed.ac.uk)*/
|
|
|
33 #define RJC
|
|
|
34 #define FOURPLANEFIX
|
|
|
35
|
|
|
36 /*
|
|
|
37 #define NORMAL_FONT "-*-fixed-medium-r-*-*-10-*-*-*-*-*-*-*"
|
|
|
38 #define BOLD_FONT "-*-fixed-medium-r-*-*-10-*-*-*-*-*-*-*"
|
|
|
39 #define ITALIC_FONT "-*-fixed-medium-r-*-*-10-*-*-*-*-*-*-*"
|
|
|
40 */
|
|
|
41
|
|
|
42 #define NORMAL_FONT "6x10"
|
|
|
43 #define BOLD_FONT "6x10"
|
|
|
44 #define BOLD_FONT2 "-*-clean-bold-r-normal--10-100-75-75-c-60-*"
|
|
|
45 #define ITALIC_FONT "6x10"
|
|
|
46 #define ITALIC_FONT2 "-*-clean-bold-r-normal--10-100-75-75-c-60-*"
|
|
|
47 #define BIG_FONT "-adobe-helvetica-bold-r-normal--34-*-*-*-*-*-*-*"
|
|
|
48 #define IND_FONT "-*-clean-bold-r-normal--10-100-75-75-c-60-*"
|
|
|
49 /*#define BOLD_FONT2 "-schumacher-clean-bold-r-normal--10-100-75-75-c-60-iso8859-1"
|
|
|
50 #define ITALIC_FONT2 "-misc-fixed-medium-i-normal--10-100-75-75-c-60-iso8859-1"
|
|
|
51 #define BIG_FONT "-adobe-helvetica-bold-r-normal--34-*-*-*-*-*-*-*"
|
|
|
52 */
|
|
|
53
|
|
|
54 static char *_nfonts[] = {
|
|
|
55 NORMAL_FONT,
|
|
|
56 "-*-clean-medium-r-normal--10-100-75-75-c-60-*",
|
|
|
57 "fixed",
|
|
|
58 NULL,
|
|
|
59 };
|
|
|
60 static char *_bfonts[] = {
|
|
|
61 BOLD_FONT,
|
|
|
62 "-*-clean-bold-r-normal--10-100-75-75-c-60-*",
|
|
|
63 "fixed",
|
|
|
64 NULL,
|
|
|
65 };
|
|
|
66 static char *_ifonts[] = {
|
|
|
67 ITALIC_FONT,
|
|
|
68 "-*-clean-bold-r-normal--10-100-75-75-c-60-*",
|
|
|
69 "fixed",
|
|
|
70 NULL,
|
|
|
71 };
|
|
|
72 static char *_bgfonts[] = {
|
|
|
73 BIG_FONT,
|
|
|
74 "-*-lucidatypewriter-*-*-*-*-40-*-*-*-*-*-*-*",
|
|
|
75 "fixed",
|
|
|
76 NULL,
|
|
|
77 };
|
|
|
78
|
|
|
79 #define FONTS 4
|
|
|
80 #define BITGC 4
|
|
|
81
|
|
|
82 #define WHITE 0
|
|
|
83 #define BLACK 1
|
|
|
84 #define RED 2
|
|
|
85 #define GREEN 3
|
|
|
86 #define YELLOW 4
|
|
|
87 #define CYAN 5
|
|
|
88 #define GREY 6
|
|
|
89
|
|
|
90 static int zero = 0;
|
|
|
91 static int one = 1;
|
|
|
92 static int two = 2;
|
|
|
93 static int three = 3;
|
|
|
94
|
|
|
95 int controlkey = 0;
|
|
|
96 #define BillsScrewyAltMask (Mod1Mask|Mod2Mask|Mod3Mask|Mod4Mask|Mod5Mask)
|
|
|
97 int altkey = 0;
|
|
|
98 int W_FastClear = 0;
|
|
|
99 #ifdef CONTINUOUS_MOUSE
|
|
|
100 int buttonDown = 0;
|
|
|
101 #endif /* CONTINUOUS_MOUSE */
|
|
|
102 Display *W_Display;
|
|
|
103 Window W_Root;
|
|
|
104 Colormap W_Colormap;
|
|
|
105 int W_Screen;
|
|
|
106 #ifdef FOURPLANEFIX
|
|
|
107 Visual *W_Visual;
|
|
|
108 #endif
|
|
|
109 W_Font W_BigFont = (W_Font) & zero, W_RegularFont = (W_Font) & one;
|
|
|
110 W_Font W_HighlightFont = (W_Font) & two, W_UnderlineFont = (W_Font) & three;
|
|
|
111 W_Color W_White = WHITE, W_Black = BLACK, W_Red = RED, W_Green = GREEN;
|
|
|
112 W_Color W_Yellow = YELLOW, W_Cyan = CYAN, W_Grey = GREY;
|
|
|
113 int W_Textwidth, W_Textheight;
|
|
|
114 char *getdefault();
|
|
|
115 char *strdup();
|
|
|
116
|
|
|
117 int W_in_message = 0; /* jfy -- for Jerry's warp message hack */
|
|
|
118
|
|
|
119 #ifdef RJC
|
|
|
120 extern W_Window baseWin;
|
|
|
121 static XClassHint class_hint = {
|
|
|
122 "netrek", "Netrek",
|
|
|
123 };
|
|
|
124
|
|
|
125 static XWMHints wm_hint = {
|
|
|
126 InputHint | StateHint,
|
|
|
127 True,
|
|
|
128 WithdrawnState,
|
|
|
129 None,
|
|
|
130 None,
|
|
|
131 0, 0,
|
|
|
132 None,
|
|
|
133 None,
|
|
|
134 };
|
|
|
135
|
|
|
136 static XSizeHints wm_size_hint;
|
|
|
137 #endif /* RJC */
|
|
|
138
|
|
|
139 static W_Event W_myevent;
|
|
|
140 static int W_isEvent = 0;
|
|
|
141
|
|
|
142 struct fontInfo {
|
|
|
143 XFontStruct *fontstruct;
|
|
|
144 int baseline;
|
|
|
145 };
|
|
|
146
|
|
|
147 struct colors {
|
|
|
148 char *name;
|
|
|
149 GC contexts[FONTS + 1];
|
|
|
150 Pixmap pixmap;
|
|
|
151 long pixelValue;
|
|
|
152 };
|
|
|
153
|
|
|
154 struct icon {
|
|
|
155 Window window;
|
|
|
156 Pixmap bitmap;
|
|
|
157 int width, height;
|
|
|
158 Pixmap pixmap;
|
|
|
159 };
|
|
|
160
|
|
|
161 #define WIN_GRAPH 1
|
|
|
162 #define WIN_TEXT 2
|
|
|
163 #define WIN_MENU 3
|
|
|
164 #define WIN_SCROLL 4
|
|
|
165
|
|
|
166 struct window {
|
|
|
167 Window window;
|
|
|
168 int type;
|
|
|
169 char *data;
|
|
|
170 int mapped;
|
|
|
171 int width, height;
|
|
|
172 char *name;
|
|
|
173 Cursor cursor;
|
|
|
174 #ifdef SHORT_PACKETS
|
|
|
175 int insensitive;
|
|
|
176 #endif
|
|
|
177 #if 0
|
|
|
178 W_Callback handle_keydown;
|
|
|
179 W_Callback handle_keyup;
|
|
|
180 W_Callback handle_button;
|
|
|
181 W_Callback handle_expose;
|
|
|
182 #endif /* 0 */
|
|
|
183 };
|
|
|
184
|
|
|
185 struct stringList {
|
|
|
186 char *string;
|
|
|
187 W_Color color;
|
|
|
188 struct stringList *next;
|
|
|
189 };
|
|
|
190
|
|
|
191 struct menuItem {
|
|
|
192 char *string;
|
|
|
193 W_Color color;
|
|
|
194 W_Font font;
|
|
|
195 };
|
|
|
196
|
|
|
197 struct colors colortable[] = {
|
|
|
198 {"white"},
|
|
|
199 {"black"},
|
|
|
200 {"red"},
|
|
|
201 {"green"},
|
|
|
202 {"yellow"},
|
|
|
203 {"cyan"},
|
|
|
204 {"light grey"}
|
|
|
205 };
|
|
|
206
|
|
|
207 struct windowlist {
|
|
|
208 struct window *window;
|
|
|
209 struct windowlist *next;
|
|
|
210 };
|
|
|
211
|
|
|
212 #define HASHSIZE 29
|
|
|
213 #define hash(x) (((int) (x)) % HASHSIZE)
|
|
|
214
|
|
|
215 struct windowlist *hashtable[HASHSIZE];
|
|
|
216 struct fontInfo fonts[FONTS];
|
|
|
217
|
|
|
218 struct window *newWindow();
|
|
|
219 #ifndef NeXT
|
|
|
220 #ifndef __STDC__
|
|
|
221 char *malloc();
|
|
|
222 #endif
|
|
|
223 #endif /* NeXT */
|
|
|
224 short *x11tox10bits();
|
|
|
225
|
|
|
226 struct window myroot;
|
|
|
227
|
|
|
228 #define NCOLORS (sizeof(colortable)/sizeof(colortable[0]))
|
|
|
229 #define W_Void2Window(win) ((win) ? (struct window *) (win) : &myroot)
|
|
|
230 #define W_Window2Void(window) ((W_Window) (window))
|
|
|
231 #define W_Void2Icon(bit) ((struct icon *) (bit))
|
|
|
232 #define W_Icon2Void(bit) ((W_Icon) (bit))
|
|
|
233 #define fontNum(font) (*((int *) font))
|
|
|
234 #define TILESIDE 16
|
|
|
235
|
|
|
236 #define WIN_EDGE 5 /* border on l/r edges of text windows */
|
|
|
237 #define MENU_PAD 4 /* border on t/b edges of text windows */
|
|
|
238 #define MENU_BAR 2 /* width of menu bar */
|
|
|
239
|
|
|
240 static unsigned char gray[] = {
|
|
|
241 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55,
|
|
|
242 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55,
|
|
|
243 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55,
|
|
|
244 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55
|
|
|
245 };
|
|
|
246
|
|
|
247 static unsigned char striped[] = {
|
|
|
248 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff,
|
|
|
249 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f,
|
|
|
250 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00,
|
|
|
251 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0
|
|
|
252 };
|
|
|
253
|
|
|
254 static unsigned char solid[] = {
|
|
|
255 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
|
256 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
|
257 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
|
258 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
|
|
|
259 };
|
|
|
260
|
|
|
261 /* Prototypes */
|
|
|
262 /*static int _myerror P((Display *d , XErrorEvent *e ));*/
|
|
|
263 static void GetFonts P((void));
|
|
|
264 static XFontStruct *find_font P((char *oldf, char **fonts));
|
|
|
265 static void GetColors P((void));
|
|
|
266 static void FlushClearAreaCache P((Window win));
|
|
|
267 static int W_SpNextEvent P((W_Event * wevent));
|
|
|
268 static void FlushLineCache P((Window win, int color));
|
|
|
269 static void FlushPointCache P((Window win, int color));
|
|
|
270 static struct window *findWindow P((Window window));
|
|
|
271 static void addToHash P((struct window * win));
|
|
|
272 static void AddToScrolling P((struct window * win, W_Color color, char *str, int len));
|
|
|
273 static void redrawScrolling P((struct window * win));
|
|
|
274 static void resizeScrolling P((struct window * win, int width, int height));
|
|
|
275 static void redrawMenu P((struct window * win));
|
|
|
276 static void redrawMenuItem P((struct window * win, int n));
|
|
|
277 static void changeMenuItem P((struct window * win, int n, W_Color color, char *str, int len, W_Font font));
|
|
|
278 /*static void W_SetTransientForHint P((W_Window w , W_Window pw ));*/
|
|
|
279 static void checkGeometry P((char *name, int *x, int *y, int *width, int *height));
|
|
|
280 static void checkParent P((char *name, W_Window * parent));
|
|
|
281 static void checkCursor P((char *name, char *cursname, Cursor * cursor));
|
|
|
282 static void findMouse P((int *x, int *y));
|
|
|
283 #ifdef AUTOKEY
|
|
|
284 static void W_Flush P((void));
|
|
|
285 #endif /* AUTOKEY */
|
|
|
286 static void deleteWindow P((struct window * window));
|
|
|
287
|
|
|
288 /* X debugging */
|
|
|
289 #if 0
|
|
|
290 static int
|
|
|
291 _myerror(d, e)
|
|
|
292 Display *d;
|
|
|
293 XErrorEvent *e;
|
|
|
294 {
|
|
|
295 abort();
|
|
|
296 }
|
|
|
297 #endif /* 0 */
|
|
|
298
|
|
|
299 void
|
|
|
300 W_Initialize(str)
|
|
|
301 char *str;
|
|
|
302 {
|
|
|
303 int i;
|
|
|
304
|
|
|
305 #ifdef DEBUG
|
|
|
306 printf("Initializing...\n");
|
|
|
307 #endif
|
|
|
308 for (i = 0; i < HASHSIZE; i++) {
|
|
|
309 hashtable[i] = NULL;
|
|
|
310 }
|
|
|
311 if ((W_Display = XOpenDisplay(str)) == NULL) {
|
|
|
312 fprintf(stderr, "Cannot open display \"%s\"\n", str ? str : "(null)");
|
|
|
313 EXIT(1);
|
|
|
314 }
|
|
|
315 #if 0
|
|
|
316 /* tmp */
|
|
|
317 XSynchronize(W_Display, True);
|
|
|
318 XSetErrorHandler(_myerror);
|
|
|
319 #endif
|
|
|
320
|
|
|
321 W_Root = DefaultRootWindow(W_Display);
|
|
|
322 #ifdef FOURPLANEFIX
|
|
|
323 W_Visual = DefaultVisual(W_Display, DefaultScreen(W_Display));
|
|
|
324 #endif
|
|
|
325 W_Screen = DefaultScreen(W_Display);
|
|
|
326 W_Colormap = DefaultColormap(W_Display, W_Screen);
|
|
|
327 myroot.window = W_Root;
|
|
|
328 myroot.type = WIN_GRAPH;
|
|
|
329 GetFonts();
|
|
|
330 GetColors();
|
|
|
331 }
|
|
|
332
|
|
|
333 static void
|
|
|
334 GetFonts()
|
|
|
335 {
|
|
|
336 Font regular, italic, bold, big;
|
|
|
337 int i;
|
|
|
338 XGCValues values;
|
|
|
339 XFontStruct *fontinfo;
|
|
|
340 char *fontname;
|
|
|
341
|
|
|
342 fontname = getdefault("font");
|
|
|
343 if (fontname == NULL)
|
|
|
344 fontname = NORMAL_FONT;
|
|
|
345 fontinfo = XLoadQueryFont(W_Display, fontname);
|
|
|
346 if (fontinfo == NULL) {
|
|
|
347 fontinfo = find_font(fontname, _nfonts);
|
|
|
348 }
|
|
|
349 if (fontinfo == NULL) {
|
|
|
350 printf("netrek: Can't find any fonts!\n");
|
|
|
351 EXIT(1);
|
|
|
352 }
|
|
|
353 regular = fontinfo->fid;
|
|
|
354 W_Textwidth = fontinfo->max_bounds.width;
|
|
|
355 W_Textheight = fontinfo->max_bounds.descent + fontinfo->max_bounds.ascent;
|
|
|
356 fonts[1].baseline = fontinfo->max_bounds.ascent;
|
|
|
357 fonts[1].fontstruct = fontinfo;
|
|
|
358
|
|
|
359 fontname = getdefault("boldfont");
|
|
|
360 if (fontname == NULL) {
|
|
|
361 if (DisplayCells(W_Display, W_Screen) <= 4)
|
|
|
362 fontname = BOLD_FONT2;
|
|
|
363 else
|
|
|
364 fontname = BOLD_FONT;
|
|
|
365 }
|
|
|
366 fontinfo = XLoadQueryFont(W_Display, fontname);
|
|
|
367 if (fontinfo == NULL) {
|
|
|
368 fontinfo = find_font(fontname, _bfonts);
|
|
|
369 }
|
|
|
370 if (fontinfo == NULL) {
|
|
|
371 bold = regular;
|
|
|
372 fonts[2].baseline = fonts[1].baseline;
|
|
|
373 fonts[2].fontstruct = fonts[1].fontstruct;
|
|
|
374 } else {
|
|
|
375 bold = fontinfo->fid;
|
|
|
376 fonts[2].baseline = fontinfo->max_bounds.ascent;
|
|
|
377 fonts[2].fontstruct = fontinfo;
|
|
|
378 if (fontinfo->max_bounds.width > W_Textwidth)
|
|
|
379 W_Textwidth = fontinfo->max_bounds.width;
|
|
|
380 if (fontinfo->max_bounds.descent + fontinfo->max_bounds.ascent > W_Textheight)
|
|
|
381 W_Textheight = fontinfo->max_bounds.descent + fontinfo->max_bounds.ascent;
|
|
|
382 }
|
|
|
383
|
|
|
384 fontname = getdefault("italicfont");
|
|
|
385 if (fontname == NULL) {
|
|
|
386 if (DisplayCells(W_Display, W_Screen) <= 4)
|
|
|
387 fontname = ITALIC_FONT2;
|
|
|
388 else
|
|
|
389 fontname = ITALIC_FONT;
|
|
|
390 }
|
|
|
391 fontinfo = XLoadQueryFont(W_Display, fontname);
|
|
|
392 if (fontinfo == NULL) {
|
|
|
393 fontinfo = find_font(fontname, _ifonts);
|
|
|
394 }
|
|
|
395 if (fontinfo == NULL) {
|
|
|
396 italic = regular;
|
|
|
397 fonts[3].baseline = fonts[1].baseline;
|
|
|
398 fonts[3].fontstruct = fonts[1].fontstruct;
|
|
|
399 } else {
|
|
|
400 italic = fontinfo->fid;
|
|
|
401 fonts[3].baseline = fontinfo->max_bounds.ascent;
|
|
|
402 fonts[3].fontstruct = fontinfo;
|
|
|
403 if (fontinfo->max_bounds.width > W_Textwidth)
|
|
|
404 W_Textwidth = fontinfo->max_bounds.width;
|
|
|
405 if (fontinfo->max_bounds.descent + fontinfo->max_bounds.ascent > W_Textheight)
|
|
|
406 W_Textheight = fontinfo->max_bounds.descent + fontinfo->max_bounds.ascent;
|
|
|
407 }
|
|
|
408
|
|
|
409 fontname = getdefault("bigfont");
|
|
|
410 if (fontname == NULL)
|
|
|
411 fontname = BIG_FONT;
|
|
|
412 fontinfo = XLoadQueryFont(W_Display, fontname);
|
|
|
413 if (fontinfo == NULL) {
|
|
|
414 fontinfo = find_font(fontname, _bgfonts);
|
|
|
415 }
|
|
|
416 if (fontinfo == NULL) {
|
|
|
417 big = regular;
|
|
|
418 fonts[0].baseline = fonts[1].baseline;
|
|
|
419 fonts[0].fontstruct = fonts[1].fontstruct;
|
|
|
420 } else {
|
|
|
421 big = fontinfo->fid;
|
|
|
422 fonts[0].baseline = fontinfo->max_bounds.ascent;
|
|
|
423 fonts[0].fontstruct = fontinfo;
|
|
|
424 }
|
|
|
425 for (i = 0; i < NCOLORS; i++) {
|
|
|
426 values.font = big;
|
|
|
427 colortable[i].contexts[0] = XCreateGC(W_Display, W_Root, GCFont, &values);
|
|
|
428 XSetGraphicsExposures(W_Display, colortable[i].contexts[0], False);
|
|
|
429 values.font = regular;
|
|
|
430 colortable[i].contexts[1] = XCreateGC(W_Display, W_Root, GCFont, &values);
|
|
|
431 XSetGraphicsExposures(W_Display, colortable[i].contexts[1], False);
|
|
|
432 values.font = bold;
|
|
|
433 colortable[i].contexts[2] = XCreateGC(W_Display, W_Root, GCFont, &values);
|
|
|
434 XSetGraphicsExposures(W_Display, colortable[i].contexts[2], False);
|
|
|
435 values.font = italic;
|
|
|
436 colortable[i].contexts[3] = XCreateGC(W_Display, W_Root, GCFont, &values);
|
|
|
437 XSetGraphicsExposures(W_Display, colortable[i].contexts[3], False);
|
|
|
438 {
|
|
|
439 static char dl[] = {1, 4};
|
|
|
440 XSetLineAttributes(W_Display, colortable[i].contexts[3],
|
|
|
441 0, LineOnOffDash, CapButt, JoinMiter);
|
|
|
442 XSetDashes(W_Display, colortable[i].contexts[3], 0, dl, 2);
|
|
|
443 }
|
|
|
444 values.function = GXor;
|
|
|
445 colortable[i].contexts[BITGC] = XCreateGC(W_Display, W_Root, GCFunction, &values);
|
|
|
446 XSetGraphicsExposures(W_Display, colortable[i].contexts[BITGC], False);
|
|
|
447 }
|
|
|
448 }
|
|
|
449
|
|
|
450 static XFontStruct *
|
|
|
451 find_font(oldf, fonts)
|
|
|
452 char *oldf, **fonts;
|
|
|
453 {
|
|
|
454 XFontStruct *fi;
|
|
|
455 char **f;
|
|
|
456 fprintf(stderr, "netrek: Can't find font %s. Trying others...\n",
|
|
|
457 oldf);
|
|
|
458 for (f = fonts; *f; f++) {
|
|
|
459 if (strcmp(*f, oldf) != 0) {
|
|
|
460 if ((fi = XLoadQueryFont(W_Display, *f)))
|
|
|
461 return fi;
|
|
|
462 }
|
|
|
463 }
|
|
|
464 printf("Error - can't find any font!\n");
|
|
|
465 return NULL;
|
|
|
466 }
|
|
|
467
|
|
|
468 #ifdef FOURPLANEFIX
|
|
|
469 static unsigned short extrared[8] = {0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xb0, 0xc0};
|
|
|
470 static unsigned short extragreen[8] = {0x40, 0x60, 0x80, 0xa0, 0xb0, 0xc0, 0x00, 0x20};
|
|
|
471 static unsigned short extrablue[8] = {0x80, 0xa0, 0xb0, 0xc0, 0x00, 0x20, 0x40, 0x60};
|
|
|
472 #endif
|
|
|
473
|
|
|
474 int
|
|
|
475 W_Mono()
|
|
|
476 {
|
|
|
477 return forceMono;
|
|
|
478 }
|
|
|
479
|
|
|
480 static void
|
|
|
481 GetColors()
|
|
|
482 {
|
|
|
483 int i, j;
|
|
|
484 XColor foo;
|
|
|
485 int white, black;
|
|
|
486 unsigned long pixel;
|
|
|
487 unsigned long planes[3];
|
|
|
488 char defaultstring[100];
|
|
|
489 char *defaults;
|
|
|
490 #ifdef FOURPLANEFIX
|
|
|
491 unsigned long extracolors[8];
|
|
|
492 XColor colordef;
|
|
|
493 #endif
|
|
|
494 extern int forceMono;
|
|
|
495 forceMono = booleanDefault("forcemono", forceMono);
|
|
|
496
|
|
|
497 if ((DisplayCells(W_Display, W_Screen) <= 4) || forceMono) {
|
|
|
498 forceMono = 1;
|
|
|
499 white = WhitePixel(W_Display, W_Screen);
|
|
|
500 black = BlackPixel(W_Display, W_Screen);
|
|
|
501 for (i = 0; i < NCOLORS; i++) {
|
|
|
502 if (i != W_Black) {
|
|
|
503 colortable[i].pixelValue = white;
|
|
|
504 } else {
|
|
|
505 colortable[i].pixelValue = black;
|
|
|
506 }
|
|
|
507 if (i == W_Red) {
|
|
|
508 colortable[i].pixmap = XCreatePixmapFromBitmapData
|
|
|
509 (W_Display,
|
|
|
510 W_Root, (char *) striped, TILESIDE, TILESIDE,
|
|
|
511 white, black,
|
|
|
512 DefaultDepth(W_Display, W_Screen));
|
|
|
513 } else if (i == W_Yellow) {
|
|
|
514 colortable[i].pixmap = XCreatePixmapFromBitmapData
|
|
|
515 (W_Display,
|
|
|
516 W_Root, (char *) gray, TILESIDE, TILESIDE,
|
|
|
517 white, black,
|
|
|
518 DefaultDepth(W_Display, W_Screen));
|
|
|
519 } else {
|
|
|
520 colortable[i].pixmap = XCreatePixmapFromBitmapData
|
|
|
521 (W_Display,
|
|
|
522 W_Root, (char *) solid, TILESIDE, TILESIDE,
|
|
|
523 colortable[i].pixelValue,
|
|
|
524 colortable[i].pixelValue,
|
|
|
525 DefaultDepth(W_Display, W_Screen));
|
|
|
526 }
|
|
|
527
|
|
|
528 /*
|
|
|
529 We assume white is 0 or 1, and black is 0 or 1. We adjust
|
|
|
530 graphics function based upon who is who.
|
|
|
531 */
|
|
|
532 if (white == 0) { /* Black is 1 */
|
|
|
533 XSetFunction(W_Display, colortable[i].contexts[BITGC], GXand);
|
|
|
534 }
|
|
|
535 }
|
|
|
536 } else if (DefaultVisual(W_Display, W_Screen)->class == TrueColor) {
|
|
|
537 /* Stuff added by sheldon@iastate.edu 5/28/93
|
|
|
538 * This is supposed to detect a TrueColor display, and then do a lookup of
|
|
|
539 * the colors in default colormap, instead of creating new colormap
|
|
|
540 */
|
|
|
541 for (i = 0; i < NCOLORS; i++) {
|
|
|
542 sprintf(defaultstring, "color.%s", colortable[i].name);
|
|
|
543
|
|
|
544 defaults = getdefault(defaultstring);
|
|
|
545 if (defaults == NULL)
|
|
|
546 defaults = colortable[i].name;
|
|
|
547 XParseColor(W_Display, W_Colormap, defaults, &foo);
|
|
|
548 XAllocColor(W_Display, W_Colormap, &foo);
|
|
|
549 colortable[i].pixelValue = foo.pixel;
|
|
|
550 colortable[i].pixmap = XCreatePixmapFromBitmapData(W_Display,
|
|
|
551 W_Root, (char *) solid, TILESIDE, TILESIDE, foo.pixel, foo.pixel,
|
|
|
552 DefaultDepth(W_Display, W_Screen));
|
|
|
553 }
|
|
|
554 } else {
|
|
|
555 #ifdef FOURPLANEFIX
|
|
|
556 if (!XAllocColorCells(W_Display, W_Colormap, False, planes, 3,
|
|
|
557 &pixel, 1)) {
|
|
|
558 /* couldn't allocate 3 planes, make a new colormap */
|
|
|
559 W_Colormap = XCreateColormap(W_Display, W_Root, W_Visual, AllocNone);
|
|
|
560 if (!XAllocColorCells(W_Display, W_Colormap, False, planes, 3,
|
|
|
561 &pixel, 1)) {
|
|
|
562 fprintf(stderr, "Cannot create new colormap\n");
|
|
|
563 EXIT(1);
|
|
|
564 }
|
|
|
565 /*
|
|
|
566 and fill it with at least 8 more colors so when mouse is
|
|
|
567 inside netrek windows, use might be able to see his other
|
|
|
568 windows
|
|
|
569 */
|
|
|
570 if (XAllocColorCells(W_Display, W_Colormap, False, NULL, 0,
|
|
|
571 extracolors, 8)) {
|
|
|
572 colordef.flags = DoRed | DoGreen | DoBlue;
|
|
|
573 for (i = 0; i < 8; i++) {
|
|
|
574 colordef.pixel = extracolors[i];
|
|
|
575 colordef.red = extrared[i] << 8;
|
|
|
576 colordef.green = extragreen[i] << 8;
|
|
|
577 colordef.blue = extrablue[i] << 8;
|
|
|
578 XStoreColor(W_Display, W_Colormap, &colordef);
|
|
|
579 }
|
|
|
580 }
|
|
|
581 }
|
|
|
582 #else
|
|
|
583 XAllocColorCells(W_Display, W_Colormap, False, planes, 3, &pixel, 1);
|
|
|
584 #endif
|
|
|
585 for (i = 0; i < NCOLORS; i++) {
|
|
|
586 /*
|
|
|
587 strcpy(defaultstring, "color.%s", colortable[i].name);
|
|
|
588 */
|
|
|
589 sprintf(defaultstring, "color.%s", colortable[i].name);
|
|
|
590
|
|
|
591 defaults = getdefault(defaultstring);
|
|
|
592 if (defaults == NULL)
|
|
|
593 defaults = colortable[i].name;
|
|
|
594 XParseColor(W_Display, W_Colormap, defaults, &foo);
|
|
|
595 /*
|
|
|
596 Black must be the color with all the planes off. That is the
|
|
|
597 only restriction I concerned myself with in the following case
|
|
|
598 statement.
|
|
|
599 */
|
|
|
600 switch (i) {
|
|
|
601 case WHITE:
|
|
|
602 foo.pixel = pixel | planes[0] | planes[1] | planes[2];
|
|
|
603 break;
|
|
|
604 case BLACK:
|
|
|
605 foo.pixel = pixel;
|
|
|
606 break;
|
|
|
607 case RED:
|
|
|
608 foo.pixel = pixel | planes[0];
|
|
|
609 break;
|
|
|
610 case CYAN:
|
|
|
611 foo.pixel = pixel | planes[1];
|
|
|
612 break;
|
|
|
613 case YELLOW:
|
|
|
614 foo.pixel = pixel | planes[2];
|
|
|
615 break;
|
|
|
616 case GREY:
|
|
|
617 foo.pixel = pixel | planes[0] | planes[1];
|
|
|
618 break;
|
|
|
619 case GREEN:
|
|
|
620 foo.pixel = pixel | planes[1] | planes[2];
|
|
|
621 break;
|
|
|
622 }
|
|
|
623 XStoreColor(W_Display, W_Colormap, &foo);
|
|
|
624 colortable[i].pixelValue = foo.pixel;
|
|
|
625 colortable[i].pixmap = XCreatePixmapFromBitmapData(W_Display,
|
|
|
626 W_Root, (char *) solid, TILESIDE, TILESIDE, foo.pixel, foo.pixel,
|
|
|
627 DefaultDepth(W_Display, W_Screen));
|
|
|
628 }
|
|
|
629 }
|
|
|
630 for (i = 0; i < NCOLORS; i++) {
|
|
|
631 for (j = 0; j < FONTS + 1; j++) {
|
|
|
632 XSetForeground(W_Display, colortable[i].contexts[j],
|
|
|
633 colortable[i].pixelValue);
|
|
|
634 XSetBackground(W_Display, colortable[i].contexts[j],
|
|
|
635 colortable[W_Black].pixelValue);
|
|
|
636 }
|
|
|
637 }
|
|
|
638 }
|
|
|
639
|
|
|
640 void
|
|
|
641 W_RenameWindow(window, str)
|
|
|
642 W_Window window;
|
|
|
643 char *str;
|
|
|
644 {
|
|
|
645 XStoreName(W_Display, ((struct window *) window)->window, str);
|
|
|
646 }
|
|
|
647
|
|
|
648 static W_Window
|
|
|
649 w_MakeWindow(name, x, y, width, height, parent,
|
|
|
650 cursname, border, color, wsort)
|
|
|
651 char *name;
|
|
|
652 int x, y, width, height;
|
|
|
653 W_Window parent;
|
|
|
654 char *cursname;
|
|
|
655 int border;
|
|
|
656 W_Color color;
|
|
|
657 int wsort; /* WIN_? */
|
|
|
658 {
|
|
|
659 int gx, gy;
|
|
|
660 struct window *newwin;
|
|
|
661 Window wparent;
|
|
|
662 Cursor cursor;
|
|
|
663 XSetWindowAttributes attrs;
|
|
|
664 int pwidth, pheight; /* pixel width and height */
|
|
|
665
|
|
|
666
|
|
|
667 checkGeometry(name, &gx, &gy, &width, &height);
|
|
|
668 if (gx != INVALID_POSITION)
|
|
|
669 x = gx;
|
|
|
670 if (gy != INVALID_POSITION)
|
|
|
671 y = gy;
|
|
|
672
|
|
|
673 checkParent(name, &parent);
|
|
|
674 wparent = W_Void2Window(parent)->window;
|
|
|
675
|
|
|
676 checkCursor(name, cursname, &cursor);
|
|
|
677 attrs.cursor = cursor;
|
|
|
678
|
|
|
679 attrs.border_pixel = colortable[color].pixelValue;
|
|
|
680 attrs.background_pixel = colortable[W_Black].pixelValue;
|
|
|
681
|
|
|
682 if (wsort == WIN_TEXT || wsort == WIN_SCROLL || wsort == WIN_MENU) {
|
|
|
683 pwidth = width * W_Textwidth + WIN_EDGE * 2;
|
|
|
684 if (wsort == WIN_MENU)
|
|
|
685 pheight = height * (W_Textheight + MENU_PAD * 2 + MENU_BAR) - MENU_BAR;
|
|
|
686 else
|
|
|
687 pheight = height * W_Textheight + MENU_PAD * 2;
|
|
|
688 } else {
|
|
|
689 pwidth = width;
|
|
|
690 pheight = height;
|
|
|
691 }
|
|
|
692
|
|
|
693 switch (wsort) {
|
|
|
694 case WIN_TEXT:
|
|
|
695 case WIN_MENU:
|
|
|
696 attrs.event_mask = KeyPressMask | ButtonPressMask | ExposureMask | ButtonReleaseMask;
|
|
|
697 attrs.do_not_propagate_mask = ExposureMask | KeyPressMask | ButtonPressMask;
|
|
|
698 break;
|
|
|
699 case WIN_GRAPH:
|
|
|
700 attrs.event_mask = KeyPressMask | ButtonPressMask | ExposureMask | LeaveWindowMask | ButtonReleaseMask | ButtonMotionMask;
|
|
|
701 attrs.do_not_propagate_mask = ExposureMask;
|
|
|
702 break;
|
|
|
703 case WIN_SCROLL:
|
|
|
704 attrs.event_mask = ResizeRedirectMask | ExposureMask | KeyPressMask | ButtonReleaseMask | ButtonPressMask;
|
|
|
705 attrs.do_not_propagate_mask = ResizeRedirectMask | ExposureMask;
|
|
|
706 break;
|
|
|
707 default:
|
|
|
708 fprintf(stderr, "x11window.c: w_MakeWindow: unknown wsort %d\n", wsort);
|
|
|
709 }
|
|
|
710
|
|
|
711 #ifdef AUTOKEY
|
|
|
712 if (attrs.event_mask & KeyPressMask)
|
|
|
713 attrs.event_mask |= KeyReleaseMask;
|
|
|
714 #endif /* AUTOKEY */
|
|
|
715
|
|
|
716 if (strcmp(name, "netrek_icon") == 0) /* icon should not select for
|
|
|
717 input */
|
|
|
718 attrs.event_mask = ExposureMask;
|
|
|
719 if (strcmp(name, "wait_icon") == 0) /* same here [BDyess] */
|
|
|
720 attrs.event_mask = ExposureMask;
|
|
|
721
|
|
|
722 if (strcmp(name, "info") == 0) /* make info window passthru [BDyess] */
|
|
|
723 attrs.event_mask = ExposureMask;
|
|
|
724
|
|
|
725 newwin = newWindow
|
|
|
726 (XCreateWindow(W_Display, wparent, x, y, pwidth, pheight, border,
|
|
|
727 CopyFromParent, InputOutput, CopyFromParent,
|
|
|
728 CWBackPixel | CWBorderPixel | CWEventMask |
|
|
|
729 (cursor ? CWCursor : 0),
|
|
|
730 &attrs),
|
|
|
731 wsort);
|
|
|
732
|
|
|
733 newwin->cursor = cursor;
|
|
|
734
|
|
|
735 {
|
|
|
736 char *s;
|
|
|
737
|
|
|
738 if (0 == strcmp(name, "wait"))
|
|
|
739 s = serverName;
|
|
|
740 else if (0 == strcmp(name, "Motd"))
|
|
|
741 s = "Motd - [f] forward, [b] back, [tab] sysdefs, [space] unmap";
|
|
|
742 else if (0 == strcmp(name, "netrek")) {
|
|
|
743 if (!title) {
|
|
|
744 char buf[80];
|
|
|
745 sprintf(buf, "Netrek @ %s", serverName);
|
|
|
746 s = buf;
|
|
|
747 } else {
|
|
|
748 /* but title on command line will override */
|
|
|
749 /* from -h arg */
|
|
|
750 s = title;
|
|
|
751 }
|
|
|
752 } else
|
|
|
753 s = name;
|
|
|
754
|
|
|
755 XStoreName(W_Display, newwin->window, s);
|
|
|
756 }
|
|
|
757
|
|
|
758 wm_size_hint.width = wm_size_hint.min_width =
|
|
|
759 wm_size_hint.max_width = wm_size_hint.base_width = pwidth;
|
|
|
760 wm_size_hint.min_height = wm_size_hint.height =
|
|
|
761 wm_size_hint.max_height = wm_size_hint.base_height = pheight;
|
|
|
762 wm_size_hint.flags = USSize | PMinSize | PMaxSize | PBaseSize;
|
|
|
763 if (gx > INVALID_POSITION || gy > INVALID_POSITION) {
|
|
|
764 wm_size_hint.flags |= USPosition;
|
|
|
765 wm_size_hint.x = x;
|
|
|
766 wm_size_hint.y = y;
|
|
|
767 }
|
|
|
768 XSetWMNormalHints(W_Display, newwin->window, &wm_size_hint);
|
|
|
769
|
|
|
770 class_hint.res_name = name;
|
|
|
771 class_hint.res_class = "Netrek";
|
|
|
772 XSetClassHint(W_Display, newwin->window, &class_hint);
|
|
|
773
|
|
|
774 XSetWMHints(W_Display, newwin->window, &wm_hint);
|
|
|
775
|
|
|
776 if (((wparent == W_Root &&
|
|
|
777 baseWin != NULL &&
|
|
|
778 strcmp(name, "wait") != 0)
|
|
|
779 || wsort == WIN_MENU) &&
|
|
|
780 strcmp(name, "MetaServer List") != 0 &&
|
|
|
781 strcmp(name, "Motd") != 0) {
|
|
|
782 XSetTransientForHint(W_Display, newwin->window,
|
|
|
783 W_Void2Window(baseWin)->window);
|
|
|
784 }
|
|
|
785 newwin->name = strdup(name);
|
|
|
786 newwin->width = width;
|
|
|
787 newwin->height = height;
|
|
|
788 if (wsort == WIN_MENU) {
|
|
|
789 int i;
|
|
|
790 struct menuItem *items;
|
|
|
791 items = (struct menuItem *) malloc(height * sizeof(struct menuItem));
|
|
|
792 for (i = 0; i < height; i++) {
|
|
|
793 items[i].string = NULL;
|
|
|
794 items[i].color = W_White;
|
|
|
795 items[i].font = W_RegularFont;
|
|
|
796 }
|
|
|
797 newwin->data = (char *) items;
|
|
|
798 } else {
|
|
|
799 newwin->data = 0;
|
|
|
800 }
|
|
|
801
|
|
|
802 if (wparent != W_Root)
|
|
|
803 if (checkMapped(name))
|
|
|
804 W_MapWindow(W_Window2Void(newwin));
|
|
|
805
|
|
|
806 #ifdef DEBUG
|
|
|
807 printf("New graphics window %d, child of %d\n", newwin, parent);
|
|
|
808 #endif
|
|
|
809
|
|
|
810 #ifdef FOURPLANEFIX
|
|
|
811 XSetWindowColormap(W_Display, newwin->window, W_Colormap);
|
|
|
812 #endif
|
|
|
813
|
|
|
814 return (W_Window2Void(newwin));
|
|
|
815 }
|
|
|
816
|
|
|
817
|
|
|
818
|
|
|
819
|
|
|
820 W_Window
|
|
|
821 W_MakeWindow(name, x, y, width, height, parent, cursname, border, color)
|
|
|
822 char *name;
|
|
|
823 int x, y, width, height;
|
|
|
824 W_Window parent;
|
|
|
825 char *cursname;
|
|
|
826 int border;
|
|
|
827 W_Color color;
|
|
|
828 {
|
|
|
829 return w_MakeWindow(name, x, y, width, height, parent,
|
|
|
830 cursname, border, color, WIN_GRAPH);
|
|
|
831 }
|
|
|
832
|
|
|
833 void
|
|
|
834 W_ChangeBorder(window, color)
|
|
|
835 W_Window window;
|
|
|
836 int color;
|
|
|
837 {
|
|
|
838 #ifdef DEBUG
|
|
|
839 printf("Changing border of %d\n", window);
|
|
|
840 #endif
|
|
|
841
|
|
|
842 /* fix inexplicable color bug */
|
|
|
843 if (DisplayCells(W_Display, W_Screen) <= 2)
|
|
|
844 XSetWindowBorderPixmap(W_Display, W_Void2Window(window)->window,
|
|
|
845 colortable[color].pixmap);
|
|
|
846 else
|
|
|
847 XSetWindowBorder(W_Display, W_Void2Window(window)->window,
|
|
|
848 colortable[color].pixelValue);
|
|
|
849 }
|
|
|
850
|
|
|
851 void
|
|
|
852 W_MapWindow(window)
|
|
|
853 W_Window window;
|
|
|
854 {
|
|
|
855 struct window *win;
|
|
|
856
|
|
|
857 #ifdef DEBUG
|
|
|
858 printf("Mapping %d\n", window);
|
|
|
859 #endif
|
|
|
860 win = W_Void2Window(window);
|
|
|
861 if (win->mapped)
|
|
|
862 return;
|
|
|
863 win->mapped = 1;
|
|
|
864 XMapRaised(W_Display, win->window);
|
|
|
865 }
|
|
|
866
|
|
|
867 void
|
|
|
868 W_UnmapWindow(window)
|
|
|
869 W_Window window;
|
|
|
870 {
|
|
|
871 struct window *win;
|
|
|
872
|
|
|
873 #ifdef DEBUG
|
|
|
874 printf("UnMapping %d\n", window);
|
|
|
875 #endif
|
|
|
876 win = W_Void2Window(window);
|
|
|
877 if (win->mapped == 0)
|
|
|
878 return;
|
|
|
879 win->mapped = 0;
|
|
|
880 XUnmapWindow(W_Display, win->window);
|
|
|
881 }
|
|
|
882
|
|
|
883 int
|
|
|
884 W_IsMapped(window)
|
|
|
885 W_Window window;
|
|
|
886 {
|
|
|
887 struct window *win;
|
|
|
888
|
|
|
889 win = W_Void2Window(window);
|
|
|
890 if (win == NULL)
|
|
|
891 return (0);
|
|
|
892 return (win->mapped);
|
|
|
893 }
|
|
|
894
|
|
|
895 void
|
|
|
896 W_FillArea(window, x, y, width, height, color)
|
|
|
897 W_Window window;
|
|
|
898 int x, y, width, height;
|
|
|
899 W_Color color;
|
|
|
900 {
|
|
|
901 struct window *win;
|
|
|
902
|
|
|
903 #ifdef DEBUG
|
|
|
904 printf("Clearing (%d %d) x (%d %d) with %d on %d\n", x, y, width, height,
|
|
|
905 color, window);
|
|
|
906 #endif
|
|
|
907 win = W_Void2Window(window);
|
|
|
908 switch (win->type) {
|
|
|
909 case WIN_GRAPH:
|
|
|
910 XFillRectangle(W_Display, win->window, colortable[color].contexts[0],
|
|
|
911 x, y, width, height);
|
|
|
912 break;
|
|
|
913 default:
|
|
|
914 XFillRectangle(W_Display, win->window, colortable[color].contexts[0],
|
|
|
915 WIN_EDGE + x * W_Textwidth, MENU_PAD + y * W_Textheight,
|
|
|
916 width * W_Textwidth, height * W_Textheight);
|
|
|
917 }
|
|
|
918 }
|
|
|
919
|
|
|
920 /* XFIX */
|
|
|
921
|
|
|
922 static XRectangle _rcache[MAXCACHE];
|
|
|
923 static int _rcache_index;
|
|
|
924
|
|
|
925 static void
|
|
|
926 FlushClearAreaCache(win)
|
|
|
927 Window win;
|
|
|
928 {
|
|
|
929 XFillRectangles(W_Display, win, colortable[backColor].contexts[0],
|
|
|
930 _rcache, _rcache_index);
|
|
|
931 _rcache_index = 0;
|
|
|
932 }
|
|
|
933
|
|
|
934 /* local window only */
|
|
|
935 void
|
|
|
936 W_CacheClearArea(window, x, y, width, height)
|
|
|
937 W_Window window;
|
|
|
938 int x, y, width, height;
|
|
|
939 {
|
|
|
940 Window win = W_Void2Window(window)->window;
|
|
|
941 register XRectangle *r;
|
|
|
942
|
|
|
943 if (_rcache_index == MAXCACHE)
|
|
|
944 FlushClearAreaCache(win);
|
|
|
945
|
|
|
946 r = &_rcache[_rcache_index++];
|
|
|
947 r->x = (short) x;
|
|
|
948 r->y = (short) y;
|
|
|
949 r->width = (unsigned short) width;
|
|
|
950 r->height = (unsigned short) height;
|
|
|
951 }
|
|
|
952
|
|
|
953 void
|
|
|
954 W_FlushClearAreaCache(window)
|
|
|
955 W_Window window;
|
|
|
956 {
|
|
|
957 Window win = W_Void2Window(window)->window;
|
|
|
958
|
|
|
959 if (_rcache_index)
|
|
|
960 FlushClearAreaCache(win);
|
|
|
961 }
|
|
|
962
|
|
|
963 /* XFIX: clears now instead of filling. */
|
|
|
964 void
|
|
|
965 W_ClearArea(window, x, y, width, height)
|
|
|
966 W_Window window;
|
|
|
967 int x, y, width, height;
|
|
|
968 {
|
|
|
969 struct window *win;
|
|
|
970
|
|
|
971 #ifdef DEBUG
|
|
|
972 printf("Clearing (%d %d) x (%d %d) with %d on %d\n", x, y, width, height,
|
|
|
973 color, window);
|
|
|
974 #endif
|
|
|
975 win = W_Void2Window(window);
|
|
|
976 switch (win->type) {
|
|
|
977 case WIN_GRAPH:
|
|
|
978 /* XFIX: changed */
|
|
|
979 XClearArea(W_Display, win->window, x, y, width, height, False);
|
|
|
980 break;
|
|
|
981 default:
|
|
|
982 /* XFIX: changed */
|
|
|
983 XClearArea(W_Display, win->window, WIN_EDGE + x * W_Textwidth,
|
|
|
984 MENU_PAD + y * W_Textheight, width * W_Textwidth, height * W_Textheight, False);
|
|
|
985 break;
|
|
|
986 }
|
|
|
987 }
|
|
|
988
|
|
|
989 void
|
|
|
990 W_ClearWindow(window)
|
|
|
991 W_Window window;
|
|
|
992 {
|
|
|
993 #ifdef DEBUG
|
|
|
994 printf("Clearing %d\n", window);
|
|
|
995 #endif
|
|
|
996 XClearWindow(W_Display, W_Void2Window(window)->window);
|
|
|
997 }
|
|
|
998
|
|
|
999 void
|
|
|
1000 W_GetEvent(wevent)
|
|
|
1001 W_Event *wevent;
|
|
|
1002 {
|
|
|
1003 /* blocks until an event is received [BDyess] */
|
|
|
1004 XEvent event;
|
|
|
1005
|
|
|
1006 if (W_isEvent) {
|
|
|
1007 *wevent = W_myevent;
|
|
|
1008 W_isEvent = 0;
|
|
|
1009 return;
|
|
|
1010 }
|
|
|
1011 XNextEvent(W_Display, &event);
|
|
|
1012 XPutBackEvent(W_Display, &event);
|
|
|
1013 W_SpNextEvent(wevent);
|
|
|
1014 }
|
|
|
1015
|
|
|
1016 int
|
|
|
1017 W_EventsPending()
|
|
|
1018 {
|
|
|
1019 if (W_isEvent)
|
|
|
1020 return (1);
|
|
|
1021 while (XPending(W_Display) || buttonDown) {
|
|
|
1022 if (W_SpNextEvent(&W_myevent)) {
|
|
|
1023 W_isEvent = 1;
|
|
|
1024 return (1);
|
|
|
1025 }
|
|
|
1026 }
|
|
|
1027 return (0);
|
|
|
1028 }
|
|
|
1029
|
|
|
1030 void
|
|
|
1031 W_NextEvent(wevent)
|
|
|
1032 W_Event *wevent;
|
|
|
1033 {
|
|
|
1034 if (W_isEvent) {
|
|
|
1035 *wevent = W_myevent;
|
|
|
1036 W_isEvent = 0;
|
|
|
1037 return;
|
|
|
1038 }
|
|
|
1039 while (W_SpNextEvent(wevent) == 0);
|
|
|
1040 }
|
|
|
1041
|
|
|
1042 static int
|
|
|
1043 W_SpNextEvent(wevent)
|
|
|
1044 W_Event *wevent;
|
|
|
1045 {
|
|
|
1046 XEvent event;
|
|
|
1047 XKeyEvent *key;
|
|
|
1048 XButtonEvent *button;
|
|
|
1049 XExposeEvent *expose;
|
|
|
1050 XResizeRequestEvent *resize;
|
|
|
1051 char ch;
|
|
|
1052 struct window *win;
|
|
|
1053 #ifdef CONTINUOUS_MOUSE
|
|
|
1054 static W_Event buttonEvent;
|
|
|
1055 static int delay, cupd = -1;
|
|
|
1056 #endif /* CONTINUOUS_MOUSE */
|
|
|
1057
|
|
|
1058 #ifdef DEBUG
|
|
|
1059 printf("Getting an event...\n");
|
|
|
1060 #endif
|
|
|
1061 key = (XKeyEvent *) & event;
|
|
|
1062 button = (XButtonEvent *) & event;
|
|
|
1063 expose = (XExposeEvent *) & event;
|
|
|
1064 resize = (XResizeRequestEvent *) & event;
|
|
|
1065 for (;;) {
|
|
|
1066 if (XPending(W_Display))
|
|
|
1067 XNextEvent(W_Display, &event);
|
|
|
1068 #ifdef CONTINUOUS_MOUSE
|
|
|
1069 else if (buttonDown) {
|
|
|
1070 if (continuousMouse && allowContinuousMouse) {
|
|
|
1071 if (cupd != udcounter) {
|
|
|
1072 cupd = udcounter;
|
|
|
1073 if (delay == 0) {
|
|
|
1074 bcopy(&buttonEvent, wevent, sizeof(W_Event));
|
|
|
1075 delay = clickDelay;
|
|
|
1076 } else {
|
|
|
1077 delay--;
|
|
|
1078 wevent->type = -1;
|
|
|
1079 }
|
|
|
1080 } else
|
|
|
1081 wevent->type = -1;
|
|
|
1082 exitInputLoop = 1;
|
|
|
1083 } else {
|
|
|
1084 wevent->type = -1;
|
|
|
1085 buttonDown = 0;
|
|
|
1086 }
|
|
|
1087 return (1);
|
|
|
1088 }
|
|
|
1089 #endif
|
|
|
1090 else
|
|
|
1091 return (0);
|
|
|
1092 /*
|
|
|
1093 printf("read an event %d\n", event.type);
|
|
|
1094 */
|
|
|
1095 win = findWindow(key->window);
|
|
|
1096 if (win == NULL)
|
|
|
1097 return (0);
|
|
|
1098 if ((event.type == KeyPress || event.type == ButtonPress) &&
|
|
|
1099 win->type == WIN_MENU) {
|
|
|
1100 if (key->y % (W_Textheight + MENU_PAD * 2 + MENU_BAR) >=
|
|
|
1101 W_Textheight + MENU_PAD * 2)
|
|
|
1102 return (0);
|
|
|
1103 key->y = key->y / (W_Textheight + MENU_PAD * 2 + MENU_BAR);
|
|
|
1104 }
|
|
|
1105 switch ((int) event.type) {
|
|
|
1106 case LeaveNotify: /* for message window -- jfy */
|
|
|
1107 if (win == (struct window *) messagew) {
|
|
|
1108 W_in_message = 0;
|
|
|
1109 }
|
|
|
1110 return (0);
|
|
|
1111 break;
|
|
|
1112 case KeyPress:
|
|
|
1113 if (key->state & ControlMask) {
|
|
|
1114 controlkey = 1;
|
|
|
1115 key->state &= ~ControlMask;
|
|
|
1116 } else
|
|
|
1117 controlkey = 0;
|
|
|
1118 if (key->state & BillsScrewyAltMask) {
|
|
|
1119 altkey = 1;
|
|
|
1120 key->state &= ~BillsScrewyAltMask;
|
|
|
1121 } else
|
|
|
1122 altkey = 0;
|
|
|
1123 if (XLookupString(key, &ch, 1, NULL, NULL) > 0) {
|
|
|
1124 wevent->type = W_EV_KEY;
|
|
|
1125 wevent->Window = W_Window2Void(win);
|
|
|
1126 wevent->x = key->x;
|
|
|
1127 wevent->y = key->y;
|
|
|
1128 if (controlkey)
|
|
|
1129 wevent->key = (int) ch + 128;
|
|
|
1130 else if (altkey)
|
|
|
1131 wevent->key = (int) ch + 256;
|
|
|
1132 else
|
|
|
1133 wevent->key = ch;
|
|
|
1134 return (1);
|
|
|
1135 }
|
|
|
1136 return (0);
|
|
|
1137 break;
|
|
|
1138 #ifdef AUTOKEY
|
|
|
1139 case KeyRelease:
|
|
|
1140 if (XLookupString(key, &ch, 1, NULL, NULL) > 0) {
|
|
|
1141 wevent->type = W_EV_KEY_OFF;
|
|
|
1142 wevent->Window = W_Window2Void(win);
|
|
|
1143 wevent->x = key->x;
|
|
|
1144 wevent->y = key->y;
|
|
|
1145 wevent->key = ch;
|
|
|
1146 return (1);
|
|
|
1147 }
|
|
|
1148 return (0);
|
|
|
1149 break;
|
|
|
1150 #endif /* AUTOKEY */
|
|
|
1151 case ButtonPress:
|
|
|
1152 wevent->type = W_EV_BUTTON;
|
|
|
1153 wevent->Window = W_Window2Void(win);
|
|
|
1154 wevent->x = button->x;
|
|
|
1155 wevent->y = button->y;
|
|
|
1156 switch (button->button & 0xf) {
|
|
|
1157 case Button3:
|
|
|
1158 wevent->key = W_RBUTTON;
|
|
|
1159 break;
|
|
|
1160 case Button1:
|
|
|
1161 wevent->key = W_LBUTTON;
|
|
|
1162 break;
|
|
|
1163 case Button2:
|
|
|
1164 wevent->key = W_MBUTTON;
|
|
|
1165 break;
|
|
|
1166 }
|
|
|
1167 if (key->state & ControlMask)
|
|
|
1168 wevent->key += 6;
|
|
|
1169 if (key->state & ShiftMask)
|
|
|
1170 wevent->key += 3;
|
|
|
1171 if (key->state & BillsScrewyAltMask)
|
|
|
1172 wevent->key += 12; /* alt */
|
|
|
1173 #ifdef CONTINUOUS_MOUSE
|
|
|
1174 if (continuousMouse && allowContinuousMouse &&
|
|
|
1175 (wevent->Window == w || wevent->Window == mapw) &&
|
|
|
1176 /*
|
|
|
1177 buttonRepeatMask allows only certain buttons to repeat
|
|
|
1178 [BDyess]
|
|
|
1179 */
|
|
|
1180 (1 << (wevent->key) & buttonRepeatMask)) {
|
|
|
1181 buttonDown = 1;
|
|
|
1182 exitInputLoop = 1;
|
|
|
1183 delay = clickDelay;
|
|
|
1184 bcopy(wevent, &buttonEvent, sizeof(W_Event));
|
|
|
1185 }
|
|
|
1186 return (1);
|
|
|
1187 case ButtonRelease:
|
|
|
1188 /* bcopy(&buttonEvent,wevent,sizeof(W_Event)); */
|
|
|
1189 wevent->type = -1;
|
|
|
1190 buttonDown = 0;
|
|
|
1191 return (1);
|
|
|
1192 case MotionNotify:
|
|
|
1193 /*
|
|
|
1194 the !buttonDown ensures that if you press a button and then
|
|
|
1195 press another, release just the second, and then move the
|
|
|
1196 mouse that nothing happens.
|
|
|
1197 */
|
|
|
1198 if (!(continuousMouse && allowContinuousMouse) || !buttonDown) {
|
|
|
1199 wevent->type = -1;
|
|
|
1200 return (1);
|
|
|
1201 }
|
|
|
1202 wevent->type = W_EV_BUTTON;
|
|
|
1203 wevent->Window = W_Window2Void(win);
|
|
|
1204 wevent->x = button->x;
|
|
|
1205 wevent->y = button->y;
|
|
|
1206 wevent->key = buttonEvent.key;
|
|
|
1207 bcopy(wevent, &buttonEvent, sizeof(W_Event));
|
|
|
1208 if (cupd == udcounter)
|
|
|
1209 wevent->type = -1;
|
|
|
1210 else
|
|
|
1211 cupd = udcounter;
|
|
|
1212
|
|
|
1213 return (1);
|
|
|
1214 #else
|
|
|
1215 return (1);
|
|
|
1216 #endif /* CONTINUOUS_MOUSE */
|
|
|
1217 case Expose:
|
|
|
1218 if (expose->count != 0)
|
|
|
1219 return (0);
|
|
|
1220 if (win->type == WIN_SCROLL) {
|
|
|
1221 redrawScrolling(win);
|
|
|
1222 return (0);
|
|
|
1223 }
|
|
|
1224 if (win->type == WIN_MENU) {
|
|
|
1225 redrawMenu(win);
|
|
|
1226 return (0);
|
|
|
1227 }
|
|
|
1228 wevent->type = W_EV_EXPOSE;
|
|
|
1229 wevent->Window = W_Window2Void(win);
|
|
|
1230 return (1);
|
|
|
1231 case ResizeRequest:
|
|
|
1232 resizeScrolling(win, resize->width, resize->height);
|
|
|
1233 break;
|
|
|
1234 default:
|
|
|
1235 return (0);
|
|
|
1236 break;
|
|
|
1237 }
|
|
|
1238 }
|
|
|
1239 }
|
|
|
1240
|
|
|
1241 void
|
|
|
1242 W_MakeLine(window, x0, y0, x1, y1, color)
|
|
|
1243 W_Window window;
|
|
|
1244 int x0, y0, x1, y1;
|
|
|
1245 W_Color color;
|
|
|
1246 {
|
|
|
1247 Window win;
|
|
|
1248
|
|
|
1249 #ifdef DEBUG
|
|
|
1250 printf("Line on %d\n", window);
|
|
|
1251 #endif
|
|
|
1252 win = W_Void2Window(window)->window;
|
|
|
1253 XDrawLine(W_Display, win, colortable[color].contexts[0], x0, y0, x1, y1);
|
|
|
1254 }
|
|
|
1255
|
|
|
1256 void
|
|
|
1257 W_DrawPoint(window, x, y, color)
|
|
|
1258 W_Window window;
|
|
|
1259 int x, y;
|
|
|
1260 W_Color color;
|
|
|
1261 {
|
|
|
1262 Window win;
|
|
|
1263
|
|
|
1264 #ifdef DEBUG
|
|
|
1265 printf("Point on %d\n", window);
|
|
|
1266 #endif
|
|
|
1267 win = W_Void2Window(window)->window;
|
|
|
1268 XDrawPoint(W_Display, win, colortable[color].contexts[0], x, y);
|
|
|
1269 }
|
|
|
1270
|
|
|
1271 /* XFIX */
|
|
|
1272
|
|
|
1273 static XSegment _lcache[NCOLORS][MAXCACHE];
|
|
|
1274 static int _lcache_index[NCOLORS];
|
|
|
1275
|
|
|
1276 static void
|
|
|
1277 FlushLineCache(win, color)
|
|
|
1278 Window win;
|
|
|
1279 int color;
|
|
|
1280 {
|
|
|
1281 XDrawSegments(W_Display, win, colortable[color].contexts[0],
|
|
|
1282 _lcache[color], _lcache_index[color]);
|
|
|
1283 _lcache_index[color] = 0;
|
|
|
1284 }
|
|
|
1285
|
|
|
1286 /* for local window only */
|
|
|
1287 void
|
|
|
1288 W_CacheLine(window, x0, y0, x1, y1, color)
|
|
|
1289 W_Window window;
|
|
|
1290 int x0, y0, x1, y1, color;
|
|
|
1291 {
|
|
|
1292 Window win = W_Void2Window(window)->window;
|
|
|
1293 register XSegment *s;
|
|
|
1294
|
|
|
1295 if (_lcache_index[color] == MAXCACHE)
|
|
|
1296 FlushLineCache(win, color);
|
|
|
1297
|
|
|
1298 s = &_lcache[color][_lcache_index[color]++];
|
|
|
1299 s->x1 = (short) x0;
|
|
|
1300 s->y1 = (short) y0;
|
|
|
1301 s->x2 = (short) x1;
|
|
|
1302 s->y2 = (short) y1;
|
|
|
1303 }
|
|
|
1304
|
|
|
1305 void
|
|
|
1306 W_FlushLineCaches(window)
|
|
|
1307 W_Window window;
|
|
|
1308 {
|
|
|
1309 Window win = W_Void2Window(window)->window;
|
|
|
1310 register i;
|
|
|
1311 for (i = 0; i < NCOLORS; i++) {
|
|
|
1312 if (_lcache_index[i])
|
|
|
1313 FlushLineCache(win, i);
|
|
|
1314 }
|
|
|
1315 }
|
|
|
1316
|
|
|
1317 static XPoint _pcache[NCOLORS][MAXCACHE];
|
|
|
1318 static int _pcache_index[NCOLORS];
|
|
|
1319
|
|
|
1320 static void
|
|
|
1321 FlushPointCache(win, color)
|
|
|
1322 Window win;
|
|
|
1323 int color;
|
|
|
1324 {
|
|
|
1325 XDrawPoints(W_Display, win, colortable[color].contexts[0],
|
|
|
1326 _pcache[color], _pcache_index[color], CoordModeOrigin);
|
|
|
1327 _pcache_index[color] = 0;
|
|
|
1328 }
|
|
|
1329
|
|
|
1330 void
|
|
|
1331 W_CachePoint(window, x, y, color)
|
|
|
1332 W_Window window;
|
|
|
1333 int x, y, color;
|
|
|
1334 {
|
|
|
1335 Window win = W_Void2Window(window)->window;
|
|
|
1336 register XPoint *p;
|
|
|
1337
|
|
|
1338 if (_pcache_index[color] == MAXCACHE)
|
|
|
1339 FlushPointCache(win, color);
|
|
|
1340
|
|
|
1341 p = &_pcache[color][_pcache_index[color]++];
|
|
|
1342 p->x = (short) x;
|
|
|
1343 p->y = (short) y;
|
|
|
1344 }
|
|
|
1345
|
|
|
1346 void
|
|
|
1347 W_FlushPointCaches(window)
|
|
|
1348 W_Window window;
|
|
|
1349 {
|
|
|
1350 Window win = W_Void2Window(window)->window;
|
|
|
1351 register i;
|
|
|
1352 for (i = 0; i < NCOLORS; i++) {
|
|
|
1353 if (_pcache_index[i])
|
|
|
1354 FlushPointCache(win, i);
|
|
|
1355 }
|
|
|
1356 }
|
|
|
1357
|
|
|
1358 void
|
|
|
1359 W_MakeTractLine(window, x0, y0, x1, y1, color)
|
|
|
1360 W_Window window;
|
|
|
1361 int x0, y0, x1, y1;
|
|
|
1362 W_Color color;
|
|
|
1363 {
|
|
|
1364 Window win;
|
|
|
1365
|
|
|
1366 #ifdef DEBUG
|
|
|
1367 printf("Line on %d\n", window);
|
|
|
1368 #endif
|
|
|
1369 win = W_Void2Window(window)->window;
|
|
|
1370 XDrawLine(W_Display, win, colortable[color].contexts[3], x0, y0, x1, y1);
|
|
|
1371 }
|
|
|
1372
|
|
|
1373 void
|
|
|
1374 W_DrawSectorHighlight(window, x, y, w, h, color)
|
|
|
1375 W_Window window;
|
|
|
1376 int x, y, w, h;
|
|
|
1377 W_Color color;
|
|
|
1378 {
|
|
|
1379 Window win;
|
|
|
1380 #ifdef YUCK
|
|
|
1381 XRectangle r[2];
|
|
|
1382
|
|
|
1383 r[0].x = (short) x;
|
|
|
1384 r[0].y = (short) y;
|
|
|
1385 r[0].width = (unsigned short) w;
|
|
|
1386 r[0].height = (unsigned short) h;
|
|
|
1387 r[1].x = (short) x + 2;
|
|
|
1388 r[1].y = (short) y + 2;
|
|
|
1389 r[1].width = (unsigned short) w - 4;
|
|
|
1390 r[1].height = (unsigned short) h - 4;
|
|
|
1391
|
|
|
1392 win = W_Void2Window(window)->window;
|
|
|
1393 XDrawRectangles(W_Display, win, colortable[color].contexts[3],
|
|
|
1394 r, 2);
|
|
|
1395 #else
|
|
|
1396 XRectangle r[1];
|
|
|
1397
|
|
|
1398 r[0].x = (short) x + 2;
|
|
|
1399 r[0].y = (short) y + 2;
|
|
|
1400 r[0].width = (unsigned short) w - 4;
|
|
|
1401 r[0].height = (unsigned short) h - 4;
|
|
|
1402
|
|
|
1403 win = W_Void2Window(window)->window;
|
|
|
1404 XDrawRectangles(W_Display, win, colortable[color].contexts[3],
|
|
|
1405 r, 1);
|
|
|
1406 #endif
|
|
|
1407 }
|
|
|
1408
|
|
|
1409 void
|
|
|
1410 W_WriteTriangle(window, x, y, s, t, color)
|
|
|
1411 W_Window window;
|
|
|
1412 int x, y, s;
|
|
|
1413 int t;
|
|
|
1414 W_Color color;
|
|
|
1415 {
|
|
|
1416 struct window *win = W_Void2Window(window);
|
|
|
1417 XPoint points[3];
|
|
|
1418
|
|
|
1419 if (t == 0) {
|
|
|
1420 points[0].x = x;
|
|
|
1421 points[0].y = y;
|
|
|
1422 points[1].x = x + s;
|
|
|
1423 points[1].y = y - s;
|
|
|
1424 points[2].x = x - s;
|
|
|
1425 points[2].y = y - s;
|
|
|
1426 } else {
|
|
|
1427 points[0].x = x;
|
|
|
1428 points[0].y = y;
|
|
|
1429 points[1].x = x + s;
|
|
|
1430 points[1].y = y + s;
|
|
|
1431 points[2].x = x - s;
|
|
|
1432 points[2].y = y + s;
|
|
|
1433 }
|
|
|
1434
|
|
|
1435
|
|
|
1436 XFillPolygon(W_Display, win->window, colortable[color].contexts[0],
|
|
|
1437 points, 3, Convex, CoordModeOrigin);
|
|
|
1438 }
|
|
|
1439
|
|
|
1440 void
|
|
|
1441 W_WriteText(window, x, y, color, str, len, font)
|
|
|
1442 W_Window window;
|
|
|
1443 int x, y, len;
|
|
|
1444 W_Color color;
|
|
|
1445 W_Font font;
|
|
|
1446 char *str;
|
|
|
1447 {
|
|
|
1448 struct window *win;
|
|
|
1449 int addr;
|
|
|
1450
|
|
|
1451 if (!font)
|
|
|
1452 font = W_RegularFont;
|
|
|
1453 #ifdef DEBUG
|
|
|
1454 printf("Text for %d @ (%d, %d) in %d: [%s]\n", window, x, y, color, str);
|
|
|
1455 #endif
|
|
|
1456 win = W_Void2Window(window);
|
|
|
1457 switch (win->type) {
|
|
|
1458 case WIN_GRAPH:
|
|
|
1459 addr = fonts[fontNum(font)].baseline;
|
|
|
1460 XDrawImageString(W_Display, win->window,
|
|
|
1461 colortable[color].contexts[fontNum(font)], x, y + addr, str, len);
|
|
|
1462 break;
|
|
|
1463 case WIN_SCROLL:
|
|
|
1464 if (y<0) {
|
|
|
1465 XCopyArea(W_Display, win->window, win->window,
|
|
|
1466
|
|
|
1467 colortable[W_White].contexts[0], WIN_EDGE, MENU_PAD,
|
|
|
1468 win->width * W_Textwidth, (win->height - 1) * W_Textheight,
|
|
|
1469 WIN_EDGE, MENU_PAD+W_Textheight);
|
|
|
1470 XClearArea(W_Display, win->window,
|
|
|
1471 WIN_EDGE, MENU_PAD,
|
|
|
1472 W_Textwidth * win->width, W_Textheight, False);
|
|
|
1473 XDrawImageString(W_Display, win->window,
|
|
|
1474 colortable[color].contexts[1],
|
|
|
1475 WIN_EDGE, MENU_PAD + fonts[1].baseline,
|
|
|
1476 str, len);
|
|
|
1477 } else {
|
|
|
1478 XCopyArea(W_Display, win->window, win->window,
|
|
|
1479 colortable[W_White].contexts[0], WIN_EDGE, MENU_PAD + W_Textheight,
|
|
|
1480 win->width * W_Textwidth, (win->height - 1) * W_Textheight,
|
|
|
1481 WIN_EDGE, MENU_PAD);
|
|
|
1482 XClearArea(W_Display, win->window,
|
|
|
1483 WIN_EDGE, MENU_PAD + W_Textheight * (win->height - 1),
|
|
|
1484 W_Textwidth * win->width, W_Textheight, False);
|
|
|
1485 XDrawImageString(W_Display, win->window,
|
|
|
1486 colortable[color].contexts[1],
|
|
|
1487 WIN_EDGE, MENU_PAD + W_Textheight * (win->height - 1) + fonts[1].baseline,
|
|
|
1488 str, len);
|
|
|
1489 }
|
|
|
1490 AddToScrolling(win, color, str, len);
|
|
|
1491 break;
|
|
|
1492 case WIN_MENU:
|
|
|
1493 changeMenuItem(win, y, color, str, len, font);
|
|
|
1494 break;
|
|
|
1495 default:
|
|
|
1496 addr = fonts[fontNum(font)].baseline;
|
|
|
1497 XDrawImageString(W_Display, win->window,
|
|
|
1498 colortable[color].contexts[fontNum(font)],
|
|
|
1499 x * W_Textwidth + WIN_EDGE, MENU_PAD + y * W_Textheight + addr,
|
|
|
1500 str, len);
|
|
|
1501 break;
|
|
|
1502 }
|
|
|
1503 }
|
|
|
1504
|
|
|
1505 void
|
|
|
1506 W_MaskText(window, x, y, color, str, len, font)
|
|
|
1507 W_Window window;
|
|
|
1508 int x, y, len;
|
|
|
1509 W_Color color;
|
|
|
1510 W_Font font;
|
|
|
1511 char *str;
|
|
|
1512 {
|
|
|
1513 struct window *win;
|
|
|
1514 int addr;
|
|
|
1515
|
|
|
1516 addr = fonts[fontNum(font)].baseline;
|
|
|
1517 #ifdef DEBUG
|
|
|
1518 printf("TextMask for %d @ (%d, %d) in %d: [%s]\n", window, x, y, color, str);
|
|
|
1519 #endif
|
|
|
1520 win = W_Void2Window(window);
|
|
|
1521 XDrawString(W_Display, win->window,
|
|
|
1522 colortable[color].contexts[fontNum(font)], x, y + addr, str, len);
|
|
|
1523 }
|
|
|
1524
|
|
|
1525 W_Icon
|
|
|
1526 W_StoreBitmap(width, height, data, window)
|
|
|
1527 int width, height;
|
|
|
1528 W_Window window;
|
|
|
1529 char *data;
|
|
|
1530 {
|
|
|
1531 struct icon *newicon;
|
|
|
1532 struct window *win;
|
|
|
1533
|
|
|
1534 #ifdef DEBUG
|
|
|
1535 printf("Storing bitmap for %d (%d x %d)\n", window, width, height);
|
|
|
1536 fflush(stdout);
|
|
|
1537 #endif
|
|
|
1538 win = W_Void2Window(window);
|
|
|
1539 newicon = (struct icon *) malloc(sizeof(struct icon));
|
|
|
1540 newicon->width = width;
|
|
|
1541 newicon->height = height;
|
|
|
1542 newicon->bitmap = XCreateBitmapFromData(W_Display, win->window,
|
|
|
1543 data, width, height);
|
|
|
1544 newicon->window = win->window;
|
|
|
1545 newicon->pixmap = 0;
|
|
|
1546 return (W_Icon2Void(newicon));
|
|
|
1547 }
|
|
|
1548
|
|
|
1549 void
|
|
|
1550 W_FreeBitmap(bit)
|
|
|
1551 W_Icon bit;
|
|
|
1552 {
|
|
|
1553 struct icon *icon;
|
|
|
1554 icon = W_Void2Icon(bit);
|
|
|
1555 XFreePixmap(W_Display, icon->bitmap);
|
|
|
1556 free(icon);
|
|
|
1557 }
|
|
|
1558
|
|
|
1559 void
|
|
|
1560 W_WriteBitmap(x, y, bit, color)
|
|
|
1561 int x, y;
|
|
|
1562 W_Icon bit;
|
|
|
1563 W_Color color;
|
|
|
1564 {
|
|
|
1565 struct icon *icon;
|
|
|
1566
|
|
|
1567 icon = W_Void2Icon(bit);
|
|
|
1568 #ifdef DEBUG
|
|
|
1569 printf("Writing bitmap to %d\n", icon->window);
|
|
|
1570 #endif
|
|
|
1571
|
|
|
1572 XCopyPlane(W_Display, icon->bitmap, icon->window,
|
|
|
1573 colortable[color].contexts[BITGC], 0, 0, icon->width, icon->height,
|
|
|
1574 x, y, 1);
|
|
|
1575
|
|
|
1576 }
|
|
|
1577
|
|
|
1578 void
|
|
|
1579 W_WriteWinBitmap(win, x, y, bit, color)
|
|
|
1580 W_Window win;
|
|
|
1581 int x, y;
|
|
|
1582 W_Icon bit;
|
|
|
1583 W_Color color;
|
|
|
1584 {
|
|
|
1585 struct icon *icon;
|
|
|
1586 Window original;
|
|
|
1587
|
|
|
1588 icon = W_Void2Icon(bit);
|
|
|
1589 original = icon->window;
|
|
|
1590 icon->window = W_Void2Window(win)->window;
|
|
|
1591 W_WriteBitmap(x, y, bit, color);
|
|
|
1592 icon->window = original;
|
|
|
1593 return;
|
|
|
1594 }
|
|
|
1595
|
|
|
1596 void
|
|
|
1597 W_TileWindow(window, bit)
|
|
|
1598 W_Window window;
|
|
|
1599 W_Icon bit;
|
|
|
1600 {
|
|
|
1601 Window win;
|
|
|
1602 struct icon *icon;
|
|
|
1603
|
|
|
1604 #ifdef DEBUG
|
|
|
1605 printf("Tiling window %d\n", window);
|
|
|
1606 #endif
|
|
|
1607 icon = W_Void2Icon(bit);
|
|
|
1608 win = W_Void2Window(window)->window;
|
|
|
1609
|
|
|
1610 if (icon->pixmap == 0) {
|
|
|
1611 icon->pixmap = XCreatePixmap(W_Display, W_Root,
|
|
|
1612 icon->width, icon->height, DefaultDepth(W_Display, W_Screen));
|
|
|
1613 XCopyPlane(W_Display, icon->bitmap, icon->pixmap,
|
|
|
1614 colortable[W_White].contexts[0], 0, 0, icon->width, icon->height,
|
|
|
1615 0, 0, 1);
|
|
|
1616 }
|
|
|
1617 XSetWindowBackgroundPixmap(W_Display, win, icon->pixmap);
|
|
|
1618 XClearWindow(W_Display, win);
|
|
|
1619
|
|
|
1620 /*
|
|
|
1621 if (icon->pixmap==0) { icon->pixmap=XMakePixmap(icon->bitmap,
|
|
|
1622 colortable[W_White].pixelValue, colortable[W_Black].pixelValue); }
|
|
|
1623 XChangeBackground(win, icon->pixmap); XClear(win);
|
|
|
1624 */
|
|
|
1625 }
|
|
|
1626
|
|
|
1627 void
|
|
|
1628 W_UnTileWindow(window)
|
|
|
1629 W_Window window;
|
|
|
1630 {
|
|
|
1631 Window win;
|
|
|
1632
|
|
|
1633 #ifdef DEBUG
|
|
|
1634 printf("Untiling window %d\n", window);
|
|
|
1635 #endif
|
|
|
1636 win = W_Void2Window(window)->window;
|
|
|
1637
|
|
|
1638 XSetWindowBackground(W_Display, win, colortable[W_Black].pixelValue);
|
|
|
1639 XClearWindow(W_Display, win);
|
|
|
1640 }
|
|
|
1641
|
|
|
1642 W_Window
|
|
|
1643 W_MakeTextWindow(name, x, y, width, height, parent, cursname, border)
|
|
|
1644 char *name;
|
|
|
1645 int x, y, width, height;
|
|
|
1646 W_Window parent;
|
|
|
1647 char *cursname;
|
|
|
1648 int border;
|
|
|
1649 {
|
|
|
1650 return w_MakeWindow(name, x, y, width, height,
|
|
|
1651 parent, cursname, border, W_White, WIN_TEXT);
|
|
|
1652 }
|
|
|
1653
|
|
|
1654 struct window *
|
|
|
1655 newWindow(window, type)
|
|
|
1656 Window window;
|
|
|
1657 int type;
|
|
|
1658 {
|
|
|
1659 struct window *newwin;
|
|
|
1660
|
|
|
1661 newwin = (struct window *) malloc(sizeof(struct window));
|
|
|
1662 newwin->window = window;
|
|
|
1663 newwin->type = type;
|
|
|
1664 newwin->mapped = 0;
|
|
|
1665 newwin->insensitive = 0;
|
|
|
1666 addToHash(newwin);
|
|
|
1667 return (newwin);
|
|
|
1668 }
|
|
|
1669
|
|
|
1670
|
|
|
1671 static struct window *
|
|
|
1672 findWindow(window)
|
|
|
1673 Window window;
|
|
|
1674 {
|
|
|
1675 struct windowlist *entry;
|
|
|
1676
|
|
|
1677 entry = hashtable[hash(window)];
|
|
|
1678 while (entry != NULL) {
|
|
|
1679 if (entry->window->window == window)
|
|
|
1680 return (entry->window);
|
|
|
1681 entry = entry->next;
|
|
|
1682 }
|
|
|
1683 return (NULL);
|
|
|
1684 }
|
|
|
1685
|
|
|
1686 static void
|
|
|
1687 addToHash(win)
|
|
|
1688 struct window *win;
|
|
|
1689 {
|
|
|
1690 struct windowlist **new;
|
|
|
1691
|
|
|
1692 #ifdef DEBUG
|
|
|
1693 printf("Adding to %d\n", hash(win->window));
|
|
|
1694 #endif
|
|
|
1695 new = &hashtable[hash(win->window)];
|
|
|
1696 while (*new != NULL) {
|
|
|
1697 new = &((*new)->next);
|
|
|
1698 }
|
|
|
1699 *new = (struct windowlist *) malloc(sizeof(struct windowlist));
|
|
|
1700 (*new)->next = NULL;
|
|
|
1701 (*new)->window = win;
|
|
|
1702 }
|
|
|
1703
|
|
|
1704 W_Window
|
|
|
1705 W_MakeScrollingWindow(name, x, y, width, height, parent, cursname, border)
|
|
|
1706 char *name;
|
|
|
1707 int x, y, width, height;
|
|
|
1708 W_Window parent;
|
|
|
1709 char *cursname;
|
|
|
1710 int border;
|
|
|
1711 {
|
|
|
1712 return w_MakeWindow(name, x, y, width, height, parent, cursname,
|
|
|
1713 border, W_White, WIN_SCROLL);
|
|
|
1714 }
|
|
|
1715
|
|
|
1716 /* Add a string to the string list of the scrolling window.
|
|
|
1717 */
|
|
|
1718 static void
|
|
|
1719 AddToScrolling(win, color, str, len)
|
|
|
1720 struct window *win;
|
|
|
1721 W_Color color;
|
|
|
1722 char *str;
|
|
|
1723 int len;
|
|
|
1724 {
|
|
|
1725 struct stringList **strings;
|
|
|
1726 char *newstring;
|
|
|
1727 int count;
|
|
|
1728
|
|
|
1729 strings = (struct stringList **) & (win->data);
|
|
|
1730 count = 0;
|
|
|
1731 while ((*strings) != NULL) {
|
|
|
1732 count++;
|
|
|
1733 strings = &((*strings)->next);
|
|
|
1734 }
|
|
|
1735 (*strings) = (struct stringList *) malloc(sizeof(struct stringList));
|
|
|
1736 (*strings)->next = NULL;
|
|
|
1737 (*strings)->color = color;
|
|
|
1738 newstring = (char *) malloc(len + 1);
|
|
|
1739 strncpy(newstring, str, len);
|
|
|
1740 newstring[len] = 0;
|
|
|
1741 (*strings)->string = newstring;
|
|
|
1742 if (count >= 100) { /* Arbitrary large size. */
|
|
|
1743 struct stringList *temp;
|
|
|
1744
|
|
|
1745 temp = (struct stringList *) win->data;
|
|
|
1746 free(temp->string);
|
|
|
1747 temp = temp->next;
|
|
|
1748 free((char *) win->data);
|
|
|
1749 win->data = (char *) temp;
|
|
|
1750 }
|
|
|
1751 }
|
|
|
1752
|
|
|
1753 #ifdef SHORT_PACKETS
|
|
|
1754 void
|
|
|
1755 W_SetSensitive(w, v)
|
|
|
1756 W_Window w;
|
|
|
1757 int v;
|
|
|
1758 {
|
|
|
1759 struct window *win = W_Void2Window(w);
|
|
|
1760
|
|
|
1761 win->insensitive = !v;
|
|
|
1762
|
|
|
1763 if (win->type == WIN_SCROLL)
|
|
|
1764 redrawScrolling(win);
|
|
|
1765 }
|
|
|
1766 #endif
|
|
|
1767
|
|
|
1768 static void
|
|
|
1769 redrawScrolling(win)
|
|
|
1770 struct window *win;
|
|
|
1771 {
|
|
|
1772 int count;
|
|
|
1773 struct stringList *list;
|
|
|
1774 int y;
|
|
|
1775
|
|
|
1776 XClearWindow(W_Display, win->window);
|
|
|
1777 count = 0;
|
|
|
1778 list = (struct stringList *) win->data;
|
|
|
1779 while (list != NULL) {
|
|
|
1780 list = list->next;
|
|
|
1781 count++;
|
|
|
1782 }
|
|
|
1783 list = (struct stringList *) win->data;
|
|
|
1784 while (count > win->height) {
|
|
|
1785 list = list->next;
|
|
|
1786 count--;
|
|
|
1787 }
|
|
|
1788 y = (win->height - count) * W_Textheight + fonts[1].baseline;
|
|
|
1789 if (count == 0)
|
|
|
1790 return;
|
|
|
1791 while (list != NULL) {
|
|
|
1792 XDrawImageString(W_Display, win->window,
|
|
|
1793 colortable[list->color].contexts[1],
|
|
|
1794 WIN_EDGE, MENU_PAD + y, list->string, strlen(list->string));
|
|
|
1795 list = list->next;
|
|
|
1796 y = y + W_Textheight;
|
|
|
1797 }
|
|
|
1798 }
|
|
|
1799
|
|
|
1800 static void
|
|
|
1801 resizeScrolling(win, width, height)
|
|
|
1802 struct window *win;
|
|
|
1803 int width, height;
|
|
|
1804 {
|
|
|
1805 win->height = (height - MENU_PAD * 2) / W_Textheight;
|
|
|
1806 win->width = (width - WIN_EDGE * 2) / W_Textwidth;
|
|
|
1807 XResizeWindow(W_Display, win->window, win->width * W_Textwidth + WIN_EDGE * 2,
|
|
|
1808 win->height * W_Textheight + MENU_PAD * 2);
|
|
|
1809 }
|
|
|
1810
|
|
|
1811 W_Window
|
|
|
1812 W_MakeMenu(name, x, y, width, height, parent, border)
|
|
|
1813 char *name;
|
|
|
1814 int x, y, width, height;
|
|
|
1815 W_Window parent;
|
|
|
1816 int border;
|
|
|
1817 {
|
|
|
1818 return w_MakeWindow(name, x, y, width, height, parent,
|
|
|
1819 "left_ptr", border, W_White, WIN_MENU);
|
|
|
1820 }
|
|
|
1821
|
|
|
1822 static void
|
|
|
1823 redrawMenu(win)
|
|
|
1824 struct window *win;
|
|
|
1825 {
|
|
|
1826 int count;
|
|
|
1827
|
|
|
1828 for (count = 1; count < win->height; count++) {
|
|
|
1829 XFillRectangle(W_Display, win->window,
|
|
|
1830 colortable[W_Grey].contexts[0],
|
|
|
1831 0, count * (W_Textheight + MENU_PAD * 2) + (count - 1) * MENU_BAR,
|
|
|
1832 win->width * W_Textwidth + WIN_EDGE * 2, MENU_BAR);
|
|
|
1833 }
|
|
|
1834 for (count = 0; count < win->height; count++) {
|
|
|
1835 redrawMenuItem(win, count);
|
|
|
1836 }
|
|
|
1837 }
|
|
|
1838
|
|
|
1839 static void
|
|
|
1840 redrawMenuItem(win, n)
|
|
|
1841 struct window *win;
|
|
|
1842 int n;
|
|
|
1843 {
|
|
|
1844 struct menuItem *items;
|
|
|
1845 int addr;
|
|
|
1846
|
|
|
1847 items = (struct menuItem *) win->data;
|
|
|
1848
|
|
|
1849 XFillRectangle(W_Display, win->window,
|
|
|
1850 colortable[W_Black].contexts[0],
|
|
|
1851 WIN_EDGE, n * (W_Textheight + MENU_PAD * 2 + MENU_BAR) + MENU_PAD,
|
|
|
1852 win->width * W_Textwidth, W_Textheight);
|
|
|
1853 if (items[n].string) {
|
|
|
1854 addr = fonts[fontNum(items[n].font)].baseline;
|
|
|
1855 XDrawImageString(W_Display, win->window,
|
|
|
1856 colortable[items[n].color].contexts[fontNum(items[n].font)],
|
|
|
1857 WIN_EDGE,
|
|
|
1858 n * (W_Textheight + MENU_PAD * 2 + MENU_BAR) + MENU_PAD + addr,
|
|
|
1859 items[n].string, strlen(items[n].string));
|
|
|
1860 }
|
|
|
1861 }
|
|
|
1862
|
|
|
1863 static void
|
|
|
1864 changeMenuItem(win, n, color, str, len, font)
|
|
|
1865 struct window *win;
|
|
|
1866 int n;
|
|
|
1867 W_Color color;
|
|
|
1868 char *str;
|
|
|
1869 int len;
|
|
|
1870 W_Font font;
|
|
|
1871 {
|
|
|
1872 struct menuItem *items;
|
|
|
1873 char *news;
|
|
|
1874
|
|
|
1875 items = (struct menuItem *) win->data;
|
|
|
1876 if (items[n].string) {
|
|
|
1877 free(items[n].string);
|
|
|
1878 }
|
|
|
1879 news = malloc(len + 1);
|
|
|
1880 strncpy(news, str, len);
|
|
|
1881 news[len] = 0;
|
|
|
1882 items[n].string = news;
|
|
|
1883 items[n].color = color;
|
|
|
1884 items[n].font = font;
|
|
|
1885 redrawMenuItem(win, n);
|
|
|
1886 XFlush(W_Display);
|
|
|
1887 }
|
|
|
1888
|
|
|
1889 static Cursor
|
|
|
1890 make_cursor(bits, mask, width, height, xhot, yhot)
|
|
|
1891 char *bits, *mask;
|
|
|
1892 int width, height, xhot, yhot;
|
|
|
1893 {
|
|
|
1894 Pixmap cursbits;
|
|
|
1895 Pixmap cursmask;
|
|
|
1896 XColor whiteCol, blackCol;
|
|
|
1897 Cursor curs;
|
|
|
1898
|
|
|
1899 whiteCol.pixel = colortable[W_White].pixelValue;
|
|
|
1900 XQueryColor(W_Display, W_Colormap, &whiteCol);
|
|
|
1901 blackCol.pixel = colortable[W_Black].pixelValue;
|
|
|
1902 XQueryColor(W_Display, W_Colormap, &blackCol);
|
|
|
1903
|
|
|
1904 cursbits = XCreateBitmapFromData(W_Display, DefaultRootWindow(W_Display),
|
|
|
1905 bits, width, height);
|
|
|
1906 cursmask = XCreateBitmapFromData(W_Display, DefaultRootWindow(W_Display),
|
|
|
1907 mask, width, height);
|
|
|
1908
|
|
|
1909 curs = XCreatePixmapCursor(W_Display, cursbits, cursmask,
|
|
|
1910 &whiteCol, &blackCol, xhot, yhot);
|
|
|
1911
|
|
|
1912 XFreePixmap(W_Display, cursbits);
|
|
|
1913 XFreePixmap(W_Display, cursmask);
|
|
|
1914 return curs;
|
|
|
1915 }
|
|
|
1916
|
|
|
1917 #ifdef TCURSORS
|
|
|
1918 #if 1
|
|
|
1919
|
|
|
1920 void
|
|
|
1921 W_DefineTCrossCursor(window)
|
|
|
1922 W_Window window;
|
|
|
1923 {
|
|
|
1924 return;
|
|
|
1925 }
|
|
|
1926
|
|
|
1927 void
|
|
|
1928 W_DefineTextCursor(window)
|
|
|
1929 W_Window window;
|
|
|
1930 {
|
|
|
1931 static Cursor new = 0;
|
|
|
1932 struct window *win = W_Void2Window(window);
|
|
|
1933 XColor f, b;
|
|
|
1934
|
|
|
1935 if (!new) {
|
|
|
1936 f.pixel = colortable[W_Yellow].pixelValue;
|
|
|
1937 b.pixel = colortable[W_Black].pixelValue;
|
|
|
1938
|
|
|
1939 XQueryColor(W_Display, W_Colormap, &f);
|
|
|
1940 XQueryColor(W_Display, W_Colormap, &b);
|
|
|
1941
|
|
|
1942 new = XCreateFontCursor(W_Display, XC_xterm);
|
|
|
1943
|
|
|
1944 XRecolorCursor(W_Display, new, &f, &b);
|
|
|
1945 }
|
|
|
1946 XDefineCursor(W_Display, win->window, new);
|
|
|
1947
|
|
|
1948 return;
|
|
|
1949 }
|
|
|
1950
|
|
|
1951 void
|
|
|
1952 W_RevertCursor(window)
|
|
|
1953 W_Window window;
|
|
|
1954 {
|
|
|
1955 struct window *win = W_Void2Window(window);
|
|
|
1956
|
|
|
1957 XDefineCursor(W_Display, win->window, win->cursor);
|
|
|
1958
|
|
|
1959 return;
|
|
|
1960 }
|
|
|
1961
|
|
|
1962 void
|
|
|
1963 W_DefineCursor(window, width, height, bits, mask, xhot, yhot)
|
|
|
1964 W_Window window;
|
|
|
1965 int width, height, xhot, yhot;
|
|
|
1966 char *bits, *mask;
|
|
|
1967 {
|
|
|
1968 return;
|
|
|
1969 }
|
|
|
1970
|
|
|
1971 #else
|
|
|
1972
|
|
|
1973 #ifdef YUCK
|
|
|
1974 void
|
|
|
1975 W_DefineTCrossCursor(window)
|
|
|
1976 W_Window window;
|
|
|
1977 {
|
|
|
1978 static
|
|
|
1979 Cursor new;
|
|
|
1980 struct window *win = W_Void2Window(window);
|
|
|
1981 static
|
|
|
1982 XColor f, b;
|
|
|
1983
|
|
|
1984 if (new) {
|
|
|
1985 XDefineCursor(W_Display, win->window, new);
|
|
|
1986 return;
|
|
|
1987 }
|
|
|
1988 f.pixel = colortable[W_White].pixelValue;
|
|
|
1989 b.pixel = colortable[W_Black].pixelValue;
|
|
|
1990
|
|
|
1991 XQueryColor(W_Display, W_Colormap, &f);
|
|
|
1992 XQueryColor(W_Display, W_Colormap, &b);
|
|
|
1993
|
|
|
1994 new = XCreateFontCursor(W_Display, XC_tcross);
|
|
|
1995 XRecolorCursor(W_Display, new, &f, &b);
|
|
|
1996 XDefineCursor(W_Display, win->window, new);
|
|
|
1997 }
|
|
|
1998
|
|
|
1999 #else
|
|
|
2000 W_DefineTCrossCursor(window)
|
|
|
2001 W_Window window;
|
|
|
2002 {
|
|
|
2003 W_DefineCursor(window, cross_width, cross_height,
|
|
|
2004 cross_bits, crossmask_bits, cross_x_hot, cross_y_hot);
|
|
|
2005 }
|
|
|
2006
|
|
|
2007 #endif
|
|
|
2008
|
|
|
2009 void
|
|
|
2010 W_DefineTextCursor(window)
|
|
|
2011 W_Window window;
|
|
|
2012 {
|
|
|
2013 static
|
|
|
2014 Cursor new;
|
|
|
2015 struct window *win = W_Void2Window(window);
|
|
|
2016 XColor f, b;
|
|
|
2017
|
|
|
2018 if (new) {
|
|
|
2019 XDefineCursor(W_Display, win->window, new);
|
|
|
2020 return;
|
|
|
2021 }
|
|
|
2022 f.pixel = colortable[W_Yellow].pixelValue;
|
|
|
2023 b.pixel = colortable[W_Black].pixelValue;
|
|
|
2024
|
|
|
2025 XQueryColor(W_Display, W_Colormap, &f);
|
|
|
2026 XQueryColor(W_Display, W_Colormap, &b);
|
|
|
2027
|
|
|
2028 new = XCreateFontCursor(W_Display, XC_xterm);
|
|
|
2029 XRecolorCursor(W_Display, new, &f, &b);
|
|
|
2030 XDefineCursor(W_Display, win->window, new);
|
|
|
2031 }
|
|
|
2032
|
|
|
2033 void
|
|
|
2034 W_DefineCursor(window, width, height, bits, mask, xhot, yhot)
|
|
|
2035 W_Window window;
|
|
|
2036 int width, height, xhot, yhot;
|
|
|
2037 char *bits, *mask;
|
|
|
2038 {
|
|
|
2039 static char *oldbits = NULL;
|
|
|
2040 static Cursor curs;
|
|
|
2041 struct window *win;
|
|
|
2042
|
|
|
2043 #ifdef DEBUG
|
|
|
2044 printf("Defining cursor for %d\n", window);
|
|
|
2045 #endif
|
|
|
2046 win = W_Void2Window(window);
|
|
|
2047 if (!oldbits || oldbits != bits) {
|
|
|
2048 oldbits = bits;
|
|
|
2049 curs = make_cursor(bits, mask, width, height, xhot, yhot);
|
|
|
2050 }
|
|
|
2051 XDefineCursor(W_Display, win->window, curs);
|
|
|
2052 }
|
|
|
2053 #endif
|
|
|
2054 #endif
|
|
|
2055
|
|
|
2056 void
|
|
|
2057 W_Beep()
|
|
|
2058 {
|
|
|
2059 XBell(W_Display, 0);
|
|
|
2060 }
|
|
|
2061
|
|
|
2062 int
|
|
|
2063 W_WindowWidth(window)
|
|
|
2064 W_Window window;
|
|
|
2065 {
|
|
|
2066 return (W_Void2Window(window)->width);
|
|
|
2067 }
|
|
|
2068
|
|
|
2069 int
|
|
|
2070 W_WindowHeight(window)
|
|
|
2071 W_Window window;
|
|
|
2072 {
|
|
|
2073 return (W_Void2Window(window)->height);
|
|
|
2074 }
|
|
|
2075
|
|
|
2076 int
|
|
|
2077 W_Socket()
|
|
|
2078 {
|
|
|
2079 return (ConnectionNumber(W_Display));
|
|
|
2080 }
|
|
|
2081
|
|
|
2082 void
|
|
|
2083 W_DestroyWindow(window)
|
|
|
2084 W_Window window;
|
|
|
2085 {
|
|
|
2086 struct window *win;
|
|
|
2087
|
|
|
2088 #ifdef DEBUG
|
|
|
2089 printf("Destroying %d\n", window);
|
|
|
2090 #endif
|
|
|
2091 win = W_Void2Window(window);
|
|
|
2092 deleteWindow(win);
|
|
|
2093 XDestroyWindow(W_Display, win->window);
|
|
|
2094 free((char *) win);
|
|
|
2095 }
|
|
|
2096
|
|
|
2097 static void
|
|
|
2098 deleteWindow(window)
|
|
|
2099 struct window *window;
|
|
|
2100 {
|
|
|
2101 struct windowlist **rm;
|
|
|
2102 struct windowlist *temp;
|
|
|
2103
|
|
|
2104 rm = &hashtable[hash(window->window)];
|
|
|
2105 while (*rm != NULL && (*rm)->window != window) {
|
|
|
2106 rm = &((*rm)->next);
|
|
|
2107 }
|
|
|
2108 if (*rm == NULL) {
|
|
|
2109 printf("Attempt to delete non-existent window!\n");
|
|
|
2110 return;
|
|
|
2111 }
|
|
|
2112 temp = *rm;
|
|
|
2113 *rm = temp->next;
|
|
|
2114 free((char *) temp);
|
|
|
2115 }
|
|
|
2116
|
|
|
2117 void
|
|
|
2118 W_SetIconWindow(main, icon)
|
|
|
2119 W_Window main;
|
|
|
2120 W_Window icon;
|
|
|
2121 {
|
|
|
2122 XWMHints hints;
|
|
|
2123
|
|
|
2124 XSetIconName(W_Display, W_Void2Window(icon)->window, W_Void2Window(main)->name);
|
|
|
2125
|
|
|
2126 hints.flags = IconWindowHint;
|
|
|
2127 hints.icon_window = W_Void2Window(icon)->window;
|
|
|
2128 XSetWMHints(W_Display, W_Void2Window(main)->window, &hints);
|
|
|
2129 }
|
|
|
2130
|
|
|
2131 static void
|
|
|
2132 checkGeometry(name, x, y, width, height)
|
|
|
2133 char *name;
|
|
|
2134 int *x, *y, *width, *height;
|
|
|
2135 /* fixed so that it handles negative positions 12/21/93 */
|
|
|
2136 /* note that this is NOT standard X syntax, but it was requested */
|
|
|
2137 /* and it's how BRM-Hadley works. [BDyess] */
|
|
|
2138 {
|
|
|
2139 char *adefault;
|
|
|
2140 char buf[100];
|
|
|
2141 char *s;
|
|
|
2142
|
|
|
2143 #ifdef RJC
|
|
|
2144 *x = *y = INVALID_POSITION;
|
|
|
2145 #endif /* RJC */
|
|
|
2146
|
|
|
2147 sprintf(buf, "%s.geometry", name);
|
|
|
2148 adefault = getdefault(buf);
|
|
|
2149 if (adefault == NULL)
|
|
|
2150 return;
|
|
|
2151 /* geometry should be of the form 502x885+1+1, 502x885, or +1+1 */
|
|
|
2152 s = adefault;
|
|
|
2153 if (*s != '+' && *s != '-') {
|
|
|
2154 while (*s != 'x' && *s != 0)
|
|
|
2155 s++;
|
|
|
2156 *width = atoi(adefault);
|
|
|
2157 if (*s == 0)
|
|
|
2158 return;
|
|
|
2159 s++;
|
|
|
2160 adefault = s;
|
|
|
2161 while (*s != '+' && *s != '-' && *s != 0)
|
|
|
2162 s++;
|
|
|
2163 *height = atoi(adefault);
|
|
|
2164 if (*s == 0)
|
|
|
2165 return;
|
|
|
2166 }
|
|
|
2167 adefault = s;
|
|
|
2168 s++;
|
|
|
2169 if (*s == '-')
|
|
|
2170 s++; /* for the case where they have wxh+-x+y */
|
|
|
2171 while (*s != '+' && *s != '-' && *s != 0)
|
|
|
2172 s++;
|
|
|
2173 *x = atoi(adefault + 1);
|
|
|
2174 if (*adefault == '-')
|
|
|
2175 *x = -*x;
|
|
|
2176 if (*s == 0)
|
|
|
2177 return;
|
|
|
2178 *y = atoi(s + 1);
|
|
|
2179 if (*s == '-')
|
|
|
2180 *y = -*y;
|
|
|
2181 /* printf("width: %d, height: %d, x: %d, y: %d\n",*width, *height,*x,*y); */
|
|
|
2182 return;
|
|
|
2183 }
|
|
|
2184
|
|
|
2185 static void
|
|
|
2186 checkParent(name, parent)
|
|
|
2187 char *name;
|
|
|
2188 W_Window *parent;
|
|
|
2189 {
|
|
|
2190 char *adefault;
|
|
|
2191 char buf[100];
|
|
|
2192 int i;
|
|
|
2193 struct windowlist *windows;
|
|
|
2194
|
|
|
2195 sprintf(buf, "%s.parent", name);
|
|
|
2196 adefault = getdefault(buf);
|
|
|
2197 if (adefault == NULL)
|
|
|
2198 return;
|
|
|
2199 /* parent must be name of other window or "root" */
|
|
|
2200 if (strcmpi(adefault, "root") == 0) {
|
|
|
2201 *parent = W_Window2Void(&myroot);
|
|
|
2202 return;
|
|
|
2203 }
|
|
|
2204 for (i = 0; i < HASHSIZE; i++) {
|
|
|
2205 windows = hashtable[i];
|
|
|
2206 while (windows != NULL) {
|
|
|
2207 if (strcmpi(adefault, windows->window->name) == 0) {
|
|
|
2208 *parent = W_Window2Void(windows->window);
|
|
|
2209 return;
|
|
|
2210 }
|
|
|
2211 windows = windows->next;
|
|
|
2212 }
|
|
|
2213 }
|
|
|
2214 }
|
|
|
2215
|
|
|
2216 #ifdef YUCK
|
|
|
2217 #define cross_width 15
|
|
|
2218 #define cross_height 15
|
|
|
2219 #define cross_x_hot 7
|
|
|
2220 #define cross_y_hot 7
|
|
|
2221 static unsigned char cross_bits[] = {
|
|
|
2222 0x00, 0x00, 0xc0, 0x01, 0xa0, 0x02, 0x00, 0x00, 0x80, 0x00, 0x04, 0x10, 0x82, 0x20, 0x56,
|
|
|
2223 0x35, 0x82, 0x20, 0x04, 0x10, 0x80, 0x00, 0x00, 0x00, 0xa0, 0x02, 0xc0, 0x01, 0x00, 0x00};
|
|
|
2224 static unsigned char crossmask_bits[] = {
|
|
|
2225 0xe0, 0x03, 0xf0, 0x07, 0xf0, 0x07, 0xf0, 0x07, 0xce, 0x39, 0xcf, 0x79, 0xff, 0x7f, 0xff,
|
|
|
2226 0x7f, 0xff, 0x7f, 0xcf, 0x79, 0xce, 0x39, 0xf0, 0x07, 0xf0, 0x07, 0xf0, 0x07, 0xe0, 0x03};
|
|
|
2227 #else
|
|
|
2228 #define cross_width 16
|
|
|
2229 #define cross_height 16
|
|
|
2230 #define cross_x_hot 7
|
|
|
2231 #define cross_y_hot 7
|
|
|
2232 static unsigned char cross_bits[] = {
|
|
|
2233 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0xc0, 0x01, 0x80, 0x00,
|
|
|
2234 0x10, 0x04, 0x3f, 0x7e, 0x10, 0x04, 0x80, 0x00, 0xc0, 0x01, 0x80, 0x00,
|
|
|
2235 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x00, 0x00};
|
|
|
2236 static unsigned char crossmask_bits[] = {
|
|
|
2237 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xe0, 0x03, 0xd0, 0x05,
|
|
|
2238 0xbf, 0x7e, 0x7f, 0x7f, 0xbf, 0x7e, 0xd0, 0x05, 0xe0, 0x03, 0xc0, 0x01,
|
|
|
2239 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0x00, 0x00};
|
|
|
2240 #endif
|
|
|
2241
|
|
|
2242 static void
|
|
|
2243 checkCursor(name, cursname, cursor)
|
|
|
2244 char *name;
|
|
|
2245 char *cursname;
|
|
|
2246 Cursor *cursor;
|
|
|
2247 {
|
|
|
2248 char buf[100];
|
|
|
2249 unsigned cnum;
|
|
|
2250 char *adefault;
|
|
|
2251
|
|
|
2252 *cursor = 0;
|
|
|
2253
|
|
|
2254 sprintf(buf, "%s.cursor", name);
|
|
|
2255 adefault = getdefault(buf);
|
|
|
2256 if (adefault == NULL)
|
|
|
2257 adefault = cursname;
|
|
|
2258 if (adefault == NULL)
|
|
|
2259 return;
|
|
|
2260
|
|
|
2261 #ifdef RFCURSORS
|
|
|
2262 cnum = XmuCursorNameToIndex(adefault);
|
|
|
2263 if (cnum != -1) {
|
|
|
2264 XColor f, b;
|
|
|
2265 *cursor = XCreateFontCursor(W_Display, cnum);
|
|
|
2266 if (cnum == XC_xterm) {
|
|
|
2267
|
|
|
2268 f.pixel = colortable[W_Yellow].pixelValue;
|
|
|
2269 b.pixel = colortable[W_Black].pixelValue;
|
|
|
2270
|
|
|
2271 XQueryColor(W_Display, W_Colormap, &f);
|
|
|
2272 XQueryColor(W_Display, W_Colormap, &b);
|
|
|
2273
|
|
|
2274 XRecolorCursor(W_Display, *cursor, &f, &b);
|
|
|
2275 } else if (cnum == XC_pirate) {
|
|
|
2276 f.pixel = colortable[W_Red].pixelValue;
|
|
|
2277 b.pixel = colortable[W_Black].pixelValue;
|
|
|
2278
|
|
|
2279 XQueryColor(W_Display, W_Colormap, &f);
|
|
|
2280 XQueryColor(W_Display, W_Colormap, &b);
|
|
|
2281
|
|
|
2282 XRecolorCursor(W_Display, *cursor, &f, &b);
|
|
|
2283 }
|
|
|
2284 } else
|
|
|
2285 #endif
|
|
|
2286 if (0 == strcmp("bomb here", adefault)) {
|
|
|
2287 static Cursor bomb_here = 0;
|
|
|
2288 if (bomb_here == 0) {
|
|
|
2289 bomb_here = make_cursor(cross_bits, crossmask_bits,
|
|
|
2290 cross_width, cross_height,
|
|
|
2291 cross_x_hot, cross_y_hot);
|
|
|
2292 }
|
|
|
2293 *cursor = bomb_here;
|
|
|
2294 }
|
|
|
2295 }
|
|
|
2296
|
|
|
2297 int
|
|
|
2298 checkMapped(name)
|
|
|
2299 char *name;
|
|
|
2300 {
|
|
|
2301 char buf[100];
|
|
|
2302
|
|
|
2303 sprintf(buf, "%s.mapped", name);
|
|
|
2304 return (booleanDefault(buf, 0));
|
|
|
2305 }
|
|
|
2306
|
|
|
2307 void
|
|
|
2308 W_WarpPointer(window, x, y)
|
|
|
2309 W_Window window;
|
|
|
2310 int x, y;
|
|
|
2311 {
|
|
|
2312 static int warped_from_x = 0, warped_from_y = 0;
|
|
|
2313
|
|
|
2314 if (window == NULL) {
|
|
|
2315 if (W_in_message) {
|
|
|
2316 XWarpPointer(W_Display, None, W_Root, 0, 0, 0, 0, warped_from_x, warped_from_y);
|
|
|
2317 W_in_message = 0;
|
|
|
2318 }
|
|
|
2319 } else {
|
|
|
2320 findMouse(&warped_from_x, &warped_from_y);
|
|
|
2321 XWarpPointer(W_Display, None, W_Void2Window(window)->window, 0, 0, 0, 0, 0, 0);
|
|
|
2322 W_in_message = 1;
|
|
|
2323 }
|
|
|
2324 }
|
|
|
2325
|
|
|
2326 static void
|
|
|
2327 findMouse(x, y)
|
|
|
2328 int *x, *y;
|
|
|
2329 {
|
|
|
2330 Window theRoot, theChild;
|
|
|
2331 int wX, wY, rootX, rootY, status;
|
|
|
2332 unsigned int wButtons;
|
|
|
2333
|
|
|
2334 status = XQueryPointer(W_Display, W_Root, &theRoot, &theChild, &rootX, &rootY, &wX, &wY, &wButtons);
|
|
|
2335 if (status == True) {
|
|
|
2336 *x = wX;
|
|
|
2337 *y = wY;
|
|
|
2338 } else {
|
|
|
2339 *x = 0;
|
|
|
2340 *y = 0;
|
|
|
2341 }
|
|
|
2342 }
|
|
|
2343
|
|
|
2344 int
|
|
|
2345 findMouseInWin(x, y, w)
|
|
|
2346 int *x, *y;
|
|
|
2347 W_Window w;
|
|
|
2348 {
|
|
|
2349 Window theRoot, theChild;
|
|
|
2350 int wX, wY, rootX, rootY, status;
|
|
|
2351 unsigned int wButtons;
|
|
|
2352 struct window *win = W_Void2Window(w);
|
|
|
2353 Window thisWin = win->window;
|
|
|
2354
|
|
|
2355 status = XQueryPointer(W_Display, thisWin, &theRoot, &theChild,
|
|
|
2356 &rootX, &rootY, &wX, &wY, &wButtons);
|
|
|
2357 if (status == True) {
|
|
|
2358 /*
|
|
|
2359 if it's in the window we specified then the values returned should
|
|
|
2360 be within the with and height of the window
|
|
|
2361 */
|
|
|
2362 if (wX <= win->width && wY <= win->height) {
|
|
|
2363 *x = wX;
|
|
|
2364 *y = wY;
|
|
|
2365 return 1;
|
|
|
2366 }
|
|
|
2367 }
|
|
|
2368 *x = 0;
|
|
|
2369 *y = 0;
|
|
|
2370 return 0;
|
|
|
2371 }
|
|
|
2372
|
|
|
2373 #ifdef AUTOKEY
|
|
|
2374 static void
|
|
|
2375 W_Flush()
|
|
|
2376 {
|
|
|
2377 XFlush(W_Display);
|
|
|
2378 }
|
|
|
2379
|
|
|
2380 W_AutoRepeatOff()
|
|
|
2381 {
|
|
|
2382 XAutoRepeatOff(W_Display);
|
|
|
2383 W_Flush();
|
|
|
2384 }
|
|
|
2385
|
|
|
2386 W_AutoRepeatOn()
|
|
|
2387 {
|
|
|
2388 XAutoRepeatOn(W_Display);
|
|
|
2389 W_Flush();
|
|
|
2390 }
|
|
|
2391 #endif /* AUTOKEY */
|
|
|
2392
|
|
|
2393 /* find the width of a font */
|
|
|
2394 int
|
|
|
2395 W_StringWidth(string, font)
|
|
|
2396 char string[];
|
|
|
2397 W_Font font;
|
|
|
2398 {
|
|
|
2399 int x, y;
|
|
|
2400
|
|
|
2401 y = strlen(string);
|
|
|
2402 x = XTextWidth(fonts[fontNum(font)].fontstruct, string, y);
|
|
|
2403 return (x); /* just a guess ?? old never returned! WHS
|
|
|
2404 4/6/93 */
|
|
|
2405 }
|
|
|
2406
|
|
|
2407 void
|
|
|
2408 W_TranslatePoints(w, x, y)
|
|
|
2409 int *x, *y;
|
|
|
2410 W_Window w;
|
|
|
2411 {
|
|
|
2412 struct window *win;
|
|
|
2413 win = W_Void2Window(w);
|
|
|
2414
|
|
|
2415 if (win->type == WIN_TEXT) {
|
|
|
2416 *y = (*y - MENU_PAD) / W_Textheight;
|
|
|
2417 *x = (*x - MENU_PAD) / W_Textwidth;
|
|
|
2418 }
|
|
|
2419 return;
|
|
|
2420 }
|
|
|
2421
|
|
|
2422 #if 0
|
|
|
2423 #define MAKE_WINDOW_GETTER(name, part) \
|
|
|
2424 W_Callback name(w) \
|
|
|
2425 W_Window w; \
|
|
|
2426 { \
|
|
|
2427 return W_Void2Window(w)->part; \
|
|
|
2428 }
|
|
|
2429
|
|
|
2430 #define MAKE_WINDOW_SETTER(name, port) \
|
|
|
2431 W_Callback name(w, c) \
|
|
|
2432 W_Window w; \
|
|
|
2433 W_Callback c; \
|
|
|
2434 { \
|
|
|
2435 W_Void2Window(w)->port = c; \
|
|
|
2436 }
|
|
|
2437
|
|
|
2438 MAKE_WINDOW_GETTER(W_GetWindowKeyDownHandler, handle_keydown);
|
|
|
2439 MAKE_WINDOW_SETTER(W_SetWindowKeyDownHandler, handle_keydown);
|
|
|
2440
|
|
|
2441 MAKE_WINDOW_GETTER(W_GetWindowKeyUpHandler, handle_keyup);
|
|
|
2442 MAKE_WINDOW_SETTER(W_SetWindowKeyUpHandler, handle_keyup);
|
|
|
2443
|
|
|
2444 MAKE_WINDOW_GETTER(W_GetWindowButtonHandler, handle_button);
|
|
|
2445 MAKE_WINDOW_SETTER(W_SetWindowButtonHandler, handle_button);
|
|
|
2446
|
|
|
2447 MAKE_WINDOW_GETTER(W_GetWindowExposeHandler, handle_expose);
|
|
|
2448 MAKE_WINDOW_SETTER(W_SetWindowExposeHandler, handle_expose);
|
|
|
2449 #endif /* 0 */
|
|
|
2450
|
|
|
2451 void
|
|
|
2452 W_ResizeWindow(window, neww, newh) /* TSH 2/93 */
|
|
|
2453 W_Window window;
|
|
|
2454 int neww, newh;
|
|
|
2455 {
|
|
|
2456 Window win = W_Void2Window(window)->window;
|
|
|
2457
|
|
|
2458 XResizeWindow(W_Display, win, (unsigned int) neww, (unsigned int) newh);
|
|
|
2459 }
|
|
|
2460
|
|
|
2461 void
|
|
|
2462 W_ResizeMenu(window, neww, newh)/* TSH 2/93 */
|
|
|
2463 W_Window window;
|
|
|
2464 int neww, newh;
|
|
|
2465 {
|
|
|
2466 W_ResizeWindow(window, neww * W_Textwidth + WIN_EDGE * 2,
|
|
|
2467 newh * (W_Textheight + MENU_PAD * 2) + (newh - 1) * MENU_BAR);
|
|
|
2468 }
|
|
|
2469
|
|
|
2470 void
|
|
|
2471 W_ResizeText(window, neww, newh)/* TSH 2/93 */
|
|
|
2472 W_Window window;
|
|
|
2473 int neww, newh;
|
|
|
2474 {
|
|
|
2475 W_ResizeWindow(window, neww * W_Textwidth + WIN_EDGE * 2,
|
|
|
2476 newh * W_Textheight + MENU_PAD * 2);
|
|
|
2477 }
|
|
|
2478
|
|
|
2479 void
|
|
|
2480 W_Deiconify(window)
|
|
|
2481 W_Window window;
|
|
|
2482 {
|
|
|
2483 struct window *win;
|
|
|
2484 win = W_Void2Window(window);
|
|
|
2485 /* according to ICCCM 4.1.4, this is how you deiconify a window. */
|
|
|
2486 XMapWindow(W_Display, win->window);
|
|
|
2487 }
|
|
|
2488
|
|
|
2489 W_Icon
|
|
|
2490 W_MakeShieldBitmap(width, height, window)
|
|
|
2491 int width, height;
|
|
|
2492 W_Window window;
|
|
|
2493 {
|
|
|
2494 static GC pen = 0;
|
|
|
2495 struct window *win;
|
|
|
2496 struct icon *newicon;
|
|
|
2497
|
|
|
2498 win = W_Void2Window(window);
|
|
|
2499
|
|
|
2500 newicon = (struct icon *) malloc(sizeof(struct icon));
|
|
|
2501 newicon->width = width;
|
|
|
2502 newicon->height = height;
|
|
|
2503 newicon->bitmap = XCreatePixmap(W_Display, win->window, width, height, 1);
|
|
|
2504 newicon->window = win->window;
|
|
|
2505 newicon->pixmap = 0;
|
|
|
2506
|
|
|
2507 pen = XCreateGC(W_Display, newicon->bitmap, 0L, 0);
|
|
|
2508 XSetForeground(W_Display, pen, 0L);
|
|
|
2509 XFillRectangle(W_Display, newicon->bitmap, pen, 0, 0, width, height);
|
|
|
2510 XSetForeground(W_Display, pen, 1L);
|
|
|
2511 XDrawArc(W_Display, newicon->bitmap, pen, 0, 0, width - 1, height - 1, 0, 360 * 64);
|
|
|
2512 XFreeGC(W_Display, pen);
|
|
|
2513
|
|
|
2514 return W_Icon2Void(newicon);
|
|
|
2515 }
|
|
|
2516
|
|
|
2517 #ifdef BEEPLITE
|
|
|
2518 void
|
|
|
2519 W_OverlayBitmap(x, y, bit, color)
|
|
|
2520 int x, y;
|
|
|
2521 W_Icon bit;
|
|
|
2522 W_Color color;
|
|
|
2523 {
|
|
|
2524 struct icon *icon = W_Void2Icon(bit);
|
|
|
2525 #ifdef DEBUG
|
|
|
2526 printf("Overlaying bitmap to %d\n", icon->window);
|
|
|
2527 #endif
|
|
|
2528 XCopyPlane(W_Display, icon->bitmap, icon->window,
|
|
|
2529 colortable[color].contexts[0], 0, 0, icon->width, icon->height,
|
|
|
2530 x, y, 1);
|
|
|
2531 }
|
|
|
2532 #endif
|
