363 lines
12 KiB
C
363 lines
12 KiB
C
#include "xlib.h"
|
|
|
|
unsigned long Attribs_To_XSetWindowAttributes(s48_value attribs,
|
|
XSetWindowAttributes* Xattrs) {
|
|
int i; unsigned long mask = 0;
|
|
for (i=0; i<15; i++) {
|
|
s48_value value = S48_VECTOR_REF(attribs, i);
|
|
if (S48_FALSE != value) {
|
|
switch (i) {
|
|
case 0: Xattrs->background_pixmap =
|
|
S48_SYMBOL_P(value) ? ParentRelative : SCX_EXTRACT_PIXMAP(value);
|
|
mask |= CWBackPixmap;
|
|
break;
|
|
case 1: Xattrs->background_pixel = s48_extract_integer(value);
|
|
mask |= CWBackPixel;
|
|
break;
|
|
case 2: Xattrs->border_pixmap =
|
|
S48_SYMBOL_P(value) ? CopyFromParent : s48_extract_integer(value);
|
|
mask |= CWBorderPixmap;
|
|
break;
|
|
case 3: Xattrs->border_pixel = s48_extract_integer(value);
|
|
mask |= CWBitGravity;
|
|
break;
|
|
case 4: Xattrs->bit_gravity = Symbol_To_Bit(value, Bit_Grav_Syms);
|
|
mask |= CWBitGravity;
|
|
break;
|
|
case 5: Xattrs->win_gravity = Symbol_To_Bit(value, Grav_Syms);
|
|
mask |= CWWinGravity;
|
|
break;
|
|
case 6: Xattrs->backing_store = Symbol_To_Bit(value, Backing_Store_Syms);
|
|
mask |= CWBackingStore;
|
|
break;
|
|
case 7: Xattrs->backing_planes = s48_extract_integer(value);
|
|
mask |= CWBackingPlanes;
|
|
break;
|
|
case 8: Xattrs->backing_pixel = s48_extract_integer(value);
|
|
mask |= CWBackingPixel;
|
|
break;
|
|
case 9: Xattrs->override_redirect = s48_extract_integer(value);
|
|
mask |= CWOverrideRedirect;
|
|
break;
|
|
case 10: Xattrs->save_under = s48_extract_integer(value);
|
|
mask |= CWSaveUnder;
|
|
break;
|
|
case 11: Xattrs->event_mask = Symbols_To_Bits(value, Event_Mask_Syms);
|
|
mask |= CWEventMask;
|
|
break;
|
|
case 12: Xattrs->do_not_propagate_mask =
|
|
Symbols_To_Bits(value, Event_Mask_Syms);
|
|
mask |= CWDontPropagate;
|
|
break;
|
|
case 13: Xattrs->colormap = s48_extract_integer(value);
|
|
mask |= CWColormap;
|
|
break;
|
|
case 14: Xattrs->cursor = s48_extract_integer(value);
|
|
mask |= CWCursor;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return mask;
|
|
}
|
|
|
|
s48_value scx_Create_Window (s48_value Xdisplay, s48_value Xparent,
|
|
s48_value x, s48_value y,
|
|
s48_value width, s48_value height,
|
|
s48_value border_width, s48_value depth,
|
|
s48_value class, s48_value Xvisual,
|
|
s48_value attribs) {
|
|
Window win;
|
|
XSetWindowAttributes Xattrs;
|
|
unsigned long mask = Attribs_To_XSetWindowAttributes( attribs, &Xattrs );
|
|
int dep = S48_FALSE_P(depth) ? CopyFromParent : s48_extract_integer(depth);
|
|
int cla = 0;
|
|
Visual* vis = S48_FALSE_P(Xvisual) ? CopyFromParent :
|
|
SCX_EXTRACT_VISUAL(Xvisual);
|
|
|
|
switch (s48_extract_integer(class)) {
|
|
case 0: cla = InputOutput;
|
|
case 1: cla = InputOnly;
|
|
case 2: cla = CopyFromParent;
|
|
}
|
|
|
|
win = XCreateWindow( SCX_EXTRACT_DISPLAY(Xdisplay),
|
|
SCX_EXTRACT_WINDOW(Xparent),
|
|
(int)s48_extract_integer(x),
|
|
(int)s48_extract_integer(y),
|
|
(int)s48_extract_integer (width),
|
|
(int)s48_extract_integer (height),
|
|
(int)s48_extract_integer (border_width),
|
|
dep, cla, vis,
|
|
mask,&Xattrs );
|
|
return SCX_ENTER_WINDOW(win);
|
|
}
|
|
|
|
s48_value scx_Destroy_Window (s48_value Xdisplay, s48_value Xwindow) {
|
|
XDestroyWindow (SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_WINDOW(Xwindow));
|
|
return S48_UNSPECIFIC;
|
|
}
|
|
|
|
s48_value scx_Change_Window_Attributes(s48_value Xwindow, s48_value Xdisplay,
|
|
s48_value attribs) {
|
|
|
|
XSetWindowAttributes Xattrs;
|
|
unsigned long mask = Attribs_To_XSetWindowAttributes( attribs, &Xattrs );
|
|
|
|
XChangeWindowAttributes(SCX_EXTRACT_DISPLAY(Xdisplay),
|
|
SCX_EXTRACT_WINDOW(Xwindow),
|
|
mask, &Xattrs);
|
|
|
|
return S48_UNSPECIFIC;
|
|
}
|
|
|
|
|
|
s48_value scx_Get_Window_Attributes(s48_value Xdisplay, s48_value Xwindow) {
|
|
XWindowAttributes WA;
|
|
|
|
S48_DECLARE_GC_PROTECT(1);
|
|
|
|
s48_value res = S48_NULL;
|
|
|
|
if (!XGetWindowAttributes(SCX_EXTRACT_DISPLAY(Xdisplay),SCX_EXTRACT_WINDOW(Xwindow),
|
|
&WA))
|
|
res = S48_FALSE;
|
|
else {
|
|
S48_GC_PROTECT_1(res);
|
|
|
|
res = s48_make_vector(23, S48_FALSE);
|
|
|
|
S48_VECTOR_SET(res, 0, s48_enter_integer(WA.x));
|
|
S48_VECTOR_SET(res, 1, s48_enter_integer(WA.y));
|
|
S48_VECTOR_SET(res, 2, s48_enter_integer(WA.width));
|
|
S48_VECTOR_SET(res, 3, s48_enter_integer(WA.height));
|
|
S48_VECTOR_SET(res, 4, s48_enter_integer(WA.border_width));
|
|
S48_VECTOR_SET(res, 5, s48_enter_integer(WA.depth));
|
|
S48_VECTOR_SET(res, 6, SCX_ENTER_VISUAL(WA.visual));
|
|
S48_VECTOR_SET(res, 7, SCX_ENTER_WINDOW(WA.root));
|
|
S48_VECTOR_SET(res, 8, Bit_To_Symbol(WA.class, Class_Syms));
|
|
S48_VECTOR_SET(res, 9, Bit_To_Symbol(WA.bit_gravity, Bit_Grav_Syms));
|
|
S48_VECTOR_SET(res, 10, Bit_To_Symbol(WA.win_gravity, Grav_Syms));
|
|
S48_VECTOR_SET(res, 11, Bit_To_Symbol(WA.backing_store,
|
|
Backing_Store_Syms));
|
|
S48_VECTOR_SET(res, 12, s48_enter_integer(WA.backing_planes));
|
|
S48_VECTOR_SET(res, 13, SCX_ENTER_PIXEL(WA.backing_pixel));
|
|
S48_VECTOR_SET(res, 14, WA.save_under ? S48_TRUE : S48_FALSE );
|
|
S48_VECTOR_SET(res, 15, SCX_ENTER_COLORMAP( WA.colormap ));
|
|
S48_VECTOR_SET(res, 16, WA.map_installed ? S48_TRUE : S48_FALSE);
|
|
S48_VECTOR_SET(res, 17, Bit_To_Symbol( WA.map_state, Map_State_Syms));
|
|
S48_VECTOR_SET(res, 18, Bits_To_Symbols( WA.all_event_masks,
|
|
Event_Mask_Syms ));
|
|
S48_VECTOR_SET(res, 19, Bits_To_Symbols( WA.your_event_mask,
|
|
Event_Mask_Syms ));
|
|
S48_VECTOR_SET(res, 20, Bits_To_Symbols( WA.do_not_propagate_mask,
|
|
Event_Mask_Syms ));
|
|
S48_VECTOR_SET(res, 21, WA.override_redirect ? S48_TRUE : S48_FALSE);
|
|
|
|
S48_VECTOR_SET(res, 22, S48_FALSE);
|
|
//S48_VECTOR_SET(res, 22, s48_enter_integer((long)WA.screen));
|
|
// WA.screen not yet supported
|
|
}
|
|
|
|
S48_GC_UNPROTECT();
|
|
return res;
|
|
}
|
|
|
|
s48_value Changes_To_XWindowChanges(s48_value changes, XWindowChanges* WC) {
|
|
int i; unsigned long mask = 0;
|
|
for (i=0; i<7; i++) {
|
|
s48_value value = S48_VECTOR_REF(changes, i);
|
|
if (S48_FALSE != value) {
|
|
switch (i) {
|
|
case 0: WC->x = s48_extract_integer(value);
|
|
mask |= CWX;
|
|
break;
|
|
case 2: WC->y = s48_extract_integer(value);
|
|
mask |= CWY;
|
|
break;
|
|
case 3: WC->width = s48_extract_integer(value);
|
|
mask |= CWWidth;
|
|
break;
|
|
case 4: WC->height = s48_extract_integer(value);
|
|
mask |= CWHeight;
|
|
break;
|
|
case 5: WC->sibling = SCX_EXTRACT_WINDOW(value);
|
|
mask |= CWSibling;
|
|
break;
|
|
case 6: WC->stack_mode = Symbol_To_Bit(value, Stack_Mode_Syms);
|
|
mask |= CWStackMode;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return mask;
|
|
}
|
|
|
|
s48_value scx_Configure_Window (s48_value Xwindow, s48_value Xdisplay,
|
|
s48_value changes) {
|
|
XWindowChanges WC;
|
|
unsigned long mask = Changes_To_XWindowChanges(changes, &WC);
|
|
|
|
XConfigureWindow (SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_WINDOW(Xwindow),
|
|
mask, &WC);
|
|
return S48_UNSPECIFIC;
|
|
}
|
|
|
|
s48_value scx_Map_Window(s48_value Xwindow, s48_value Xdisplay) {
|
|
XMapWindow(SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_WINDOW(Xwindow));
|
|
return S48_UNSPECIFIC;
|
|
}
|
|
|
|
s48_value scx_Unmap_Window(s48_value Xwindow, s48_value Xdisplay) {
|
|
XUnmapWindow(SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_WINDOW(Xwindow));
|
|
return S48_UNSPECIFIC;
|
|
}
|
|
|
|
s48_value scx_Destroy_Subwindows (s48_value Xwindow, s48_value Xdisplay) {
|
|
XDestroySubwindows(SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_WINDOW(Xwindow));
|
|
return S48_UNSPECIFIC;
|
|
}
|
|
|
|
s48_value scx_Map_Subwindows (s48_value Xwindow, s48_value Xdisplay) {
|
|
XMapSubwindows(SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_WINDOW(Xwindow));
|
|
return S48_UNSPECIFIC;
|
|
}
|
|
|
|
s48_value scx_Unmap_Subwindows (s48_value Xwindow, s48_value Xdisplay) {
|
|
XUnmapSubwindows(SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_WINDOW(Xwindow));
|
|
return S48_UNSPECIFIC;
|
|
}
|
|
|
|
s48_value scx_Circulate_Subwindows(s48_value Xwindow, s48_value Xdisplay,
|
|
s48_value dir) {
|
|
XCirculateSubwindows(SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_WINDOW(Xwindow),
|
|
S48_FALSE_P(dir) ? RaiseLowest : LowerHighest);
|
|
return S48_UNSPECIFIC;
|
|
}
|
|
|
|
s48_value scx_Query_Tree (s48_value Xwindow, s48_value Xdisplay) {
|
|
Window root, parent, *children;
|
|
int i;
|
|
unsigned n;
|
|
|
|
s48_value v = S48_FALSE, ret = S48_FALSE;
|
|
S48_DECLARE_GC_PROTECT(2);
|
|
|
|
XQueryTree (SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_WINDOW(Xwindow),
|
|
&root, &parent, &children, &n);
|
|
|
|
ret = s48_make_vector(3, S48_FALSE);
|
|
v = S48_FALSE;
|
|
|
|
S48_GC_PROTECT_2 (v, ret);
|
|
|
|
// vector of child-windows
|
|
v = s48_make_vector (n, S48_FALSE);
|
|
for (i = 0; i < n; i++) {
|
|
S48_VECTOR_SET(v, i, SCX_ENTER_WINDOW(children[i]));
|
|
}
|
|
|
|
S48_VECTOR_SET(ret, 0, SCX_ENTER_WINDOW(root));
|
|
S48_VECTOR_SET(ret, 1, SCX_ENTER_WINDOW(parent));
|
|
S48_VECTOR_SET(ret, 2, v);
|
|
|
|
S48_GC_UNPROTECT();
|
|
return ret;
|
|
}
|
|
|
|
s48_value scx_Translate_Coordinates (s48_value Xdisplay, s48_value srcXwindow,
|
|
s48_value x, s48_value y,
|
|
s48_value dstXwindow) {
|
|
int rx, ry;
|
|
Window child;
|
|
s48_value v = S48_FALSE;
|
|
|
|
S48_DECLARE_GC_PROTECT(1);
|
|
|
|
if (!XTranslateCoordinates (SCX_EXTRACT_DISPLAY(Xdisplay),
|
|
SCX_EXTRACT_WINDOW(srcXwindow),
|
|
SCX_EXTRACT_WINDOW(dstXwindow),
|
|
(int)s48_extract_integer (x),
|
|
(int)s48_extract_integer (y),
|
|
&rx, &ry, &child))
|
|
return S48_FALSE;
|
|
|
|
S48_GC_PROTECT_1 (v);
|
|
|
|
v = s48_make_vector(3, S48_FALSE);
|
|
S48_VECTOR_SET(v, 0, s48_enter_integer(rx));
|
|
S48_VECTOR_SET(v, 1, s48_enter_integer(ry));
|
|
S48_VECTOR_SET(v, 2, SCX_ENTER_WINDOW(child));
|
|
|
|
S48_GC_UNPROTECT();
|
|
return v;
|
|
}
|
|
|
|
s48_value scx_Query_Pointer (s48_value Xdisplay, s48_value Xwindow) {
|
|
|
|
s48_value v = S48_FALSE;
|
|
Bool ret;
|
|
Window root, child;
|
|
int r_x, r_y, x, y;
|
|
unsigned int mask;
|
|
S48_DECLARE_GC_PROTECT(1);
|
|
|
|
ret = XQueryPointer (SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_WINDOW(Xwindow),
|
|
&root, &child, &r_x, &r_y, &x, &y, &mask);
|
|
|
|
v = s48_make_vector(8, S48_FALSE);
|
|
S48_GC_PROTECT_1(v);
|
|
|
|
S48_VECTOR_SET(v, 0, s48_enter_integer(x));
|
|
S48_VECTOR_SET(v, 1, s48_enter_integer(y));
|
|
S48_VECTOR_SET(v, 2, ret ? S48_TRUE : S48_FALSE);
|
|
S48_VECTOR_SET(v, 3, SCX_ENTER_WINDOW(root));
|
|
S48_VECTOR_SET(v, 4, s48_enter_integer(r_x));
|
|
S48_VECTOR_SET(v, 5, s48_enter_integer(r_y));
|
|
S48_VECTOR_SET(v, 6, SCX_ENTER_WINDOW(child));
|
|
S48_VECTOR_SET(v, 7, Bits_To_Symbols ((unsigned long)mask, State_Syms));
|
|
|
|
S48_GC_UNPROTECT();
|
|
return v;
|
|
}
|
|
|
|
s48_value scx_Get_Geometry(s48_value Xdisplay, s48_value Xdrawable) {
|
|
s48_value v = S48_FALSE;
|
|
Window root;
|
|
unsigned int x,y,width,height,border_width,depth;
|
|
S48_DECLARE_GC_PROTECT(1);
|
|
|
|
XGetGeometry(SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_DRAWABLE(Xdrawable),
|
|
&root, &x, &y, &width, &height, &border_width, &depth);
|
|
|
|
v = s48_make_vector(7, S48_FALSE);
|
|
S48_GC_PROTECT_1(v);
|
|
S48_VECTOR_SET(v, 0, SCX_ENTER_WINDOW(root));
|
|
S48_VECTOR_SET(v, 1, s48_enter_integer(x));
|
|
S48_VECTOR_SET(v, 2, s48_enter_integer(y));
|
|
S48_VECTOR_SET(v, 3, s48_enter_integer(width));
|
|
S48_VECTOR_SET(v, 4, s48_enter_integer(height));
|
|
S48_VECTOR_SET(v, 5, s48_enter_integer(border_width));
|
|
S48_VECTOR_SET(v, 6, s48_enter_integer(depth));
|
|
S48_GC_UNPROTECT();
|
|
return v;
|
|
}
|
|
|
|
void scx_init_window(void) {
|
|
S48_EXPORT_FUNCTION(scx_Create_Window);
|
|
S48_EXPORT_FUNCTION(scx_Destroy_Window);
|
|
S48_EXPORT_FUNCTION(scx_Change_Window_Attributes);
|
|
S48_EXPORT_FUNCTION(scx_Get_Window_Attributes);
|
|
S48_EXPORT_FUNCTION(scx_Configure_Window);
|
|
S48_EXPORT_FUNCTION(scx_Map_Window);
|
|
S48_EXPORT_FUNCTION(scx_Unmap_Window);
|
|
S48_EXPORT_FUNCTION(scx_Destroy_Subwindows);
|
|
S48_EXPORT_FUNCTION(scx_Map_Subwindows);
|
|
S48_EXPORT_FUNCTION(scx_Unmap_Subwindows);
|
|
S48_EXPORT_FUNCTION(scx_Circulate_Subwindows);
|
|
S48_EXPORT_FUNCTION(scx_Query_Tree);
|
|
S48_EXPORT_FUNCTION(scx_Translate_Coordinates);
|
|
S48_EXPORT_FUNCTION(scx_Query_Pointer);
|
|
S48_EXPORT_FUNCTION(scx_Get_Geometry);
|
|
}
|