void getimage(int left, int top, int right, int bottom, void *bitmap)
{
int X;
int Y;
int width;
int height;
bgi_image *bm = (bgi_image*)bitmap;
Pixmap pixmap;
XGCValues op_gcv;
GC op_gc;
X = left + VPorigin.x;
Y = top + VPorigin.y;
width = right - left + 1;
height = bottom - top + 1;
pixmap = XCreatePixmap(dpy, window, width, height,
XDefaultDepth(dpy, DefaultScreen(dpy)));
op_gc = XCreateGC(dpy, drawable, 0, NULL);
XCopyGC(dpy, gc, (GCBackground | GCForeground | GCPlaneMask),
op_gc);
op_gcv.function = GXcopy;
XChangeGC(dpy, op_gc, GCFunction, &op_gcv);
XCopyArea(dpy, drawable, pixmap, op_gc, X, Y, width, height, 0, 0);
bm->width = width;
bm->height = height;
bm->pixmap = pixmap;
XFreeGC(dpy, op_gc);
}
void DrawCharacters(Page *page)
{
size_t start = page->start;
size_t i;
for (i = start; i < page->end; i++) {
short x = character_positions[i].x;
short y = character_positions[i].y;
if (IsPrint(text[i])) {
draw:
;
XChar2b font_code;
XFontStruct *font = SelectFont(text[i], &font_code);
GC gc = XCreateGC(disp, back_buffer, 0, NULL);
XCopyGC(disp, default_gc, GCForeground | GCBackground, gc);
XSetFont(disp, gc, font->fid);
XDrawString16(disp, back_buffer, gc,
x, y + (font->ascent - default_font->ascent), &font_code, 1);
XFreeGC(disp, gc);
} else {
if (EqAscii2b(text[i], '\n')) {
// DOWNWARDS ARROW WITH TIP LEFTWARDS
XChar2b symbol = { .byte1 = 0x21, .byte2 = 0xb2 };
XDrawString16(disp, back_buffer, control_gc,
x, y,
&symbol, 1);
} else if (EqAscii2b(text[i], '\t')) {
;
} else {
goto draw;
}
}
}
/*
* Lookup/cache a GC for the double-size character display. We save up to
* NUM_CHRSET values.
*/
GC
xterm_DoubleGC(unsigned chrset, unsigned flags, GC old_gc)
{
XGCValues gcv;
register TScreen *screen = &term->screen;
unsigned long mask = (GCForeground | GCBackground | GCFont);
int n;
char *name;
XTermFonts *data;
if ((name = xtermSpecialFont(flags, chrset)) == 0)
return 0;
n = xterm_Double_index(chrset, flags);
data = &(screen->double_fonts[n]);
if (data->fn != 0) {
if (!strcmp(data->fn, name)) {
if (data->fs != 0) {
XCopyGC(screen->display, old_gc, ~GCFont, data->gc);
return data->gc;
}
}
discard_font(screen, data);
data->chrset = chrset;
data->flags = flags & BOLD;
}
data->fn = name;
TRACE(("xterm_DoubleGC %s %d: %s\n", flags & BOLD ? "BOLD" : "NORM", n, name));
if ((data->fs = XLoadQueryFont(screen->display, name)) == 0)
return 0;
TRACE(("-> OK\n"));
gcv.graphics_exposures = TRUE; /* default */
gcv.font = data->fs->fid;
gcv.foreground = screen->foreground;
gcv.background = term->core.background_pixel;
data->gc = XCreateGC(screen->display, VWindow(screen), mask, &gcv);
XCopyGC(screen->display, old_gc, ~GCFont, data->gc);
return data->gc;
}
void DrawEOF(Drawable d, int x, int baseline)
{
GC gc = XCreateGC(disp, win, 0, NULL);
XCopyGC(disp, default_gc, GCFont, gc);
XSetForeground(disp, gc, Color.skyblue.pixel);
XSetBackground(disp, gc, WhitePixel(disp, 0));
XDrawImageString(disp, d, gc,
x, baseline,
"[EOF]", 5);
XFreeGC(disp, gc);
}
/** Copy \a pGCSrc to \a pGCDst on the back-end server associated with
* \a pGCSrc's screen. */
void
dmxCopyGC(GCPtr pGCSrc, unsigned long changes, GCPtr pGCDst)
{
ScreenPtr pScreen = pGCSrc->pScreen;
DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];
dmxGCPrivPtr pGCSrcPriv = DMX_GET_GC_PRIV(pGCSrc);
dmxGCPrivPtr pGCDstPriv = DMX_GET_GC_PRIV(pGCDst);
DMX_GC_FUNC_PROLOGUE(pGCDst);
pGCDst->funcs->CopyGC(pGCSrc, changes, pGCDst);
/* Copy the GC on the back-end server */
if (dmxScreen->beDisplay)
XCopyGC(dmxScreen->beDisplay, pGCSrcPriv->gc, changes, pGCDstPriv->gc);
DMX_GC_FUNC_EPILOGUE(pGCDst);
}
/* scrolls a pixmap by x_off/y_off pixels, wrapping around at the edges. */
Pixmap ScrollPixmap(
Display *dpy, Pixmap p, GC gc, int x_off, int y_off, int width,
int height, unsigned int depth)
{
GC tgc;
XGCValues xgcv;
Pixmap p2;
if (p == None || p == ParentRelative || (x_off == 0 && y_off == 0))
{
return p;
}
tgc = fvwmlib_XCreateGC(dpy, p, 0, &xgcv);
if (tgc == None)
{
return p;
}
XCopyGC(dpy, gc, GCFunction | GCPlaneMask| GCSubwindowMode |
GCClipXOrigin | GCClipYOrigin | GCClipMask, tgc);
xgcv.tile = p;
xgcv.ts_x_origin = x_off;
xgcv.ts_y_origin = y_off;
xgcv.fill_style = FillTiled;
XChangeGC(
dpy, tgc, GCTile | GCTileStipXOrigin | GCTileStipYOrigin |
GCFillStyle, &xgcv);
p2 = XCreatePixmap(dpy, p, width, height, depth);
if (p2 == None)
{
return p;
}
XFillRectangle(dpy, p2, tgc, 0, 0, width, height);
XFreeGC(dpy, tgc);
return p2;
}
static int XRotDrawHorizontalString(Display* dpy, XFontStruct* font,
Drawable drawable, GC gc,
int x, int y,
char* text,
int align, int bg)
{
GC my_gc;
int nl=1, i;
int height;
int xp, yp;
char *str1, *str2, *str3;
char *str2_a="\0", *str2_b="\n\0";
int dir, asc, desc;
XCharStruct overall;
DEBUG_PRINT1("**\nHorizontal text.\n");
/* this gc has similar properties to the user's gc (including stipple) */
my_gc=XCreateGC(dpy, drawable, 0, 0);
XCopyGC(dpy, gc,
GCForeground|GCBackground|GCFunction|GCStipple|GCFillStyle|
GCTileStipXOrigin|GCTileStipYOrigin|GCPlaneMask, my_gc);
XSetFont(dpy, my_gc, font->fid);
/* count number of sections in string */
if(align!=NONE)
for(i=0; i<strlen(text)-1; i++)
if(text[i]=='\n')
nl++;
/* ignore newline characters if not doing alignment */
if(align==NONE)
str2=str2_a;
else
str2=str2_b;
/* overall font height */
height=font->ascent+font->descent;
/* y position */
if(align==TLEFT || align==TCENTRE || align==TRIGHT)
yp=y+font->ascent;
else if(align==MLEFT || align==MCENTRE || align==MRIGHT)
yp=y-nl*height/2+font->ascent;
else if(align==BLEFT || align==BCENTRE || align==BRIGHT)
yp=y-nl*height+font->ascent;
else
yp=y;
str1=my_strdup(text);
if(str1==NULL)
return 1;
str3=my_strtok(str1, str2);
/* loop through each section in the string */
do {
XTextExtents(font, str3, strlen(str3), &dir, &asc, &desc,
&overall);
/* where to draw section in x ? */
if(align==TLEFT || align==MLEFT || align==BLEFT || align==NONE)
xp=x;
else if(align==TCENTRE || align==MCENTRE || align==BCENTRE)
xp=x-overall.rbearing/2;
else
xp=x-overall.rbearing;
/* draw string onto bitmap */
if(!bg)
XDrawString(dpy, drawable, my_gc, xp, yp, str3, strlen(str3));
else
XDrawImageString(dpy, drawable, my_gc, xp, yp, str3, strlen(str3));
/* move to next line */
yp+=height;
str3=my_strtok((char *)NULL, str2);
}
while(str3!=NULL);
free(str1);
XFreeGC(dpy, my_gc);
return 0;
}
static int XRotPaintAlignedString(Display* dpy, XFontStruct* font,
float angle, Drawable drawable,
GC gc, int x, int y,
char* text,
int align, int bg)
{
int i;
GC my_gc;
int xp, yp;
float hot_x, hot_y;
float hot_xp, hot_yp;
float sin_angle, cos_angle;
RotatedTextItem *item;
Pixmap bitmap_to_paint;
/* return early for NULL/empty strings */
if(text==NULL)
return 0;
if(strlen(text)==0)
return 0;
/* manipulate angle to 0<=angle<360 degrees */
while(angle<0)
angle+=360;
while(angle>=360)
angle-=360;
angle*=M_PI/180;
/* horizontal text made easy */
if(angle==0. && style.magnify==1.)
return(XRotDrawHorizontalString(dpy, font, drawable, gc, x, y,
text, align, bg));
/* get a rotated bitmap */
item=XRotRetrieveFromCache(dpy, font, angle, text, align);
if(item==NULL)
return 0;
/* this gc has similar properties to the user's gc */
my_gc=XCreateGC(dpy, drawable, 0, 0);
XCopyGC(dpy, gc, GCForeground|GCBackground|GCFunction|GCPlaneMask,
my_gc);
/* alignment : which point (hot_x, hot_y) relative to bitmap centre
coincides with user's specified point? */
/* y position */
if(align==TLEFT || align==TCENTRE || align==TRIGHT)
hot_y=(float)item->rows_in/2*style.magnify;
else if(align==MLEFT || align==MCENTRE || align==MRIGHT)
hot_y=0;
else if(align==BLEFT || align==BCENTRE || align==BRIGHT)
hot_y=-(float)item->rows_in/2*style.magnify;
else
hot_y=-((float)item->rows_in/2-(float)font->descent)*style.magnify;
/* x position */
if(align==TLEFT || align==MLEFT || align==BLEFT || align==NONE)
hot_x=-(float)item->max_width/2*style.magnify;
else if(align==TCENTRE || align==MCENTRE || align==BCENTRE)
hot_x=0;
else
hot_x=(float)item->max_width/2*style.magnify;
/* pre-calculate sin and cos */
sin_angle=sin(angle);
cos_angle=cos(angle);
/* rotate hot_x and hot_y around bitmap centre */
hot_xp= hot_x*cos_angle - hot_y*sin_angle;
hot_yp= hot_x*sin_angle + hot_y*cos_angle;
/* text background will be drawn using XFillPolygon */
if(bg) {
GC depth_one_gc;
XPoint *xpoints;
Pixmap empty_stipple;
/* reserve space for XPoints */
xpoints=(XPoint *)malloc((unsigned)(4*item->nl*sizeof(XPoint)));
if(!xpoints)
return 1;
/* rotate corner positions */
for(i=0; i<4*item->nl; i++) {
xpoints[i].x=(float)x + ( (item->corners_x[i]-hot_x)*cos_angle +
(item->corners_y[i]+hot_y)*sin_angle);
xpoints[i].y=(float)y + (-(item->corners_x[i]-hot_x)*sin_angle +
(item->corners_y[i]+hot_y)*cos_angle);
}
/* we want to swap foreground and background colors here;
XGetGCValues() is only available in R4+ */
empty_stipple=XCreatePixmap(dpy, drawable, 1, 1, 1);
depth_one_gc=XCreateGC(dpy, empty_stipple, 0, 0);
XSetForeground(dpy, depth_one_gc, 0);
XFillRectangle(dpy, empty_stipple, depth_one_gc, 0, 0, 2, 2);
XSetStipple(dpy, my_gc, empty_stipple);
XSetFillStyle(dpy, my_gc, FillOpaqueStippled);
XFillPolygon(dpy, drawable, my_gc, xpoints, 4*item->nl, Nonconvex,
CoordModeOrigin);
/* free our resources */
free((char *)xpoints);
XFreeGC(dpy, depth_one_gc);
XFreePixmap(dpy, empty_stipple);
}
/* where should top left corner of bitmap go ? */
xp=(float)x-((float)item->cols_out/2 +hot_xp);
yp=(float)y-((float)item->rows_out/2 -hot_yp);
/* by default we draw the rotated bitmap, solid */
bitmap_to_paint=item->bitmap;
/* handle user stippling */
#ifndef X11R3
{
GC depth_one_gc;
XGCValues values;
Pixmap new_bitmap, inverse;
/* try and get some GC properties */
if(XGetGCValues(dpy, gc,
GCStipple|GCFillStyle|GCForeground|GCBackground|
GCTileStipXOrigin|GCTileStipYOrigin,
&values)) {
/* only do this if stippling requested */
if((values.fill_style==FillStippled ||
values.fill_style==FillOpaqueStippled) && !bg) {
/* opaque stipple: draw rotated text in background colour */
if(values.fill_style==FillOpaqueStippled) {
XSetForeground(dpy, my_gc, values.background);
XSetFillStyle(dpy, my_gc, FillStippled);
XSetStipple(dpy, my_gc, item->bitmap);
XSetTSOrigin(dpy, my_gc, xp, yp);
XFillRectangle(dpy, drawable, my_gc, xp, yp,
item->cols_out, item->rows_out);
XSetForeground(dpy, my_gc, values.foreground);
}
/* this will merge the rotated text and the user's stipple */
new_bitmap=XCreatePixmap(dpy, drawable,
item->cols_out, item->rows_out, 1);
/* create a GC */
depth_one_gc=XCreateGC(dpy, new_bitmap, 0, 0);
XSetForeground(dpy, depth_one_gc, 1);
XSetBackground(dpy, depth_one_gc, 0);
/* set the relative stipple origin */
XSetTSOrigin(dpy, depth_one_gc,
values.ts_x_origin-xp, values.ts_y_origin-yp);
/* fill the whole bitmap with the user's stipple */
XSetStipple(dpy, depth_one_gc, values.stipple);
XSetFillStyle(dpy, depth_one_gc, FillOpaqueStippled);
XFillRectangle(dpy, new_bitmap, depth_one_gc,
0, 0, item->cols_out, item->rows_out);
/* set stipple origin back to normal */
XSetTSOrigin(dpy, depth_one_gc, 0, 0);
/* this will contain an inverse copy of the rotated text */
inverse=XCreatePixmap(dpy, drawable,
item->cols_out, item->rows_out, 1);
/* invert text */
XSetFillStyle(dpy, depth_one_gc, FillSolid);
XSetFunction(dpy, depth_one_gc, GXcopyInverted);
XCopyArea(dpy, item->bitmap, inverse, depth_one_gc,
0, 0, item->cols_out, item->rows_out, 0, 0);
/* now delete user's stipple everywhere EXCEPT on text */
XSetForeground(dpy, depth_one_gc, 0);
XSetBackground(dpy, depth_one_gc, 1);
XSetStipple(dpy, depth_one_gc, inverse);
XSetFillStyle(dpy, depth_one_gc, FillStippled);
XSetFunction(dpy, depth_one_gc, GXcopy);
XFillRectangle(dpy, new_bitmap, depth_one_gc,
0, 0, item->cols_out, item->rows_out);
/* free resources */
XFreePixmap(dpy, inverse);
XFreeGC(dpy, depth_one_gc);
/* this is the new bitmap */
bitmap_to_paint=new_bitmap;
}
}
}
#endif /*X11R3*/
/* paint text using stipple technique */
XSetFillStyle(dpy, my_gc, FillStippled);
XSetStipple(dpy, my_gc, bitmap_to_paint);
XSetTSOrigin(dpy, my_gc, xp, yp);
XFillRectangle(dpy, drawable, my_gc, xp, yp,
item->cols_out, item->rows_out);
/* free our resources */
XFreeGC(dpy, my_gc);
/* stippled bitmap no longer needed */
if(bitmap_to_paint!=item->bitmap)
XFreePixmap(dpy, bitmap_to_paint);
#ifdef CACHE_XIMAGES
XFreePixmap(dpy, item->bitmap);
#endif /*CACHE_XIMAGES*/
/* if item isn't cached, destroy it completely */
if(!item->cached)
XRotFreeTextItem(dpy,item);
/* we got to the end OK! */
return 0;
}
/*
* Vytvoøit a namapovat top-level okno, vytvoøit dal¹í zdroje (napø. GC)
*/
static void create_resources(int argc, char *argv[])
{
XWMHints *wm_hints; /* Doporuèení pro window manager */
XSizeHints *size_hints; /* Doporuèená velikost okna */
XClassHint *class_hint; /* Jméno a tøída pro resource manager */
XTextProperty window_name, icon_name; /* Jména pro window manager */
XGCValues gc_values; /* Hodnoty pro nastavení GC */
char *str_window_name = (char *)"Hello Window"; /* Titulek okna */
char *str_icon_name = (char *)"Hello Icon"; /* Titulek ikony */
XSetWindowAttributes set_attr;
/* Vytvoøit top-level okno */
topwin_x = topwin_y = 0; /* Okno umístí window manager */
topwin_w = screen_width / 2;
topwin_h = screen_height / 2;
topwin_b = 0;
set_attr.bit_gravity = bit_gravity;
set_attr.background_pixel = white;
topwin = XCreateWindow(display, root, topwin_x, topwin_y, topwin_w,
topwin_h, topwin_b, CopyFromParent, InputOutput,
CopyFromParent,
CWBitGravity | CWBackPixel,
&set_attr);
debug("Created top-level window ID %#lx\n", topwin);
/* Vytvoøit ikonu pro top-level okno */
topwin_icon = XCreateBitmapFromData(display, topwin, Xlib_icon_bits,
Xlib_icon_width, Xlib_icon_height);
debug("Created icon %#lx for top-level window\n", topwin_icon);
/* Nastavit properties pro window manager */
if(!(size_hints = XAllocSizeHints()) ||
!(wm_hints = XAllocWMHints()) ||
!(class_hint = XAllocClassHint())) {
fprintf(stderr, "Cannot allocate memory\n");
exit(1);
}
/* Poloha a velikost se bere ze skuteèných hodnot okna v oka¾iku
* namapování. PPosition | PSize øíká, ¾e hodnoty nastavil program (a
* window manager je mù¾e mìnit podle potøeby). USSize | USPosition by
* znamenalo, ¾e hodnoty zadal u¾ivatel (napø. na pøíkazové øádce) a
* window manager by je nemìl mìnit. */
size_hints->flags = PPosition | PSize | PMinSize;
/* Window manager by nemìl okno nikdy zmen¹it na ménì ne¾
* min_width x min_height pixelù. */
size_hints->min_width = 200;
size_hints->min_height = 100;
wm_hints->initial_state = NormalState;/* Na zaèátku má být zobrazeno
normální okno (ne ikona) */
wm_hints->input = True; /* Aplikace potøebuje vstup z klávesnice */
wm_hints->icon_pixmap = topwin_icon;
wm_hints->flags = StateHint | InputHint | IconPixmapHint;
/* Ulo¾ení jména okna a ikony */
if(!XStringListToTextProperty(&str_window_name, 1, &window_name) ||
!XStringListToTextProperty(&str_icon_name, 1, &icon_name)) {
fprintf(stderr, "XStringListToTextProperty() for failed\n");
exit(1);
}
/* Jméno programu a tøídy pro hledání v resource databázi */
class_hint->res_name = progname;
class_hint->res_class = (char *) "HelloWorld";
/* Nastavit v¹echny properties */
XSetWMProperties(display, topwin, &window_name, &icon_name, argv, argc,
size_hints, wm_hints, class_hint);
/* Vybrat události pro top-level okno */
XSelectInput(display, topwin, ExposureMask | KeyPressMask |
ButtonPressMask | StructureNotifyMask);
/* Vytvoøit synovské okno */
win1 = XCreateSimpleWindow(display, topwin, (int)topwin_w / 3,
(int)topwin_h / 3, topwin_w / 3, topwin_h / 3,
5, black, white);
set_attr.win_gravity = win_gravity;
XChangeWindowAttributes(display, win1, CWWinGravity, &set_attr);
/* Vytvoøit GC */
gc_values.background = white;
gc_values.foreground = black;
my_gc = XCreateGC(display, topwin, GCBackground | GCForeground, &gc_values);
XCopyGC(display, def_gc, GCFont, my_gc); /* default font */
/* Namapovat okna */
XMapWindow(display, win1);
XMapWindow(display, topwin);
}
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;
}
}
Bool
apc_gp_get_region( Handle self, Handle rgn)
{
DEFXX;
GC gc;
XGCValues gcv;
int w, h;
Pixmap pixmap;
XImage * i;
Image pi;
Region rgn2;
if ( !XF_IN_PAINT(XX)) return false;
if ( !rgn)
return XX-> clip_mask_extent. x != 0 && XX-> clip_mask_extent. y != 0;
if ( XX-> clip_mask_extent. x == 0 || XX-> clip_mask_extent. y == 0)
return false;
w = XX-> clip_mask_extent. x;
h = XX-> clip_mask_extent. y;
pixmap = XCreatePixmap( DISP, guts.root, w, h,
XF_LAYERED(XX) ? guts. argb_depth :
( XT_IS_BITMAP(XX) ? 1 : guts. depth )
);
XCHECKPOINT;
gcv. graphics_exposures = false;
gcv. fill_style = FillSolid;
gcv. foreground = 0;
gcv. clip_y_origin = -XX-> clip_rect. y + XX-> btransform. y;
gcv. clip_x_origin = -XX-> clip_rect. x - XX-> btransform. x;
XCHECKPOINT;
gc = XCreateGC( DISP, pixmap, GCGraphicsExposures|GCFillStyle|GCForeground|GCClipXOrigin|GCClipYOrigin, &gcv);
XFillRectangle( DISP, pixmap, gc, 0, 0, w, h);
XSetForeground( DISP, gc, 1 );
XCopyGC( DISP, XX->gc, GCClipMask, gc);
XFillRectangle( DISP, pixmap, gc, 0, 0, w, h);
XFreeGC( DISP, gc);
XCHECKPOINT;
i = XGetImage( DISP, pixmap, 0, 0, w, h, 1, XYPixmap);
XFreePixmap( DISP, pixmap);
if ( !i ) {
warn("Cannot query image");
return false;
}
img_fill_dummy( &pi, w, h, imBW | imGrayScale, NULL, NULL);
if ( !( pi.data = malloc(pi.lineSize * h))) {
XDestroyImage( i);
warn("Not enough memory");
return false;
}
prima_copy_xybitmap( pi.data, (Byte*)i-> data, w, h, pi.lineSize, i-> bytes_per_line);
XDestroyImage( i);
rgn2 = prima_region_create((Handle) &pi);
free(pi.data);
if ( GET_REGION(rgn)-> region )
XDestroyRegion( GET_REGION(rgn)-> region );
if ( rgn2 ) {
XOffsetRegion( rgn2, XX-> clip_rect.x, 0);
GET_REGION(rgn)-> height = XX-> size.y - XX-> clip_rect.y;
GET_REGION(rgn)-> region = rgn2;
} else {
GET_REGION(rgn)-> height = 0;
GET_REGION(rgn)-> region = XCreateRegion();
}
return true;
}
void
xnestCopyGC(GCPtr pGCSrc, unsigned long mask, GCPtr pGCDst)
{
XCopyGC(xnestDisplay, xnestGC(pGCSrc), mask, xnestGC(pGCDst));
}
