1 /*****************************************************************\
2
3
4 Library of X window functions which call Windows 32
5 equivalent functions.
6
7 Some data structures are maintained by this code,
8 simulating the operation of an X server and window manager.
9
10 Aug/Sep-92 xyz $$1 Created.
11 Oct-92 abc $$2 Added color stuff.
12
13 \******************************************************************/
14
15 #ifndef __XNT
16 #define __XNT
17
18 #include <X11/Xlib.h>
19 #include <X11/Xatom.h>
20
21 #include <stdio.h>
22 #include <math.h>
23 #include <string.h>
24 #include <fcntl.h>
25 #include "ntdef.h"
26
27 /* Local Data */
28
29 static void NT_set_GC_pen();
30 static void NT_set_GC_brush();
31 static HPEN NT_get_GC_pen();
32 static HBRUSH NT_get_GC_brush();
33 static HBRUSH NT_get_GC_bgbrush();
34
35 void NT_set_rop();
36 double NT_deg64_to_rad(int a);
37
38 /*----------------------------------------------------------------*\
39 | FUNCTIONS TO MAINTAIN AN INTERNAL LIST OF WINDOWS AND THEIR |
40 | ATTRIBUTES - AS WOULD BE MAINTAINED IN THE X SERVER. |
41 \*----------------------------------------------------------------*/
42
43 /* Structure to hold pen and brush info in GC ext_data field */
44
45 typedef struct NTGC_
46 {
47 HPEN pen;
48 HBRUSH brush;
49 HBRUSH bgbrush;
50 } NTGC;
51
52 HDC
cjh_get_dc(NT_window * window)53 cjh_get_dc(NT_window *window)
54 {
55 /* pixmaps have to do SelectObject() on their dc's */
56 if (window->hDC == INVALID_HANDLE)
57 if (window->w == INVALID_HANDLE)
58 {
59 window->hDC= CreateDC("DISPLAY", NULL, NULL, NULL);
60 }
61 else
62 window->hDC=GetDC(window->w);
63 return window->hDC;
64 }
65
66 int
cjh_rel_dc(NT_window * window,HDC dc)67 cjh_rel_dc(NT_window *window,HDC dc)
68 {
69 return TRUE;
70 /* return ReleaseDC(window, dc); */
71 }
72
73 HDC
drawableGetDC(Drawable drawable)74 drawableGetDC(Drawable drawable)
75 {
76 cjh_get_dc((NT_window *)drawable);
77 }
78
79 int
drawableRelDC(Drawable drawable,HDC hDC)80 drawableRelDC(Drawable drawable, HDC hDC)
81 {
82 cjh_rel_dc((NT_window *)drawable, hDC);
83 }
84
85
86
87 /*****************************************************************\
88
89 Function: XOpenDisplay
90 Inputs: Display name
91
92 Comments: Fills out a Display structure and a Visual and Screen.
93 Hopefully all the X macros should work with this
94 structure. Note that the default visual is for a
95 True colour screen (24bits).
96 \*****************************************************************/
97 Display *
XOpenDisplay(name)98 XOpenDisplay (name)
99 const char *name;
100 {
101 static char vstring[]="NT Xlibemu",
102 *vs,*dn;
103
104 Display *d = NULL;
105 Screen *scrd;
106 static Depth dlist[1];
107 static Visual vlist[1];
108 Colormap cmap;
109 RECT rect;
110 int depth;
111 HDC rootDC = CreateDC("DISPLAY",NULL,NULL,NULL);
112
113 depth = GetDeviceCaps(rootDC, BITSPIXEL);
114
115 xtrace("XOpenDisplay\n");
116
117 initQ();
118
119 dlist[0].depth=depth;
120 dlist[0].nvisuals=1;
121 dlist[0].visuals=vlist;
122 vlist[0].ext_data=NULL;
123 vlist[0].visualid=0;
124 vlist[0].class=PseudoColor;
125 vlist[0].bits_per_rgb=8;
126 vlist[0].map_entries=256;
127 vlist[0].red_mask=255;
128 vlist[0].green_mask=255<<8;
129 vlist[0].blue_mask=255<<16;
130 scrd=(Screen *) allocateMemory (sizeof (Screen));
131 (NT_window*)(scrd->root)= NT_new_window();
132 ((NT_window*)(scrd->root))->w=GetDesktopWindow();
133 ((NT_window*)(scrd->root))->parent=0;
134 GetWindowRect(GetDesktopWindow(),&rect);
135 scrd->width=rect.right-rect.left;
136 scrd->height=rect.bottom-rect.top;
137 scrd->mwidth=260;
138 scrd->mheight=190;
139 scrd->ndepths=1;
140 scrd->depths=dlist;
141 scrd->root_depth=depth;
142 scrd->root_visual=vlist;
143 scrd->default_gc=NULL;
144 scrd->cmap=cmap;
145 scrd->white_pixel=0xffffff;
146 scrd->black_pixel=0;
147
148 d=(Display *) allocateMemory (sizeof (Display));
149 scrd->display=d;
150 vs=(char *) allocateMemory (sizeof (char)*strlen (vstring)+1);
151 dn=(char *) allocateMemory (sizeof (char)*strlen (name)+1);
152 strcpy (vs,vstring);
153 strcpy (dn,name);
154 d->ext_data=NULL;
155 d->fd=0;
156 d->proto_major_version=11;
157 d->proto_minor_version=4;
158 d->vendor=vs;
159 d->release=4;
160 d->display_name=dn;
161 d->nscreens=1;
162 d->screens=scrd;
163 d->max_keycode=255;
164
165 return (d);
166 }
167
168
169 int
XCloseDisplay(Display * display)170 XCloseDisplay(Display *display)
171 {
172 NT_window *wanderer;
173
174 xtrace("XCloseDisplay\n");
175 /* Do something ? */
176 /* Must GlobalDelete all atoms/properties leftover */
177 return 0;
178 }
179
180 char *
XDisplayString(Display * display)181 XDisplayString(Display *display)
182 {
183 return (display->display_name);
184 }
185
186
187 int
XFlush(Display * display)188 XFlush(Display *display)
189 {
190 xtrace("XFlush\n");
191 return 0;
192 }
193
194
195 int
XSync(display,discard)196 XSync(display,discard)
197 Display *display;
198 int discard;
199 {
200 /* Do nothing here either */
201 return 0;
202 }
203
204 /*****************************************************************\
205
206 Function: XGetVisualInfo
207 Inputs: display, info mask, template, number of matches.
208 Returned: List of XVisualInfo structures, one for each matching
209 Visual.
210
211 Comments: Behaves like X routine, but there is only ever one
212 Visual, so the returned list is never longer than one.
213
214 \*****************************************************************/
215 XVisualInfo *
XGetVisualInfo(display,vinm,vint,n)216 XGetVisualInfo(display,vinm,vint,n)
217 Display *display;
218 long vinm;
219 XVisualInfo *vint;
220 int *n;
221 {
222 static XVisualInfo xvi;
223 int status=1;
224 xtrace("XGetVisualInfo\n");
225
226 if ((vinm&VisualIDMask|vinm==VisualAllMask)&&
227 vint->visualid!=display->screens->root_visual->visualid)
228 status=0;
229 if ((vinm&VisualScreenMask|vinm==VisualAllMask)&&
230 vint->screen!=0)
231 status=0;
232 if ((vinm&VisualDepthMask|vinm==VisualAllMask)&&
233 vint->depth!=24)
234 status=0;
235 if ((vinm&VisualClassMask|vinm==VisualAllMask)&&
236 vint->class!=display->screens->root_visual->class)
237 status=0;
238 if ((vinm&VisualRedMaskMask|vinm==VisualAllMask)&&
239 vint->red_mask!=display->screens->root_visual->red_mask)
240 status=0;
241 if ((vinm&VisualGreenMaskMask|vinm==VisualAllMask)&&
242 vint->green_mask!=display->screens->root_visual->green_mask)
243 status=0;
244 if ((vinm&VisualBlueMaskMask|vinm==VisualAllMask)&&
245 vint->blue_mask!=display->screens->root_visual->blue_mask)
246 status=0;
247 if ((vinm&VisualColormapSizeMask|vinm==VisualAllMask)&&
248 vint->colormap_size!=display->screens->root_visual->map_entries)
249 status=0;
250 if ((vinm&VisualBitsPerRGBMask|vinm==VisualAllMask)&&
251 vint->bits_per_rgb!=display->screens->root_visual->bits_per_rgb)
252 status=0;
253 if (status==1)
254 {
255 xvi.visualid=display->screens->root_visual->visualid;
256 xvi.screen=0;
257 xvi.depth=display->screens->root_visual->bits_per_rgb;
258 xvi.class=display->screens->root_visual->class;
259 xvi.red_mask=display->screens->root_visual->red_mask;
260 xvi.green_mask=display->screens->root_visual->green_mask;
261 xvi.blue_mask=display->screens->root_visual->blue_mask;
262 xvi.colormap_size=display->screens->root_visual->map_entries;
263 xvi.bits_per_rgb=display->screens->root_visual->bits_per_rgb;
264 xvi.visual=display->screens->root_visual;
265 *n=1;
266 return (&xvi);
267 }
268 *n=0;
269 return (&xvi);
270 }
271
XMatchVisualInfo(Display * display,int screen,int depth,int class,XVisualInfo * vinfo_return)272 StatusDef XMatchVisualInfo(
273 Display* display,
274 int screen,
275 int depth,
276 int class,
277 XVisualInfo* vinfo_return)
278 {
279 int status=0;
280 xtrace("XMatchVisualInfo\n");
281 return status;
282 }
283
284 /*****************************************************************\
285
286 Function: XClearWindow
287 Inputs: display, window
288
289 Comments: As mentioned, the Window structure is not the one windows
290 recognises. The background colour for the window is
291 stored in this structure.
292
293 The sequence of GetDC, CreateBrush/Pen, SelectObject,
294 <draw stuff>, DeleteObject, ReleaseDC occurs in all the
295 drawing functions.
296
297 \*****************************************************************/
298 int
XClearWindow(display,w)299 XClearWindow(display, w)
300 Display *display;
301 Window w;
302 {
303 RECT rRect;
304 HBRUSH hbrush;
305 HDC hDC;
306 HANDLE oldObj;
307 int oldROP;
308 NT_window *window = (NT_window *)w;
309 xtrace("XClearWindow\n");
310
311 if (VALID_WINDOW(window)) {
312 rRect.left= rRect.right=rRect.bottom=rRect.top =0;
313
314 hDC = cjh_get_dc(window);
315 oldROP = SetROP2(hDC,R2_COPYPEN);
316 hbrush = window->bg;
317 oldObj = SelectObject(hDC, hbrush);
318 GetClientRect(window->w, &rRect);
319 FillRect(hDC, &rRect, hbrush);
320 SelectObject(hDC, oldObj);
321 // DeleteObject(hbrush);
322 SetROP2(hDC,oldROP);
323 cjh_rel_dc(window,hDC);
324 }
325
326 return 0;
327 }
328
329 /*****************************************************************\
330
331 Function: XCreateSimpleWindow
332 Inputs: display, parent window, geometry, border width,
333 border colour, background colour.
334 Returned: Window ID
335
336 Comments: The first time a window is made by the application, it
337 has to be registered.
338 To simulate the action of a window manager, the toplevel
339 client window is reparented and a frame window is created.
340 A MapNotify event is sent to the new client.
341 Note that child windows are created in the manner of the
342 default X behaviour, ie. each is clipped individually.
343
344
345 NOTE: This routine has now changed. As part of our role as
346 Window manager, we now defer creation of the windows until
347 they are mapped. The fact that a window has been created
348 and not mapped is flagged to other routines by setting the
349 w element of the structure to -1.
350 WE STILL CREATE THE Window STRUCTURES.
351 (SEE XMapWindow)
352
353 \*****************************************************************/
354
355 Window
XCreateSimpleWindow(display,parent,x,y,w,h,brd,brd_col,bg)356 XCreateSimpleWindow(display, parent,x, y, w, h, brd, brd_col, bg)
357 Display *display;
358 Window parent;
359 int x, y;
360 unsigned int brd,w,h;
361 unsigned long bg, brd_col;
362 {
363 NT_window *canvas;
364 xtrace("XCreateSimpleWindow\n");
365
366 canvas = NT_new_window();
367
368 canvas->x = x;
369 canvas->y = y;
370 canvas->wdth = w;
371 canvas->hght = h;
372 NT_add_child((NT_window *)parent,canvas);
373 canvas->bg=CreateSolidBrush (CNUMTORGB(bg));
374 canvas->parent=(NT_window *)parent;
375 canvas->title_text = NULL;
376 if (canvas->parent->w == GetDesktopWindow())
377 {
378 if (x==0 && y==0)
379 {
380 canvas->x = -1;
381 canvas->y = -1;
382 }
383 canvas->top_flag = TRUE;
384 }
385 else
386 canvas->top_flag = 0;
387 return ((Window)canvas);
388 }
389
390
391 /*****************************************************************\
392
393 Function: XCreateWindow
394 Inputs: display, parent window, geometry, border width, depth,
395 class, visual, attributes mask, attributes structure
396 Returned: Window ID
397
398 Comments: Simply calls XCreateSimpleWindow. Some of the arguments
399 are ignored :-).
400
401 \*****************************************************************/
402
403 Window
XCreateWindow(display,parent,x,y,width,height,bw,depth,class,visual,valuemask,attr)404 XCreateWindow(display,parent,x,y,width,height,bw,depth,class,visual,
405 valuemask,attr)
406 Display *display;
407 Window parent;
408 int x,y;
409 unsigned int width,height,bw;
410 int depth;
411 unsigned int class;
412 Visual *visual;
413 unsigned long valuemask;
414 XSetWindowAttributes *attr;
415 {
416 xtrace("XCreateWindow\n");
417 return (XCreateSimpleWindow(display,parent,x,y,width,height,bw,
418 attr->border_pixel,attr->background_pixel));
419 }
420
421
422 /*****************************************************************\
423
424 Function: XDestroyWindow
425 Inputs: Display, window to be destroyed.
426
427 Comments: Removes a window from the server.
428
429 \*****************************************************************/
430 int
XDestroyWindow(display,w)431 XDestroyWindow(display,w)
432 Display *display;
433 Window w;
434 {
435 NT_window *ntw = (NT_window *)w;
436 xtrace("XDestroyWindow\n");
437 if (ntw->hDC != INVALID_HANDLE)
438 {
439 ReleaseDC(ntw->w,ntw->hDC);
440 ntw->hDC = INVALID_HANDLE;
441 }
442
443 /*DestroyWindow(w->w);*/
444 NT_delete_window(ntw); /* Remove window from data structure */
445 return 0;
446 }
447
448
449 /*****************************************************************\
450
451 Function: XGetGeometry
452 Inputs: display, window
453 Returned: root window, screen depth, geometry, border width
454
455 Comments: fetches information from the windows kernel and our
456 display structure.
457
458 \*****************************************************************/
459
460 StatusDef
XGetGeometry(display,w,root,x,y,width,height,bw,depth)461 XGetGeometry(display,w,root,x,y,width,height,bw,depth)
462 Display *display;
463 Drawable w;
464 Window *root;
465 int *x,*y;
466 unsigned int *width,*height;
467 unsigned int *bw,*depth;
468 {
469 NT_window *ntw = (NT_window *)w;
470 RECT r;
471 xtrace("XGetGeometry\n");
472
473 *root=display->screens[0].root;
474 *depth=24;
475
476 GetWindowRect(ntw->w,&r);
477 *x=r.left;
478 *y=r.top;
479 GetClientRect(ntw->w,&r);
480 *width=r.right-r.left;
481 if (*width<ntw->minx)
482 *width=ntw->minx;
483 *height=r.bottom-r.top;
484 if (*height<ntw->miny)
485 *height=ntw->miny;
486 *bw=(*width-(r.right-r.left))/2;
487
488 return 0;
489 }
490
491
492 /*****************************************************************\
493
494 Function: XGetWindowAttributes
495 Inputs: display, window, attributes
496 Returned: 1 = ok.
497
498 Comments: Fills out attributes structure.
499
500 \*****************************************************************/
501
502 StatusDef
XGetWindowAttributes(display,w,wattr)503 XGetWindowAttributes(display,w,wattr)
504 Display *display;
505 Window w;
506 XWindowAttributes *wattr;
507 {
508 xtrace("XGetWindowAttributes\n");
509 XGetGeometry(display,w,&wattr->root,&wattr->x,&wattr->y,&wattr->width,
510 &wattr->height,&wattr->border_width,&wattr->depth);
511 wattr->class=InputOutput;
512 wattr->bit_gravity=StaticGravity;
513 wattr->win_gravity=CenterGravity;
514 wattr->backing_store=NotUseful;
515 wattr->backing_planes=0;
516 wattr->backing_pixel=0;
517 wattr->save_under=0;
518 wattr->colormap=None;
519 wattr->map_installed=TRUE;
520 wattr->map_state=IsViewable;
521 wattr->override_redirect=FALSE;
522 wattr->screen=display->screens;
523 return (1);
524 }
525
526
527
528 int
XSelectInput(display,window,mask)529 XSelectInput(display, window, mask)
530 Display *display;
531 Window window;
532 long mask;
533 {
534 NT_window *ntw = (NT_window *)window;
535 xtrace("XSelectInput\n");
536 ntw->mask=mask;
537 return 0;
538 }
539
NT_dispError(char * msg)540 void NT_dispError(char *msg)
541 {
542 LPVOID lpMsgBuf=NULL;
543 FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,NULL,
544 GetLastError(),
545 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
546 (LPTSTR) &lpMsgBuf,
547 0,
548 NULL);
549 MessageBox( NULL, lpMsgBuf, msg, MB_OK|MB_ICONINFORMATION );
550 LocalFree( lpMsgBuf );
551 }
552
553
554 /*****************************************************************\
555
556 Function: XMapWindow
557 Inputs: display, window to be mapped
558
559 Comments: If the specified window is not already mapped, this
560 routine calls the Windows function which displays it.
561 Again, frames have to be mapped as well as clients.
562
563 \*****************************************************************/
564 int
XMapWindow(display,window)565 XMapWindow(display, window)
566 Display *display;
567 Window window;
568 {
569 NT_window *ntw = (NT_window *)window;
570 RECT rect;
571 unsigned char *hints;
572 Atom property;
573 Atom ret_type;
574 int ret_format;
575 DWORD frame_style;
576 long ret_nitems;
577 long ret_after;
578 HDC hDC;
579 char *title = "";
580 xtrace("XMapWindow\n");
581
582 if (ntw->w == INVALID_HANDLE)
583 {
584 frame_style = WS_CHILD|WS_CLIPCHILDREN|WS_CLIPSIBLINGS;
585 if (ntw->top_flag)
586 {
587 /* frame_style = WS_CLIPCHILDREN;
588 frame_style |= WS_BORDER;
589 frame_style |= WS_THICKFRAME;
590 frame_style |= WS_CAPTION;
591 frame_style |= WS_POPUP;
592 frame_style |= WS_SYSMENU;
593 frame_style |= WS_MINIMIZEBOX;
594 frame_style |= WS_MAXIMIZEBOX;
595 */
596 frame_style = WS_OVERLAPPEDWINDOW|WS_CLIPCHILDREN;
597 ntw->hght += GetSystemMetrics(SM_CYSIZE)+(GetSystemMetrics(SM_CYBORDER)+GetSystemMetrics(SM_CYFRAME))*2;
598 ntw->wdth += (GetSystemMetrics(SM_CXBORDER) + GetSystemMetrics(SM_CXFRAME))*2;
599 title = ntw->title_text;
600 if (ntw->x == -1 && ntw->y == -1)
601 {
602 ntw->x = CW_USEDEFAULT;
603 ntw->y = CW_USEDEFAULT;
604 }
605 }
606 else if (ntw->x == -1 && ntw->y == -1)
607 {
608 GetClientRect(ntw->parent->w,&rect);
609 ntw->x = rect.left;
610 ntw->y = rect.top;
611 ntw->wdth = rect.right-rect.left;
612 ntw->hght = rect.bottom - rect.top;
613 }
614
615 ntw->hDC = INVALID_HANDLE;
616
617 if (ntw->parent->w == INVALID_HANDLE)
618 {
619 XMapWindow(display, (Window)ntw->parent);
620 }
621 ntw->w = NT_create_window(title,frame_style,
622 ntw->x,ntw->y,ntw->wdth,ntw->hght,
623 ntw->parent->w);
624 if (ntw->w==NULL) NT_dispError("create window1");
625 hDC = cjh_get_dc(ntw);
626 PostMessage(ntw->w,USR_MapNotify,0,0);
627 }
628 if (IsWindowVisible(ntw->w)==0)
629 {
630 ShowWindow(ntw->w, SW_SHOW);
631 PostMessage(ntw->w,USR_MapNotify,0,0);
632 }
633 UpdateWindow(ntw->w);
634 return 0;
635 }
636
637 int
XIconifyWindow(Display * display,Window w,int screen_number)638 XIconifyWindow(Display *display,
639 Window w,
640 int screen_number)
641 {
642 xtrace("XIconifyWindow\n");
643 return 0;
644 }
645
646
647 /*****************************************************************\
648
649 Function: XCreateGC
650 Inputs: display, window, mask of setup values, setup values.
651 Returned: GC pointer.
652
653 Comments: Fills out a GC structure with the X defaults unless
654 the caller specifies otherwise.
655
656 \*****************************************************************/
657
658 GC
XCreateGC(display,window,mask,gc_values)659 XCreateGC(display, window, mask, gc_values)
660 Display *display;
661 Drawable window;
662 unsigned long mask;
663 XGCValues *gc_values;
664 {
665 GC local_gc;
666 int size;
667 char *ptr;
668 xtrace("XCreateGC\n");
669
670 size = sizeof(GC);
671
672 ptr = (char *)allocateMemory((size_t)1000);
673 local_gc = (GC)ptr;
674 local_gc->ext_data = NULL;
675 local_gc->gid=(GContext) window;
676 local_gc->rects=FALSE;
677 local_gc->dashes=FALSE;
678
679 if (mask&GCArcMode)
680 local_gc->values.arc_mode=gc_values->arc_mode;
681 else
682 local_gc->values.arc_mode=ArcPieSlice;
683 if (mask&GCBackground)
684 local_gc->values.background=gc_values->background;
685 else
686 local_gc->values.background=display->screens->white_pixel;
687 if (mask&GCCapStyle)
688 local_gc->values.cap_style=gc_values->cap_style;
689 else
690 local_gc->values.cap_style=CapButt;
691 if (mask&GCClipMask)
692 local_gc->values.clip_mask=gc_values->clip_mask;
693 else
694 local_gc->values.clip_mask=None;
695 if (mask&GCClipXOrigin)
696 local_gc->values.clip_x_origin=gc_values->clip_x_origin;
697 else
698 local_gc->values.clip_x_origin=0;
699 if (mask&GCClipYOrigin)
700 local_gc->values.clip_y_origin=gc_values->clip_y_origin;
701 else
702 local_gc->values.clip_y_origin=0;
703 if (mask&GCDashList)
704 local_gc->values.dashes=gc_values->dashes;
705 else
706 local_gc->values.dashes=4;
707 if (mask&GCDashOffset)
708 local_gc->values.dash_offset=gc_values->dash_offset;
709 else
710 local_gc->values.dash_offset=0;
711 if (mask&GCFillRule)
712 local_gc->values.fill_rule=gc_values->fill_rule;
713 else
714 local_gc->values.fill_rule=EvenOddRule;
715 if (mask&GCFillStyle)
716 local_gc->values.fill_style=gc_values->fill_style;
717 else
718 local_gc->values.fill_style=FillSolid;
719 if (mask&GCFont)
720 local_gc->values.font=gc_values->font;
721 else
722 local_gc->values.font= 999;/*"fixed";*/
723 if (mask&GCForeground)
724 local_gc->values.foreground=gc_values->foreground;
725 else
726 local_gc->values.foreground=display->screens->black_pixel;
727 if (mask&GCFunction)
728 local_gc->values.function=gc_values->function;
729 else
730 local_gc->values.function=GXcopy;
731 if (mask&GCGraphicsExposures)
732 local_gc->values.graphics_exposures=gc_values->graphics_exposures;
733 else
734 local_gc->values.graphics_exposures=True;
735 if (mask&GCJoinStyle)
736 local_gc->values.join_style=gc_values->join_style;
737 else
738 local_gc->values.join_style=JoinMiter;
739 if (mask&GCLineStyle)
740 local_gc->values.line_style=gc_values->line_style;
741 else
742 local_gc->values.line_style=LineSolid;
743 if (mask&GCLineWidth)
744 local_gc->values.line_width=gc_values->line_width;
745 else
746 local_gc->values.line_width=0;
747 if (mask&GCPlaneMask)
748 local_gc->values.plane_mask=gc_values->plane_mask;
749 else
750 local_gc->values.plane_mask=255;
751 if (mask&GCStipple)
752 local_gc->values.stipple=gc_values->stipple;
753 else
754 local_gc->values.stipple=0;
755 if (mask&GCSubwindowMode)
756 local_gc->values.subwindow_mode=gc_values->subwindow_mode;
757 else
758 local_gc->values.subwindow_mode=ClipByChildren;
759 if (mask&GCTile)
760 local_gc->values.tile=gc_values->tile;
761 else
762 local_gc->values.tile=0;
763 if (mask&GCTileStipXOrigin)
764 local_gc->values.ts_x_origin=gc_values->ts_x_origin;
765 else
766 local_gc->values.ts_x_origin=0;
767 if (mask&GCTileStipYOrigin)
768 local_gc->values.ts_y_origin=gc_values->ts_y_origin;
769 else
770 local_gc->values.ts_y_origin=0;
771
772 local_gc->dirty = ~0;
773
774 return (local_gc);
775 }
776
777 int
XFreeGC(display,gc)778 XFreeGC(display, gc)
779 Display *display;
780 GC gc;
781 {
782 freeMemory(gc);
783 }
784
785 /*****************************************************************\
786
787 Function: XSetForeground
788 Inputs: display, gc, colour.
789
790 Comments: Colour is an RGB triple (24bits).
791 \*****************************************************************/
792 int
XSetForeground(display,gc,color)793 XSetForeground(display, gc, color)
794 Display *display;
795 GC gc;
796 unsigned long color;
797 {
798 xtrace("XSetForegrond\n");
799 gc->values.foreground=color;
800 gc->dirty |= GCForeground;
801 return 0;
802 }
803
804
805 /*****************************************************************\
806
807 Function: XDrawString
808 Inputs: display, window, gc, position, string, length of string.
809
810 Comments: Writes text to the screen in the manner of X windows.
811 Note that the y origin is on the text baseline, ie.
812 the lowest part of a letter o rests on the baseline and
813 descenders fall below it.
814 The text is transparent.
815
816 \*****************************************************************/
817
818 int
XDrawString(Display * display,Drawable window,GC gc,int x,int y,const char * str,int len)819 XDrawString(Display *display, Drawable window,
820 GC gc, int x, int y, const char* str, int len)
821 {
822 HDC hDC;
823 TEXTMETRIC tmet;
824 HFONT old;
825 xtrace("XDrawString\n");
826
827 if (VALID_WINDOW(window))
828 {
829 hDC = drawableGetDC(window);
830 SetBkMode(hDC,TRANSPARENT);
831 SetTextColor(hDC,CNUMTORGB(gc->values.foreground));
832 old=SelectObject(hDC,(HFONT)gc->values.font);
833 GetTextMetrics(hDC,&tmet);
834 TextOut(hDC,x,y-tmet.tmAscent,str,len);
835 SelectObject(hDC,old);
836 drawableRelDC(window,hDC);
837 }
838 return 0;
839 }
840
841
842
843 int
XDrawString16(Display * display,Drawable window,GC gc,int x,int y,const XChar2b * str,int len)844 XDrawString16(Display *display, Drawable window,
845 GC gc, int x, int y,
846 const XChar2b* str,
847 int len)
848 {
849 xtrace("XDrawString16\n");
850 XDrawString(display, window, gc, x, y, (const char*)str, len*2);
851 return 0;
852 }
XDrawImageString(Display * display,Drawable d,GC gc,int x,int y,const char * string,int length)853 XDrawImageString(
854 Display* display,
855 Drawable d,
856 GC gc,
857 int x,
858 int y,
859 const char* string,
860 int length)
861 {
862 HDC hDC = NULL;
863 TEXTMETRIC tmet;
864 HFONT old;
865 xtrace("XDrawImageString\n");
866 if (VALID_WINDOW(d))
867 {
868 hDC = drawableGetDC(d);
869 SetBkMode(hDC,TRANSPARENT);
870 SetBkColor(hDC, CNUMTORGB(gc->values.background));
871 SetTextColor(hDC,CNUMTORGB(gc->values.foreground));
872 old=SelectObject(hDC,(HFONT)gc->values.font);
873 if (GetTextMetrics(hDC,&tmet) && length>0) {
874 RECT fill;
875 fill.top = y-tmet.tmAscent;
876 fill.bottom = y+tmet.tmDescent;
877 fill.left = x;
878 fill.right = x + (tmet.tmAveCharWidth * length);
879 FillRect( hDC, &fill, NT_get_GC_bgbrush(hDC,gc));
880 }
881 TextOut( hDC, x, y-tmet.tmAscent, string, length );
882 SelectObject(hDC,old);
883 drawableRelDC(d,hDC);
884 }
885 return 0;
886 }
887
888 int
XDrawImageString16(Display * display,Drawable window,GC gc,int x,int y,const XChar2b * str,int len)889 XDrawImageString16(Display *display, Drawable window,
890 GC gc, int x, int y,
891 const XChar2b* str,
892 int len)
893 {
894 xtrace("XDrawImageString16\n");
895 XDrawImageString(display, window, gc, x, y, (const char*)str, len*2);
896 return 0;
897 }
898
899
900 /*****************************************************************\
901
902 Function: XFillRectangle
903 Inputs: display, window, gc, geometry.
904
905 Comments: fills rectangles in uniform colours. No tiles/Pixmaps
906 are implemented yet.
907
908 \*****************************************************************/
909
910 int
XFillRectangle(display,window,gc,x,y,w,h)911 XFillRectangle (display,window,gc,x,y,w,h)
912 Display *display;
913 Drawable window;
914 GC gc;
915 int x,y;
916 unsigned int w,h;
917 {
918 RECT rct;
919 HBRUSH hbrush;
920 HDC hDC;
921 HANDLE oldObj;
922 int ret;
923 xtrace("XFillRectangle\n");
924
925 if (VALID_WINDOW(window))
926 {
927 hDC = drawableGetDC(window);
928 NT_set_rop(hDC,gc);
929 hbrush = NT_get_GC_brush(hDC,gc);
930 oldObj = SelectObject(hDC, hbrush);
931 rct.left=(LONG) x;
932 rct.right=(LONG) (x+w);
933 rct.top=(LONG) y;
934 rct.bottom=(LONG) (y+h);
935 ret=FillRect(hDC, &rct, hbrush);
936 SelectObject(hDC, oldObj);
937 drawableRelDC(window,hDC);
938 }
939 return (ret);
940 }
941
942
943 /*****************************************************************\
944
945 Function: XClearArea
946 Inputs: display, geometry, exposure events allowed.
947
948 Comments: Straightforward.
949
950 \*****************************************************************/
951 int
XClearArea(display,w,x,y,width,height,exposures)952 XClearArea(display,w,x,y,width,height,exposures)
953 Display *display;
954 Window w;
955 int x,y;
956 unsigned int width,height;
957 BoolDef exposures;
958 {
959 NT_window *ntw = (NT_window *)w;
960 RECT rct;
961 HBRUSH hbrush;
962 HDC hDC;
963 HANDLE oldObj;
964 int oldROP;
965 xtrace("XClearArea\n");
966
967 if (VALID_WINDOW(ntw))
968 {
969 hDC = cjh_get_dc(ntw);
970 oldROP = SetROP2(hDC,R2_COPYPEN);
971 hbrush=ntw->bg;
972 oldObj = SelectObject(hDC,hbrush);
973 GetClientRect(ntw->w,&rct);
974
975 if ((width != 0) && (height != 0))
976 {
977 rct.left=(LONG)x;
978 rct.right=(LONG)(x+width);
979 rct.top=(LONG)y;
980 rct.bottom=(LONG)(y+height);
981 FillRect(hDC,&rct,hbrush);
982 }
983
984 SelectObject(hDC, oldObj);
985 // DeleteObject(hbrush);
986 SetROP2(hDC,oldROP);
987 cjh_rel_dc(ntw,hDC);
988 }
989 return 0;
990 }
991
992
993 Region
XCreateRegion()994 XCreateRegion()
995 {
996 HRGN hrgn;
997 xtrace("XCreateRegion\n");
998
999 hrgn=CreateRectRgn(0,0,1,1);
1000 return ((Region)hrgn);
1001 }
1002
1003
1004 /* Untested. The Region stuff needs thinking about. */
1005
1006 int
XClipBox(hrgn,rect)1007 XClipBox(hrgn,rect)
1008 Region hrgn;
1009 XRectangle *rect;
1010 {
1011 RECT rct;
1012 xtrace("XClipBox\n");
1013
1014 GetRgnBox((HRGN)hrgn,&rct);
1015 rect->x=(short)rct.left;
1016 rect->y=(short)rct.top;
1017 rect->width=(unsigned short)(rct.right-rct.left);
1018 rect->height=(unsigned short)(rct.bottom-rct.top);
1019 return TRUE;/*(rect);*/
1020 }
1021
1022
1023 int
XSetRegion(display,gc,hrgn)1024 XSetRegion(display,gc,hrgn)
1025 Display *display;
1026 GC gc;
1027 Region hrgn;
1028 {
1029 /* What to do here ? */
1030 xtrace("XSetRegion\n");
1031 return 0;
1032 }
1033
1034
1035 int
XDestroyRegion(hrgn)1036 XDestroyRegion(hrgn)
1037 Region hrgn;
1038 {
1039 xtrace("XDestroyRegion\n");
1040 DeleteObject(hrgn);
1041 return 0;
1042 }
1043
1044
1045 int
XUnionRectWithRegion(rect,hrgnsrc,hrgndest)1046 XUnionRectWithRegion(rect,hrgnsrc,hrgndest)
1047 XRectangle *rect;
1048 Region hrgnsrc,hrgndest;
1049 {
1050 HRGN temp;
1051 xtrace("XUnionRectWithRegion\n");
1052 temp=CreateRectRgn(rect->x,rect->y,rect->x+rect->width,
1053 rect->y+rect->height);
1054 CombineRgn((HRGN)hrgndest,(HRGN)hrgnsrc,temp,RGN_OR);
1055 return 0;
1056 }
1057
1058
1059 /*****************************************************************\
1060
1061 Function: XDrawArc
1062 Inputs: display, window, gc, bounding box geometry, arc angles.
1063
1064 Comments: Works fine.
1065
1066 \*****************************************************************/
1067
1068 int
XDrawArc(display,w,gc,x,y,width,height,a1,a2)1069 XDrawArc(display,w,gc,x,y,width,height,a1,a2)
1070 Display *display;
1071 Drawable w;
1072 GC gc;
1073 int x,y;
1074 unsigned int width,height;
1075 int a1,a2;
1076 {
1077 HDC hDC;
1078 HPEN hpen;
1079 int tmp;
1080 double NT_deg64_to_rad();
1081 HANDLE oldObj;
1082 xtrace("XDrawArc\n");
1083 if (a2>=0)
1084 a2+=a1;
1085 else
1086 {
1087 tmp=a1;
1088 a1-=a2;
1089 a2=tmp;
1090 }
1091
1092 if (VALID_WINDOW(w))
1093 {
1094 hDC = drawableGetDC(w);
1095 hpen = NT_get_GC_pen(hDC,gc);
1096 oldObj = SelectObject(hDC,hpen);
1097 Arc(hDC,x,y,x+width-1,y+height-1,
1098 (int) (x+width/2+width*cos(NT_deg64_to_rad(a1))),
1099 (int) (y+height/2-height*sin(NT_deg64_to_rad(a1))),
1100 (int) (x+width/2+width*cos(NT_deg64_to_rad(a2))),
1101 (int) (y+height/2-height*sin(NT_deg64_to_rad(a2))));
1102 SelectObject(hDC, oldObj);
1103 drawableRelDC(w,hDC);
1104 }
1105 return 0;
1106 }
1107
1108
1109 /*****************************************************************\
1110
1111 Function: XFillArc
1112 Inputs: display, window, gc, geometry as above.
1113
1114 Comments: Not tested at all, but should work.
1115
1116 \*****************************************************************/
1117
1118 int
XFillArc(display,w,gc,x,y,width,height,a1,a2)1119 XFillArc(display,w,gc,x,y,width,height,a1,a2)
1120 Display *display;
1121 Drawable w;
1122 GC gc;
1123 int x,y;
1124 unsigned int width,height;
1125 int a1,a2;
1126 {
1127 HDC hDC;
1128 HBRUSH hbrush;
1129 int tmp;
1130 HANDLE oldObj;
1131 xtrace("XFillArc\n");
1132 if (a2>=0)
1133 a2+=a1;
1134 else
1135 {
1136 tmp=a1;
1137 a1-=a2;
1138 a2=tmp;
1139 }
1140 if (VALID_WINDOW(w))
1141 {
1142 hDC = drawableGetDC(w);
1143 hbrush = NT_get_GC_brush(hDC,gc);
1144 oldObj = SelectObject(hDC,hbrush);
1145 if (gc->values.arc_mode==ArcChord)
1146 {
1147 Chord(hDC,x,y,x+width,y+height,
1148 (int) (x+width/2+width*cos(NT_deg64_to_rad(a1))),
1149 (int) (y+height/2+height*sin(NT_deg64_to_rad(a1))),
1150 (int) (x+width/2+width*cos(NT_deg64_to_rad(a2))),
1151 (int) (y+height/2+height*sin(NT_deg64_to_rad(a2))));
1152 }
1153 else
1154 {
1155 Pie(hDC,x,y,x+width,y+height,
1156 (int) (x+width/2+width*cos(NT_deg64_to_rad(a1))),
1157 (int) (y+height/2+height*sin(NT_deg64_to_rad(a1))),
1158 (int) (x+width/2+width*cos(NT_deg64_to_rad(a2))),
1159 (int) (y+height/2+height*sin(NT_deg64_to_rad(a2))));
1160 }
1161 SelectObject(hDC, oldObj);
1162 drawableRelDC(w,hDC);
1163 }
1164 return 0;
1165 }
1166
1167
1168 /*****************************************************************\
1169
1170 Function: XFillPolygon
1171 Inputs: display, window, gc, points list, number of points,
1172 shape hint, relative drawing mode.
1173
1174 Comments: Works for convex polygons. Untested on otherwise.
1175 Optimisation hints are unused, as is the mode.
1176
1177 \*****************************************************************/
1178
1179 int
XFillPolygon(display,w,gc,points,nps,shape,mode)1180 XFillPolygon(display,w,gc,points,nps,shape,mode)
1181 Display *display;
1182 Drawable w;
1183 GC gc;
1184 XPoint *points;
1185 int nps,shape,mode;
1186 {
1187 HBRUSH hbrush;
1188 int n;
1189 POINT ntps[1000];
1190 HDC hDC;
1191 HANDLE oldObj;
1192 xtrace("XFillPolygon\n");
1193 /*ntps=allocateMemory(sizeof(POINT)*nps);*/
1194 if (VALID_WINDOW(w))
1195 {
1196 hDC = drawableGetDC(w);
1197 hbrush = NT_get_GC_brush(hDC,gc);
1198 oldObj = SelectObject(hDC,hbrush);
1199 for (n=0;n<nps;++n)
1200 {
1201 (ntps+n)->x=(LONG)points->x;
1202 (ntps+n)->y=(LONG)(points++)->y;
1203 }
1204 Polygon(hDC,ntps,nps);
1205 SelectObject(hDC, oldObj);
1206 drawableRelDC(w,hDC);
1207 }
1208
1209 /*free(ntps);*/
1210 return 0;
1211 }
1212
1213
1214 /*****************************************************************\
1215
1216 Function: XDrawLine
1217 Inputs: display, window, geometry.
1218
1219 Comments: Seems to work ok.
1220
1221 \*****************************************************************/
1222
1223 int
XDrawLine(display,w,gc,x1,y1,x2,y2)1224 XDrawLine(display,w,gc,x1,y1,x2,y2)
1225 Display *display;
1226 Drawable w;
1227 GC gc;
1228 int x1,y1,x2,y2;
1229 {
1230 HDC hDC;
1231 HPEN hpen;
1232 RECT da;
1233 HANDLE oldObj;
1234 xtrace("XDrawLine\n");
1235
1236 if (VALID_WINDOW(w))
1237 {
1238 hDC = drawableGetDC(w);
1239 hpen = NT_get_GC_pen(hDC,gc);
1240 oldObj = SelectObject(hDC,hpen);
1241 MoveToEx(hDC,x1,y1,NULL);
1242 LineTo(hDC,x2,y2);
1243 SelectObject(hDC, oldObj);
1244 drawableRelDC(w,hDC);
1245 }
1246 return 0;
1247 }
1248
1249
1250 /*****************************************************************\
1251
1252 Function: XDrawLines
1253 Inputs: display, window, gc, points list, number of points, mode.
1254
1255 Comments: Untested.
1256
1257 \*****************************************************************/
1258
1259 int
XDrawLines(display,w,gc,points,nps,mode)1260 XDrawLines(display,w,gc,points,nps,mode)
1261 Display *display;
1262 Drawable w;
1263 GC gc;
1264 XPoint *points;
1265 int nps,mode;
1266 {
1267 HPEN hpen;
1268 int n;
1269 POINT pts[1000];
1270 HDC hDC;
1271 HANDLE oldObj;
1272 xtrace("XDrawLines\n");
1273
1274 pts->x=(LONG)points->x;
1275 pts->y=(LONG)points->y;
1276
1277 for(n=1;n<nps;++n)
1278 if (mode==CoordModeOrigin)
1279 {
1280 (pts+n)->x=(LONG)(points+n)->x;
1281 (pts+n)->y=(LONG)(points+n)->y;
1282 }
1283 else
1284 {
1285 (pts+n)->x=(LONG)(points+n)->x+(pts+n-1)->x;
1286 (pts+n)->y=(LONG)(points+n)->y+(pts+n-1)->y;
1287 }
1288
1289 if (VALID_WINDOW(w))
1290 {
1291 hDC = drawableGetDC(w);
1292 hpen = NT_get_GC_pen(hDC,gc);
1293 oldObj = SelectObject(hDC,hpen);
1294 Polyline(hDC,pts,nps);
1295 SelectObject(hDC, oldObj);
1296 drawableRelDC(w,hDC);
1297 }
1298 return 0;
1299 }
1300
1301
1302 /*****************************************************************\
1303
1304 Function: XDrawPoints
1305 Inputs: display, window, gc, points list, number of points, mode.
1306
1307 Comments: Untested.
1308
1309 \*****************************************************************/
1310
1311 int
XDrawPoints(display,w,gc,points,nps,mode)1312 XDrawPoints(display,w,gc,points,nps,mode)
1313 Display *display;
1314 Drawable w;
1315 GC gc;
1316 XPoint *points;
1317 int nps,mode;
1318 {
1319 HDC hDC;
1320 int n;
1321 xtrace("XDrawPoints\n");
1322 if (VALID_WINDOW(w))
1323 {
1324 hDC = drawableGetDC(w);
1325 SetPixelV(hDC,points->x,points->y,CNUMTORGB(gc->values.foreground));
1326 for (n=1;n<nps;++n)
1327 {
1328 if (mode==CoordModeOrigin)
1329 SetPixelV(hDC,(points+n)->x,(points+n)->y,
1330 CNUMTORGB(gc->values.foreground));
1331 else
1332 SetPixelV(hDC,(points+n-1)->x+(points+n)->x,
1333 (points+n-1)->y+(points+n)->y,
1334 CNUMTORGB(gc->values.foreground));
1335 }
1336 drawableRelDC(w,hDC);
1337 }
1338 return 0;
1339 }
1340 int
XDrawPoint(display,w,gc,x,y)1341 XDrawPoint(display,w,gc,x,y)
1342 Display *display;
1343 Drawable w;
1344 GC gc;
1345 int x,y;
1346 {
1347 HDC hDC;
1348 xtrace("XDrawPoint\n");
1349 if (VALID_WINDOW(w))
1350 {
1351 hDC = drawableGetDC(w);
1352 SetPixelV(hDC,x,y,CNUMTORGB(gc->values.foreground));
1353 drawableRelDC(w,hDC);
1354 }
1355 return 0;
1356 }
1357
1358
1359 /*****************************************************************\
1360
1361 Function: XDrawRectangle
1362 Inputs: display, window, gc, geometry
1363
1364 Comments: Seems to work.
1365
1366 \*****************************************************************/
1367
1368 int
XDrawRectangle(display,w,gc,x,y,width,height)1369 XDrawRectangle(display,w,gc,x,y,width,height)
1370 Display *display;
1371 Drawable w;
1372 GC gc;
1373 int x,y;
1374 unsigned int width,height;
1375 {
1376 HDC hDC;
1377 RECT rect;
1378 HBRUSH hbrush;
1379 HPEN hpen;
1380 HANDLE oldbrush, oldpen;
1381 xtrace("XDrawRectangle\n");
1382 if (VALID_WINDOW(w))
1383 {
1384 hDC = drawableGetDC(w);
1385 hbrush = NT_get_GC_brush(hDC,gc);
1386 rect.left=(LONG)x;
1387 rect.right=(LONG)(x+width);
1388 rect.top=(LONG)y;
1389 rect.bottom=(LONG)(y+height);
1390 oldbrush = SelectObject(hDC,GetStockObject(NULL_BRUSH));
1391 hpen = NT_get_GC_pen(hDC,gc);
1392 oldpen = SelectObject(hDC,hpen);
1393
1394 Rectangle(hDC,(int)rect.left,(int)rect.top,(int)rect.right,(int)rect.bottom);
1395 /*
1396 FrameRect(hDC,&rect,hbrush);
1397 */
1398 SelectObject(hDC, oldbrush);
1399 SelectObject(hDC, oldpen);
1400 drawableRelDC(w,hDC);
1401 }
1402 return 0;
1403 }
1404
1405
1406 /*****************************************************************\
1407
1408 Function: XDrawSegments
1409 Inputs: display, window, gc, segment list, number of segments.
1410
1411 Comments: Untested.
1412
1413 \*****************************************************************/
1414
1415 int
XDrawSegments(display,w,gc,segs,nsegs)1416 XDrawSegments(display,w,gc,segs,nsegs)
1417 Display *display;
1418 Drawable w;
1419 GC gc;
1420 XSegment *segs;
1421 int nsegs;
1422 {
1423 HDC hDC;
1424 HPEN hpen;
1425 int n;
1426 HANDLE oldObj;
1427 xtrace("XDrawSegments\n");
1428 if (VALID_WINDOW(w))
1429 {
1430 hDC = drawableGetDC(w);
1431 hpen = NT_get_GC_pen(hDC,gc);
1432 oldObj = SelectObject(hDC,hpen);
1433 SetBkMode(hDC,TRANSPARENT);
1434 for (n=0;n<nsegs;n++)
1435 {
1436 MoveToEx(hDC,(segs+n)->x1,(segs+n)->y1,NULL);
1437 LineTo(hDC,(segs+n)->x2,(segs+n)->y2);
1438 }
1439 SelectObject(hDC, oldObj);
1440 drawableRelDC(w,hDC);
1441 }
1442 return 0;
1443 }
1444
1445 Pixmap
XCreatePixmap(display,drawable,width,height,depth)1446 XCreatePixmap(display,drawable,width,height,depth)
1447 Display *display;
1448 Drawable drawable;
1449 unsigned int width, height;
1450 unsigned int depth;
1451 {
1452 RECT rct;
1453 NT_window *w = (NT_window *)NT_new_window();
1454 HDC parenthDC = drawableGetDC(drawable);
1455 w->hDC = CreateCompatibleDC(parenthDC);
1456 w->hBitmap = CreateCompatibleBitmap(parenthDC,width,height);
1457 SelectObject(w->hDC, w->hBitmap);
1458
1459 rct.left=(LONG) 0;
1460 rct.right=(LONG) width;
1461 rct.top=(LONG) 0;
1462 rct.bottom=(LONG) height;
1463 FillRect(w->hDC, &rct, GetStockObject(WHITE_BRUSH));
1464
1465 drawableRelDC(drawable,parenthDC);
1466
1467 w->w = NONMAPPED_HANDLE;
1468 w->x=0;
1469 w->y=0;
1470 w->wdth = width;
1471 w->hght = height;
1472 w->min = depth;
1473 return (Pixmap)w;
1474 }
1475
1476 const char revBytes[]={
1477 0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0, 0x10, 0x90, 0x50,
1478 0xd0, 0x30, 0xb0, 0x70, 0xf0, 0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8,
1479 0x68, 0xe8, 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8, 0x04,
1480 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4, 0x14, 0x94, 0x54, 0xd4,
1481 0x34, 0xb4, 0x74, 0xf4, 0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c,
1482 0xec, 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc, 0x02, 0x82,
1483 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2, 0x12, 0x92, 0x52, 0xd2, 0x32,
1484 0xb2, 0x72, 0xf2, 0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
1485 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa, 0x06, 0x86, 0x46,
1486 0xc6, 0x26, 0xa6, 0x66, 0xe6, 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6,
1487 0x76, 0xf6, 0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee, 0x1e,
1488 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe, 0x01, 0x81, 0x41, 0xc1,
1489 0x21, 0xa1, 0x61, 0xe1, 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71,
1490 0xf1, 0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9, 0x19, 0x99,
1491 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9, 0x05, 0x85, 0x45, 0xc5, 0x25,
1492 0xa5, 0x65, 0xe5, 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
1493 0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed, 0x1d, 0x9d, 0x5d,
1494 0xdd, 0x3d, 0xbd, 0x7d, 0xfd, 0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3,
1495 0x63, 0xe3, 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3, 0x0b,
1496 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb, 0x1b, 0x9b, 0x5b, 0xdb,
1497 0x3b, 0xbb, 0x7b, 0xfb, 0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67,
1498 0xe7, 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7, 0x0f, 0x8f,
1499 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef, 0x1f, 0x9f, 0x5f, 0xdf, 0x3f,
1500 0xbf, 0x7f, 0xff
1501 };
1502
1503
1504 Pixmap
XCreateBitmapFromData(Display * display,Drawable drawable,const char * data,unsigned int width,unsigned int height)1505 XCreateBitmapFromData(Display *display,
1506 Drawable drawable, const char *data,
1507 unsigned int width, unsigned int height)
1508 {
1509 NT_window *w = (NT_window *)NT_new_window();
1510 HDC parenthDC = drawableGetDC(drawable);
1511 w->hDC = CreateCompatibleDC(parenthDC);
1512
1513 {
1514 int i,j;
1515 char *newdata;
1516 int bytes = (width+7)>>3;
1517 int newbytes = (bytes&1)?bytes+1:bytes;
1518 newdata = allocateMemory(newbytes*height);
1519 for (i=0;i<height;i++)
1520 {
1521 for (j=0;j<bytes;j++)
1522 {
1523 newdata[(i*newbytes)+j]=revBytes[(unsigned char)data[(i*bytes)+j]];
1524 }
1525 }
1526 w->hBitmap = CreateBitmap(width,height,1,1,newdata);
1527 freeMemory(newdata);
1528 }
1529
1530 SelectObject(w->hDC, w->hBitmap);
1531 drawableRelDC(drawable,parenthDC);
1532 w->x=0;
1533 w->y=0;
1534 w->wdth = width;
1535 w->hght = height;
1536 w->min = 1;
1537 return (Pixmap)w;
1538 }
1539
1540 int
XFreePixmap(display,pixmap)1541 XFreePixmap(display, pixmap)
1542 Display *display;
1543 Pixmap pixmap;
1544 {
1545 NT_window *w = (NT_window *)pixmap;
1546 NT_delete_window(w);
1547 return 0;
1548 }
1549
1550 int
XCopyArea(display,src,dest,gc,src_x,src_y,width,height,dest_x,dest_y)1551 XCopyArea(display, src, dest, gc, src_x, src_y, width, height, dest_x, dest_y)
1552 Display *display;
1553 Drawable src, dest;
1554 GC gc;
1555 int src_x, src_y;
1556 unsigned int width, height;
1557 int dest_x, dest_y;
1558 {
1559 HDC hsrc, hdst;
1560 hsrc = drawableGetDC(src);
1561 if (VALID_WINDOW(dest))
1562 {
1563 hdst = drawableGetDC(dest);
1564 (void)BitBlt(hdst,dest_x,dest_y,width,height,hsrc,src_x,src_y,SRCCOPY);
1565 drawableRelDC(src,hsrc);
1566 }
1567 drawableRelDC(dest,hdst);
1568 return 0;
1569 }
1570
1571 XImage *
NT_XCreateImage()1572 NT_XCreateImage()
1573 {
1574 return NULL;
1575 }
1576
NT_XDestroyImage(ximage)1577 int NT_XDestroyImage(ximage)
1578 XImage *ximage;
1579 {
1580 /* freeMemory(ximage->data); */
1581 freeMemory(ximage);
1582 return 1;
1583 }
1584
1585 unsigned long
NT_XGetPixel(ximage,x,y)1586 NT_XGetPixel(ximage,x,y)
1587 XImage *ximage;
1588 int x,y;
1589 {
1590 return 0;
1591 }
1592 int
NT_XPutPixel(ximage,x,y,pixel)1593 NT_XPutPixel(ximage,x,y,pixel)
1594 XImage *ximage;
1595 int x,y;
1596 unsigned long pixel;
1597 {
1598 return 0;
1599 }
1600 XImage *
NT_XSubImage(ximage,x,y,w,h)1601 NT_XSubImage(ximage,x,y,w,h)
1602 XImage *ximage;
1603 int x,y;
1604 unsigned int w,h;
1605 {
1606 return NULL;
1607 }
1608 int
NT_XAddPixel(ximage,value)1609 NT_XAddPixel(ximage,value)
1610 XImage *ximage;
1611 unsigned long value;
1612 {
1613 return 0;
1614 }
1615
1616 XImage *
XGetImage(display,drawable,x,y,width,height,plane_mask,format)1617 XGetImage(display,drawable,x,y,width,height,plane_mask,format)
1618 Display *display;
1619 Drawable drawable;
1620 int x,y;
1621 unsigned int width, height;
1622 unsigned long plane_mask;
1623 int format;
1624 {
1625 return NULL;
1626 }
1627
1628 XImage *
XCreateImage(display,visual,depth,format,offset,data,width,height,bitmap_pad,bytes_per_line)1629 XCreateImage(display,visual,depth,format,offset,data,width,height, bitmap_pad, bytes_per_line)
1630 Display *display;
1631 Visual *visual;
1632 unsigned int depth;
1633 int format;
1634 int offset;
1635 char *data;
1636 unsigned int width, height;
1637 int bitmap_pad, bytes_per_line;
1638 {
1639 XImage *img = (XImage *) allocateMemory(sizeof(XImage));
1640
1641 if (img) {
1642 img->depth = 24; /* depth; */
1643 img->format = format;
1644 img->xoffset = offset;
1645 img->data = data;
1646 img->width = width;
1647 img->height = height;
1648 img->bitmap_pad = 32;
1649 img->bytes_per_line=width*((24)>>3);
1650 img->bits_per_pixel = 24; /* depth; */
1651 img->bitmap_bit_order = LSBFirst;
1652 img->byte_order = MSBFirst;
1653 img->blue_mask = 0x0ff00000;
1654 img->green_mask=0x00ff0000;
1655 img->red_mask= 0x0000ff00;
1656
1657 img->f.create_image = NT_XCreateImage;
1658 img->f.destroy_image = NT_XDestroyImage;
1659 img->f.get_pixel = NT_XGetPixel;
1660 img->f.put_pixel = NT_XPutPixel;
1661 img->f.sub_image = NT_XSubImage;
1662 img->f.add_pixel = NT_XAddPixel;
1663
1664 }
1665
1666 return img;
1667 }
1668 void
DrawBitmap(HDC hdc,HBITMAP hBitmap,int xStart,int yStart)1669 DrawBitmap(HDC hdc, HBITMAP hBitmap, int xStart, int yStart)
1670 {
1671 BITMAP bm;
1672 HDC hdcMem;
1673 DWORD dwSize;
1674 POINT ptSize, ptOrg;
1675 hdcMem = CreateCompatibleDC(hdc);
1676 SelectObject(hdcMem, hBitmap);
1677 SetMapMode(hdcMem,GetMapMode(hdc));
1678 GetObject(hBitmap, sizeof(BITMAP), (LPVOID)&bm);
1679 ptSize.x = bm.bmWidth;
1680 ptSize.y = bm.bmHeight;
1681 DPtoLP(hdc, &ptSize,1);
1682 ptOrg.x=0;
1683 ptOrg.y=0;
1684 DPtoLP(hdcMem,&ptOrg,1);
1685 BitBlt(hdc,xStart,yStart,ptSize.x,ptSize.y,hdcMem,ptOrg.x,ptOrg.y,SRCCOPY);
1686 DeleteDC(hdcMem);
1687 }
1688 /*
1689 static unsigned char wBrickBits[]={
1690 0xff,0x0c,0x0c,0x0c, 0xff,0xc0,0xc0,0xc0,
1691 0xff,0x0c,0xff,0xff, 0xff,0xff,0xc0,0xc0,
1692 0xff,0x0c,0xff,0xff, 0xff,0xff,0xc0,0xc0,
1693 0xff,0x0c,0x0c,0x0c, 0xff,0xc0,0xc0,0xc0
1694 };
1695 */
1696 int
XPutImage(display,w,gc,image,sx,sy,dx,dy,width,height)1697 XPutImage(display,w,gc,image,sx,sy,dx,dy,width,height)
1698 Display *display;
1699 Drawable w;
1700 XImage *image;
1701 GC gc;
1702 int sx,sy,dx,dy;
1703 unsigned int width,height;
1704 {
1705 BITMAPINFO bmInfo;
1706 NT_window *pix = (NT_window *)w;
1707 int res;
1708 if (VALID_WINDOW(w))
1709 {
1710 HDC hDC = drawableGetDC(w);
1711 bmInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1712 bmInfo.bmiHeader.biWidth = width;
1713 bmInfo.bmiHeader.biHeight = height;
1714 bmInfo.bmiHeader.biPlanes = 1;
1715 bmInfo.bmiHeader.biBitCount = 24; /*image->depth; */
1716 bmInfo.bmiHeader.biCompression = BI_RGB;
1717 bmInfo.bmiHeader.biSizeImage = 0;
1718 bmInfo.bmiHeader.biXPelsPerMeter = 3600;
1719 bmInfo.bmiHeader.biYPelsPerMeter = 3600;
1720 bmInfo.bmiHeader.biClrUsed = 0;
1721 bmInfo.bmiHeader.biClrImportant = 0;
1722 res = SetDIBitsToDevice(hDC,0,0,width,height,0,0,0,height,image->data,&bmInfo,DIB_RGB_COLORS);
1723 /* BitBlt(CreateDC("DISPLAY",NULL,NULL,NULL),10,0,width,height,hDC,0,0,SRCCOPY); */
1724 if (res==0)
1725 printf("SetDIBitsfailed %d\n",res,GetLastError());
1726 drawableRelDC(w,hDC);
1727 }
1728 return 0;
1729 }
1730
1731 int
XSetWindowBackground(display,w,bg)1732 XSetWindowBackground(display, w, bg)
1733 Display *display;
1734 Window w;
1735 unsigned long bg;
1736 {
1737 NT_window *window = (NT_window *)w;
1738 xtrace("XSetWindowBackground\n");
1739 DeleteObject(window->bg);
1740 window->bg=CreateSolidBrush(CNUMTORGB(bg));
1741 return 0;
1742 }
1743
1744 int
XSetWindowBackgroundPixmap(display,w,background_tile)1745 XSetWindowBackgroundPixmap(display, w, background_tile)
1746 Display *display;
1747 Window w;
1748 Pixmap background_tile;
1749 {
1750 NT_window *window = (NT_window *)w;
1751 NT_window *wpix = (NT_window *)background_tile;
1752 BITMAPINFO *bmInfo;
1753 BITMAP bm;
1754 int res;
1755
1756 xtrace("XSetWindowBackgroundPixmap\n");
1757 if (background_tile==ParentRelative)
1758 {
1759 if (!window->parentRelative)
1760 {
1761 HBITMAP hb = NT_getWallpaper();
1762 if (hb!=NULL) {
1763 DeleteObject(window->bg);
1764 window->bg = CreatePatternBrush(hb);
1765 window->parentRelative=1;
1766 NT_configureNotify(window,window->x,window->y);
1767 }
1768 }
1769 }
1770 else
1771 {
1772 GetObject(wpix->hBitmap, sizeof(BITMAP), &bm);
1773
1774 bmInfo = allocateMemory(sizeof(BITMAPINFO) + ( (bm.bmBitsPixel>>3)* bm.bmWidth*bm.bmHeight));
1775 bmInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1776 bmInfo->bmiHeader.biWidth = bm.bmWidth;
1777 bmInfo->bmiHeader.biHeight = bm.bmHeight;
1778 bmInfo->bmiHeader.biPlanes = 1;
1779 bmInfo->bmiHeader.biBitCount = bm.bmBitsPixel;
1780 bmInfo->bmiHeader.biCompression = BI_RGB;
1781 bmInfo->bmiHeader.biSizeImage = 0;
1782 bmInfo->bmiHeader.biClrImportant = 0;
1783 bmInfo->bmiHeader.biClrUsed = 0;
1784
1785 res =GetDIBits(wpix->hDC,wpix->hBitmap,0,bm.bmHeight,bmInfo->bmiColors,bmInfo,DIB_RGB_COLORS);
1786 if (res==0)
1787 printf("getDIBits failed %d\n",res,GetLastError());
1788
1789 DeleteObject(window->bg);
1790 window->bg = CreateDIBPatternBrushPt(bmInfo, DIB_RGB_COLORS);
1791 freeMemory(bmInfo);
1792 }
1793 }
1794
1795
1796 /*****************************************************************\
1797
1798 Function: XSetFillStyle
1799 Inputs: display, gc, fill style.
1800
1801 Comments: ZZzzz...
1802
1803 \*****************************************************************/
1804
1805 int
XSetFillStyle(display,gc,fs)1806 XSetFillStyle(display,gc,fs)
1807 Display *display;
1808 GC gc;
1809 int fs;
1810 {
1811 xtrace("XSetFillStyle\n");
1812 gc->values.fill_style=fs;
1813 gc->dirty |= GCFillStyle;
1814 return 0;
1815 }
1816
1817
1818 int
XSetDashes(Display * display,GC gc,int dash_offset,const char * dash_list,int n)1819 XSetDashes(Display *display,
1820 GC gc, int dash_offset,
1821 const char * dash_list,
1822 int n)
1823 {
1824 xtrace("XSetDashes\n");
1825 return 0;
1826 }
1827
1828
1829 int
XChangeWindowAttributes(display,w,vmask,attr)1830 XChangeWindowAttributes(display,w,vmask,attr)
1831 Display *display;
1832 Window w;
1833 unsigned long vmask;
1834 XSetWindowAttributes *attr;
1835 {
1836 xtrace("XChangeWindowAttributes\n");
1837 return 0;
1838 }
1839
1840
1841 /*****************************************************************\
1842
1843 Function: XLowerWindow
1844 Inputs: display, window to be lowered.
1845
1846 Comments: Make sure if the window has a frame that that gets lowered
1847 too.
1848
1849 \*****************************************************************/
1850
1851 int
XLowerWindow(display,w)1852 XLowerWindow(display,w)
1853 Display *display;
1854 Window w;
1855 {
1856 NT_window *ntw=(NT_window *)w;
1857 xtrace("XLowerWindow\n");
1858 SetWindowPos((HWND)ntw->w,HWND_BOTTOM,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE);
1859 return 0;
1860 }
1861
1862
1863 /*****************************************************************\
1864
1865 Function: XMapRaised
1866 Inputs: display, window.
1867
1868 Comments: Frames get raised first.
1869
1870 \*****************************************************************/
1871
1872 int
XMapRaised(display,w)1873 XMapRaised(display,w)
1874 Display *display;
1875 Window w;
1876 {
1877 NT_window *ntw=(NT_window *)w;
1878 xtrace("XMapRaised\n");
1879 XMapWindow(display,w);
1880 SetWindowPos(ntw->w,HWND_TOP,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE);
1881 return 0;
1882 }
1883
1884
1885 /*****************************************************************\
1886
1887 Function: XMapSubwindows
1888 Inputs: display, window.
1889
1890 Comments: Unfortunately, the optimisations normally made by
1891 the X server are not made here.
1892
1893 \*****************************************************************/
1894
1895 int
XMapSubwindows(display,w)1896 XMapSubwindows(display,w)
1897 Display *display;
1898 Window w;
1899 {
1900 NT_window *ntw=(NT_window *)w;
1901 struct NT_child *tmp;
1902
1903 xtrace("XMapSubWindows\n");
1904 tmp=ntw->child;
1905 while (tmp!=NULL)
1906 {
1907 XMapWindow(display,(Window)tmp->w);
1908 tmp=tmp->next;
1909 }
1910 return 0;
1911 }
1912
1913
1914 /*****************************************************************\
1915
1916 Function: XQueryTree
1917 Inputs: display, window.
1918 Returned: root window, parent window, list of children, status.
1919
1920 Comments: Not fully implemented. The child field is wrong.
1921
1922 \*****************************************************************/
1923
1924 StatusDef
XQueryTree(display,w,root,parent,ch,n)1925 XQueryTree(display,w,root,parent,ch,n)
1926 Display *display;
1927 Window w;
1928 Window* root;
1929 Window* parent;
1930 Window** ch;
1931 unsigned int *n;
1932 {
1933 NT_window *ntw=(NT_window *)w;
1934 StatusDef status=1;
1935
1936 xtrace("XQueryTree\n");
1937 *parent=(Window)ntw->parent;
1938 if (ntw->parent==NULL)
1939 status=0;
1940 *root=display->screens[0].root;
1941 *ch=NULL;
1942 *n=0;
1943 return (status);
1944 }
1945
1946
1947 /*****************************************************************\
1948
1949 Function: XRaiseWindow
1950 Inputs: display, window.
1951
1952 Comments: Recursive raising of window and its children.
1953
1954 \*****************************************************************/
1955
1956 int
XRaiseWindow(display,w)1957 XRaiseWindow(display,w)
1958 Display *display;
1959 Window w;
1960 {
1961 NT_window *ntw=(NT_window *)w;
1962 struct NT_child *tmp;
1963 xtrace("XRaiseWindows\n");
1964
1965 BringWindowToTop(ntw->w);
1966 tmp=ntw->child;
1967 while (tmp!=NULL)
1968 {
1969 XRaiseWindow(display,(Window)tmp->w);
1970 tmp=tmp->next;
1971 }
1972 return 0;
1973 }
1974
1975
1976 /*****************************************************************\
1977
1978 Function: XRootWindow
1979 Inputs: display, screen number
1980 Returned: root window ID.
1981
1982 Comments: Info taken from display structure.
1983
1984 \*****************************************************************/
1985
1986 Window
XRootWindow(display,scr)1987 XRootWindow(display,scr)
1988 Display *display;
1989 int scr;
1990 {
1991 xtrace("XRootWindow\n");
1992 return(display->screens[0].root);
1993 }
1994
1995
1996 /*****************************************************************\
1997
1998 Function: XRootWindowOfScreen
1999 Inputs: screen pointer
2000 Returned: root window ID.
2001
2002 Comments: ZZzzz...
2003
2004 \*****************************************************************/
2005
2006 Window
XRootWindowOfScreen(scr)2007 XRootWindowOfScreen(scr)
2008 Screen *scr;
2009 {
2010 xtrace("XRootWindowOfScreen\n");
2011 return(scr->root);
2012 }
2013
2014
2015 /*****************************************************************\
2016
2017 Function: XTranslateCoordinates
2018 Inputs: display, source window, destination window, source x, y.
2019 Returned: destination x, y, child window if any.
2020
2021 Comments: Seems to work properly.
2022
2023 \*****************************************************************/
2024
2025 BoolDef
XTranslateCoordinates(display,sw,dw,sx,sy,dx,dy,ch)2026 XTranslateCoordinates(display,sw,dw,sx,sy,dx,dy,ch)
2027 Display *display;
2028 Window sw,dw;
2029 int sx,sy,*dx,*dy;
2030 Window *ch;
2031 {
2032 xtrace("XTranslateCoordinates\n");
2033 return (True);
2034 }
2035
2036
2037 /*****************************************************************\
2038
2039 Function: XUnmapWindow
2040 Inputs: display, window.
2041
2042 Comments: Removes a window and its frame, if it has one, from the
2043 screen.
2044
2045 \*****************************************************************/
2046
2047 int
XUnmapWindow(display,w)2048 XUnmapWindow(display,w)
2049 Display *display;
2050 Window w;
2051 {
2052 NT_window *ntw=(NT_window *)w;
2053 xtrace("XUnmapWindow\n");
2054 ShowWindow(ntw->w,SW_HIDE);
2055 return 0;
2056 }
2057
2058
2059 /*****************************************************************\
2060
2061 Function: XCopyGC
2062 Inputs: display, source gc, values mask, destination gc.
2063
2064 Comments: Copies masked elements from source to destination.
2065
2066 \*****************************************************************/
2067
2068 int
XCopyGC(display,sgc,vmask,dgc)2069 XCopyGC(display,sgc,vmask,dgc)
2070 Display *display;
2071 GC sgc,dgc;
2072 unsigned long vmask;
2073 {
2074 xtrace("XCopyGC\n");
2075 if (vmask&GCFunction)
2076 dgc->values.function=sgc->values.function;
2077 if (vmask&GCPlaneMask)
2078 dgc->values.plane_mask=sgc->values.plane_mask;
2079 if (vmask&GCForeground)
2080 dgc->values.foreground=sgc->values.foreground;
2081 if (vmask&GCBackground)
2082 dgc->values.background=sgc->values.background;
2083 if (vmask&GCLineWidth)
2084 dgc->values.line_width=sgc->values.line_width;
2085 if (vmask&GCLineStyle)
2086 dgc->values.line_style=sgc->values.line_style;
2087 if (vmask&GCCapStyle)
2088 dgc->values.cap_style=sgc->values.cap_style;
2089 if (vmask&GCJoinStyle)
2090 dgc->values.join_style=sgc->values.join_style;
2091 if (vmask&GCFillStyle)
2092 dgc->values.fill_style=sgc->values.fill_style;
2093 if (vmask&GCFillRule)
2094 dgc->values.fill_rule=sgc->values.fill_rule;
2095 if (vmask&GCTile)
2096 dgc->values.tile=sgc->values.tile;
2097 if (vmask&GCStipple)
2098 dgc->values.stipple=sgc->values.stipple;
2099 if (vmask&GCTileStipXOrigin)
2100 dgc->values.ts_x_origin=sgc->values.ts_x_origin;
2101 if (vmask&GCTileStipYOrigin)
2102 dgc->values.ts_y_origin=sgc->values.ts_y_origin;
2103 if (vmask&GCFont)
2104 dgc->values.font=sgc->values.font;
2105 if (vmask&GCSubwindowMode)
2106 dgc->values.subwindow_mode=sgc->values.subwindow_mode;
2107 if (vmask&GCGraphicsExposures)
2108 dgc->values.graphics_exposures=sgc->values.graphics_exposures;
2109 if (vmask&GCClipXOrigin)
2110 dgc->values.clip_x_origin=sgc->values.clip_x_origin;
2111 if (vmask&GCClipYOrigin)
2112 dgc->values.clip_y_origin=sgc->values.clip_y_origin;
2113 if (vmask&GCClipMask)
2114 dgc->values.clip_mask=sgc->values.clip_mask;
2115 if (vmask&GCDashList)
2116 dgc->values.dashes=sgc->values.dashes;
2117 if (vmask&GCArcMode)
2118 dgc->values.arc_mode=sgc->values.arc_mode;
2119
2120 dgc->dirty = 0xFFFF;
2121 return 0;
2122 }
2123
2124
2125 int
XSetClipMask(display,gc,cmask)2126 XSetClipMask(display,gc,cmask)
2127 Display *display;
2128 GC gc;
2129 Pixmap cmask;
2130 {
2131 xtrace("XSetClipMask\n");
2132 return 0;
2133 }
2134
2135
2136 int
XSetClipRectangles(display,gc,clx,cly,rs,n,order)2137 XSetClipRectangles(display,gc,clx,cly,rs,n,order)
2138 Display *display;
2139 GC gc;
2140 int clx,cly;
2141 XRectangle *rs;
2142 int n,order;
2143 {
2144 xtrace("XSetClipRectangles\n");
2145 return 0;
2146 }
2147
2148
2149 /*****************************************************************\
2150
2151 Function: XSetFunction
2152 Inputs: display, gc, graphics operation.
2153
2154 Comments: ZZzzz...
2155
2156 \*****************************************************************/
2157
2158 int
XSetFunction(display,gc,fn)2159 XSetFunction(display,gc,fn)
2160 Display *display;
2161 GC gc;
2162 int fn;
2163 {
2164 xtrace("XSetFunction\n");
2165 gc->values.function=fn;
2166 gc->dirty |= GCFunction;
2167 return 0;
2168 }
2169
2170
2171 /*****************************************************************\
2172
2173 Function: XSetLineAttributes
2174 Inputs: display, gc, line width, line style, cap style, join style.
2175
2176 Comments: These all have windows equivalents.
2177
2178 \*****************************************************************/
2179
2180 int
XSetLineAttributes(display,gc,lw,ls,cs,js)2181 XSetLineAttributes(display,gc,lw,ls,cs,js)
2182 Display *display;
2183 GC gc;
2184 unsigned int lw;
2185 int ls,cs,js;
2186 {
2187 xtrace("XSetLineAttributes\n");
2188 gc->values.line_width=lw;
2189 gc->values.line_style=ls;
2190 gc->values.cap_style=cs;
2191 gc->values.join_style=js;
2192 gc->dirty |= GCLineWidth | GCLineStyle | GCCapStyle | GCJoinStyle;
2193 return 0;
2194 }
2195
2196
2197 /*****************************************************************\
2198
2199 Function: XSetPlaneMask
2200 Inputs: display, gc, plane mask.
2201
2202 Comments: What's a plane mask?
2203
2204 \*****************************************************************/
2205
2206 int
XSetPlaneMask(display,gc,pmask)2207 XSetPlaneMask(display,gc,pmask)
2208 Display *display;
2209 GC gc;
2210 unsigned long pmask;
2211 {
2212 xtrace("XSetPlaneMask\n");
2213 gc->values.plane_mask=pmask;
2214 return 0;
2215 }
2216
2217
2218 int
XSetTile(display,gc,tile)2219 XSetTile(display,gc,tile)
2220 Display *display;
2221 GC gc;
2222 Pixmap tile;
2223 {
2224 xtrace("XSetTile\n");
2225 return 0;
2226 }
2227
2228
2229 StatusDef
XAllocColorCells(display,cmap,cont,pmasks,np,pixels,nc)2230 XAllocColorCells(display,cmap,cont,pmasks,np,pixels,nc)
2231 Display *display;
2232 Colormap cmap;
2233 BoolDef cont;
2234 unsigned long *pmasks;
2235 unsigned int np;
2236 unsigned long *pixels;
2237 unsigned int nc;
2238 {
2239 unsigned int i;
2240 xtrace("XAllocColorCells\n");
2241 for (i = 0;i<nc;i++)
2242 pixels[i] = i;
2243 if(np==1)
2244 {
2245 *pmasks = nc;
2246 }
2247 return 1;
2248 }
2249
2250
2251 /*****************************************************************\
2252
2253 Function: XAllocColorPlanes
2254 Inputs: display, colour map, contiguous flag, pixel value list,
2255 number of colours, number of reds, greens, blues.
2256 Returned: red mask, green mask, blue mask, status.
2257
2258 Comments: Works for True Colour only.
2259
2260 \*****************************************************************/
2261
2262 StatusDef
XAllocColorPlanes(display,cmap,cont,pixels,nc,nr,ng,nb,rmask,gmask,bmask)2263 XAllocColorPlanes(display,cmap,cont,pixels,nc,nr,ng,nb,rmask,gmask,bmask)
2264 Display *display;
2265 Colormap cmap;
2266 BoolDef cont;
2267 unsigned long *pixels;
2268 int nc;
2269 int nr,ng,nb;
2270 unsigned long *rmask,*gmask,*bmask;
2271 {
2272 xtrace("XAllocColorPlanes\n");
2273 *rmask=255;
2274 *gmask=255<<8;
2275 *bmask=255<<16;
2276 return (1);
2277 }
2278
2279
2280 StatusDef
XAllocNamedColor(Display * display,Colormap cmap,const char * cname,XColor * cell,XColor * rgb)2281 XAllocNamedColor(Display *display,
2282 Colormap cmap, const char *cname,
2283 XColor *cell, XColor *rgb)
2284 {
2285 xtrace("XAllocNamedColor\n");
2286 return 0;
2287 }
2288
2289
2290 Colormap
XCreateColormap(display,w,visual,alloc)2291 XCreateColormap(display,w,visual,alloc)
2292 Display *display;
2293 Window w;
2294 Visual *visual;
2295 int alloc;
2296 {
2297 xtrace("XCreateColormap\n");
2298 return 0;
2299 }
2300
2301
2302 StatusDef
XGetStandardColormap(display,w,cmapinf,prop)2303 XGetStandardColormap(display,w,cmapinf,prop)
2304 Display *display;
2305 Window w;
2306 XStandardColormap *cmapinf;
2307 Atom prop;
2308 {
2309 xtrace("XGetStandardColormap\n");
2310 return 0;
2311 }
2312
2313 StatusDef
XAllocColor(display,cmap,xc)2314 XAllocColor(display,cmap,xc)
2315 Display *display;
2316 Colormap cmap;
2317 XColor *xc;
2318 {
2319 xtrace("XAllocColor\n");
2320 xc->pixel = RGB((BYTE) (xc->red>>8)&0xff, (BYTE) (xc->green>>8)&0xff, (BYTE) (xc->blue>>8)&0xff);
2321 return 1;
2322 }
2323
2324 int
XQueryColor(display,cmap,cell)2325 XQueryColor(display,cmap,cell)
2326 Display *display;
2327 Colormap cmap;
2328 XColor *cell;
2329 {
2330 xtrace("XQueryColor\n");
2331 cell->red = (cell->pixel>>8)&0x0ff00;
2332 cell->green = (cell->pixel)&0x0ff00;
2333 cell->blue = (cell->pixel<<8)&0x0ff00;
2334 return 1;
2335 }
2336
2337
2338 int
XQueryColors(display,cmap,cells,nc)2339 XQueryColors(display,cmap,cells,nc)
2340 Display *display;
2341 Colormap cmap;
2342 XColor *cells;
2343 int nc;
2344 {
2345 int i;
2346
2347 xtrace("XQueryColors\n");
2348 for (i=0;i<nc;i++)
2349 {
2350 cells[i].red=(cells[i].pixel>>8)&0xff00;
2351 cells[i].green=(cells[i].pixel)&0xff00;
2352 cells[i].blue=(cells[i].pixel<<8)&0xff00;
2353 }
2354 return 0;
2355 }
2356
2357
2358 int
XStoreColor(display,cmap,cell)2359 XStoreColor(display,cmap,cell)
2360 Display *display;
2361 Colormap cmap;
2362 XColor *cell;
2363 {
2364 xtrace("XStoreColor\n");
2365 return 0;
2366 }
2367
2368
2369
2370 int
XStoreColors(display,cmap,cells,nc)2371 XStoreColors(display,cmap,cells,nc)
2372 Display *display;
2373 Colormap cmap;
2374 XColor *cells;
2375 int nc;
2376 {
2377 int i;
2378 xtrace("XStoreColors\n");
2379 return 0;
2380 }
2381
2382 char **
XGetFontPath(display,nps)2383 XGetFontPath(display,nps)
2384 Display *display;
2385 int *nps;
2386 {
2387 xtrace("XGetFontPath\n");
2388 return (NULL);
2389 }
2390
2391
2392 BoolDef
XGetFontProperty(fstruct,atom,val)2393 XGetFontProperty(fstruct,atom,val)
2394 XFontStruct *fstruct;
2395 Atom atom;
2396 unsigned long *val;
2397 {
2398 xtrace("XGetFontProperty\n");
2399 return (0);
2400 }
2401
2402 static BYTE
getCharSetFromName(const char * name,char ** lang)2403 getCharSetFromName(const char *name,char **lang)
2404 {
2405 static struct {
2406 char *label;
2407 BYTE id;
2408 } charset[] = {
2409 "-gb2312", GB2312_CHARSET,
2410 "-big5", CHINESEBIG5_CHARSET,
2411 "-jis", SHIFTJIS_CHARSET,
2412 NULL, DEFAULT_CHARSET
2413 };
2414 int i;
2415 char *p;
2416 if (!name)
2417 {
2418 if (lang) *lang=NULL;
2419 return DEFAULT_CHARSET;
2420 }
2421 else if (lang) *lang=(char *)name+strlen((char *)name);
2422 for (i=0; charset[i].label; i++)
2423 if (NULL!=(p=strstr(name, charset[i].label)))
2424 {
2425 if (lang) *lang=p;
2426 break;
2427 }
2428 return charset[i].id;
2429 }
2430
2431 /* attempts to translate the font name into
2432 ** something win32 understands.
2433 **
2434 */
2435 Font
NT_loadfont(name)2436 NT_loadfont(name)
2437 char *name;
2438 {
2439 LOGFONT lf;
2440 HFONT hfont;
2441 char *p,*q,*lang;
2442 int size = 0;
2443 char buff[33];
2444
2445 memset(&lf,0,sizeof(lf));
2446 lf.lfHeight = -13;
2447
2448 lf.lfWeight = FW_NORMAL;
2449 lf.lfFaceName[0]='\0';
2450
2451 lf.lfCharSet = getCharSetFromName(name,&lang);
2452
2453 if (name && strstr(name,"-bold"))
2454 {
2455 lf.lfWeight = FW_BOLD;
2456 }
2457 for(p=name, q=buff; p&&p<=lang; p++)
2458 {
2459 if (((!*p || *p=='-') && q!=buff) || (q-buff>31))
2460 {
2461 *q++='\0';
2462 if (lf.lfFaceName[0]=='\0')
2463 {
2464 if (isalpha(buff[0]) || IsDBCSLeadByte(buff[0]))
2465 strcpy(lf.lfFaceName, buff);
2466 else if (isdigit(buff[0]) && ((q=strchr(buff,'x')) || (q=strchr(buff,'X'))))
2467 {
2468 strcpy(lf.lfFaceName, "Courier New");
2469 size = -atoi(q+1);
2470 }
2471 else if (size == 0 && isdigit(buff[0]))
2472 size = -atoi(buff);
2473 }
2474 else if (size == 0 && isdigit(buff[0]))
2475 {
2476 size = -atoi(buff);
2477 }
2478 q = buff;
2479 }
2480 else
2481 *q++ = *p;
2482 if (!*p) break;
2483 }
2484
2485 if (size > 99)
2486 lf.lfHeight = - (size/10);
2487 else if (size)
2488 lf.lfHeight = - size;
2489
2490 if (!strcmp(lf.lfFaceName,"lucidatypewriter"))
2491 strcpy(lf.lfFaceName,"Lucida Console");
2492 else if (lf.lfFaceName[0]=='\0'&&lf.lfCharSet==DEFAULT_CHARSET)
2493 strcpy(lf.lfFaceName,"Courier New");
2494 hfont = CreateFontIndirect(&lf);
2495 return (Font)hfont;
2496 }
2497
2498 XFontStruct *
XLoadQueryFont(Display * display,const char * name)2499 XLoadQueryFont(Display *display, const char *name)
2500 {
2501 XFontStruct *fs;
2502 TEXTMETRIC tm;
2503 HDC hdc;
2504 HWND root;
2505 HFONT old;
2506 int i;
2507
2508 xtrace("XLoadQueryFont\n");
2509 fs = allocateMemory(sizeof(XFontStruct));
2510 fs->fid = NT_loadfont(name);
2511
2512 root=GetDesktopWindow();
2513 hdc=GetDC(root);
2514 old = SelectObject(hdc, (HFONT)fs->fid);
2515 GetTextMetrics(hdc, &tm);
2516 fs->min_bounds.width = tm.tmAveCharWidth;
2517 fs->max_bounds.width = tm.tmMaxCharWidth;
2518 fs->n_properties = 0;
2519 fs->properties = NULL;
2520 fs->min_char_or_byte2 =tm.tmFirstChar;
2521 fs->max_char_or_byte2 =tm.tmLastChar;
2522 fs->per_char = (XCharStruct*)allocateMemory(sizeof(XCharStruct)*(tm.tmLastChar+1));
2523 ZeroMemory(fs->per_char, sizeof(XCharStruct)*(tm.tmLastChar+1));
2524
2525 if (!(tm.tmPitchAndFamily & TMPF_FIXED_PITCH)) {
2526 for (i=tm.tmFirstChar; i<=tm.tmLastChar; i++) {
2527 fs->per_char[i].width = tm.tmAveCharWidth;
2528 fs->per_char[i].rbearing = tm.tmAveCharWidth;
2529 }
2530 } else if (tm.tmPitchAndFamily & TMPF_TRUETYPE) {
2531 for (i=tm.tmFirstChar; i<=tm.tmLastChar; i++)
2532 {
2533 ABC abc;
2534 if (!GetCharABCWidths(hdc,i,i,&abc))
2535 {
2536 abc.abcA = 0;
2537 abc.abcB = tm.tmAveCharWidth;
2538 abc.abcC = 0;
2539 }
2540 fs->per_char[i].lbearing = abc.abcA;
2541 fs->per_char[i].width = abc.abcB;
2542 fs->per_char[i].rbearing = abc.abcB+abc.abcC;
2543 }
2544 } else {
2545 for (i=tm.tmFirstChar; i<=tm.tmLastChar; i++)
2546 {
2547 INT fw;
2548 if (!GetCharWidth(hdc,i,i,&fw))
2549 {
2550 fw = tm.tmAveCharWidth;
2551 }
2552 fs->per_char[i].lbearing = 0;
2553 fs->per_char[i].width = fw;
2554 fs->per_char[i].rbearing = fw;
2555 }
2556 }
2557 if (getCharSetFromName(name,NULL) == DEFAULT_CHARSET)
2558 {
2559 int last = tm.tmLastChar;
2560
2561 switch(tm.tmCharSet) {
2562 case CHINESEBIG5_CHARSET:
2563 case GB2312_CHARSET:
2564 case SHIFTJIS_CHARSET:
2565 if (tm.tmLastChar > 127) last = 127;
2566 break;
2567 }
2568
2569 if (last >= tm.tmFirstChar)
2570 {
2571 fs->max_bounds = fs->per_char[last];
2572 fs->min_bounds = fs->per_char[last];
2573 for (i=tm.tmFirstChar; i<last; i++)
2574 {
2575 if (fs->per_char[i].lbearing > fs->max_bounds.lbearing)
2576 fs->max_bounds.lbearing = fs->per_char[i].lbearing;
2577 else if(fs->per_char[i].lbearing < fs->min_bounds.lbearing)
2578 fs->min_bounds.lbearing = fs->per_char[i].lbearing;
2579
2580 if (fs->per_char[i].width > fs->max_bounds.width)
2581 fs->max_bounds.width = fs->per_char[i].width;
2582 else if(fs->per_char[i].width < fs->min_bounds.width)
2583 fs->min_bounds.width = fs->per_char[i].width;
2584
2585 if (fs->per_char[i].rbearing > fs->max_bounds.rbearing)
2586 fs->max_bounds.rbearing = fs->per_char[i].rbearing;
2587 else if(fs->per_char[i].rbearing < fs->min_bounds.rbearing)
2588 fs->min_bounds.rbearing = fs->per_char[i].rbearing;
2589 }
2590 }
2591 }
2592 fs->ascent = tm.tmAscent;
2593 fs->descent= tm.tmDescent;
2594 SelectObject(hdc,old);
2595 ReleaseDC(root,hdc);
2596 return(fs);
2597 }
2598
2599 XFontStruct *
XQueryFont(display,font_id)2600 XQueryFont(display, font_id)
2601 Display *display;
2602 XID font_id;
2603 {
2604 static XFontStruct fs;
2605
2606 xtrace("XQueryFont\n");
2607 return(&fs);
2608 }
2609
2610 KeySym
XKeycodeToKeysym(display,keycode,index)2611 XKeycodeToKeysym(display, keycode, index)
2612 Display *display;
2613 unsigned int keycode;
2614 int index;
2615 {
2616 xtrace("XKeycodeToKeysym\n");
2617 if (keycode == 254) return XK_Alt_L;
2618 else if (keycode == 255) return XK_Num_Lock;
2619 return(NoSymbol);
2620 }
2621 KeyCode
XKeysymToKeycode(display,keysym)2622 XKeysymToKeycode(display, keysym)
2623 Display *display;
2624 KeySym keysym;
2625 {
2626 xtrace("XKeycodeToKeysym\n");
2627 if (keysym == XK_Alt_L) return 254;
2628 else if (keysym == XK_Num_Lock) return 255;
2629 return(0);
2630 }
2631 KeySym
XStringToKeysym(const char * str)2632 XStringToKeysym(const char *str)
2633 {
2634 xtrace("XStringToKeysym\n");
2635 return(NoSymbol);
2636 }
2637
2638 XModifierKeymap *
XGetModifierMapping(display)2639 XGetModifierMapping(display)
2640 Display *display;
2641 {
2642 XModifierKeymap *map = NULL;
2643 xtrace("XGetModifierMapping\n");
2644 map = (XModifierKeymap *)allocateMemory(sizeof(XModifierKeymap));
2645 map->max_keypermod = 1;
2646 map->modifiermap = (KeyCode *)allocateMemory(sizeof(KeyCode)*8);
2647 map->modifiermap[0]=0;
2648 map->modifiermap[1]=0;
2649 map->modifiermap[2]=0;
2650 map->modifiermap[3]=XKeysymToKeycode(display,XK_Alt_L);
2651 map->modifiermap[4]=0;
2652 map->modifiermap[5]=0;
2653 map->modifiermap[6]=0;
2654 map->modifiermap[7]=XKeysymToKeycode(display,XK_Num_Lock);
2655 return(map);
2656 }
2657 int
XFreeModifiermap(XModifierKeymap * modmap)2658 XFreeModifiermap(XModifierKeymap *modmap)
2659 {
2660 xtrace("XFreeModifiermap\n");
2661 freeMemory(modmap->modifiermap);
2662 freeMemory(modmap);
2663 return 0;
2664 }
2665
2666
2667 int
XSetFont(display,gc,font)2668 XSetFont(display,gc,font)
2669 Display *display;
2670 GC gc;
2671 Font font;
2672 {
2673 xtrace("XSetFont\n");
2674 gc->values.font = font;
2675 return 0;
2676 }
2677
2678
2679 int
XSetFontPath(display,dirs,nd)2680 XSetFontPath(display,dirs,nd)
2681 Display *display;
2682 char **dirs;
2683 int nd;
2684 {
2685 xtrace("XSetFontPath\n");
2686 return 0;
2687 }
2688
2689
2690 /*****************************************************************\
2691
2692 Function: XTextExtents
2693 Inputs: font structure, string, string length.
2694 Returned: writing direction, max ascent, max descent, font overall
2695 characteristics.
2696
2697 Comments: The design of windows fonts is similar to X, as far as
2698 ascent and descent are concerned. However, they are
2699 positioned differently on the screen (see XDrawText).
2700
2701 \*****************************************************************/
2702
2703 static HDC desktopHDC;
2704 static int firstTE = TRUE;
2705 int
XTextExtents(fstruct,str,nc,dir,ascent,descent,overall)2706 XTextExtents(fstruct,str,nc,dir,ascent,descent,overall)
2707 XFontStruct *fstruct;
2708 const char *str;
2709 int nc;
2710 int *dir,*ascent,*descent;
2711 XCharStruct *overall;
2712 {
2713 TEXTMETRIC tmet;
2714 HDC hdc;
2715 SIZE tsize;
2716 HWND desktop;
2717 HFONT old;
2718
2719 xtrace("XTextExtents\n");
2720 if (firstTE)
2721 {
2722 firstTE = FALSE;
2723 desktop=GetDesktopWindow();
2724 desktopHDC=GetDC(desktop);
2725 }
2726 hdc = desktopHDC;
2727 old = SelectObject(hdc, (HFONT)fstruct->fid);
2728 GetTextMetrics(hdc,&tmet);
2729 GetTextExtentPoint(hdc,str,nc,&tsize);
2730 *dir=FontLeftToRight;
2731 *ascent=tmet.tmAscent + 1;
2732 *descent=tmet.tmDescent;
2733 overall->ascent=(short)(tmet.tmAscent + 1);
2734 overall->descent=(short)tmet.tmDescent;
2735 overall->width=(short)tsize.cx;
2736 overall->lbearing=0;
2737 overall->rbearing=(short)tsize.cx;
2738 /* cjh_rel_dc(desktop,hdc);*/
2739 SelectObject(hdc,old);
2740 return 0;
2741 }
2742
2743
2744 int
XTextExtents16(fstruct,str,nc,dir,ascent,descent,overall)2745 XTextExtents16(fstruct,str,nc,dir,ascent,descent,overall)
2746 XFontStruct *fstruct;
2747 const XChar2b *str;
2748 int nc;
2749 int *dir,*ascent,*descent;
2750 XCharStruct *overall;
2751 {
2752 xtrace("XTextExtents16\n");
2753 return 0;
2754 }
2755
2756
2757 /*****************************************************************\
2758
2759
2760 Function: XTextWidth
2761 Inputs: font structure, string, length of string.
2762 Returned: String width in pixels.
2763
2764 Comments:
2765
2766 \*****************************************************************/
2767
2768 int
XTextWidth(fstruct,str,co)2769 XTextWidth(fstruct,str,co)
2770 XFontStruct *fstruct;
2771 const char *str;
2772 int co;
2773 {
2774 HDC hdc;
2775 SIZE tsize;
2776 HWND root;
2777 HFONT old;
2778 xtrace("XTextWidth\n");
2779
2780 if(firstTE)
2781 {
2782 firstTE = FALSE;
2783 root=GetDesktopWindow();
2784 hdc=GetDC(root);
2785 }
2786 old = SelectObject(hdc, (HFONT)fstruct->fid);
2787 GetTextExtentPoint(hdc,str,co,&tsize);
2788 SelectObject(hdc,old);
2789 /*cjh_rel_dc(root,hdc);*/
2790 return (tsize.cx);
2791 }
2792
2793
2794 int
XTextWidth16(fstruct,str,co)2795 XTextWidth16(fstruct,str,co)
2796 XFontStruct *fstruct;
2797 const XChar2b *str;
2798 int co;
2799 {
2800 xtrace("XTextWidth16\n");
2801 return 0;
2802 }
2803
2804
2805 int
XGetErrorDatabaseText(display,name,msg,defstr,buf,len)2806 XGetErrorDatabaseText(display,name,msg,defstr,buf,len)
2807 Display *display;
2808 const char *name,*msg;
2809 const char *defstr;
2810 char *buf;
2811 int len;
2812 {
2813 static char def_err[]="Errors not implemented";
2814 int n;
2815
2816 xtrace("XGetErrorDatabaseText\n");
2817 while (n<len && def_err[n] != 0)
2818 *(buf+n)=def_err[n++];
2819 *(buf+n)=0;
2820 return 0;
2821 }
2822
2823
2824 int
XGetErrorText(display,code,buf,len)2825 XGetErrorText(display,code,buf,len)
2826 Display *display;
2827 int code;
2828 char *buf;
2829 int len;
2830 {
2831 xtrace("XGetErrorText\n");
2832 return 0;
2833 }
2834
2835
2836 XErrorHandler
XSetErrorHandler(handler)2837 XSetErrorHandler(handler)
2838 XErrorHandler handler;
2839 {
2840 xtrace("XSetErrorHandler\n");
2841 return 0;
2842 }
2843
2844
2845 /*****************************************************************\
2846
2847
2848 Function: XDefaultScreen
2849 Inputs: display
2850 Returned: default screen number
2851
2852 Comments:
2853
2854 \*****************************************************************/
2855
2856 int
XDefaultScreen(display)2857 XDefaultScreen(display)
2858 Display *display;
2859 {
2860 xtrace("XDefaultScreen\n");
2861 return (display->default_screen);
2862 }
2863
2864 Visual *
XDefaultVisual(display,screen)2865 XDefaultVisual(display, screen)
2866 Display *display;
2867 int screen;
2868 {
2869 xtrace("XDefaultVisual\n");
2870 return DefaultVisual(display, screen);
2871 }
2872 int
XDefaultDepth(display,screen)2873 XDefaultDepth(display, screen)
2874 Display *display;
2875 int screen;
2876 {
2877 xtrace("XDefaultDepth\n");
2878 return DefaultDepth(display, screen);
2879 }
2880 Colormap
XDefaultColormap(display,screen)2881 XDefaultColormap(display, screen)
2882 Display *display;
2883 int screen;
2884 {
2885 xtrace("XDefaultColormap\n");
2886 return DefaultColormap(display, screen);
2887 }
2888
2889
2890 /*****************************************************************\
2891
2892
2893 Function: XScreenOfDisplay
2894 Inputs: display,screen number
2895 Returned: screen list.
2896
2897 Comments:
2898
2899 \*****************************************************************/
2900
2901 Screen *
XScreenOfDisplay(display,scr)2902 XScreenOfDisplay(display,scr)
2903 Display *display;
2904 int scr;
2905 {
2906 xtrace("XScreenOfDisplay\n");
2907 return (display->screens);
2908 }
2909
2910
2911 Cursor
XCreateFontCursor(display,shape)2912 XCreateFontCursor(display,shape)
2913 Display *display;
2914 unsigned int shape;
2915 {
2916 xtrace("XCreateFontCursor\n");
2917 return 0;
2918 }
2919
2920
2921 int
XRecolorCursor(display,cursor,fg,bg)2922 XRecolorCursor(display,cursor,fg,bg)
2923 Display *display;
2924 Cursor cursor;
2925 XColor *fg,*bg;
2926 {
2927 xtrace("XRecolorCursor\n");
2928 return 0;
2929 }
2930
2931
2932 /*****************************************************************\
2933
2934
2935 Function: XWarpPointer
2936 Inputs: display, source window, destination window, source window
2937 geometry, destination x, y.
2938
2939 Comments: Not knowingly tested.
2940
2941 \*****************************************************************/
2942
2943 int
XWarpPointer(display,sw,dw,sx,sy,swidth,sheight,dx,dy)2944 XWarpPointer(display,sw,dw,sx,sy,swidth,sheight,dx,dy)
2945 Display *display;
2946 Window sw,dw;
2947 int sx,sy;
2948 unsigned int swidth,sheight;
2949 int dx,dy;
2950 {
2951 NT_window *ntsw=(NT_window *)sw;
2952 NT_window *ntdw=(NT_window *)dw;
2953
2954 POINT cpt,tmp;
2955 RECT srct;
2956 HDC hDC;
2957
2958 xtrace("XWarpPointer\n");
2959 GetCursorPos(&cpt);
2960 if (ntsw==None)
2961 {
2962 if (ntdw==None)
2963 SetCursorPos(dx,dy);
2964 else
2965 {
2966 tmp.x=dx;
2967 tmp.y=dy;
2968 ClientToScreen(ntdw->w,&tmp);
2969 SetCursorPos(tmp.x,tmp.y);
2970 }
2971 }
2972 else
2973 {
2974 GetWindowRect(ntsw->w,&srct);
2975 tmp.x=sx;
2976 tmp.y=sy;
2977 ClientToScreen(ntsw->w,&tmp);
2978 if (swidth==0)
2979 swidth=srct.right-sx;
2980 if (sheight==0)
2981 sheight=srct.bottom-sy;
2982 hDC = cjh_get_dc(ntdw);
2983 if (cpt.x>=tmp.x && cpt.x<tmp.x+(int)swidth &&
2984 cpt.y>=tmp.y && cpt.y<tmp.y+(int)sheight &&
2985 PtVisible(hDC,cpt.x,cpt.y))
2986 {
2987 if (ntdw==None)
2988 SetCursorPos(cpt.x+dx,cpt.y+dy);
2989 else
2990 {
2991 tmp.x=dx;
2992 tmp.y=dy;
2993 ClientToScreen(ntdw->w,&tmp);
2994 SetCursorPos(tmp.x,tmp.y);
2995 }
2996 }
2997 cjh_rel_dc(ntdw,hDC);
2998 }
2999 return 0;
3000 }
3001
3002
3003 /*****************************************************************\
3004
3005
3006 Function: XBell
3007 Inputs: display, percent loudness.
3008
3009 Comments: Don't throw away your CD just yet.
3010
3011 \*****************************************************************/
3012
3013 int
XBell(display,pc)3014 XBell(display,pc)
3015 Display *display;
3016 int pc;
3017 {
3018 xtrace("XBell\n");
3019 MessageBeep(MB_OK);
3020 return 0;
3021 }
3022
3023
3024 /*****************************************************************\
3025
3026
3027 Function: XGetInputFocus
3028 Inputs: display, focus window, revert to window.
3029
3030 Comments: We don't have the data in place for the revert to field
3031 to work.
3032
3033 \*****************************************************************/
3034
3035 int
XGetInputFocus(display,focus,revto)3036 XGetInputFocus(display,focus,revto)
3037 Display *display;
3038 Window *focus;
3039 int *revto;
3040 {
3041 xtrace("XGetInputFocus\n");
3042 *focus=(Window)GetFocus(); /* Note: returns NULL if the focus window */
3043 revto=RevertToNone; /* belongs to another thread. */
3044 return 0;
3045 }
3046
3047
3048 /*****************************************************************\
3049
3050
3051 Function: XSetInputFocus
3052 Inputs: display, focus window, revert to window, time.
3053
3054 Comments: Set focus to requested client window.
3055
3056 \*****************************************************************/
3057
3058 int
XSetInputFocus(display,focus,revto,time)3059 XSetInputFocus(display,focus,revto,time)
3060 Display *display;
3061 Window focus;
3062 int revto;
3063 Time time;
3064 {
3065 NT_window *ntw=(NT_window *)focus;
3066 xtrace("XSetInputFocus\n");
3067 SetFocus(ntw->w);
3068 return 0;
3069 }
3070
3071
3072 int
XLookupString(event,buf,nbytes,keysym,status)3073 XLookupString(event,buf,nbytes,keysym,status)
3074 XKeyEvent *event;
3075 char *buf;
3076 int nbytes;
3077 KeySym *keysym;
3078 XComposeStatus *status;
3079 {
3080 xtrace("XLookupString\n");
3081 *buf=event->keycode;
3082 *keysym=event->keycode;
3083 return 1;
3084 }
3085
3086
3087 int
XRefreshKeyboardMapping(event)3088 XRefreshKeyboardMapping(event)
3089 XMappingEvent *event;
3090 {
3091 xtrace("XRefreshKeyboardMapping\n");
3092 return 0;
3093 }
3094
3095
3096 int
XSetClassHint(display,w,chints)3097 XSetClassHint(display,w,chints)
3098 Display *display;
3099 Window w;
3100 XClassHint *chints;
3101 {
3102 xtrace("XSetClassHint\n");
3103 return 0;
3104 }
3105
3106
3107 /*****************************************************************\
3108
3109
3110 Function: XSetNormalHints
3111 Inputs: display, window, size hints.
3112
3113 Comments: Assuming the role of the window manager, we alter the
3114 window geometry as requested.
3115
3116 \*****************************************************************/
3117
3118 int
XSetNormalHints(display,w,hints)3119 XSetNormalHints(display,w,hints)
3120 Display *display;
3121 Window w;
3122 XSizeHints *hints;
3123 {
3124 NT_window *ntw=(NT_window *)w;
3125 UINT ff;
3126
3127 xtrace("XSetNormalHints\n");
3128
3129 if (!hints->flags&PPosition)
3130 ff=SWP_NOMOVE;
3131 else
3132 ff=0;
3133
3134 if (!hints->flags&PSize)
3135 ff=ff|SWP_NOSIZE;
3136
3137 if (hints->flags &USPosition)
3138 {
3139 ntw->x = hints->x;
3140 ntw->y = hints->y;
3141 }
3142 if (hints->flags & USSize)
3143 {
3144 ntw->wdth = hints->width;
3145 ntw->hght = hints->height;
3146 }
3147
3148 if (hints->flags&PMinSize)
3149 {
3150 ntw->minx = hints->min_width;
3151 ntw->miny = hints->min_height;
3152 }
3153
3154 if (VALID_WINDOW(ntw) && (hints->flags & USSize || hints->flags &USPosition))
3155 {
3156 SetWindowPos(ntw->w,HWND_TOPMOST,hints->x,hints->y,
3157 hints->width,hints->height,ff|SWP_SHOWWINDOW);
3158 }
3159 return 0;
3160 }
3161
3162
3163 int
XSetWMHints(display,w,wmhints)3164 XSetWMHints(display,w,wmhints)
3165 Display *display;
3166 Window w;
3167 XWMHints *wmhints;
3168 {
3169 xtrace("XSetWMHints\n");
3170 return 0;
3171 }
3172
3173
3174 StatusDef
XSetWMProtocols(display,w,prots,co)3175 XSetWMProtocols(display,w,prots,co)
3176 Display *display;
3177 Window w;
3178 Atom *prots;
3179 int co;
3180 {
3181 xtrace("XSetWMProtocols\n");
3182 return 0;
3183 }
3184
3185
3186 /*****************************************************************\
3187
3188
3189 Function: XStoreName
3190 Inputs: display, window, window name.
3191
3192 Comments: Only set names to the frame windows, otherwise captions
3193 appear in the client areas.
3194
3195 \*****************************************************************/
3196
3197 int
XStoreName(display,w,wname)3198 XStoreName(display,w,wname)
3199 Display *display;
3200 Window w;
3201 const char *wname;
3202 {
3203 NT_window *ntw=(NT_window *)w;
3204 int status = 0;
3205
3206 xtrace("XStoreName\n");
3207 if (ntw->top_flag)
3208 {
3209 ntw->title_text = strdup(wname);
3210 if (VALID_WINDOW(ntw))
3211 status = SetWindowText (ntw->w , wname);
3212 }
3213 return(status);
3214 }
3215
3216 StatusDef
XFetchName(Display * display,Window w,char ** window_name_return)3217 XFetchName(
3218 Display *display,
3219 Window w,
3220 char **window_name_return)
3221 {
3222 NT_window *ntw=(NT_window *)w;
3223 int status = 1;
3224 xtrace("XFetchName\n");
3225 *window_name_return = NULL;
3226 if (ntw->title_text!=NULL)
3227 {
3228 *window_name_return = strdup(ntw->title_text);
3229 status =0;
3230 }
3231 return(status);
3232 }
3233
3234
3235
3236 /*****************************************************************\
3237
3238
3239 Function: XDoesBackingStore
3240 Inputs: screen
3241
3242 Comments: No backing store at the moment. Windows doesn't seem
3243 to support it, unless we do it ourselves with compatible
3244 bitmaps.
3245
3246 \*****************************************************************/
3247
3248 int
XDoesBackingStore(scr)3249 XDoesBackingStore(scr)
3250 Screen *scr;
3251 {
3252 xtrace("XDoesBackingStore\n");
3253 return(0);
3254 }
3255
3256
3257 XExtCodes *
XInitExtension(display,name)3258 XInitExtension(display,name)
3259 Display *display;
3260 const char *name;
3261 {
3262 xtrace("XInitExtension\n");
3263 return 0;
3264 }
3265
3266
3267 /*****************************************************************\
3268
3269
3270 Function: XFree
3271 Inputs: data to be freed.
3272
3273 Comments: This might need changing sometime. No crashes so far.
3274
3275 \*****************************************************************/
3276
3277 int
XFree(data)3278 XFree(data)
3279 void *data;
3280 {
3281 xtrace("XFree\n");
3282 freeMemory(data);
3283 return 0;
3284 }
3285
3286 /*****************************************************************\
3287
3288
3289 Function: XServerVendor
3290 Inputs: display.
3291 Returned: string of vendor's name.
3292
3293 Comments: Copied from the display structure.
3294
3295 \*****************************************************************/
3296
3297 char *
XServerVendor(display)3298 XServerVendor(display)
3299 Display *display;
3300 {
3301 xtrace("XServerVendor\n");
3302 return (display->vendor);
3303 }
3304
3305
3306 int
XSetIconName(display,w,iname)3307 XSetIconName(display,w,iname)
3308 Display *display;
3309 Window w;
3310 const char *iname;
3311 {
3312 xtrace("XSetIconName\n");
3313 return 0;
3314 }
3315 int
XGetIconName(display,w,iname)3316 XGetIconName(display,w,iname)
3317 Display *display;
3318 Window w;
3319 char **iname;
3320 {
3321 xtrace("XGetIconName\n");
3322 *iname = NULL;
3323 return 0;
3324 }
3325
3326
3327 int
XSetSelectionOwner(display,sel,owner,time)3328 XSetSelectionOwner(display, sel, owner, time)
3329 Display* display;
3330 Atom sel;
3331 Window owner;
3332 Time time;
3333 {
3334 HWND hwnd = owner ? ((NT_window*)owner)->w : NULL;
3335 HWND cowner = GetClipboardOwner();
3336 OpenClipboard(hwnd);
3337 if (cowner==hwnd)
3338 catchNextDestroyClipboard();
3339 EmptyClipboard();
3340 CloseClipboard();
3341 return 0;
3342 }
3343
3344 Window
XGetSelectionOwner(display,selection)3345 XGetSelectionOwner(display,selection)
3346 Display* display;
3347 Atom selection;
3348 {
3349 HWND hwnd = NULL;
3350 Window w;
3351 xtrace("XGetSelectionOwner\n");
3352 hwnd = GetClipboardOwner();
3353 w = (Window)NT_find_window_from_id(hwnd);
3354 if (!w) w=None;
3355 return w;
3356 }
3357
3358 /*****************************************************************\
3359
3360 Function: NT_set_rop
3361 Inputs: window device context, X graphics context
3362
3363 Comments: Sets the graphics drawing operation.
3364
3365 \*****************************************************************/
3366
3367 void
NT_set_rop(hdc,gc)3368 NT_set_rop(hdc,gc)
3369 HDC hdc;
3370 GC gc;
3371 {
3372 switch (gc->values.function)
3373 {
3374 case GXclear:
3375 SetROP2(hdc,R2_BLACK);
3376 break;
3377
3378 case GXand:
3379 SetROP2(hdc,R2_MASKPEN);
3380 break;
3381
3382 case GXandReverse:
3383 SetROP2(hdc,R2_MASKPENNOT);
3384 break;
3385
3386 case GXcopy:
3387 SetROP2(hdc,R2_COPYPEN);
3388 break;
3389
3390 case GXnoop:
3391 SetROP2(hdc,R2_NOP);
3392 break;
3393
3394 case GXxor:
3395 SetROP2(hdc,R2_XORPEN);/*XORPEN);*/
3396 break;
3397
3398 case GXor:
3399 SetROP2(hdc,R2_MERGEPEN);
3400 break;
3401
3402 case GXnor:
3403 SetROP2(hdc,R2_NOTMERGEPEN);
3404 break;
3405
3406 case GXequiv:
3407 SetROP2(hdc,R2_NOTXORPEN);
3408 break;
3409
3410 case GXinvert:
3411 SetROP2(hdc,R2_NOT);
3412 break;
3413
3414 case GXorReverse:
3415 SetROP2(hdc,R2_MERGEPENNOT);
3416 break;
3417
3418 case GXcopyInverted:
3419 SetROP2(hdc,R2_NOTCOPYPEN);
3420 break;
3421
3422 case GXorInverted:
3423 SetROP2(hdc,R2_MERGENOTPEN);
3424 break;
3425
3426 case GXnand:
3427 SetROP2(hdc,R2_NOTMASKPEN);
3428 break;
3429
3430 case GXset:
3431 SetROP2(hdc,R2_WHITE);
3432 break;
3433 }
3434 }
3435
3436 /*****************************************************************\
3437
3438 Function: NT_check_update_GC
3439 Inputs: gc - Graphics Context
3440
3441 Comments: Check what has changed in the GC and modify the
3442 pen and brush accordingly.
3443
3444 \*****************************************************************/
3445 static int
NT_check_update_GC(gc)3446 NT_check_update_GC(gc)
3447 GC gc;
3448 {
3449 DWORD style=PS_GEOMETRIC;
3450 LOGBRUSH lbr;
3451 int width;
3452 NTGC *lntgc;
3453
3454 if ( gc->ext_data == NULL )
3455 {
3456 gc->ext_data = (XExtData *)allocateMemory(sizeof(XExtData));
3457 lntgc = (NTGC *)allocateMemory(sizeof(NTGC));
3458 gc->ext_data->private_data = (char *)lntgc;
3459 lntgc->pen = INVALID_HANDLE;
3460 lntgc->brush = INVALID_HANDLE;
3461 lntgc->bgbrush = INVALID_HANDLE;
3462 gc->dirty=~0;
3463 }
3464
3465 if ((gc->dirty & GCForeground) ||
3466 (gc->dirty & GCLineStyle) ||
3467 (gc->dirty & GCCapStyle) ||
3468 (gc->dirty & GCJoinStyle) ||
3469 (gc->dirty & GCLineWidth) )
3470 {
3471 lbr.lbStyle=BS_SOLID;
3472 lbr.lbColor=CNUMTORGB(gc->values.foreground);
3473 lbr.lbHatch=0;
3474
3475 if (gc->values.line_style==LineDoubleDash)
3476 style|=PS_DASHDOT;
3477 else if (gc->values.line_style==LineOnOffDash)
3478 style|=PS_DASH;
3479 else
3480 style|=PS_SOLID;
3481
3482 if (gc->values.cap_style==CapProjecting)
3483 style|=PS_ENDCAP_SQUARE;
3484 else if (gc->values.cap_style==CapRound)
3485 style|=PS_ENDCAP_ROUND;
3486 else
3487 style|=PS_ENDCAP_FLAT;
3488
3489 if (gc->values.join_style==JoinRound)
3490 style|=PS_JOIN_ROUND;
3491 else if (gc->values.join_style==JoinMiter)
3492 style|=PS_JOIN_MITER;
3493 else
3494 style|=PS_JOIN_BEVEL;
3495 width=gc->values.line_width;
3496 if (width==0)
3497 width=1;
3498
3499 lntgc = (NTGC *)gc->ext_data->private_data;
3500 if ( lntgc->pen != INVALID_HANDLE )
3501 DeleteObject(lntgc->pen);
3502
3503 lntgc->pen = ExtCreatePen(style,width,&lbr,0,NULL);
3504 }
3505 if (gc->values.fill_style != FillSolid)
3506 {
3507 if ((gc->dirty & GCStipple))
3508 {
3509 NT_window *pixmap = (NT_window *)gc->values.stipple;
3510 lntgc->brush = CreatePatternBrush(pixmap->hBitmap);
3511 }
3512 }
3513 else if ((gc->dirty & GCForeground) )
3514 {
3515 lntgc = (NTGC *)gc->ext_data->private_data;
3516 if ( lntgc->brush != INVALID_HANDLE )
3517 DeleteObject(lntgc->brush);
3518 lntgc->brush = CreateSolidBrush(CNUMTORGB(gc->values.foreground));
3519
3520 }
3521
3522 if ((gc->dirty & GCBackground) )
3523 {
3524 lntgc = (NTGC *)gc->ext_data->private_data;
3525 if ( lntgc->bgbrush != INVALID_HANDLE )
3526 DeleteObject(lntgc->bgbrush);
3527 lntgc->bgbrush = CreateSolidBrush(CNUMTORGB(gc->values.background));
3528
3529 }
3530
3531 gc->dirty = 0;
3532
3533 return(1);
3534 }
3535
3536
3537 /*****************************************************************\
3538
3539 Function: NT_get_GC_pen
3540 Inputs: device context, graphics context
3541
3542 Comments: Sets the device context and pen according to the
3543 graphics context.
3544
3545 \*****************************************************************/
3546 static HPEN
NT_get_GC_pen(hdc,gc)3547 NT_get_GC_pen(hdc,gc)
3548 HDC hdc;
3549 GC gc;
3550 {
3551 NTGC *lntgc;
3552
3553 NT_check_update_GC(gc);
3554 NT_set_rop(hdc,gc);
3555
3556 lntgc = (NTGC *)gc->ext_data->private_data;
3557
3558 return(lntgc->pen);
3559 }
3560
3561
3562 /*****************************************************************\
3563
3564 Function: NT_get_GC_brush
3565 Inputs: device context, graphics context
3566 Returns: handle for brush.
3567
3568 Comments: Same as above for painting operations.
3569
3570 \*****************************************************************/
3571 static HBRUSH
NT_get_GC_brush(hdc,gc)3572 NT_get_GC_brush(hdc,gc)
3573 HDC hdc;
3574 GC gc;
3575 {
3576 NTGC *lntgc;
3577
3578 NT_check_update_GC(gc);
3579
3580 if (gc->values.fill_rule==EvenOddRule)
3581 SetPolyFillMode(hdc,ALTERNATE);
3582 else
3583 SetPolyFillMode(hdc,WINDING);
3584
3585 if (gc->values.fill_style == FillSolid ||
3586 gc->values.fill_style == FillOpaqueStippled)
3587 {
3588 SetTextColor(hdc, CNUMTORGB(gc->values.foreground));
3589 SetBkColor(hdc, CNUMTORGB(gc->values.background));
3590 }
3591
3592 NT_set_rop(hdc,gc);
3593
3594 lntgc = (NTGC *)gc->ext_data->private_data;
3595
3596 return(lntgc->brush);
3597 }
3598
3599 static HBRUSH
NT_get_GC_bgbrush(hdc,gc)3600 NT_get_GC_bgbrush(hdc,gc)
3601 HDC hdc;
3602 GC gc;
3603 {
3604 NTGC *lntgc;
3605 NT_check_update_GC(gc);
3606 lntgc = (NTGC *)gc->ext_data->private_data;
3607 return(lntgc->bgbrush);
3608 }
3609
3610
3611
3612 /*****************************************************************\
3613
3614 Function: NT_deg64_to_rad
3615 Inputs: angle (in 64ths of a degree)
3616
3617 Comments: Converts int angle to double in radians.
3618
3619 \*****************************************************************/
3620
3621 double
NT_deg64_to_rad(a)3622 NT_deg64_to_rad(a)
3623 int a;
3624 {
3625 return ((double)a/64.0*0.017453);
3626 }
3627
3628
3629 /******************************************************************/
3630 /* */
3631 /* Atoms and properties code. */
3632 /* */
3633 /******************************************************************/
3634
3635 static char **nt_atoms;
3636 static int num_nt_atoms = 0;
3637 static int max_num_nt_atoms = 0;
3638 #define ATOMS_BLOCK_SIZE 40
3639
3640 /******************************************************************\
3641
3642 Function: XInternAtom
3643 Inputs: Display, property name, creation flag.
3644
3645 Comments: Could be made much more efficient.
3646
3647 \******************************************************************/
3648
3649 Atom
XInternAtom(display,property_name,only_if_exists)3650 XInternAtom(display, property_name, only_if_exists)
3651 Display *display;
3652 const char *property_name;
3653 BoolDef only_if_exists;
3654 {
3655 int i;
3656 char **new_nt_atoms;
3657
3658 xtrace("XInternAtom\n");
3659 if (strcmp(property_name,"VT_SELECTION")==0)
3660 {
3661 return XA_LAST_PREDEFINED + 667;
3662 }
3663
3664 for (i=0;i< num_nt_atoms ;i++)
3665 if (strcmp(nt_atoms[i],property_name) == 0)
3666 return XA_LAST_PREDEFINED + i;
3667
3668 if (only_if_exists)
3669 return None;
3670
3671 if (num_nt_atoms >= max_num_nt_atoms)
3672 {
3673 new_nt_atoms = (char **)realloc(nt_atoms,(max_num_nt_atoms + ATOMS_BLOCK_SIZE)*sizeof(char *));
3674 if (!new_nt_atoms)
3675 return None;
3676 nt_atoms = new_nt_atoms;
3677 max_num_nt_atoms+= ATOMS_BLOCK_SIZE;
3678 nt_atoms[num_nt_atoms] = allocateMemory(strlen(property_name)+1);
3679 if (!nt_atoms[num_nt_atoms])
3680 return None;
3681 strcpy(nt_atoms[num_nt_atoms],property_name);
3682 return (XA_LAST_PREDEFINED + num_nt_atoms++);
3683 }
3684 }
3685
3686 /******************************************************************\
3687
3688 Function: XGetAtomName
3689 Inputs: Display,Atom
3690
3691 Comments: None.
3692
3693 \******************************************************************/
3694 char *
XGetAtomName(display,atom)3695 XGetAtomName(display,atom)
3696 Display *display;
3697 Atom atom;
3698 {
3699 char *ret_string;
3700 xtrace("XGetAtomName\n");
3701 if (atom > num_nt_atoms + XA_LAST_PREDEFINED)
3702 return NULL;
3703
3704 if (! (ret_string = allocateMemory(strlen(nt_atoms[atom - XA_LAST_PREDEFINED])+1)))
3705 return FALSE;
3706
3707 strcpy(ret_string,nt_atoms[atom]);
3708
3709 return ret_string;
3710 }
3711
3712 /******************************************************************\
3713
3714 Function: XChangeProperty
3715 Inputs: Display,Window,Property,type,format,mode,data,
3716 nelements.
3717
3718 Comments: None.
3719
3720 \******************************************************************/
3721 int
XChangeProperty(Display * display,Window window,Atom property,Atom type,int format,int mode,const unsigned char * data,int nelements)3722 XChangeProperty(
3723 Display *display,
3724 Window window,
3725 Atom property,
3726 Atom type,
3727 int format,
3728 int mode,
3729 const unsigned char *data,
3730 int nelements)
3731 {
3732 NT_window *ntw=(NT_window *)window;
3733 struct NT_prop_list *wanderer, *new;
3734 xtrace("XChangeProperty\n");
3735
3736 if (property == XA_CUT_BUFFER0 && type==XA_STRING)
3737 {
3738 HGLOBAL handle=NULL;
3739 char *buffer=NULL;
3740 int i,j,cr=0;
3741 for (i=0; i<nelements; i++)
3742 if (data[i]=='\n' && (i==0 || data[i-1]!='\r')) cr++;
3743
3744 handle = GlobalAlloc(GMEM_MOVEABLE|GMEM_DDESHARE, nelements+cr+1);
3745 if (!handle) return;
3746 OpenClipboard(ntw->w);
3747 buffer = GlobalLock(handle);
3748 for (i=j=0; i<nelements; buffer[j++]=data[i++])
3749 if (data[i]=='\n' && (i==0 || data[i-1]!='\r')) buffer[j++]='\r';
3750 buffer[j++]='\0';
3751 GlobalUnlock(handle);
3752 SetClipboardData(CF_TEXT, handle);
3753 handle = GlobalAlloc(GMEM_MOVEABLE|GMEM_DDESHARE, sizeof(LCID));
3754 if (handle) {
3755 *(LCID*)GlobalLock(handle) = GetThreadLocale();
3756 GlobalUnlock(handle);
3757 SetClipboardData(CF_LOCALE, handle);
3758 }
3759 CloseClipboard();
3760 return;
3761 }
3762 }
3763
3764 int
XDeleteProperty(Display * display,Window w,Atom property)3765 XDeleteProperty(
3766 Display *display,
3767 Window w,
3768 Atom property)
3769 {
3770 return 0;
3771 }
3772
3773 static char *
NT_getClipboard()3774 NT_getClipboard()
3775 {
3776 char *ret = NULL;
3777 char *s,*t;
3778 int size, format=0;
3779 HGLOBAL handle;
3780 LPVOID data;
3781 OpenClipboard(NULL);
3782 for (format = EnumClipboardFormats(format); format; format = EnumClipboardFormats(format)) {
3783 if (format != CF_TEXT && format != CF_UNICODETEXT) continue;
3784 handle = GetClipboardData(format);
3785 if (handle==NULL) break;
3786 data = GlobalLock(handle);
3787 if (format == CF_UNICODETEXT) {
3788 int conv = CP_THREAD_ACP;
3789 size = WideCharToMultiByte(conv,0,data,-1,NULL,0,NULL,NULL);
3790 if (size == 0) /* NT doesn't support CF_THREAD_ACP */
3791 size = WideCharToMultiByte( (conv = CP_UTF8),0,data,-1,NULL,0,NULL,NULL);
3792 if (size==0) continue; /* let windows convert it */
3793 ret = allocateMemory(size);
3794 WideCharToMultiByte(conv, 0, data, -1, ret, size, NULL, NULL);
3795 } else {
3796 size = strlen(data)+1;
3797 ret = allocateMemory(size);
3798 strcpy(ret,data);
3799 }
3800 GlobalUnlock(handle);
3801 break;
3802 }
3803 CloseClipboard();
3804 for (s=t=ret;s && (*t=*s++);) if (*t!='\r') t++;
3805 return ret;
3806 }
3807
3808 int
XGetWindowProperty(display,window,property,long_offset,long_length,delete,req_type,actual_type_return,actual_format_return,nitems_return,bytes_after_return,prop_return)3809 XGetWindowProperty(display,window,property,long_offset,long_length,delete,
3810 req_type,actual_type_return,actual_format_return,
3811 nitems_return,bytes_after_return,prop_return)
3812 Display *display;
3813 Window window;
3814 Atom property;
3815 long long_offset;
3816 long long_length;
3817 BoolDef delete;
3818 Atom req_type;
3819 Atom *actual_type_return;
3820 int *actual_format_return;
3821 unsigned long *nitems_return;
3822 unsigned long *bytes_after_return;
3823 unsigned char **prop_return;
3824 {
3825 xtrace("XGetWindowProperty\n");
3826 if (property == XA_CUT_BUFFER0 && prop_return && (*prop_return = NT_getClipboard())) {
3827 *nitems_return=strlen(*prop_return);
3828 *actual_type_return = XA_STRING;
3829 *bytes_after_return = 0;
3830 }
3831 else {
3832 *prop_return = NULL;
3833 *actual_type_return = None;
3834 *actual_format_return = 0;
3835 *bytes_after_return = 0;
3836 }
3837 return 0;
3838 }
3839
3840
3841
3842 char **
XListExtensions(display,ret_num)3843 XListExtensions(display,ret_num)
3844 Display *display;
3845 int *ret_num;
3846 {
3847 *ret_num = 0;
3848 xtrace("XListExtensions\n");
3849 return NULL;
3850 }
3851
XFreeExtensionList(list)3852 XFreeExtensionList(list)
3853 char **list;
3854 {
3855 xtrace("XFreeExtensionList\n");
3856 return 0;
3857 }
3858
XChangeGC(Display * display,GC gc,unsigned long mask,XGCValues * gc_values)3859 XChangeGC(
3860 Display* display,
3861 GC gc,
3862 unsigned long mask,
3863 XGCValues* gc_values)
3864 {
3865 xtrace("XChangeGC\n");
3866 if (mask&GCArcMode)
3867 gc->values.arc_mode=gc_values->arc_mode;
3868 if (mask&GCBackground)
3869 gc->values.background=gc_values->background;
3870 if (mask&GCCapStyle)
3871 gc->values.cap_style=gc_values->cap_style;
3872 if (mask&GCClipMask)
3873 gc->values.clip_mask=gc_values->clip_mask;
3874 if (mask&GCClipXOrigin)
3875 gc->values.clip_x_origin=gc_values->clip_x_origin;
3876 if (mask&GCClipYOrigin)
3877 gc->values.clip_y_origin=gc_values->clip_y_origin;
3878 if (mask&GCDashList)
3879 gc->values.dashes=gc_values->dashes;
3880 if (mask&GCDashOffset)
3881 gc->values.dash_offset=gc_values->dash_offset;
3882 if (mask&GCFillRule)
3883 gc->values.fill_rule=gc_values->fill_rule;
3884 if (mask&GCFillStyle)
3885 gc->values.fill_style=gc_values->fill_style;
3886 if (mask&GCFont)
3887 gc->values.font=gc_values->font;
3888 if (mask&GCForeground)
3889 gc->values.foreground=gc_values->foreground;
3890 if (mask&GCFunction)
3891 gc->values.function=gc_values->function;
3892 if (mask&GCGraphicsExposures)
3893 gc->values.graphics_exposures=gc_values->graphics_exposures;
3894 if (mask&GCJoinStyle)
3895 gc->values.join_style=gc_values->join_style;
3896 if (mask&GCLineStyle)
3897 gc->values.line_style=gc_values->line_style;
3898 if (mask&GCLineWidth)
3899 gc->values.line_width=gc_values->line_width;
3900 if (mask&GCPlaneMask)
3901 gc->values.plane_mask=gc_values->plane_mask;
3902 if (mask&GCStipple)
3903 gc->values.stipple=gc_values->stipple;
3904 if (mask&GCSubwindowMode)
3905 gc->values.subwindow_mode=gc_values->subwindow_mode;
3906 if (mask&GCTile)
3907 gc->values.tile=gc_values->tile;
3908 if (mask&GCTileStipXOrigin)
3909 gc->values.ts_x_origin=gc_values->ts_x_origin;
3910 if (mask&GCTileStipYOrigin)
3911 gc->values.ts_y_origin=gc_values->ts_y_origin;
3912 gc->dirty |= mask;
3913 return 0;
3914 }
3915
3916 int
XConnectionNumber(Display * display)3917 XConnectionNumber(Display* display)
3918 {
3919 int fd;
3920 xtrace("XConnectionNumber\n");
3921 fd = open ("/dev/windows", O_NONBLOCK, 0);
3922 return fd;
3923 }
3924
XFreeFont(Display * display,XFontStruct * font_struct)3925 XFreeFont(Display* display,XFontStruct* font_struct)
3926 {
3927 xtrace("XFreeFont\n");
3928 return 0;
3929 }
3930
3931 char *
_Xsetlocale(int category,const char * name)3932 _Xsetlocale(int category, const char *name)
3933 {
3934 xtrace("Xsetlocale\n");
3935 return (char *)name;
3936 }
3937
3938 char *
XSetLocaleModifiers(const char * modifier_list)3939 XSetLocaleModifiers(const char* modifier_list)
3940 {
3941 xtrace("XSetLocaleModifiers\n");
3942 return NULL;
3943 }
3944 XIM
XOpenIM(Display * dpy,struct _XrmHashBucketRec * rdb,char * res_name,char * res_class)3945 XOpenIM(
3946 Display* dpy,
3947 struct _XrmHashBucketRec* rdb,
3948 char* res_name,
3949 char* res_class)
3950 {
3951 xtrace("XOpenIM\n");
3952 return 0;
3953 }
3954 char *
XGetIMValues(XIM im,...)3955 XGetIMValues(XIM im , ...)
3956 {
3957 xtrace("XGetIMValues\n");
3958 return NULL;
3959 }
3960 XIC
XCreateIC(XIM im,...)3961 XCreateIC(XIM im , ...)
3962 {
3963 xtrace("XCreateIC\n");
3964 return 0;
3965 }
3966 StatusDef
XCloseIM(XIM im)3967 XCloseIM(XIM im)
3968 {
3969 xtrace("XCloseIM\n");
3970 return 0;
3971 }
3972
3973 char *
XrmQuarkToString(void * quark)3974 XrmQuarkToString(void *quark)
3975 {
3976 xtrace("XrmQuarkToString\n");
3977 return NULL;
3978 }
3979
3980 int
XmbLookupString(XIC ic,XKeyPressedEvent * event,char * buffer_return,int bytes_buffer,KeySym * keysym_return,StatusDef * status_return)3981 XmbLookupString(
3982 XIC ic,
3983 XKeyPressedEvent* event,
3984 char* buffer_return,
3985 int bytes_buffer,
3986 KeySym* keysym_return,
3987 StatusDef* status_return)
3988 {
3989 xtrace("XmbLookupString\n");
3990 return 0;
3991 }
3992 int
XmbTextPropertyToTextList(Display * display,XTextProperty * text_prop,char *** list_return,int * count_return)3993 XmbTextPropertyToTextList(
3994 Display *display,
3995 XTextProperty *text_prop,
3996 char ***list_return,
3997 int *count_return)
3998 {
3999 xtrace("XmbTextPropertyToTextList\n");
4000 /* in the future copy this, for 2.7.1 rxvt leaks this, so don't yet */
4001 *list_return = (char **)allocateMemory(sizeof(char *));
4002 *list_return[0] = text_prop->value;
4003 *count_return = 1;
4004 return 0;
4005 }
4006
4007 void
XFreeStringList(char ** list)4008 XFreeStringList(char **list)
4009 {
4010 freeMemory(list);
4011 }
4012
4013 int
XmbTextListToTextProperty(Display * display,char ** list,int count,XICCEncodingStyle style,XTextProperty * text_prop_return)4014 XmbTextListToTextProperty(
4015 Display *display,
4016 char **list,
4017 int count,
4018 XICCEncodingStyle style,
4019 XTextProperty *text_prop_return)
4020 {
4021 int ret = 0;
4022 if (count!=1) ret = XNoMemory;
4023 text_prop_return->value = strdup(list[0]);
4024 switch (style)
4025 {
4026 case XStringStyle: text_prop_return->encoding = XA_STRING; break;
4027 /* case XCompoundTextStyle: text_prop_return->encoding = XA_COMPOUND; break; */
4028 default: ret = XLocaleNotSupported;
4029 }
4030 text_prop_return->format = 8;
4031 text_prop_return->nitems = count;
4032 return ret;
4033 }
XmbDrawString(Display * display,Drawable d,XFontSet font_set,GC gc,int x,int y,char * string,int num_bytes)4034 void XmbDrawString(
4035 Display *display,
4036 Drawable d,
4037 XFontSet font_set,
4038 GC gc,
4039 int x, int y,
4040 char *string,
4041 int num_bytes)
4042 {
4043 xtrace("XmbDrawString\n");
4044 }
4045
4046
4047 void
XSetICFocus(XIC ic)4048 XSetICFocus(XIC ic)
4049 {
4050 xtrace("XSetICFocus\n");
4051 }
4052 void
XUnsetICFocus(XIC ic)4053 XUnsetICFocus(XIC ic)
4054 {
4055 xtrace("XUnsetICFocus\n");
4056 }
4057
4058
4059
4060 /* lifted from emacs */
4061 /*
4062 * XParseGeometry parses strings of the form
4063 * "=<width>x<height>{+-}<xoffset>{+-}<yoffset>", where
4064 * width, height, xoffset, and yoffset are unsigned integers.
4065 * Example: "=80x24+300-49"
4066 * The equal sign is optional.
4067 * It returns a bitmask that indicates which of the four values
4068 * were actually found in the string. For each value found,
4069 * the corresponding argument is updated; for each value
4070 * not found, the corresponding argument is left unchanged.
4071 */
4072
4073 static int
read_integer(string,NextString)4074 read_integer (string, NextString)
4075 register char *string;
4076 char **NextString;
4077 {
4078 register int Result = 0;
4079 int Sign = 1;
4080
4081 if (*string == '+')
4082 string++;
4083 else if (*string == '-')
4084 {
4085 string++;
4086 Sign = -1;
4087 }
4088 for (; (*string >= '0') && (*string <= '9'); string++)
4089 {
4090 Result = (Result * 10) + (*string - '0');
4091 }
4092 *NextString = string;
4093 if (Sign >= 0)
4094 return (Result);
4095 else
4096 return (-Result);
4097 }
4098
4099 /* lifted from emacs */
4100 int
XParseGeometry(const char * string,int * x,int * y,unsigned int * width,unsigned int * height)4101 XParseGeometry(
4102 const char* string,
4103 int* x,
4104 int* y,
4105 unsigned int* width,
4106 unsigned int* height)
4107 {
4108 int mask = NoValue;
4109 register char *strind;
4110 unsigned int tempWidth, tempHeight;
4111 int tempX, tempY;
4112 char *nextCharacter;
4113
4114 if ((string == NULL) || (*string == '\0')) return (mask);
4115 if (*string == '=')
4116 string++; /* ignore possible '=' at beg of geometry spec */
4117
4118 strind = (char *)string;
4119 if (*strind != '+' && *strind != '-' && *strind != 'x')
4120 {
4121 tempWidth = read_integer (strind, &nextCharacter);
4122 if (strind == nextCharacter)
4123 return (0);
4124 strind = nextCharacter;
4125 mask |= WidthValue;
4126 }
4127
4128 if (*strind == 'x' || *strind == 'X')
4129 {
4130 strind++;
4131 tempHeight = read_integer (strind, &nextCharacter);
4132 if (strind == nextCharacter)
4133 return (0);
4134 strind = nextCharacter;
4135 mask |= HeightValue;
4136 }
4137
4138 if ((*strind == '+') || (*strind == '-'))
4139 {
4140 if (*strind == '-')
4141 {
4142 strind++;
4143 tempX = -read_integer (strind, &nextCharacter);
4144 if (strind == nextCharacter)
4145 return (0);
4146 strind = nextCharacter;
4147 mask |= XNegative;
4148
4149 }
4150 else
4151 {
4152 strind++;
4153 tempX = read_integer (strind, &nextCharacter);
4154 if (strind == nextCharacter)
4155 return (0);
4156 strind = nextCharacter;
4157 }
4158 mask |= XValue;
4159 if ((*strind == '+') || (*strind == '-'))
4160 {
4161 if (*strind == '-')
4162 {
4163 strind++;
4164 tempY = -read_integer (strind, &nextCharacter);
4165 if (strind == nextCharacter)
4166 return (0);
4167 strind = nextCharacter;
4168 mask |= YNegative;
4169
4170 }
4171 else
4172 {
4173 strind++;
4174 tempY = read_integer (strind, &nextCharacter);
4175 if (strind == nextCharacter)
4176 return (0);
4177 strind = nextCharacter;
4178 }
4179 mask |= YValue;
4180 }
4181 }
4182
4183 /* If strind isn't at the end of the string the it's an invalid
4184 geometry specification. */
4185
4186 if (*strind != '\0') return (0);
4187
4188 if (mask & XValue)
4189 *x = tempX;
4190 if (mask & YValue)
4191 *y = tempY;
4192 if (mask & WidthValue)
4193 *width = tempWidth;
4194 if (mask & HeightValue)
4195 *height = tempHeight;
4196 return (mask);
4197 }
4198
XResizeWindow(Display * display,Window w,unsigned int width,unsigned int height)4199 XResizeWindow(
4200 Display* display,
4201 Window w,
4202 unsigned int width,
4203 unsigned int height)
4204 {
4205 RECT r;
4206 NT_window *ntw=(NT_window *)w;
4207 xtrace("XResizeWindow\n");
4208 r.left = ntw->x;
4209 r.top = ntw->y;
4210 r.right = r.left + width;
4211 r.bottom = r.top + height;
4212 if (ntw->top_flag)
4213 AdjustWindowRect(&r, WS_OVERLAPPEDWINDOW, FALSE);
4214 if (VALID_WINDOW(ntw))
4215 MoveWindow(ntw->w, r.left, r.top,
4216 r.right-r.left, r.bottom-r.top,TRUE);
4217 return 0;
4218 }
4219
4220 void
XSetWMNormalHints(Display * display,Window w,XSizeHints * hints)4221 XSetWMNormalHints(Display* display,Window w,XSizeHints* hints)
4222 {
4223 xtrace("XSetWMNormalHints\n");
4224 XSetNormalHints(display,w,hints);
4225 }
4226
4227 void
XSetWMProperties(Display * display,Window w,XTextProperty * window_name,XTextProperty * icon_name,char ** argv,int argc,XSizeHints * normal_hints,XWMHints * wm_hints,XClassHint * class_hints)4228 XSetWMProperties(
4229 Display* display,
4230 Window w,
4231 XTextProperty* window_name,
4232 XTextProperty* icon_name,
4233 char** argv,
4234 int argc,
4235 XSizeHints* normal_hints,
4236 XWMHints* wm_hints,
4237 XClassHint* class_hints)
4238 {
4239 xtrace("XSetWMProperties\n");
4240 XSetNormalHints(display,w,normal_hints);
4241 }
XDefineCursor(Display * display,Window w,Cursor cursor)4242 XDefineCursor(Display* display,Window w,Cursor cursor)
4243 {
4244 xtrace("XDefineCursor\n");
4245 return 0;
4246 }
4247
XMoveResizeWindow(Display * display,Window w,int x,int y,unsigned int width,unsigned int height)4248 XMoveResizeWindow(
4249 Display* display,
4250 Window w,
4251 int x,
4252 int y,
4253 unsigned int width,
4254 unsigned int height)
4255 {
4256 NT_window *ntw=(NT_window *)w;
4257 xtrace("XMoveResizeWindow\n");
4258 ntw->x = x;
4259 ntw->y = y;
4260 ntw->wdth = width;
4261 ntw->hght = height;
4262 if (VALID_WINDOW(ntw)) {
4263 NT_moveWindow(ntw,TRUE);
4264 }
4265
4266 }
4267
XMoveWindow(Display * display,Window w,int x,int y)4268 XMoveWindow(
4269 Display* display,
4270 Window w,
4271 int x,
4272 int y)
4273 {
4274 NT_window *ntw=(NT_window *)w;
4275 xtrace("XMoveWindow\n");
4276 ntw->x = x;
4277 ntw->y = y;
4278 if (VALID_WINDOW(ntw)) {
4279 NT_moveWindow(ntw,TRUE);
4280 }
4281 return 0;
4282 }
4283
4284 /*
4285 * xcolors.c --
4286 *
4287 * This file contains the routines used to map from X color
4288 * names to RGB and pixel values.
4289 *
4290 * Copyright (c) 1996 by Sun Microsystems, Inc.
4291 *
4292 * See the file "license.terms" for information on usage and redistribution
4293 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
4294 *
4295 * SCCS: @(#) xcolors.c 1.3 96/12/17 13:07:02
4296 */
4297
4298 /*
4299 * Define an array that defines the mapping from color names to RGB values.
4300 * Note that this array must be kept sorted alphabetically so that the
4301 * binary search used in XParseColor will succeed.
4302 */
4303 typedef struct {
4304 char *name;
4305 unsigned char red;
4306 unsigned char green;
4307 unsigned char blue;
4308 } XColorEntry;
4309
4310 static XColorEntry xColors[] = {
4311 "alice blue", 240, 248, 255,
4312 "AliceBlue", 240, 248, 255,
4313 "antique white", 250, 235, 215,
4314 "AntiqueWhite", 250, 235, 215,
4315 "AntiqueWhite1", 255, 239, 219,
4316 "AntiqueWhite2", 238, 223, 204,
4317 "AntiqueWhite3", 205, 192, 176,
4318 "AntiqueWhite4", 139, 131, 120,
4319 "aquamarine", 127, 255, 212,
4320 "aquamarine1", 127, 255, 212,
4321 "aquamarine2", 118, 238, 198,
4322 "aquamarine3", 102, 205, 170,
4323 "aquamarine4", 69, 139, 116,
4324 "azure", 240, 255, 255,
4325 "azure1", 240, 255, 255,
4326 "azure2", 224, 238, 238,
4327 "azure3", 193, 205, 205,
4328 "azure4", 131, 139, 139,
4329 "beige", 245, 245, 220,
4330 "bisque", 255, 228, 196,
4331 "bisque1", 255, 228, 196,
4332 "bisque2", 238, 213, 183,
4333 "bisque3", 205, 183, 158,
4334 "bisque4", 139, 125, 107,
4335 "black", 0, 0, 0,
4336 "blanched almond", 255, 235, 205,
4337 "BlanchedAlmond", 255, 235, 205,
4338 "blue", 0, 0, 255,
4339 "blue violet", 138, 43, 226,
4340 "blue1", 0, 0, 255,
4341 "blue2", 0, 0, 238,
4342 "blue3", 0, 0, 205,
4343 "blue4", 0, 0, 139,
4344 "BlueViolet", 138, 43, 226,
4345 "brown", 165, 42, 42,
4346 "brown1", 255, 64, 64,
4347 "brown2", 238, 59, 59,
4348 "brown3", 205, 51, 51,
4349 "brown4", 139, 35, 35,
4350 "burlywood", 222, 184, 135,
4351 "burlywood1", 255, 211, 155,
4352 "burlywood2", 238, 197, 145,
4353 "burlywood3", 205, 170, 125,
4354 "burlywood4", 139, 115, 85,
4355 "cadet blue", 95, 158, 160,
4356 "CadetBlue", 95, 158, 160,
4357 "CadetBlue1", 152, 245, 255,
4358 "CadetBlue2", 142, 229, 238,
4359 "CadetBlue3", 122, 197, 205,
4360 "CadetBlue4", 83, 134, 139,
4361 "chartreuse", 127, 255, 0,
4362 "chartreuse1", 127, 255, 0,
4363 "chartreuse2", 118, 238, 0,
4364 "chartreuse3", 102, 205, 0,
4365 "chartreuse4", 69, 139, 0,
4366 "chocolate", 210, 105, 30,
4367 "chocolate1", 255, 127, 36,
4368 "chocolate2", 238, 118, 33,
4369 "chocolate3", 205, 102, 29,
4370 "chocolate4", 139, 69, 19,
4371 "coral", 255, 127, 80,
4372 "coral1", 255, 114, 86,
4373 "coral2", 238, 106, 80,
4374 "coral3", 205, 91, 69,
4375 "coral4", 139, 62, 47,
4376 "cornflower blue", 100, 149, 237,
4377 "CornflowerBlue", 100, 149, 237,
4378 "cornsilk", 255, 248, 220,
4379 "cornsilk1", 255, 248, 220,
4380 "cornsilk2", 238, 232, 205,
4381 "cornsilk3", 205, 200, 177,
4382 "cornsilk4", 139, 136, 120,
4383 "cyan", 0, 255, 255,
4384 "cyan1", 0, 255, 255,
4385 "cyan2", 0, 238, 238,
4386 "cyan3", 0, 205, 205,
4387 "cyan4", 0, 139, 139,
4388 "dark goldenrod", 184, 134, 11,
4389 "dark green", 0, 100, 0,
4390 "dark khaki", 189, 183, 107,
4391 "dark olive green", 85, 107, 47,
4392 "dark orange", 255, 140, 0,
4393 "dark orchid", 153, 50, 204,
4394 "dark salmon", 233, 150, 122,
4395 "dark sea green", 143, 188, 143,
4396 "dark slate blue", 72, 61, 139,
4397 "dark slate gray", 47, 79, 79,
4398 "dark slate grey", 47, 79, 79,
4399 "dark turquoise", 0, 206, 209,
4400 "dark violet", 148, 0, 211,
4401 "DarkGoldenrod", 184, 134, 11,
4402 "DarkGoldenrod1", 255, 185, 15,
4403 "DarkGoldenrod2", 238, 173, 14,
4404 "DarkGoldenrod3", 205, 149, 12,
4405 "DarkGoldenrod4", 139, 101, 8,
4406 "DarkGreen", 0, 100, 0,
4407 "DarkKhaki", 189, 183, 107,
4408 "DarkOliveGreen", 85, 107, 47,
4409 "DarkOliveGreen1", 202, 255, 112,
4410 "DarkOliveGreen2", 188, 238, 104,
4411 "DarkOliveGreen3", 162, 205, 90,
4412 "DarkOliveGreen4", 110, 139, 61,
4413 "DarkOrange", 255, 140, 0,
4414 "DarkOrange1", 255, 127, 0,
4415 "DarkOrange2", 238, 118, 0,
4416 "DarkOrange3", 205, 102, 0,
4417 "DarkOrange4", 139, 69, 0,
4418 "DarkOrchid", 153, 50, 204,
4419 "DarkOrchid1", 191, 62, 255,
4420 "DarkOrchid2", 178, 58, 238,
4421 "DarkOrchid3", 154, 50, 205,
4422 "DarkOrchid4", 104, 34, 139,
4423 "DarkSalmon", 233, 150, 122,
4424 "DarkSeaGreen", 143, 188, 143,
4425 "DarkSeaGreen1", 193, 255, 193,
4426 "DarkSeaGreen2", 180, 238, 180,
4427 "DarkSeaGreen3", 155, 205, 155,
4428 "DarkSeaGreen4", 105, 139, 105,
4429 "DarkSlateBlue", 72, 61, 139,
4430 "DarkSlateGray", 47, 79, 79,
4431 "DarkSlateGray1", 151, 255, 255,
4432 "DarkSlateGray2", 141, 238, 238,
4433 "DarkSlateGray3", 121, 205, 205,
4434 "DarkSlateGray4", 82, 139, 139,
4435 "DarkSlateGrey", 47, 79, 79,
4436 "DarkTurquoise", 0, 206, 209,
4437 "DarkViolet", 148, 0, 211,
4438 "deep pink", 255, 20, 147,
4439 "deep sky blue", 0, 191, 255,
4440 "DeepPink", 255, 20, 147,
4441 "DeepPink1", 255, 20, 147,
4442 "DeepPink2", 238, 18, 137,
4443 "DeepPink3", 205, 16, 118,
4444 "DeepPink4", 139, 10, 80,
4445 "DeepSkyBlue", 0, 191, 255,
4446 "DeepSkyBlue1", 0, 191, 255,
4447 "DeepSkyBlue2", 0, 178, 238,
4448 "DeepSkyBlue3", 0, 154, 205,
4449 "DeepSkyBlue4", 0, 104, 139,
4450 "dim gray", 105, 105, 105,
4451 "dim grey", 105, 105, 105,
4452 "DimGray", 105, 105, 105,
4453 "DimGrey", 105, 105, 105,
4454 "dodger blue", 30, 144, 255,
4455 "DodgerBlue", 30, 144, 255,
4456 "DodgerBlue1", 30, 144, 255,
4457 "DodgerBlue2", 28, 134, 238,
4458 "DodgerBlue3", 24, 116, 205,
4459 "DodgerBlue4", 16, 78, 139,
4460 "firebrick", 178, 34, 34,
4461 "firebrick1", 255, 48, 48,
4462 "firebrick2", 238, 44, 44,
4463 "firebrick3", 205, 38, 38,
4464 "firebrick4", 139, 26, 26,
4465 "floral white", 255, 250, 240,
4466 "FloralWhite", 255, 250, 240,
4467 "forest green", 34, 139, 34,
4468 "ForestGreen", 34, 139, 34,
4469 "gainsboro", 220, 220, 220,
4470 "ghost white", 248, 248, 255,
4471 "GhostWhite", 248, 248, 255,
4472 "gold", 255, 215, 0,
4473 "gold1", 255, 215, 0,
4474 "gold2", 238, 201, 0,
4475 "gold3", 205, 173, 0,
4476 "gold4", 139, 117, 0,
4477 "goldenrod", 218, 165, 32,
4478 "goldenrod1", 255, 193, 37,
4479 "goldenrod2", 238, 180, 34,
4480 "goldenrod3", 205, 155, 29,
4481 "goldenrod4", 139, 105, 20,
4482 "gray", 190, 190, 190,
4483 "gray0", 0, 0, 0,
4484 "gray1", 3, 3, 3,
4485 "gray10", 26, 26, 26,
4486 "gray100", 255, 255, 255,
4487 "gray11", 28, 28, 28,
4488 "gray12", 31, 31, 31,
4489 "gray13", 33, 33, 33,
4490 "gray14", 36, 36, 36,
4491 "gray15", 38, 38, 38,
4492 "gray16", 41, 41, 41,
4493 "gray17", 43, 43, 43,
4494 "gray18", 46, 46, 46,
4495 "gray19", 48, 48, 48,
4496 "gray2", 5, 5, 5,
4497 "gray20", 51, 51, 51,
4498 "gray21", 54, 54, 54,
4499 "gray22", 56, 56, 56,
4500 "gray23", 59, 59, 59,
4501 "gray24", 61, 61, 61,
4502 "gray25", 64, 64, 64,
4503 "gray26", 66, 66, 66,
4504 "gray27", 69, 69, 69,
4505 "gray28", 71, 71, 71,
4506 "gray29", 74, 74, 74,
4507 "gray3", 8, 8, 8,
4508 "gray30", 77, 77, 77,
4509 "gray31", 79, 79, 79,
4510 "gray32", 82, 82, 82,
4511 "gray33", 84, 84, 84,
4512 "gray34", 87, 87, 87,
4513 "gray35", 89, 89, 89,
4514 "gray36", 92, 92, 92,
4515 "gray37", 94, 94, 94,
4516 "gray38", 97, 97, 97,
4517 "gray39", 99, 99, 99,
4518 "gray4", 10, 10, 10,
4519 "gray40", 102, 102, 102,
4520 "gray41", 105, 105, 105,
4521 "gray42", 107, 107, 107,
4522 "gray43", 110, 110, 110,
4523 "gray44", 112, 112, 112,
4524 "gray45", 115, 115, 115,
4525 "gray46", 117, 117, 117,
4526 "gray47", 120, 120, 120,
4527 "gray48", 122, 122, 122,
4528 "gray49", 125, 125, 125,
4529 "gray5", 13, 13, 13,
4530 "gray50", 127, 127, 127,
4531 "gray51", 130, 130, 130,
4532 "gray52", 133, 133, 133,
4533 "gray53", 135, 135, 135,
4534 "gray54", 138, 138, 138,
4535 "gray55", 140, 140, 140,
4536 "gray56", 143, 143, 143,
4537 "gray57", 145, 145, 145,
4538 "gray58", 148, 148, 148,
4539 "gray59", 150, 150, 150,
4540 "gray6", 15, 15, 15,
4541 "gray60", 153, 153, 153,
4542 "gray61", 156, 156, 156,
4543 "gray62", 158, 158, 158,
4544 "gray63", 161, 161, 161,
4545 "gray64", 163, 163, 163,
4546 "gray65", 166, 166, 166,
4547 "gray66", 168, 168, 168,
4548 "gray67", 171, 171, 171,
4549 "gray68", 173, 173, 173,
4550 "gray69", 176, 176, 176,
4551 "gray7", 18, 18, 18,
4552 "gray70", 179, 179, 179,
4553 "gray71", 181, 181, 181,
4554 "gray72", 184, 184, 184,
4555 "gray73", 186, 186, 186,
4556 "gray74", 189, 189, 189,
4557 "gray75", 191, 191, 191,
4558 "gray76", 194, 194, 194,
4559 "gray77", 196, 196, 196,
4560 "gray78", 199, 199, 199,
4561 "gray79", 201, 201, 201,
4562 "gray8", 20, 20, 20,
4563 "gray80", 204, 204, 204,
4564 "gray81", 207, 207, 207,
4565 "gray82", 209, 209, 209,
4566 "gray83", 212, 212, 212,
4567 "gray84", 214, 214, 214,
4568 "gray85", 217, 217, 217,
4569 "gray86", 219, 219, 219,
4570 "gray87", 222, 222, 222,
4571 "gray88", 224, 224, 224,
4572 "gray89", 227, 227, 227,
4573 "gray9", 23, 23, 23,
4574 "gray90", 229, 229, 229,
4575 "gray91", 232, 232, 232,
4576 "gray92", 235, 235, 235,
4577 "gray93", 237, 237, 237,
4578 "gray94", 240, 240, 240,
4579 "gray95", 242, 242, 242,
4580 "gray96", 245, 245, 245,
4581 "gray97", 247, 247, 247,
4582 "gray98", 250, 250, 250,
4583 "gray99", 252, 252, 252,
4584 "green", 0, 255, 0,
4585 "green yellow", 173, 255, 47,
4586 "green1", 0, 255, 0,
4587 "green2", 0, 238, 0,
4588 "green3", 0, 205, 0,
4589 "green4", 0, 139, 0,
4590 "GreenYellow", 173, 255, 47,
4591 "grey", 190, 190, 190,
4592 "grey0", 0, 0, 0,
4593 "grey1", 3, 3, 3,
4594 "grey10", 26, 26, 26,
4595 "grey100", 255, 255, 255,
4596 "grey11", 28, 28, 28,
4597 "grey12", 31, 31, 31,
4598 "grey13", 33, 33, 33,
4599 "grey14", 36, 36, 36,
4600 "grey15", 38, 38, 38,
4601 "grey16", 41, 41, 41,
4602 "grey17", 43, 43, 43,
4603 "grey18", 46, 46, 46,
4604 "grey19", 48, 48, 48,
4605 "grey2", 5, 5, 5,
4606 "grey20", 51, 51, 51,
4607 "grey21", 54, 54, 54,
4608 "grey22", 56, 56, 56,
4609 "grey23", 59, 59, 59,
4610 "grey24", 61, 61, 61,
4611 "grey25", 64, 64, 64,
4612 "grey26", 66, 66, 66,
4613 "grey27", 69, 69, 69,
4614 "grey28", 71, 71, 71,
4615 "grey29", 74, 74, 74,
4616 "grey3", 8, 8, 8,
4617 "grey30", 77, 77, 77,
4618 "grey31", 79, 79, 79,
4619 "grey32", 82, 82, 82,
4620 "grey33", 84, 84, 84,
4621 "grey34", 87, 87, 87,
4622 "grey35", 89, 89, 89,
4623 "grey36", 92, 92, 92,
4624 "grey37", 94, 94, 94,
4625 "grey38", 97, 97, 97,
4626 "grey39", 99, 99, 99,
4627 "grey4", 10, 10, 10,
4628 "grey40", 102, 102, 102,
4629 "grey41", 105, 105, 105,
4630 "grey42", 107, 107, 107,
4631 "grey43", 110, 110, 110,
4632 "grey44", 112, 112, 112,
4633 "grey45", 115, 115, 115,
4634 "grey46", 117, 117, 117,
4635 "grey47", 120, 120, 120,
4636 "grey48", 122, 122, 122,
4637 "grey49", 125, 125, 125,
4638 "grey5", 13, 13, 13,
4639 "grey50", 127, 127, 127,
4640 "grey51", 130, 130, 130,
4641 "grey52", 133, 133, 133,
4642 "grey53", 135, 135, 135,
4643 "grey54", 138, 138, 138,
4644 "grey55", 140, 140, 140,
4645 "grey56", 143, 143, 143,
4646 "grey57", 145, 145, 145,
4647 "grey58", 148, 148, 148,
4648 "grey59", 150, 150, 150,
4649 "grey6", 15, 15, 15,
4650 "grey60", 153, 153, 153,
4651 "grey61", 156, 156, 156,
4652 "grey62", 158, 158, 158,
4653 "grey63", 161, 161, 161,
4654 "grey64", 163, 163, 163,
4655 "grey65", 166, 166, 166,
4656 "grey66", 168, 168, 168,
4657 "grey67", 171, 171, 171,
4658 "grey68", 173, 173, 173,
4659 "grey69", 176, 176, 176,
4660 "grey7", 18, 18, 18,
4661 "grey70", 179, 179, 179,
4662 "grey71", 181, 181, 181,
4663 "grey72", 184, 184, 184,
4664 "grey73", 186, 186, 186,
4665 "grey74", 189, 189, 189,
4666 "grey75", 191, 191, 191,
4667 "grey76", 194, 194, 194,
4668 "grey77", 196, 196, 196,
4669 "grey78", 199, 199, 199,
4670 "grey79", 201, 201, 201,
4671 "grey8", 20, 20, 20,
4672 "grey80", 204, 204, 204,
4673 "grey81", 207, 207, 207,
4674 "grey82", 209, 209, 209,
4675 "grey83", 212, 212, 212,
4676 "grey84", 214, 214, 214,
4677 "grey85", 217, 217, 217,
4678 "grey86", 219, 219, 219,
4679 "grey87", 222, 222, 222,
4680 "grey88", 224, 224, 224,
4681 "grey89", 227, 227, 227,
4682 "grey9", 23, 23, 23,
4683 "grey90", 229, 229, 229,
4684 "grey91", 232, 232, 232,
4685 "grey92", 235, 235, 235,
4686 "grey93", 237, 237, 237,
4687 "grey94", 240, 240, 240,
4688 "grey95", 242, 242, 242,
4689 "grey96", 245, 245, 245,
4690 "grey97", 247, 247, 247,
4691 "grey98", 250, 250, 250,
4692 "grey99", 252, 252, 252,
4693 "honeydew", 240, 255, 240,
4694 "honeydew1", 240, 255, 240,
4695 "honeydew2", 224, 238, 224,
4696 "honeydew3", 193, 205, 193,
4697 "honeydew4", 131, 139, 131,
4698 "hot pink", 255, 105, 180,
4699 "HotPink", 255, 105, 180,
4700 "HotPink1", 255, 110, 180,
4701 "HotPink2", 238, 106, 167,
4702 "HotPink3", 205, 96, 144,
4703 "HotPink4", 139, 58, 98,
4704 "indian red", 205, 92, 92,
4705 "IndianRed", 205, 92, 92,
4706 "IndianRed1", 255, 106, 106,
4707 "IndianRed2", 238, 99, 99,
4708 "IndianRed3", 205, 85, 85,
4709 "IndianRed4", 139, 58, 58,
4710 "ivory", 255, 255, 240,
4711 "ivory1", 255, 255, 240,
4712 "ivory2", 238, 238, 224,
4713 "ivory3", 205, 205, 193,
4714 "ivory4", 139, 139, 131,
4715 "khaki", 240, 230, 140,
4716 "khaki1", 255, 246, 143,
4717 "khaki2", 238, 230, 133,
4718 "khaki3", 205, 198, 115,
4719 "khaki4", 139, 134, 78,
4720 "lavender", 230, 230, 250,
4721 "lavender blush", 255, 240, 245,
4722 "LavenderBlush", 255, 240, 245,
4723 "LavenderBlush1", 255, 240, 245,
4724 "LavenderBlush2", 238, 224, 229,
4725 "LavenderBlush3", 205, 193, 197,
4726 "LavenderBlush4", 139, 131, 134,
4727 "lawn green", 124, 252, 0,
4728 "LawnGreen", 124, 252, 0,
4729 "lemon chiffon", 255, 250, 205,
4730 "LemonChiffon", 255, 250, 205,
4731 "LemonChiffon1", 255, 250, 205,
4732 "LemonChiffon2", 238, 233, 191,
4733 "LemonChiffon3", 205, 201, 165,
4734 "LemonChiffon4", 139, 137, 112,
4735 "light blue", 173, 216, 230,
4736 "light coral", 240, 128, 128,
4737 "light cyan", 224, 255, 255,
4738 "light goldenrod", 238, 221, 130,
4739 "light goldenrod yellow", 250, 250, 210,
4740 "light gray", 211, 211, 211,
4741 "light grey", 211, 211, 211,
4742 "light pink", 255, 182, 193,
4743 "light salmon", 255, 160, 122,
4744 "light sea green", 32, 178, 170,
4745 "light sky blue", 135, 206, 250,
4746 "light slate blue", 132, 112, 255,
4747 "light slate gray", 119, 136, 153,
4748 "light slate grey", 119, 136, 153,
4749 "light steel blue", 176, 196, 222,
4750 "light yellow", 255, 255, 224,
4751 "LightBlue", 173, 216, 230,
4752 "LightBlue1", 191, 239, 255,
4753 "LightBlue2", 178, 223, 238,
4754 "LightBlue3", 154, 192, 205,
4755 "LightBlue4", 104, 131, 139,
4756 "LightCoral", 240, 128, 128,
4757 "LightCyan", 224, 255, 255,
4758 "LightCyan1", 224, 255, 255,
4759 "LightCyan2", 209, 238, 238,
4760 "LightCyan3", 180, 205, 205,
4761 "LightCyan4", 122, 139, 139,
4762 "LightGoldenrod", 238, 221, 130,
4763 "LightGoldenrod1", 255, 236, 139,
4764 "LightGoldenrod2", 238, 220, 130,
4765 "LightGoldenrod3", 205, 190, 112,
4766 "LightGoldenrod4", 139, 129, 76,
4767 "LightGoldenrodYellow", 250, 250, 210,
4768 "LightGray", 211, 211, 211,
4769 "LightGrey", 211, 211, 211,
4770 "LightPink", 255, 182, 193,
4771 "LightPink1", 255, 174, 185,
4772 "LightPink2", 238, 162, 173,
4773 "LightPink3", 205, 140, 149,
4774 "LightPink4", 139, 95, 101,
4775 "LightSalmon", 255, 160, 122,
4776 "LightSalmon1", 255, 160, 122,
4777 "LightSalmon2", 238, 149, 114,
4778 "LightSalmon3", 205, 129, 98,
4779 "LightSalmon4", 139, 87, 66,
4780 "LightSeaGreen", 32, 178, 170,
4781 "LightSkyBlue", 135, 206, 250,
4782 "LightSkyBlue1", 176, 226, 255,
4783 "LightSkyBlue2", 164, 211, 238,
4784 "LightSkyBlue3", 141, 182, 205,
4785 "LightSkyBlue4", 96, 123, 139,
4786 "LightSlateBlue", 132, 112, 255,
4787 "LightSlateGray", 119, 136, 153,
4788 "LightSlateGrey", 119, 136, 153,
4789 "LightSteelBlue", 176, 196, 222,
4790 "LightSteelBlue1", 202, 225, 255,
4791 "LightSteelBlue2", 188, 210, 238,
4792 "LightSteelBlue3", 162, 181, 205,
4793 "LightSteelBlue4", 110, 123, 139,
4794 "LightYellow", 255, 255, 224,
4795 "LightYellow1", 255, 255, 224,
4796 "LightYellow2", 238, 238, 209,
4797 "LightYellow3", 205, 205, 180,
4798 "LightYellow4", 139, 139, 122,
4799 "lime green", 50, 205, 50,
4800 "LimeGreen", 50, 205, 50,
4801 "linen", 250, 240, 230,
4802 "magenta", 255, 0, 255,
4803 "magenta1", 255, 0, 255,
4804 "magenta2", 238, 0, 238,
4805 "magenta3", 205, 0, 205,
4806 "magenta4", 139, 0, 139,
4807 "maroon", 176, 48, 96,
4808 "maroon1", 255, 52, 179,
4809 "maroon2", 238, 48, 167,
4810 "maroon3", 205, 41, 144,
4811 "maroon4", 139, 28, 98,
4812 "medium aquamarine", 102, 205, 170,
4813 "medium blue", 0, 0, 205,
4814 "medium orchid", 186, 85, 211,
4815 "medium purple", 147, 112, 219,
4816 "medium sea green", 60, 179, 113,
4817 "medium slate blue", 123, 104, 238,
4818 "medium spring green", 0, 250, 154,
4819 "medium turquoise", 72, 209, 204,
4820 "medium violet red", 199, 21, 133,
4821 "MediumAquamarine", 102, 205, 170,
4822 "MediumBlue", 0, 0, 205,
4823 "MediumOrchid", 186, 85, 211,
4824 "MediumOrchid1", 224, 102, 255,
4825 "MediumOrchid2", 209, 95, 238,
4826 "MediumOrchid3", 180, 82, 205,
4827 "MediumOrchid4", 122, 55, 139,
4828 "MediumPurple", 147, 112, 219,
4829 "MediumPurple1", 171, 130, 255,
4830 "MediumPurple2", 159, 121, 238,
4831 "MediumPurple3", 137, 104, 205,
4832 "MediumPurple4", 93, 71, 139,
4833 "MediumSeaGreen", 60, 179, 113,
4834 "MediumSlateBlue", 123, 104, 238,
4835 "MediumSpringGreen", 0, 250, 154,
4836 "MediumTurquoise", 72, 209, 204,
4837 "MediumVioletRed", 199, 21, 133,
4838 "midnight blue", 25, 25, 112,
4839 "MidnightBlue", 25, 25, 112,
4840 "mint cream", 245, 255, 250,
4841 "MintCream", 245, 255, 250,
4842 "misty rose", 255, 228, 225,
4843 "MistyRose", 255, 228, 225,
4844 "MistyRose1", 255, 228, 225,
4845 "MistyRose2", 238, 213, 210,
4846 "MistyRose3", 205, 183, 181,
4847 "MistyRose4", 139, 125, 123,
4848 "moccasin", 255, 228, 181,
4849 "navajo white", 255, 222, 173,
4850 "NavajoWhite", 255, 222, 173,
4851 "NavajoWhite1", 255, 222, 173,
4852 "NavajoWhite2", 238, 207, 161,
4853 "NavajoWhite3", 205, 179, 139,
4854 "NavajoWhite4", 139, 121, 94,
4855 "navy", 0, 0, 128,
4856 "navy blue", 0, 0, 128,
4857 "NavyBlue", 0, 0, 128,
4858 "old lace", 253, 245, 230,
4859 "OldLace", 253, 245, 230,
4860 "olive drab", 107, 142, 35,
4861 "OliveDrab", 107, 142, 35,
4862 "OliveDrab1", 192, 255, 62,
4863 "OliveDrab2", 179, 238, 58,
4864 "OliveDrab3", 154, 205, 50,
4865 "OliveDrab4", 105, 139, 34,
4866 "orange", 255, 165, 0,
4867 "orange red", 255, 69, 0,
4868 "orange1", 255, 165, 0,
4869 "orange2", 238, 154, 0,
4870 "orange3", 205, 133, 0,
4871 "orange4", 139, 90, 0,
4872 "OrangeRed", 255, 69, 0,
4873 "OrangeRed1", 255, 69, 0,
4874 "OrangeRed2", 238, 64, 0,
4875 "OrangeRed3", 205, 55, 0,
4876 "OrangeRed4", 139, 37, 0,
4877 "orchid", 218, 112, 214,
4878 "orchid1", 255, 131, 250,
4879 "orchid2", 238, 122, 233,
4880 "orchid3", 205, 105, 201,
4881 "orchid4", 139, 71, 137,
4882 "pale goldenrod", 238, 232, 170,
4883 "pale green", 152, 251, 152,
4884 "pale turquoise", 175, 238, 238,
4885 "pale violet red", 219, 112, 147,
4886 "PaleGoldenrod", 238, 232, 170,
4887 "PaleGreen", 152, 251, 152,
4888 "PaleGreen1", 154, 255, 154,
4889 "PaleGreen2", 144, 238, 144,
4890 "PaleGreen3", 124, 205, 124,
4891 "PaleGreen4", 84, 139, 84,
4892 "PaleTurquoise", 175, 238, 238,
4893 "PaleTurquoise1", 187, 255, 255,
4894 "PaleTurquoise2", 174, 238, 238,
4895 "PaleTurquoise3", 150, 205, 205,
4896 "PaleTurquoise4", 102, 139, 139,
4897 "PaleVioletRed", 219, 112, 147,
4898 "PaleVioletRed1", 255, 130, 171,
4899 "PaleVioletRed2", 238, 121, 159,
4900 "PaleVioletRed3", 205, 104, 137,
4901 "PaleVioletRed4", 139, 71, 93,
4902 "papaya whip", 255, 239, 213,
4903 "PapayaWhip", 255, 239, 213,
4904 "peach puff", 255, 218, 185,
4905 "PeachPuff", 255, 218, 185,
4906 "PeachPuff1", 255, 218, 185,
4907 "PeachPuff2", 238, 203, 173,
4908 "PeachPuff3", 205, 175, 149,
4909 "PeachPuff4", 139, 119, 101,
4910 "peru", 205, 133, 63,
4911 "pink", 255, 192, 203,
4912 "pink1", 255, 181, 197,
4913 "pink2", 238, 169, 184,
4914 "pink3", 205, 145, 158,
4915 "pink4", 139, 99, 108,
4916 "plum", 221, 160, 221,
4917 "plum1", 255, 187, 255,
4918 "plum2", 238, 174, 238,
4919 "plum3", 205, 150, 205,
4920 "plum4", 139, 102, 139,
4921 "powder blue", 176, 224, 230,
4922 "PowderBlue", 176, 224, 230,
4923 "purple", 160, 32, 240,
4924 "purple1", 155, 48, 255,
4925 "purple2", 145, 44, 238,
4926 "purple3", 125, 38, 205,
4927 "purple4", 85, 26, 139,
4928 "red", 255, 0, 0,
4929 "red1", 255, 0, 0,
4930 "red2", 238, 0, 0,
4931 "red3", 205, 0, 0,
4932 "red4", 139, 0, 0,
4933 "rosy brown", 188, 143, 143,
4934 "RosyBrown", 188, 143, 143,
4935 "RosyBrown1", 255, 193, 193,
4936 "RosyBrown2", 238, 180, 180,
4937 "RosyBrown3", 205, 155, 155,
4938 "RosyBrown4", 139, 105, 105,
4939 "royal blue", 65, 105, 225,
4940 "RoyalBlue", 65, 105, 225,
4941 "RoyalBlue1", 72, 118, 255,
4942 "RoyalBlue2", 67, 110, 238,
4943 "RoyalBlue3", 58, 95, 205,
4944 "RoyalBlue4", 39, 64, 139,
4945 "saddle brown", 139, 69, 19,
4946 "SaddleBrown", 139, 69, 19,
4947 "salmon", 250, 128, 114,
4948 "salmon1", 255, 140, 105,
4949 "salmon2", 238, 130, 98,
4950 "salmon3", 205, 112, 84,
4951 "salmon4", 139, 76, 57,
4952 "sandy brown", 244, 164, 96,
4953 "SandyBrown", 244, 164, 96,
4954 "sea green", 46, 139, 87,
4955 "SeaGreen", 46, 139, 87,
4956 "SeaGreen1", 84, 255, 159,
4957 "SeaGreen2", 78, 238, 148,
4958 "SeaGreen3", 67, 205, 128,
4959 "SeaGreen4", 46, 139, 87,
4960 "seashell", 255, 245, 238,
4961 "seashell1", 255, 245, 238,
4962 "seashell2", 238, 229, 222,
4963 "seashell3", 205, 197, 191,
4964 "seashell4", 139, 134, 130,
4965 "sienna", 160, 82, 45,
4966 "sienna1", 255, 130, 71,
4967 "sienna2", 238, 121, 66,
4968 "sienna3", 205, 104, 57,
4969 "sienna4", 139, 71, 38,
4970 "sky blue", 135, 206, 235,
4971 "SkyBlue", 135, 206, 235,
4972 "SkyBlue1", 135, 206, 255,
4973 "SkyBlue2", 126, 192, 238,
4974 "SkyBlue3", 108, 166, 205,
4975 "SkyBlue4", 74, 112, 139,
4976 "slate blue", 106, 90, 205,
4977 "slate gray", 112, 128, 144,
4978 "slate grey", 112, 128, 144,
4979 "SlateBlue", 106, 90, 205,
4980 "SlateBlue1", 131, 111, 255,
4981 "SlateBlue2", 122, 103, 238,
4982 "SlateBlue3", 105, 89, 205,
4983 "SlateBlue4", 71, 60, 139,
4984 "SlateGray", 112, 128, 144,
4985 "SlateGray1", 198, 226, 255,
4986 "SlateGray2", 185, 211, 238,
4987 "SlateGray3", 159, 182, 205,
4988 "SlateGray4", 108, 123, 139,
4989 "SlateGrey", 112, 128, 144,
4990 "snow", 255, 250, 250,
4991 "snow1", 255, 250, 250,
4992 "snow2", 238, 233, 233,
4993 "snow3", 205, 201, 201,
4994 "snow4", 139, 137, 137,
4995 "spring green", 0, 255, 127,
4996 "SpringGreen", 0, 255, 127,
4997 "SpringGreen1", 0, 255, 127,
4998 "SpringGreen2", 0, 238, 118,
4999 "SpringGreen3", 0, 205, 102,
5000 "SpringGreen4", 0, 139, 69,
5001 "steel blue", 70, 130, 180,
5002 "SteelBlue", 70, 130, 180,
5003 "SteelBlue1", 99, 184, 255,
5004 "SteelBlue2", 92, 172, 238,
5005 "SteelBlue3", 79, 148, 205,
5006 "SteelBlue4", 54, 100, 139,
5007 "tan", 210, 180, 140,
5008 "tan1", 255, 165, 79,
5009 "tan2", 238, 154, 73,
5010 "tan3", 205, 133, 63,
5011 "tan4", 139, 90, 43,
5012 "thistle", 216, 191, 216,
5013 "thistle1", 255, 225, 255,
5014 "thistle2", 238, 210, 238,
5015 "thistle3", 205, 181, 205,
5016 "thistle4", 139, 123, 139,
5017 "tomato", 255, 99, 71,
5018 "tomato1", 255, 99, 71,
5019 "tomato2", 238, 92, 66,
5020 "tomato3", 205, 79, 57,
5021 "tomato4", 139, 54, 38,
5022 "turquoise", 64, 224, 208,
5023 "turquoise1", 0, 245, 255,
5024 "turquoise2", 0, 229, 238,
5025 "turquoise3", 0, 197, 205,
5026 "turquoise4", 0, 134, 139,
5027 "violet", 238, 130, 238,
5028 "violet red", 208, 32, 144,
5029 "VioletRed", 208, 32, 144,
5030 "VioletRed1", 255, 62, 150,
5031 "VioletRed2", 238, 58, 140,
5032 "VioletRed3", 205, 50, 120,
5033 "VioletRed4", 139, 34, 82,
5034 "wheat", 245, 222, 179,
5035 "wheat1", 255, 231, 186,
5036 "wheat2", 238, 216, 174,
5037 "wheat3", 205, 186, 150,
5038 "wheat4", 139, 126, 102,
5039 "white", 255, 255, 255,
5040 "white smoke", 245, 245, 245,
5041 "WhiteSmoke", 245, 245, 245,
5042 "yellow", 255, 255, 0,
5043 "yellow green", 154, 205, 50,
5044 "yellow1", 255, 255, 0,
5045 "yellow2", 238, 238, 0,
5046 "yellow3", 205, 205, 0,
5047 "yellow4", 139, 139, 0,
5048 "YellowGreen", 154, 205, 50,
5049 NULL, 0, 0, 0
5050 };
5051
5052
5053 /*
5054 * This value will be set to the number of colors in the color table
5055 * the first time it is needed.
5056 */
5057
5058 static int numXColors = 0;
5059
5060 /*
5061 * Forward declarations for functions used only in this file.
5062 */
5063
5064 static int FindColor(const char *name, XColor *colorPtr);
5065
strcasecmp(const char * a,const char * b)5066 int strcasecmp(const char *a, const char *b)
5067 {
5068 int i=0,c;
5069 if((a==NULL)||(b==NULL)) return -1;
5070
5071 while(((!(c=toupper(a[i])-toupper(b[i])))&&a[i]&&b[i])) i++;
5072 return c;
5073 }
5074 /*
5075 *----------------------------------------------------------------------
5076 *
5077 * FindColor --
5078 *
5079 * This routine finds the color entry that corresponds to the
5080 * specified color.
5081 *
5082 * Results:
5083 * Returns non-zero on success. The RGB values of the XColor
5084 * will be initialized to the proper values on success.
5085 *
5086 * Side effects:
5087 * None.
5088 *
5089 *----------------------------------------------------------------------
5090 */
5091
5092 static int
FindColor(name,colorPtr)5093 FindColor(name, colorPtr)
5094 const char *name;
5095 XColor *colorPtr;
5096 {
5097 int l, u, r, i;
5098
5099 /*
5100 * Count the number of elements in the color array if we haven't
5101 * done so yet.
5102 */
5103
5104 if (numXColors == 0) {
5105 XColorEntry *ePtr;
5106 for (ePtr = xColors; ePtr->name != NULL; ePtr++) {
5107 numXColors++;
5108 }
5109 }
5110
5111 /*
5112 * Perform a binary search on the sorted array of colors.
5113 */
5114
5115 l = 0;
5116 u = numXColors - 1;
5117 while (l <= u) {
5118 i = (l + u) / 2;
5119 r = strcasecmp(name, xColors[i].name);
5120 if (r == 0) {
5121 break;
5122 } else if (r < 0) {
5123 u = i-1;
5124 } else {
5125 l = i+1;
5126 }
5127 }
5128 if (l > u) {
5129 return 0;
5130 }
5131 colorPtr->red = xColors[i].red << 8;
5132 colorPtr->green = xColors[i].green << 8;
5133 colorPtr->blue = xColors[i].blue << 8;
5134 return 1;
5135 }
5136
5137 /*
5138 *----------------------------------------------------------------------
5139 *
5140 * XParseColor --
5141 *
5142 * Partial implementation of X color name parsing interface.
5143 *
5144 * Results:
5145 * Returns non-zero on success.
5146 *
5147 * Side effects:
5148 * None.
5149 *
5150 *----------------------------------------------------------------------
5151 */
5152
5153 StatusDef
XParseColor(display,map,spec,colorPtr)5154 XParseColor(display, map, spec, colorPtr)
5155 Display *display;
5156 Colormap map;
5157 const char* spec;
5158 XColor *colorPtr;
5159 {
5160 if (spec[0] == '#') {
5161 char fmt[16];
5162 int i, red, green, blue;
5163
5164 if ((i = strlen(spec+1))%3) {
5165 return 0;
5166 }
5167 i /= 3;
5168
5169 sprintf(fmt, "%%%dx%%%dx%%%dx", i, i, i);
5170 if (sscanf(spec+1, fmt, &red, &green, &blue) != 3) {
5171 return 0;
5172 }
5173 colorPtr->red = ((unsigned short) red) << (4 * (4 - i));
5174 colorPtr->green = ((unsigned short) green) << (4 * (4 - i));
5175 colorPtr->blue = ((unsigned short) blue) << (4 * (4 - i));
5176 } else {
5177 if (!FindColor(spec, colorPtr)) {
5178 return 0;
5179 }
5180 }
5181 colorPtr->pixel = ((colorPtr->red)>>8)&0xff;
5182 colorPtr->flags = DoRed|DoGreen|DoBlue;
5183 colorPtr->pad = 0;
5184 return 1;
5185 }
5186 /** xpm support */
5187 int
XFreeColors(display,cmap,pixels,npixels,planes)5188 XFreeColors(display, cmap, pixels, npixels, planes)
5189 Display *display;
5190 Colormap cmap;
5191 unsigned long pixels[];
5192 int npixels;
5193 unsigned long planes;
5194 {
5195 return 0;
5196 }
5197
5198 int
XGrabServer(display)5199 XGrabServer(display)
5200 Display *display;
5201 {
5202 return 0;
5203 }
5204
5205 int
XUngrabServer(display)5206 XUngrabServer(display)
5207 Display *display;
5208 {
5209 return 0;
5210 }
5211
5212
5213 #endif
5214