Exemplo n.º 1
0
void set_colors() {
    int theDepth;
    Colormap theColormap;
    XColor theHardwareColor, theRGBColor;

    theDisplay    = XtDisplay( topLevel );
    theScreen     = ( int *)XtScreen( topLevel );
    theDepth  = DefaultDepth(theDisplay,*theScreen);
    BlackPen  = BlackPixel( theDisplay, *theScreen);
    WhitePen  = WhitePixel( theDisplay, *theScreen);
    GrayPen   = WhitePen;
    YellowPen = WhitePen;
    LightBluePen = WhitePen;

    if (theDepth > 1) {
        theColormap = DefaultColormap(theDisplay,*theScreen);

        if ((XLookupColor(theDisplay,theColormap,"Yellow",
                          &theRGBColor,&theHardwareColor)) &&
                (XAllocColor(theDisplay,theColormap,&theHardwareColor))) {
            YellowPen = theHardwareColor.pixel;
        }
        if ((XLookupColor(theDisplay,theColormap,"LightBlue",
                          &theRGBColor,&theHardwareColor)) &&
                (XAllocColor(theDisplay,theColormap,&theHardwareColor))) {
            LightBluePen = theHardwareColor.pixel;
        }
        if ((XLookupColor(theDisplay,theColormap,"LightGray",
                          &theRGBColor,&theHardwareColor)) &&
                (XAllocColor(theDisplay,theColormap,&theHardwareColor))) {
            GrayPen = theHardwareColor.pixel;
        }
    }
}
Exemplo n.º 2
0
void MSDisplayCursor::
create(MSDisplayServer *pServer_,const char *pName_,unsigned int shape_,unsigned long fg_,unsigned long bg_)
{
  Cursor c=XCreateFontCursor(pServer_->display(),shape_);
  _pData=new MSDisplayCursorData(pServer_,pName_,c,16,16,1,fg_,bg_,shape_);
  _pCursorHashTable->add(pName_,(void *)_pData);

  XColor fgColor,bgColor,screenColor;
  
  XLookupColor(pServer_->display(),pServer_->colormap(),pServer_->colorName(fg_),&fgColor,&screenColor);
  XLookupColor(pServer_->display(),pServer_->colormap(),pServer_->colorName(bg_),&bgColor,&screenColor);
  XRecolorCursor(pServer_->display(),cursor(),&fgColor,&bgColor);
}
Exemplo n.º 3
0
/*
   This routine takes a named color and returns a color that is either
   lighter or darker
 */
PixVal XBSimColor( XBWindow *XBWin, PixVal pixel, int intensity, int is_fore ){
	XColor   colordef, colorsdef;
	char     RGBcolor[20];
	PixVal   red, green, blue;
	    /*  int      st;  */

	colordef.pixel = pixel;
	XQueryColor( XBWin->disp, XBWin->cmap, &colordef );
	/* Adjust the color value up or down.  Get the RGB values for the color */
	red   = colordef.red;
	green = colordef.green;
	blue  = colordef.blue;
	#define min(a,b) ((a)<(b) ? a : b)
	#define max(a,b) ((a)>(b) ? a : b)
	#define WHITE_AMOUNT 5000
	if (intensity > 0) {
		/* Add white to the color */
		red   = min(65535,red + WHITE_AMOUNT);
		green = min(65535,green + WHITE_AMOUNT);
		blue  = min(65535,blue + WHITE_AMOUNT);
    	} else {
		/* Subtract white from the color */
		red   = (red   < WHITE_AMOUNT) ? 0 : red - WHITE_AMOUNT;
		green = (green < WHITE_AMOUNT) ? 0 : green - WHITE_AMOUNT;
		blue  = (blue  < WHITE_AMOUNT) ? 0 : blue - WHITE_AMOUNT;
    	}
	sprintf( RGBcolor, "rgb:%4.4x/%4.4x/%4.4x", (unsigned int)red,  (unsigned int) green, (unsigned int) blue );
	XLookupColor( XBWin->disp, XBWin->cmap, RGBcolor, &colordef, &colorsdef );
	/*
	    st = XLookupColor( XBWin->disp, XBWin->cmap, RGBcolor, &colordef, 
		       &colorsdef );
	 */    
	return  colorsdef.pixel;
}
Exemplo n.º 4
0
    ///////////////////////////////////////////////////////////////////////
    ///  Function: Lookup
    ///
    ///    Author: $author$
    ///      Date: 4/25/2012
    ///////////////////////////////////////////////////////////////////////
    virtual XosError Lookup
    (Display* xDisplay, Colormap xColormap,
     const char* colorName,
     bool onlyFreed=false)
    {
        XosError error = XOS_ERROR_FAILED;
        XosError error2;
        XColor xColorDefinition;
        XColor xColor;
        Pixel detached;
        Status success;

        if ((error2 = Freed(onlyFreed)))
            return error2;

        if ((xDisplay) && (None != (xColormap)) && (colorName))
        if ((success = XLookupColor
            (xDisplay, xColormap, colorName,
             &xColorDefinition, &xColor)))
        {
            m_xDisplay = xDisplay;
            m_xColormap = xColormap;
            Attach(detached = xColor.pixel);
            error = XOS_ERROR_NONE;
        }
        else
        {   XOS_DBE(("()\n failed on XLookupColor()\n")); }

        return error;
    }
