arch/all-x11/hidd/onbitmap.c

   1 /*
   2     Copyright © 1995-2006, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Bitmap class for X11 hidd.
   6     Lang: English.
   7 */
   8
   9 #define __OOP_NOATTRBASES__
  10
  11 #include <stdlib.h>
  12 #include <stdio.h>
  13 #include <X11/Xlib.h>
  14 #include <X11/Xutil.h>
  15 #include <X11/cursorfont.h>
  16 #include <X11/keysym.h>
  17
  18 #include <string.h>
  19 #include <signal.h>
  20 #include <unistd.h>
  21
  22 #include <proto/oop.h>
  23 #include <proto/utility.h>
  24
  25 #include <exec/memory.h>
  26 #include <exec/lists.h>
  27
  28 #include <graphics/rastport.h>
  29 #include <graphics/gfx.h>
  30 #include <oop/oop.h>
  31
  32 #include <hidd/graphics.h>
  33
  34 #include <aros/symbolsets.h>
  35
  36 #define DEBUG 0
  37 #include <aros/debug.h>
  38
  39 #include LC_LIBDEFS_FILE
  40
  41 #include "x11gfx_intern.h"
  42 #include "x11.h"
  43
  44 #include "bitmap.h"
  45
  46 /****************************************************************************************/
  47
  48 static OOP_AttrBase HiddBitMapAttrBase;
  49 OOP_AttrBase HiddPixFmtAttrBase;
  50 static OOP_AttrBase HiddX11GfxAB;
  51 static OOP_AttrBase HiddX11BitMapAB;
  52
  53 /****************************************************************************************/
  54
  55 static struct OOP_ABDescr attrbases[] =
  56 {
  57     { IID_Hidd_BitMap   , &HiddBitMapAttrBase   },
  58     { IID_Hidd_PixFmt   , &HiddPixFmtAttrBase   },
  59     /* Private bases */
  60     { IID_Hidd_X11Gfx   , &HiddX11GfxAB         },
  61     { IID_Hidd_X11BitMap, &HiddX11BitMapAB      },
  62     { NULL              , NULL                  }
  63 };
  64
  65 /****************************************************************************************/
  66
  67 /* Macro trick to reuse code between offscreen and onscreen bitmap hidd
  68 (bitmap_common.c) */
  69
  70 #define DRAWABLE(data)  (data)->drawable.xwindow
  71
  72 #if ADJUST_XWIN_SIZE
  73 #define MASTERWIN(data) (data)->masterxwindow
  74 #else
  75 #define MASTERWIN(data) DRAWABLE(data)
  76 #endif
  77
  78 #define MNAME(x) X11OnBM__ ## x
  79
  80 /****************************************************************************************/
  81
  82 /* !!! Include methods whose implementation is eqaul for windows and pixmaps
  83  (except the DRAWABLE) */
  84
  85 #include "bitmap_common.c"
  86
  87 #if X11SOFTMOUSE
  88 static void init_empty_cursor(Window w, GC c, struct x11_staticdata *xsd);
  89 #endif
  90 static Pixmap init_icon(Display *d, Window w, Colormap cm, LONG depth,
  91                         struct x11_staticdata *xsd);
  92
  93 /****************************************************************************************/
  94
  95 OOP_Object *X11OnBM__Root__New(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg)
  96 {
  97     BOOL ok = TRUE;
  98
  99     EnterFunc(bug("X11Gfx.OnBitMap::New()\n"));
 100
 101     o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg) msg);
 102     if (o)
 103     {
 104         struct bitmap_data      *data;
 105         Window                   rootwin;
 106         IPTR                     width, height, depth;
 107         XSetWindowAttributes     winattr;
 108         int                      visualclass;
 109         unsigned long            valuemask;
 110
 111         data = OOP_INST_DATA(cl, o);
 112
 113         /* clear all data  */
 114         memset(data, 0, sizeof(struct bitmap_data));
 115
 116         /* Get some info passed to us by the x11gfxhidd class */
 117         data->display = (Display *)GetTagData(aHidd_X11Gfx_SysDisplay, 0, msg->attrList);
 118         data->screen  =            GetTagData(aHidd_X11Gfx_SysScreen,  0, msg->attrList);
 119         data->cursor  = (Cursor)   GetTagData(aHidd_X11Gfx_SysCursor,  0, msg->attrList);
 120         data->colmap  = (Colormap) GetTagData(aHidd_X11Gfx_ColorMap,   0, msg->attrList);
 121
 122         /* stegerg*/
 123
 124         visualclass   =            GetTagData(aHidd_X11Gfx_VisualClass, TrueColor, msg->attrList);
 125
 126         if ( visualclass == PseudoColor)
 127         {
 128             Colormap cm;
 129
 130             LOCK_X11
 131             cm = XCALL(XCreateColormap, GetSysDisplay(),
 132                                  RootWindow(GetSysDisplay(), GetSysScreen()),
 133                                  XSD(cl)->vi.visual,
 134                                  AllocAll);
 135             UNLOCK_X11
 136
 137             if (cm)
 138             {
 139                 data->colmap = cm;
 140                 data->flags |= BMDF_COLORMAP_ALLOCED;
 141             }
 142         }
 143
 144         /* end stegerg */
 145
 146         /* Get attr values */
 147         OOP_GetAttr(o, aHidd_BitMap_Width,  &width);
 148         OOP_GetAttr(o, aHidd_BitMap_Height, &height);
 149
 150         /* Open an X window to be used for viewing */
 151
 152         D(bug("Displayable bitmap\n"));
 153
 154         /* Listen for all sorts of events */
 155         winattr.event_mask = 0;
 156         /* Mouse buttons .. */
 157         winattr.event_mask |= ButtonPressMask | ButtonReleaseMask;
 158         /* Mouse movement .. */
 159         winattr.event_mask |= PointerMotionMask;
 160         /* Key press & release .. */
 161         winattr.event_mask |= KeyPressMask | KeyReleaseMask;
 162
 163         /* We must allways have this one */
 164         winattr.event_mask |= StructureNotifyMask;
 165         winattr.event_mask |= SubstructureNotifyMask;
 166
 167         winattr.event_mask |= FocusChangeMask;
 168
 169         /* Use backing store for now. (Uses lots of mem) */
 170         winattr.backing_store = Always;
 171
 172         LOCK_X11
 173
 174         winattr.cursor = GetSysCursor();
 175         winattr.save_under = True;
 176
 177         winattr.background_pixel = BlackPixel(GetSysDisplay(), GetSysScreen());
 178         rootwin = DefaultRootWindow (GetSysDisplay());
 179         D(bug("Creating XWindow: root win=%p\n", rootwin));
 180         depth = DefaultDepth(GetSysDisplay(), GetSysScreen());
 181
 182         valuemask = CWBackingStore | CWCursor | CWSaveUnder |
 183                     CWEventMask    | CWBackPixel;
 184
 185         if (data->flags & BMDF_COLORMAP_ALLOCED)
 186         {
 187             winattr.colormap = data->colmap;
 188             valuemask |= CWColormap;
 189         }
 190
 191     #if ADJUST_XWIN_SIZE
 192         {
 193             XSetWindowAttributes winattr;
 194             unsigned long        valuemask = 0;
 195
 196             if (XSD(cl)->fullscreen)
 197             {
 198                 winattr.override_redirect = True;
 199                 valuemask |= CWOverrideRedirect;
 200             }
 201
 202             if (data->flags & BMDF_COLORMAP_ALLOCED)
 203             {
 204                 winattr.colormap = data->colmap;
 205                 valuemask |= CWColormap;
 206             }
 207
 208             MASTERWIN(data) = XCALL(XCreateWindow,  GetSysDisplay(),
 209                                              rootwin,
 210                                              0, /* leftedge     */
 211                                              0, /* topedge      */
 212                                              width,
 213                                              height,
 214                                              0, /* BorderWidth  */
 215                                              depth,
 216                                              InputOutput,
 217                                              DefaultVisual(GetSysDisplay(), GetSysScreen()),
 218                                              valuemask,
 219                                              &winattr);
 220         }
 221
 222         if (MASTERWIN(data))
 223     #endif
 224
 225         DRAWABLE(data) = XCALL(XCreateWindow,  GetSysDisplay(),
 226                                     #if ADJUST_XWIN_SIZE
 227                                         MASTERWIN(data),
 228                                     #else
 229                                         rootwin,
 230                                     #endif
 231                                         0,      /* leftedge     */
 232                                         0,      /* topedge      */
 233                                         width,
 234                                         height,
 235                                         0,      /* BorderWidth  */
 236                                         depth,
 237                                         InputOutput,
 238                                         DefaultVisual (GetSysDisplay(), GetSysScreen()),
 239                                         valuemask,
 240                                         &winattr);
 241         UNLOCK_X11
 242
 243         D(bug("Xwindow : %p\n", DRAWABLE(data)));
 244
 245     #if ADJUST_XWIN_SIZE
 246         if (DRAWABLE(data) && MASTERWIN(data))
 247         {
 248     #else
 249         if (DRAWABLE(data))
 250         {
 251             XSizeHints           sizehint;
 252     #endif
 253             struct MsgPort      *port;
 254             struct notify_msg   *msg;
 255             Pixmap               icon;
 256
 257             LOCK_X11
 258
 259             XCALL(XStoreName, GetSysDisplay(), MASTERWIN(data), "AROS");
 260             XCALL(XSetIconName, GetSysDisplay(), MASTERWIN(data), "AROS Screen");
 261
 262         #if !ADJUST_XWIN_SIZE
 263             sizehint.flags      = PMinSize | PMaxSize;
 264             sizehint.min_width  = width;
 265             sizehint.min_height = height;
 266             sizehint.max_width  = width;
 267             sizehint.max_height = height;
 268
 269             XCALL(XSetWMNormalHints, GetSysDisplay(), MASTERWIN(data), &sizehint);
 270         #endif
 271
 272             XCALL(XSetWMProtocols, GetSysDisplay(), MASTERWIN(data), &XSD(cl)->delete_win_atom, 1);
 273
 274             icon = init_icon(GetSysDisplay(),
 275                              MASTERWIN(data),
 276                              DefaultColormap(GetSysDisplay(), GetSysScreen()),
 277                              depth,
 278                              XSD(cl));
 279             if (icon)
 280             {
 281                 XWMHints hints;
 282
 283                 hints.icon_pixmap = icon;
 284                 hints.flags = IconPixmapHint;
 285
 286                 XCALL(XSetWMHints, GetSysDisplay(), MASTERWIN(data), &hints);
 287             }
 288
 289
 290             D(bug("Calling XMapRaised\n"));
 291
 292 /*
 293   stegerg: XMapRaised is now called inside the X11 task when getting
 294            the NOTY_MAPWINDOW message, otherwise the X11 task can
 295            get a "dead" MapNotify event:
 296
 297            XCreateWindow is called here on the app task context.
 298            If we also call XMapRaised here then the X11 task might
 299            get the MapNotify event before he got the NOTY_WINCREATE
 300            message sent from here (see below). So the X11 task
 301            would not know about our window and therefore ignore
 302            the MapNotify event from X.
 303
 304            This caused the freezes which sometimes happened during
 305            startup when the Workbench screen was opened.
 306
 307            //XCALL(XMapRaised, GetSysDisplay(), DRAWABLE(data));
 308 */
 309
 310             UNLOCK_X11
 311
 312             /* Now we need to get some message from the X11 task about when
 313                the window has been mapped (ie. MapWindow event).
 314                This is because we cannot render into the window until the
 315                it has been mapped.kfind &
 316             */
 317
 318             /* Create X11 GC */
 319
 320             port = CreateMsgPort();
 321             msg = AllocMem(sizeof (*msg), MEMF_PUBLIC | MEMF_CLEAR);
 322
 323             if (NULL != port && NULL != msg)
 324             {
 325                 XGCValues gcval;
 326
 327                 /* Send a message to the x11 task that the window has been created */
 328
 329                 msg->notify_type = NOTY_WINCREATE;
 330                 msg->xdisplay = GetSysDisplay();
 331                 msg->xwindow = DRAWABLE(data);
 332                 msg->masterxwindow = MASTERWIN(data);
 333                 msg->bmobj = o;
 334                 msg->execmsg.mn_ReplyPort = port;
 335
 336                 LOCK_X11
 337                 XCALL(XSync, GetSysDisplay(), FALSE);
 338                 UNLOCK_X11
 339
 340                 PutMsg(XSD(cl)->x11task_notify_port, (struct Message *)msg);
 341
 342                 /* Wait for the reply, so we are sure that the x11 task
 343                    has got it */
 344
 345                 WaitPort(port);
 346                 GetMsg(port);
 347
 348             #if !DELAY_XWIN_MAPPING
 349                 /* Send a message to the X11 task to ask when the window has been mapped */
 350
 351                 msg->xdisplay = GetSysDisplay();
 352                 msg->xwindow = DRAWABLE(data);
 353                 msg->masterxwindow = MASTERWIN(data);
 354                 msg->notify_type = NOTY_MAPWINDOW;
 355                 msg->execmsg.mn_ReplyPort = port;
 356
 357                 LOCK_X11
 358                 XCALL(XSync, GetSysDisplay(), FALSE);
 359                 UNLOCK_X11
 360
 361                 PutMsg(XSD(cl)->x11task_notify_port, (struct Message *)msg);
 362
 363                 /* Wait for result */
 364                 WaitPort(port);
 365                 GetMsg(port);
 366
 367                 kprintf("NOTY_MAPWINDOW request returned\n");
 368             #endif
 369
 370                 gcval.plane_mask = AllPlanes;
 371                 gcval.graphics_exposures = False;
 372
 373                 LOCK_X11
 374                 data->gc = XCALL(XCreateGC, data->display, DRAWABLE(data),
 375                                      GCPlaneMask | GCGraphicsExposures, &gcval);
 376                 UNLOCK_X11
 377
 378                 if (data->gc)
 379                 {
 380                     ok = TRUE;
 381
 382                 #if X11SOFTMOUSE
 383                     init_empty_cursor(DRAWABLE(data), data->gc, XSD(cl));
 384                 #endif
 385                 }
 386                 else
 387                 {
 388                     ok = FALSE;
 389                 }
 390
 391             }
 392             else
 393             {
 394                 ok = FALSE;
 395             } /* if (msgport created && msg allocated) */
 396
 397             if (NULL != msg)
 398                 FreeMem(msg, sizeof (*msg));
 399
 400             if (NULL != port)
 401                 DeleteMsgPort(port);
 402
 403
 404         }
 405         else
 406         {
 407             ok = FALSE;
 408         } /* if (Xwindow created) */
 409
 410         if (!ok)
 411         {
 412
 413             OOP_MethodID disp_mid = OOP_GetMethodID(IID_Root, moRoot_Dispose);
 414
 415             OOP_CoerceMethod(cl, o, (OOP_Msg) &disp_mid);
 416
 417             o = NULL;
 418         }
 419
 420
 421     } /* if (object allocated by superclass) */
 422
 423     ReturnPtr("X11Gfx.OnBitMap::New()", OOP_Object *, o);
 424 }
 425
 426 /****************************************************************************************/
 427
 428 VOID X11OnBM__Root__Dispose(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
 429 {
 430     struct bitmap_data *data = OOP_INST_DATA(cl, o);
 431
 432     EnterFunc(bug("X11Gfx.BitMap::Dispose()\n"));
 433
 434     /* Someone is trying to dispose the framefuffer. This should really
 435     never happen in AROS. */
 436
 437     //CCALL(raise, 19);
 438
 439     if (data->gc)
 440     {
 441         LOCK_X11
 442         XCALL(XFreeGC, data->display, data->gc);
 443         UNLOCK_X11
 444     }
 445
 446     if (DRAWABLE(data))
 447     {
 448         struct MsgPort    *port;
 449         struct notify_msg *msg;
 450
 451         port = CreateMsgPort();
 452         msg = AllocMem(sizeof (*msg), MEMF_PUBLIC | MEMF_CLEAR);
 453
 454         if (NULL == port || NULL == msg)
 455         {
 456             kprintf("COULD NOT CREATE PORT OR ALLOCATE MEM IN onbitmap_dispose()\n");
 457             //CCALL(raise, 19);
 458         }
 459
 460         msg->notify_type = NOTY_WINDISPOSE;
 461         msg->xdisplay = GetSysDisplay();
 462         msg->xwindow = DRAWABLE(data);
 463         msg->masterxwindow = MASTERWIN(data);
 464         msg->execmsg.mn_ReplyPort = port;
 465
 466         PutMsg(XSD(cl)->x11task_notify_port, (struct Message *)msg);
 467         WaitPort(port);
 468
 469         GetMsg(port);
 470
 471         FreeMem(msg, sizeof (*msg));
 472         DeleteMsgPort(port);
 473
 474         LOCK_X11
 475         XCALL(XDestroyWindow,  GetSysDisplay(), DRAWABLE(data));
 476         XCALL(XFlush,  GetSysDisplay() );
 477         UNLOCK_X11
 478     }
 479
 480 #if ADJUST_XWIN_SIZE
 481     if (MASTERWIN(data))
 482     {
 483         LOCK_X11
 484         XCALL(XDestroyWindow,  GetSysDisplay(), MASTERWIN(data));
 485         XCALL(XFlush,  GetSysDisplay() );
 486         UNLOCK_X11
 487     }
 488 #endif
 489
 490     if (data->flags & BMDF_COLORMAP_ALLOCED)
 491     {
 492         LOCK_X11
 493         XCALL(XFreeColormap, GetSysDisplay(), data->colmap);
 494         UNLOCK_X11
 495     }
 496
 497     OOP_DoSuperMethod(cl, o, msg);
 498
 499     ReturnVoid("X11Gfx.BitMap::Dispose");
 500 }
 501
 502 /****************************************************************************************/
 503
 504 VOID X11OnBM__Hidd_BitMap__Clear(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_Clear *msg)
 505 {
 506     struct bitmap_data *data = OOP_INST_DATA(cl, o);
 507     ULONG               width, height;
 508
 509     XSetWindowAttributes winattr;
 510
 511     /* Get width & height from bitmap */
 512
 513     OOP_GetAttr(o, aHidd_BitMap_Width,  &width);
 514     OOP_GetAttr(o, aHidd_BitMap_Height, &height);
 515
 516     winattr.background_pixel = GC_BG(msg->gc);
 517
 518     LOCK_X11
 519     XCALL(XChangeWindowAttributes, data->display, DRAWABLE(data),
 520                             CWBackPixel, &winattr);
 521
 522     XCALL(XClearArea, data->display, DRAWABLE(data),
 523             0, 0,
 524             width, height,
 525             FALSE);
 526
 527     XCALL(XFlush, data->display);
 528     UNLOCK_X11
 529 }
 530
 531 /****************************************************************************************/
 532
 533 #undef XSD
 534 #define XSD(cl) (&LIBBASE->xsd)
 535
 536 #define NUM_ROOT_METHODS 4
 537
 538 #if USE_X11_DRAWFUNCS
 539 #   define NUM_BITMAP_METHODS 13
 540 #else
 541 #   define NUM_BITMAP_METHODS 11
 542 #endif
 543
 544 /****************************************************************************************/
 545
 546 static int X11OnBM_Init(LIBBASETYPEPTR LIBBASE)
 547 {
 548     return OOP_ObtainAttrBases(attrbases);
 549 }
 550
 551 /****************************************************************************************/
 552
 553 static int X11OnBM_Expunge(LIBBASETYPEPTR LIBBASE)
 554 {
 555     OOP_ReleaseAttrBases(attrbases);
 556     return TRUE;
 557 }
 558
 559 /****************************************************************************************/
 560
 561 ADD2INITLIB(X11OnBM_Init, 0);
 562 ADD2EXPUNGELIB(X11OnBM_Expunge, 0);
 563
 564 #if X11SOFTMOUSE
 565
 566 /****************************************************************************************/
 567
 568 static void init_empty_cursor(Window w, GC gc, struct x11_staticdata *xsd)
 569 {
 570     Pixmap  p, mask;
 571     int     width, height;
 572
 573     width = height = 1;
 574
 575     LOCK_X11
 576     p = XCALL(XCreatePixmap,  xsd->display, w, width, height, 1);
 577     UNLOCK_X11
 578
 579
 580     if (0 != p)
 581     {
 582         LOCK_X11
 583         mask = XCALL(XCreatePixmap,  xsd->display
 584                 , w
 585                 , width
 586                 , height
 587                 , 1
 588         );
 589         XCALL(XFlush, xsd->display);
 590         UNLOCK_X11
 591
 592         if (0 != mask)
 593         {
 594             /* Define cursor for window */
 595             XColor fg, bg;
 596             Cursor c;
 597             int    x, y;
 598
 599             LOCK_X11
 600             XCALL(XSetForeground, xsd->display, gc, 0);
 601             XCALL(XSetFunction, xsd->display, gc, GXcopy);
 602         #if 0
 603             XCALL(XFillRectangle, xsd->display, p, gc, 1, 1, 1, 1);
 604             for (y = 0; y < height; y ++)
 605             {
 606                 for (x = 0; x < width; x ++)
 607                 {
 608                     XCALL(XDrawPoint, xsd->display, mask, gc, x, y);
 609                 }
 610             }
 611         #endif
 612             UNLOCK_X11
 613
 614             fg.pixel    = BlackPixel(xsd->display, DefaultScreen(xsd->display));
 615             fg.red      = 0x0000;
 616             fg.green    = 0x0000;
 617             fg.blue     = 0x0000;
 618             fg.flags    = DoRed | DoGreen | DoBlue;
 619
 620             bg.pixel    = WhitePixel(xsd->display, DefaultScreen(xsd->display));
 621             bg.red      = 0xFFFF;
 622             bg.green    = 0xFFFF;
 623             bg.blue     = 0xFFFF;
 624             bg.flags    = DoRed | DoGreen | DoBlue;
 625
 626             LOCK_X11
 627             c = XCALL(XCreatePixmapCursor, xsd->display, p, mask, &fg, &bg, 0, 0);
 628             UNLOCK_X11
 629
 630             if (0 != c)
 631             {
 632                 LOCK_X11
 633                 XCALL(XDefineCursor, xsd->display, w, c);
 634                 UNLOCK_X11
 635             }
 636
 637             LOCK_X11
 638             XCALL(XFreePixmap, xsd->display, mask);
 639             UNLOCK_X11
 640         }
 641
 642         LOCK_X11
 643         XCALL(XFreePixmap, xsd->display, p);
 644         UNLOCK_X11
 645     }
 646
 647 }
 648
 649 /****************************************************************************************/
 650
 651 #endif
 652
 653 /****************************************************************************************/
 654
 655 static Pixmap init_icon(Display *d, Window w, Colormap cm, LONG depth, struct x11_staticdata *xsd)
 656 {
 657     #include "icon.h"
 658
 659     #define SHIFT_PIX(pix, shift)       \
 660         (( (shift) < 0) ? (pix) >> (-shift) : (pix) << (shift) )
 661
 662     Pixmap   icon = XCALL(XCreatePixmap, d, w, width, height, depth);
 663     char    *data = header_data;
 664     LONG     red_shift, green_shift, blue_shift;
 665     GC       gc;
 666
 667     red_shift   = 24 - xsd->red_shift;
 668     green_shift = 24 - xsd->green_shift;
 669     blue_shift  = 24 - xsd->blue_shift;
 670
 671     if (icon)
 672     {
 673         gc = XCALL(XCreateGC, d, icon, 0, 0);
 674
 675         if (gc)
 676         {
 677             WORD x, y;
 678
 679             for(y = 0; y < height; y++)
 680             {
 681                 for(x = 0; x < width; x++)
 682                 {
 683                     ULONG rgb[3];
 684                     ULONG pixel = 0;
 685
 686                     HEADER_PIXEL(data,rgb);
 687
 688                     if (xsd->vi.class == TrueColor)
 689                     {
 690                         pixel = (SHIFT_PIX(rgb[0] & 0xFF, red_shift)   & xsd->vi.red_mask)   |
 691                                 (SHIFT_PIX(rgb[1] & 0xFF, green_shift) & xsd->vi.green_mask) |
 692                                 (SHIFT_PIX(rgb[2] & 0xFF, blue_shift)  & xsd->vi.blue_mask);
 693                     }
 694                     else if (xsd->vi.class == PseudoColor)
 695                     {
 696                         XColor xcol;
 697
 698                         xcol.red   = (rgb[0] << 8) + rgb[0];
 699                         xcol.green = (rgb[1] << 8) + rgb[1];
 700                         xcol.blue  = (rgb[2] << 8) + rgb[2];
 701                         xcol.flags = DoRed | DoGreen | DoBlue;
 702
 703                         if (XCALL(XAllocColor, d, cm, &xcol))
 704                         {
 705                             pixel = xcol.pixel;
 706                         }
 707                     }
 708
 709                     XCALL(XSetForeground, d, gc, pixel);
 710                     XCALL(XDrawPoint, d, icon, gc, x, y);
 711                 }
 712             }
 713
 714             XCALL(XFreeGC, d, gc);
 715
 716         } /* if (gc) */
 717
 718     } /* if (icon) */
 719
 720     return icon;
 721 }
 722
 723 /****************************************************************************************/