Exemplo n.º 5
0
void EZX_InitDefaultColors(void)
{
   XColor	theRGBColor, theHardwareColor;
   int		theStatus;
   int		i;
   
   if (theDepth==1) {
      /* monochrome system */
      thePixels[C_WHITE] = theWhitePixel;
      thePixels[C_BLACK] = theBlackPixel;
   } else {
      for(i=0;i<MAXCOLORS;++i) {
	 theStatus = XLookupColor(theDisplay, theColormap, theColorNames[i],
				  &theRGBColor, &theHardwareColor);
	 if (theStatus != 0) {
	    theStatus = XAllocColor(theDisplay, theColormap, 
				    &theHardwareColor);
	    if (theStatus != 0)
	       thePixels[i] = theHardwareColor.pixel;
	    else
	       thePixels[i] = theBlackPixel;
	 }
      }
   }
}
Exemplo n.º 6
0
static Imlib_Color_Modifier
create_modifier(MainWin *mw, dlist *config, const char *item, const char *d_bright, const char *d_tint, const char *d_opacity)
{
	const char *tmp;
	XColor exact_color, screen_color;
	int i, alpha_v;
	DATA8 red[256], green[256], blue[256], alpha[256];
	Imlib_Color_Modifier modifier = imlib_create_color_modifier();
	
	imlib_context_set_color_modifier(modifier);
	
	tmp = config_get(config, item, "brightness", d_bright);
	imlib_modify_color_modifier_brightness(strtod(tmp, NULL));
	
	imlib_get_color_modifier_tables(red, green, blue, alpha);
	
	tmp = config_get(config, item, "tint", d_tint);
	if(XLookupColor(mw->dpy, mw->colormap, tmp, &exact_color, &screen_color) != 0)
	{
		
		double red_f = (double)exact_color.red / 65536.0,
		       green_f = (double)exact_color.green / 65536.0,
		       blue_f = (double)exact_color.blue / 65536.0;
		
		for(i = 0; i < 256; i++)
		{
			red[i] = (double)red[i] * red_f;
			green[i] = (double)green[i] * green_f;
			blue[i] = (double)blue[i] * blue_f;
		}
	} else
		fprintf(stderr, "WARNING: Couldn't look up tint color'%s'.\n", tmp);
	
	tmp = config_get(config, item, "opacity", d_opacity);
	alpha_v = strtol(tmp, 0, 10);
	if(alpha_v != 255)
	{
		for(i = 0; i < 256; i++)
			alpha[i] = alpha_v;
	}
	
	imlib_set_color_modifier_tables(red, green, blue, alpha);
	
	imlib_context_set_color_modifier(0);
	
	return modifier;
}
Exemplo n.º 7
0
int MyAllocNamedColor(Display *display,Colormap colormap,char* colorname,XColor* color)
{
 static XColor TempColor;

 if (colorname[0]=='#')
 {
  if (XParseColor(display,colormap,colorname,color))
   return XAllocColor(display,colormap,color);
  else
   return 0;
 }
 else
 {
  if (XLookupColor(display,colormap,colorname,&TempColor,color))
   return XAllocColor(display,colormap,color);
  else
   return 0;
 }
 return 0;
}
Exemplo n.º 8
0
static bool GetColorByName (const string &p, int &r, int &g, int &b)
{
  r = g = b = 0x0000;

  // empty string
  if (p.empty()) return false;

  // hexadecimal string value
  if ( p[0] == '#' ) {
    if ( p.size() == 13 ) {
      r = (((((H(p[1]) << 4) | H(p[2]))  << 4) | H(p[3])) << 4) | H(p[4]);
      g = (((((H(p[5]) << 4) | H(p[6]))  << 4) | H(p[7])) << 4) | H(p[8]);
      b = (((((H(p[9]) << 4) | H(p[10])) << 4) | H(p[11]))<< 4) | H(p[12]);
    } else if ( p.size() == 10 ) {
      r = ((((H(p[1]) << 4) | H(p[2])) << 4) | H(p[3])) << 4;
      g = ((((H(p[4]) << 4) | H(p[5])) << 4) | H(p[6])) << 4;
      b = ((((H(p[7]) << 4) | H(p[8])) << 4) | H(p[9])) << 4;
    } else if ( p.size() == 7 ) {
      r = ((H(p[1]) << 4) | H(p[2])) << 8;
      g = ((H(p[3]) << 4) | H(p[4])) << 8;
      b = ((H(p[5]) << 4) | H(p[6])) << 8;
    } else if ( p.size() == 4 ) {
      r = H(p[1]) << 12;
      g = H(p[2]) << 12;
      b = H(p[3]) << 12;
    } else {
      r = g = b = 0;
      return false;
    }      
    return true;    
  } 
  
  // look up name in data base
  if (Mp.theDisplay != NULL) {
    // use X database (rgb.txt) if there is a connection to the X server
    XColor col, screen_col;
    if ( XLookupColor(Mp.theDisplay,
                      Mp.theColormap, 
                      p.c_str(), &col, &screen_col) ) {
      r = col.red;
      g = col.green;
      b = col.blue;
      return true;
    }
  } 

  // look up name in MATPACK data base $MATPACK/cmaps/color.tbl
  // (which is in fact a copy of the X database (rgb.txt). 
  // But this way we can work with color names 
  // without an X server connection!
  const char *Home = getenv("MATPACK");
  string Path = Home;
  Path += "/cmaps/color.tbl";
  ifstream s( Path.c_str() );
  if (s.fail()) return false;
  int rx,gx,bx;
  string name;
  while (! s.eof()) {
    s >> rx >> gx >> bx >> name;
    if ( strcmp_ignore_case(p.c_str(),name.c_str()) == 0 )  {
      r = rx << 8; 
      g = gx << 8; 
      b = bx << 8;
      return true;
    } 
  }

  return false;
} 
Exemplo n.º 9
0
main()
{
      Window w2;

      Display *dpy = XOpenDisplay(NIL);
      assert(dpy);
      Screen *scr = DefaultScreenOfDisplay(dpy);

      // CreateWindow

      Window w = XCreateWindow(dpy, RootWindowOfScreen(scr), 10, 100, 200, 300, 0, CopyFromParent,
			       CopyFromParent, CopyFromParent,
			       0, NIL);

      XDestroyWindow(dpy, w);

      // CreateWindow with arguments

      XSetWindowAttributes swa;
      swa.background_pixel = WhitePixelOfScreen(scr);
      swa.bit_gravity = NorthWestGravity;
      swa.border_pixel = BlackPixelOfScreen(scr);
      swa.colormap = DefaultColormapOfScreen(scr);
      swa.cursor = None;
      swa.win_gravity = NorthGravity;

      w = XCreateWindow(dpy, RootWindowOfScreen(scr), 10, 100, 200, 300, 0, CopyFromParent,
			CopyFromParent, CopyFromParent,
			CWBackPixel | CWBitGravity | CWBorderPixel | CWColormap | CWCursor | CWWinGravity, 
			&swa);
      
      // CreateWindow with other arguments

      XDestroyWindow(dpy, w);

      Pixmap pixmap = XCreatePixmap(dpy, RootWindowOfScreen(scr), 45, 25, DefaultDepthOfScreen(scr));
      assert(pixmap);

      swa.background_pixmap = pixmap;
      swa.border_pixmap = pixmap;

      w = XCreateWindow(dpy, RootWindowOfScreen(scr), 10, 100, 200, 300, 0, CopyFromParent,
			CopyFromParent, CopyFromParent,
			CWBackPixmap | CWBorderPixmap,
			&swa);
      
      // ChangeWindowAttributes

      swa.backing_planes = 0x1;
      swa.backing_pixel = WhitePixelOfScreen(scr);
      swa.save_under = True;
      swa.event_mask = KeyPressMask | KeyReleaseMask;
      swa.do_not_propagate_mask = ButtonPressMask | Button4MotionMask;
      swa.override_redirect = False;
      XChangeWindowAttributes(dpy, w, CWBackingPlanes | CWBackingPixel | CWSaveUnder | CWEventMask
			      | CWDontPropagate | CWOverrideRedirect, &swa);

      // GetWindowAttributes

      XWindowAttributes wa;
      Status success = XGetWindowAttributes(dpy, w, &wa);

      // DestroyWindow (done)

      // DestroySubwindows

      w2 = XCreateWindow(dpy, w, 20, 30, 40, 50, 3, CopyFromParent, CopyFromParent, CopyFromParent, 0, NIL);
      XDestroySubwindows(dpy, w);

      // ChangeSaveSet

//        Display *dpy2 = XOpenDisplay(NIL);
//        assert(dpy2);
//        XAddToSaveSet(dpy2, w);
//        XCloseDisplay(dpy2);

      // ReparentWindow

      w2 = XCreateWindow(dpy, RootWindowOfScreen(scr), 20, 30, 40, 50, 3, 
			 CopyFromParent, CopyFromParent, CopyFromParent, 0, NIL);
      XReparentWindow(dpy, w2, w, 10, 5);

      // MapWindow

      XMapWindow(dpy, w);

      // MapSubwindows
      
      XMapSubwindows(dpy, w);

      // UnmapWindow
      
      XUnmapWindow(dpy, w);

      // UnmapSubwindows

      XMapWindow(dpy, w);
      XUnmapSubwindows(dpy, w2);
      XMapSubwindows(dpy, w);

      // ConfigureWindow

      Window w3 = XCreateWindow(dpy, w, 10, 50, 100, 10, 2,
			 CopyFromParent, CopyFromParent, CopyFromParent, 0, NIL);

      XMapWindow(dpy, w3);

      XWindowChanges wc;
      wc.x = -5;
      wc.y = -10;
      wc.width = 50;
      wc.height = 40;
      wc.border_width = 7;
      wc.sibling = w2;
      wc.stack_mode = Opposite;
      XConfigureWindow(dpy, w3, 
		       CWX | CWY | CWWidth | CWHeight | CWBorderWidth | CWSibling | CWStackMode, 
		       &wc);

      // CirculateWindow

      XCirculateSubwindows(dpy, w, RaiseLowest);

      // GetGeometry

      Window root;
      int x, y;
      unsigned width, height, border_width, depth;
      XGetGeometry(dpy, w, &root, &x, &y, &width, &height, &border_width, &depth);

      // QueryTree

      Window parent;
      Window *children;
      unsigned nchildren;
      success = XQueryTree(dpy, w, &root, &parent, &children, &nchildren);
      XFree(children);

      // InternAtom

      Atom a = XInternAtom(dpy, "WM_PROTOCOLS", True);

      // GetAtomName

      char *string = XGetAtomName(dpy, XA_PRIMARY);
      XFree(string);

      // ChangeProperty

      XStoreName(dpy, w, "test window");

      // DeleteProperty

      XDeleteProperty(dpy, w, XA_WM_NAME);

      // GetProperty
      // TODO

      // ListProperties

      int num_prop;
      Atom *list = XListProperties(dpy, w, &num_prop);
      XFree(list);

      // SetSelectionOwner

      XSetSelectionOwner(dpy, XA_PRIMARY, w, 12000);
      XSetSelectionOwner(dpy, XA_SECONDARY, w, CurrentTime);

      // GetSelectionOwner

      Window wx = XGetSelectionOwner(dpy, XA_PRIMARY);

      // ConvertSelection

      XConvertSelection(dpy, XA_SECONDARY, XA_CURSOR, XA_POINT, w, CurrentTime);

      // SendEvent

      // GrabPointer

      std::cerr << "Grabbing" << std::endl;
      int res = XGrabPointer(dpy, w, False, Button5MotionMask | PointerMotionHintMask,
			     GrabModeSync, GrabModeAsync, w, None, CurrentTime);
      XSync(dpy, False);
//      sleep(5);

      // UngrabPointer

      std::cerr << "Ungrabbing" << std::endl;
      XUngrabPointer(dpy, CurrentTime);

      // GrabButton

      XGrabButton(dpy, 3, ShiftMask | ControlMask, w, False, PointerMotionHintMask | Button2MotionMask, 
		  GrabModeAsync, GrabModeSync, None, None);
		  
      XGrabButton(dpy, 2, AnyModifier, w, False, PointerMotionHintMask | Button2MotionMask, 
		  GrabModeAsync, GrabModeSync, None, None);
		  
      // UngrabButton

      XUngrabButton(dpy, 2, LockMask, w);

      // ChangeActivePointerGrab

      XChangeActivePointerGrab(dpy, ButtonPressMask, None, CurrentTime);

      // GrabKeyboard

      XGrabKeyboard(dpy, w, True, GrabModeSync, GrabModeSync, 12000);

      // UngrabKeyboard

      XUngrabKeyboard(dpy, 13000);

      // GrabKey

      XGrabKey(dpy, XKeysymToKeycode(dpy, XK_Tab), ShiftMask | Mod3Mask, w, True, GrabModeSync,
	       GrabModeSync);

      // UngrabKey

      XUngrabKey(dpy, AnyKey, AnyModifier, w);

      // AllowEvents

      XAllowEvents(dpy, AsyncPointer, 14000);

      // GrabServer

      XGrabServer(dpy);

      // UngrabServer

      XUngrabServer(dpy);

      // QueryPointer

      Window child;
      int root_x, root_y, win_x, win_y;
      unsigned mask;
      Bool bres = XQueryPointer(dpy, w, &root, &child, &root_x, &root_y, &win_x, &win_y, &mask);

      // GetMotionEvents

      int nevents;
      XGetMotionEvents(dpy, w, 15000, 16000, &nevents);

      // TranslateCoordinates

      int dest_x, dest_y;

      XTranslateCoordinates(dpy, w, w2, 10, 20, &dest_x, &dest_y, &child);

      // WarpPointer

      XWarpPointer(dpy, w, w2, 0, 0, 100, 100, 20, 30);

      // SetInputFocus

      XSetInputFocus(dpy,w, RevertToPointerRoot, 17000);
      XSetInputFocus(dpy, PointerRoot, RevertToPointerRoot, 17000);

      // GetInputFocus

      Window focus;
      int revert_to;
      XGetInputFocus(dpy, &focus, &revert_to);

      // QueryKeymap

      char keys_return[32];
      XQueryKeymap(dpy, keys_return);

      // OpenFont

      Font fid = XLoadFont(dpy, "cursor");

      // CloseFont

      XUnloadFont(dpy, fid);

      // QueryFont

      XFontStruct *fs = XLoadQueryFont(dpy, "cursor");
      assert(fs);

      // QueryTextExtents

      int direction, font_ascent, font_descent;
      XCharStruct overall;
      XQueryTextExtents(dpy, fs -> fid, "toto", 4, &direction, &font_ascent, &font_descent, &overall);
      XQueryTextExtents(dpy, fs -> fid, "odd__length", 11, &direction, &font_ascent, &font_descent, &overall);

      XChar2b c2bs;
      c2bs.byte1 = '$';
      c2bs.byte2 = 'B';
      XQueryTextExtents16(dpy, fs -> fid, &c2bs, 1, &direction, &font_ascent, &font_descent, &overall);

      XQueryTextExtents(dpy, fs -> fid, longString, strlen(longString), &direction, &font_ascent, 
			&font_descent, &overall);

      // ListFonts

      int actual_count;
      char **fontList = XListFonts(dpy, "*", 100, &actual_count);
      XFree((char *)fontList);

      // ListFontsWithInfo

      int count;
      XFontStruct *info;
      char **names = XListFontsWithInfo(dpy, "*", 100, &count, &info);
      XFreeFontInfo(names, info, count);

      // SetFontPath
      // GetFontPath

      int npaths;
      char **charList = XGetFontPath(dpy, &npaths);

      char **charList2 = new char *[npaths + 1];
      memcpy(charList2, charList, npaths * sizeof(char *));
      charList2[npaths] = charList2[0];

      XSetFontPath(dpy, charList2, npaths + 1);
      XSetFontPath(dpy, charList, npaths); // Reset to some reasonnable value

      XFreeFontPath(charList);
      delete [] charList2;

      // CreatePixmap

      Pixmap pix2 = XCreatePixmap(dpy, w, 100, 200, DefaultDepthOfScreen(scr));

      // FreePixmap

      XFreePixmap(dpy, pix2);

      // CreateGC

      Pixmap bitmap = XCreateBitmapFromData(dpy, RootWindowOfScreen(scr), 
					    "\000\000\001\000\000\001\000\000\001\377\377\377", 3, 4);

      XGCValues gcv;
      gcv.function = GXand;
      gcv.plane_mask = 0x1;
      gcv.foreground = WhitePixelOfScreen(scr);
      gcv.background = BlackPixelOfScreen(scr);
      gcv.line_width = 2;
      gcv.line_style = LineDoubleDash;
      gcv.cap_style = CapProjecting;
      gcv.join_style = JoinRound;
      gcv.fill_style = FillStippled;
      gcv.fill_rule = EvenOddRule;
      gcv.arc_mode = ArcPieSlice;
      gcv.tile = pixmap;
      gcv.stipple = bitmap;
      gcv.ts_x_origin = 3;
      gcv.ts_y_origin = 4;
      gcv.font = fs -> fid;
      gcv.subwindow_mode = ClipByChildren;
      gcv.graphics_exposures = True;
      gcv.clip_x_origin = 5;
      gcv.clip_y_origin = 6;
      gcv.clip_mask = bitmap;
      gcv.dash_offset = 1;
      gcv.dashes = 0xc2;
      
      GC gc = XCreateGC(dpy, w, 
			  GCFunction | GCPlaneMask | GCForeground | GCBackground | GCLineWidth
			| GCLineStyle | GCCapStyle | GCJoinStyle | GCFillStyle | GCFillRule | GCTile
			| GCStipple | GCTileStipXOrigin | GCTileStipYOrigin | GCFont | GCSubwindowMode
			| GCGraphicsExposures | GCClipXOrigin | GCClipYOrigin | GCClipMask | GCDashOffset
			| GCDashList | GCArcMode,
			&gcv);

      // ChangeGC

      gcv.function = GXandReverse;

      // Only a few of these should appear, since the values are cached on the client side by the Xlib.

      XChangeGC(dpy, gc, GCFunction | GCLineStyle | GCStipple | GCGraphicsExposures | GCDashList, &gcv);

      // CopyGC
      
      GC gc2 = XCreateGC(dpy, w, 0, NIL);
      XCopyGC(dpy, gc, GCFunction | GCLineStyle | GCStipple | GCGraphicsExposures | GCDashList, gc2);

      // SetDashes

      XSetDashes(dpy, gc, 3, "\001\377\001", 3);

      // SetClipRectangles

      XRectangle rectangles[] = { { 10, 20, 30, 40 }, { 100, 200, 5, 3 }, { -5, 1, 12, 24 } };
      XSetClipRectangles(dpy, gc, 12, 9, rectangles, SIZEOF(rectangles), Unsorted);

      // FreeGC

	    // done already

      // ClearArea

      XClearArea(dpy, w, 30, 10, 10, 100, False);

      // CopyArea

      XCopyArea(dpy, w, pixmap, gc, 0, 0, 100, 100, 10, 10);

      // CopyPlane

      // This won't work if the Screen doesn't have at least 3 planes
      XCopyPlane(dpy, pixmap, w, gc, 20, 10, 40, 30, 0, 0, 0x4);

      // PolyPoint

      XDrawPoint(dpy, w, gc, 1, 2);

      XPoint points[] = { { 3, 4 }, { 5, 6 } };
      XDrawPoints(dpy, w, gc, points, SIZEOF(points), CoordModeOrigin);

      // PolyLine

      XDrawLines(dpy, w, gc, points, SIZEOF(points), CoordModePrevious);

      // PolySegment

      XSegment segments[] = { { 7, 8, 9, 10 }, { 11, 12, 13, 14 }, { 15, 16, 17, 18 } };
      XDrawSegments(dpy, w, gc, segments, SIZEOF(segments));

      // PolyRectangle

      XDrawRectangles(dpy, w, gc, rectangles, SIZEOF(rectangles));

      // PolyArc

      XArc arcs[] = { { 10, 20, 30, 40, 50, 60 }, { -70, 80, 90, 100, 110, 120 }, 
		      { 10, 20, 30, 40, 50, -30 } };

      XDrawArcs(dpy, w, gc, arcs, SIZEOF(arcs));

      // FillPoly

      XFillPolygon(dpy, w, gc, points, SIZEOF(points), Convex, CoordModePrevious);

      // PolyFillRectangle
      
      XFillRectangles(dpy, w, gc, rectangles, SIZEOF(rectangles));

      // PolyFillArc
      
      XFillArcs(dpy, w, gc, arcs, SIZEOF(arcs));

      // PutImage
      // GetImage

      XImage *image = XGetImage(dpy, w, 10, 20, 40, 30, AllPlanes, ZPixmap);
      XPutImage(dpy, w, gc, image, 0, 0, 50, 60, 40, 30);
      XSync(dpy, False); // Make the next request starts at the beginning of a packet

      // PolyText8
      XTextItem textItems[3];
      textItems[0].chars = "toto";
      textItems[0].nchars = strlen(textItems[0].chars);
      textItems[0].delta = -3;
      textItems[0].font = fs->fid;
      textItems[1].chars = "titi";
      textItems[1].nchars = strlen(textItems[1].chars);
      textItems[1].delta = 3;
      textItems[1].font = None;
      textItems[2].chars = "tutu";
      textItems[2].nchars = strlen(textItems[2].chars);
      textItems[2].delta = 0;
      textItems[2].font = fs->fid;

      XDrawText(dpy, w, gc, 10, 10, textItems, 3);


      XTextItem textItems2[3];
      textItems2[0].chars = "totox";
      textItems2[0].nchars = strlen(textItems2[0].chars);
      textItems2[0].delta = -3;
      textItems2[0].font = fs->fid;
      textItems2[1].chars = "titi";
      textItems2[1].nchars = strlen(textItems2[1].chars);
      textItems2[1].delta = 3;
      textItems2[1].font = None;
      textItems2[2].chars = "tutu";
      textItems2[2].nchars = strlen(textItems2[2].chars);
      textItems2[2].delta = 0;
      textItems2[2].font = fs->fid;

      XDrawText(dpy, w, gc, 10, 10, textItems2, 3);

      // PolyText16

      XChar2b c2b2[] = { 0, 't', 0, 'x' };

      XTextItem16 items16[] = { { &c2bs, 1, -5, None }, { NULL, 0, 0, None }, { c2b2, 2, 0, fs -> fid } };
      XDrawText16(dpy, w, gc, 10, 0, items16, SIZEOF(items16));

      // ImageText8

      XDrawImageString(dpy, w, gc, 10, 10, "toto", 4);

      // ImageText16

      XDrawImageString16(dpy, w, gc, 10, 10, &c2bs, 1);
      XDrawImageString16(dpy, w, gc, 10, 20, c2b2, 2);

      // CreateColormap
      // Don't forget to tell the kids how it was when we had only 8 bits per pixel.

      Colormap colormap = XCreateColormap(dpy, w, DefaultVisualOfScreen(scr), None);

      // FreeColormap

      XFreeColormap(dpy, colormap);
      colormap = XCreateColormap(dpy, w, DefaultVisualOfScreen(scr), None);

      // CopyColormapAndFree

      Colormap colormap2 = XCopyColormapAndFree(dpy, colormap);

      // InstallColormap

      XInstallColormap(dpy, colormap2);

      // UninstallColormap

      XUninstallColormap(dpy, colormap2);

      // ListInstalledColormaps

      int num;
      Colormap *colormapList = XListInstalledColormaps(dpy, w, &num);

      // AllocColor

      XColor screen;
      screen.red = 0;
      screen.green = 32767;
      screen.blue = 65535;
      screen.flags = DoRed | DoGreen | DoBlue;
      success = XAllocColor(dpy, colormap, &screen);

      // AllocNamedColor

      XColor screen2, exact;
      success = XAllocNamedColor(dpy, colormap, "Wheat", &screen2, &exact);

      // AllocColorCells

      unsigned long plane_masks, pixels;
      success = XAllocColorCells(dpy, colormap, False, &plane_masks, 1, &pixels, 1);

      // AllocColorPlanes

      unsigned long rmask, gmask, bmask;
      success = XAllocColorPlanes(dpy, colormap, False, &pixels, 1, 0, 0, 0, &rmask, &gmask, &bmask);

      // FreeColors

      unsigned long pixels2[2] = { screen.pixel, screen2.pixel };
      XFreeColors(dpy, colormap, pixels2, 2, 0);

      // StoreColors

      success = XAllocColorCells(dpy, colormap, False, NIL, 0, pixels2, 2);

      // On many contemporary (that is, year 2000) video cards, you can't allocate read / write cells
      // I want my requests to be sent, however.
      if (!success) {
	    XSetErrorHandler(errorHandler);
      }

      XColor colors[2];
      colors[0] = screen;  colors[0].pixel = pixels2[0];
      colors[1] = screen2; colors[1].pixel = pixels2[1];
      XStoreColors(dpy, colormap, colors, 2);

      // StoreNamedColor

      XStoreNamedColor(dpy, colormap, "Wheat", colors[0].pixel, DoBlue);

      XSync(dpy, False);
      XSetErrorHandler(NIL); // Restore the default handler

      // QueryColors

      screen2.pixel = WhitePixelOfScreen(scr);
      XQueryColor(dpy, colormap, &screen2);

      // LookupColor

      success = XLookupColor(dpy, colormap, "DarkCyan", &exact, &screen);

      // CreateCursor

      Cursor cursor = XCreatePixmapCursor(dpy, pixmap, None, &exact, colors, 10, 10);

      // CreateGlyphCursor
      
      Cursor cursor2 = XCreateGlyphCursor(dpy, fs -> fid, fs -> fid, 'X', 0, &exact, colors);

      // FreeCursor
      
      XFreeCursor(dpy, cursor2);

      // RecolorCursor

      XRecolorCursor(dpy, cursor, colors, &exact);

      // QueryBestSize

      success = XQueryBestSize(dpy, CursorShape, RootWindowOfScreen(scr), 100, 20, &width, &height);

      // QueryExtension

      int major_opcode, first_event, first_error;
      XQueryExtension(dpy, "toto", &major_opcode, &first_event, &first_error);

      // ListExtensions

      int nextensions;
      char **extensionList = XListExtensions(dpy, &nextensions);
      for(char **p = extensionList; nextensions; nextensions--, p++) std::cout << *p << std::endl;
      XFree(extensionList);

      // ChangeKeyboardMapping
      // GetKeyboardMapping

      int min_keycodes, max_keycodes;
      XDisplayKeycodes(dpy, &min_keycodes, &max_keycodes);

      int keysyms_per_keycode;
      KeySym *keysyms = XGetKeyboardMapping(dpy, min_keycodes, max_keycodes - min_keycodes + 1,
					    &keysyms_per_keycode);
      XChangeKeyboardMapping(dpy, min_keycodes, keysyms_per_keycode, keysyms, 
			     max_keycodes - min_keycodes + 1);

      // ChangeKeyboardControl
      // GetKeyboardControl

      XKeyboardState keyboardState;
      XGetKeyboardControl(dpy, &keyboardState);

      XKeyboardControl keyboardValues;
      keyboardValues.key_click_percent = keyboardState.key_click_percent;
      keyboardValues.bell_percent = keyboardState.bell_percent;
      keyboardValues.bell_pitch = keyboardState.bell_pitch;
      keyboardValues.bell_duration = keyboardState.bell_duration;
      keyboardValues.led = 1;
      keyboardValues.led_mode = LedModeOn;
      keyboardValues.key = min_keycodes;
      keyboardValues.auto_repeat_mode = AutoRepeatModeDefault;
      XChangeKeyboardControl(dpy, 
			       KBKeyClickPercent | KBBellPercent | KBBellPitch | KBBellDuration
			     | KBLed | KBLedMode | KBKey | KBAutoRepeatMode,
			     &keyboardValues);

      // Bell

      XBell(dpy, 90);

      // ChangePointerControl
      // GetPointerControl

      int accel_numerator, accel_denominator, threshold;
      XGetPointerControl(dpy, &accel_numerator, &accel_denominator, &threshold);

      XChangePointerControl(dpy, True, True, accel_numerator, accel_denominator, threshold);

      // SetScreenSaver
      // GetScreenSaver

      int timeout, interval, prefer_blanking, allow_exposures;
      XGetScreenSaver(dpy, &timeout, &interval, &prefer_blanking, &allow_exposures);
      XSetScreenSaver(dpy, timeout, interval, prefer_blanking, allow_exposures);

      // ChangeHosts
      // ListHosts

      int nhosts;
      Bool state;
      XHostAddress *hostList = XListHosts(dpy, &nhosts, &state);

      XHostAddress host;
      host.family = FamilyInternet;
      host.length = 4;
      host.address = "\001\002\003\004";
      XAddHost(dpy, &host);

      // SetAccessControl

      XSetAccessControl(dpy, EnableAccess);

      // SetCloseDownMode

      XSetCloseDownMode(dpy, RetainTemporary);

      // KillClient

      XKillClient(dpy, AllTemporary);

      // RotateProperties

      Atom properties[] = { XInternAtom(dpy, "CUT_BUFFER0", False), 
			    XInternAtom(dpy, "CUT_BUFFER1", False),
			    XInternAtom(dpy, "CUT_BUFFER2", False) };
      XRotateWindowProperties(dpy, RootWindowOfScreen(scr), properties, SIZEOF(properties), -1);

      // ForceScreenSaver

      XForceScreenSaver(dpy, ScreenSaverReset);

      // SetPointerMapping
      // GetPointerMapping

      unsigned char map[64];
      int map_length = XGetPointerMapping(dpy, map, 64);
      XSetPointerMapping(dpy, map, map_length);

      // SetModifierMapping
      // GetModifierMapping

      XModifierKeymap *modmap = XGetModifierMapping(dpy);
      XSetModifierMapping(dpy, modmap);

      // NoOperation

      XNoOp(dpy);

      for(;;) {
	    XEvent e;
	    XNextEvent(dpy, &e);
	    std::cout << "Got an event of type " << e.type << std::endl;
      }
}