scsh-conservatory
/
scx
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Added suffix "scx_" to all functions and macros. Added initialization 

for all GC_PROTECTed variables.
This commit is contained in:
frese 2001-07-31 14:51:21 +00:00
parent 6fffd9346a
commit 193a14a544
19 changed files with 680 additions and 661 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
c/xlib/Makefile
View File

@ -1,4 +1,4 @@
OBJECTS = main.o display.o window.o type.o color.o colormap.o pixel.o gcontext.o event.o pixmap.o graphics.o font.o OBJECTS = main.o display.o window.o type.o color.o colormap.o pixel.o gcontext.o event.o pixmap.o graphics.o font.o cursor.o text.o property.o wm.o
$(OBJECTS): xlib.h $(OBJECTS): xlib.h
.c.o: .c.o:

56
c/xlib/color.c
View File

@ -1,7 +1,7 @@
#include "xlib.h" #include "xlib.h"
#include "scheme48.h" #include "scheme48.h"
s48_value Create_Color(s48_value r, s48_value g, s48_value b) { s48_value scx_Create_Color(s48_value r, s48_value g, s48_value b) {
s48_value col = S48_MAKE_VALUE(XColor); s48_value col = S48_MAKE_VALUE(XColor);
XColor* c = S48_EXTRACT_VALUE_POINTER(col, XColor); XColor* c = S48_EXTRACT_VALUE_POINTER(col, XColor);
c->red = s48_extract_integer(r); c->red = s48_extract_integer(r);
@ -11,7 +11,7 @@ s48_value Create_Color(s48_value r, s48_value g, s48_value b) {
return col; return col;
} }
s48_value Int_Extract_RGB_Values(XColor col) { s48_value scx_Int_Extract_RGB_Values(XColor col) {
s48_value res = S48_NULL; s48_value res = S48_NULL;
S48_DECLARE_GC_PROTECT(1); S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res); S48_GC_PROTECT_1(res);
@ -24,24 +24,26 @@ s48_value Int_Extract_RGB_Values(XColor col) {
return res; return res;
} }
s48_value Extract_RGB_Values(s48_value Xcolor) { s48_value scx_Extract_RGB_Values(s48_value Xcolor) {
return Int_Extract_RGB_Values(*EXTRACT_COLOR(Xcolor)); return scx_Int_Extract_RGB_Values(*SCX_EXTRACT_COLOR(Xcolor));
} }
s48_value Query_Color (s48_value Xcolormap, s48_value Xpixel, s48_value scx_Query_Color (s48_value Xcolormap, s48_value Xpixel,
s48_value Xdisplay) { s48_value Xdisplay) {
XColor c; XColor c;
c.pixel = EXTRACT_PIXEL(Xpixel); c.pixel = SCX_EXTRACT_PIXEL(Xpixel);
XQueryColor(EXTRACT_DISPLAY(Xdisplay), EXTRACT_COLORMAP(Xcolormap), &c); XQueryColor(SCX_EXTRACT_DISPLAY(Xdisplay),
SCX_EXTRACT_COLORMAP(Xcolormap),
&c);
return Int_Extract_RGB_Values(c); return scx_Int_Extract_RGB_Values(c);
} }
s48_value Query_Colors(s48_value Xcolormap, s48_value Xpixels, s48_value scx_Query_Colors(s48_value Xcolormap, s48_value Xpixels,
s48_value Xdisplay) { s48_value Xdisplay) {
s48_value result; s48_value result = S48_FALSE;
S48_DECLARE_GC_PROTECT(1); S48_DECLARE_GC_PROTECT(1);
long n = S48_VECTOR_LENGTH(Xpixels); long n = S48_VECTOR_LENGTH(Xpixels);
@ -49,41 +51,43 @@ s48_value Query_Colors(s48_value Xcolormap, s48_value Xpixels,
int i; int i;
for (i=0; i < n; i++) for (i=0; i < n; i++)
p[i].pixel = EXTRACT_PIXEL(S48_VECTOR_REF(Xpixels, i)); p[i].pixel = SCX_EXTRACT_PIXEL(S48_VECTOR_REF(Xpixels, i));
XQueryColors( EXTRACT_DISPLAY(Xdisplay), EXTRACT_COLORMAP(Xcolormap), p, n ); XQueryColors( SCX_EXTRACT_DISPLAY(Xdisplay),
SCX_EXTRACT_COLORMAP(Xcolormap), p, n );
S48_GC_PROTECT_1(result); S48_GC_PROTECT_1(result);
result = s48_make_vector(n, S48_FALSE); result = s48_make_vector(n, S48_FALSE);
for (i=0; i < n; i++) for (i=0; i < n; i++)
S48_VECTOR_SET(result, i, Int_Extract_RGB_Values(p[i])); S48_VECTOR_SET(result, i, scx_Int_Extract_RGB_Values(p[i]));
S48_GC_UNPROTECT(); S48_GC_UNPROTECT();
return result; return result;
} }
s48_value Lookup_Color(s48_value Xcolormap, s48_value Xdisplay, s48_value scx_Lookup_Color(s48_value Xcolormap, s48_value Xdisplay,
s48_value color_name) { s48_value color_name) {
XColor visual, exact; XColor visual, exact;
s48_value res = S48_FALSE; s48_value res = S48_FALSE;
S48_DECLARE_GC_PROTECT(1); S48_DECLARE_GC_PROTECT(1);
if (XLookupColor( EXTRACT_DISPLAY(Xdisplay), EXTRACT_COLORMAP(Xcolormap), if (XLookupColor( SCX_EXTRACT_DISPLAY(Xdisplay),
SCX_EXTRACT_COLORMAP(Xcolormap),
s48_extract_string(color_name), &visual, &exact )) { s48_extract_string(color_name), &visual, &exact )) {
S48_GC_PROTECT_1(res); S48_GC_PROTECT_1(res);
res = s48_cons( Int_Extract_RGB_Values( visual ), res = s48_cons( scx_Int_Extract_RGB_Values( visual ),
Int_Extract_RGB_Values( exact ) ); scx_Int_Extract_RGB_Values( exact ) );
} }
S48_GC_UNPROTECT(); S48_GC_UNPROTECT();
return res; return res;
} }
void s48_init_color(void) { void scx_init_color(void) {
S48_EXPORT_FUNCTION(Create_Color); S48_EXPORT_FUNCTION(scx_Create_Color);
S48_EXPORT_FUNCTION(Extract_RGB_Values); S48_EXPORT_FUNCTION(scx_Extract_RGB_Values);
S48_EXPORT_FUNCTION(Query_Color); S48_EXPORT_FUNCTION(scx_Query_Color);
S48_EXPORT_FUNCTION(Query_Colors); S48_EXPORT_FUNCTION(scx_Query_Colors);
S48_EXPORT_FUNCTION(Lookup_Color); S48_EXPORT_FUNCTION(scx_Lookup_Color);
} }

42
c/xlib/colormap.c
View File

@ -1,39 +1,41 @@
#include "xlib.h" #include "xlib.h"
#include "scheme48.h" #include "scheme48.h"
s48_value Free_Colormap (s48_value Xcolormap, s48_value Xdisplay) { s48_value scx_Free_Colormap (s48_value Xcolormap, s48_value Xdisplay) {
XFreeColormap(EXTRACT_DISPLAY(Xdisplay), EXTRACT_COLORMAP(Xcolormap)); XFreeColormap(SCX_EXTRACT_DISPLAY(Xdisplay),
SCX_EXTRACT_COLORMAP(Xcolormap));
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Alloc_Color(s48_value Xcolormap, s48_value Xcolor, s48_value scx_Alloc_Color(s48_value Xcolormap, s48_value Xcolor,
s48_value Xdisplay) { s48_value Xdisplay) {
XColor* cp = EXTRACT_COLOR(Xcolor); XColor* cp = SCX_EXTRACT_COLOR(Xcolor);
if (!XAllocColor(EXTRACT_DISPLAY(Xdisplay), EXTRACT_COLORMAP(Xcolormap), cp)) if (!XAllocColor(SCX_EXTRACT_DISPLAY(Xdisplay),
SCX_EXTRACT_COLORMAP(Xcolormap), cp))
return S48_FALSE; return S48_FALSE;
else else
return ENTER_PIXEL(cp->pixel); return SCX_ENTER_PIXEL(cp->pixel);
} }
s48_value Alloc_Named_Color(s48_value Xcolormap, s48_value color_name, s48_value scx_Alloc_Named_Color(s48_value Xcolormap, s48_value color_name,
s48_value Xdisplay) { s48_value Xdisplay) {
XColor screen, exact; XColor screen, exact;
int r; int r;
s48_value ret; s48_value ret = S48_FALSE;
S48_DECLARE_GC_PROTECT(1); S48_DECLARE_GC_PROTECT(1);
r = XAllocNamedColor (EXTRACT_DISPLAY(Xdisplay), EXTRACT_COLORMAP(Xcolormap), r = XAllocNamedColor (SCX_EXTRACT_DISPLAY(Xdisplay),
SCX_EXTRACT_COLORMAP(Xcolormap),
s48_extract_string(color_name), s48_extract_string(color_name),
&screen, &exact); &screen, &exact);
if (!r) ret = S48_FALSE; if (r) {
else {
S48_GC_PROTECT_1(ret); S48_GC_PROTECT_1(ret);
ret = s48_cons(Int_Extract_RGB_Values(exact), S48_NULL); ret = s48_cons(scx_Int_Extract_RGB_Values(exact), S48_NULL);
ret = s48_cons(Int_Extract_RGB_Values(screen), ret); ret = s48_cons(scx_Int_Extract_RGB_Values(screen), ret);
ret = s48_cons(ENTER_PIXEL(screen.pixel), ret); ret = s48_cons(SCX_ENTER_PIXEL(screen.pixel), ret);
} }
S48_GC_UNPROTECT(); S48_GC_UNPROTECT();
@ -41,8 +43,8 @@ s48_value Alloc_Named_Color(s48_value Xcolormap, s48_value color_name,
} }
void s48_init_colormap(void) { void scx_init_colormap(void) {
S48_EXPORT_FUNCTION(Free_Colormap); S48_EXPORT_FUNCTION(scx_Free_Colormap);
S48_EXPORT_FUNCTION(Alloc_Color); S48_EXPORT_FUNCTION(scx_Alloc_Color);
S48_EXPORT_FUNCTION(Alloc_Named_Color); S48_EXPORT_FUNCTION(scx_Alloc_Named_Color);
} }

54
c/xlib/cursor.c
View File

@ -1,52 +1,52 @@
#include "xlib.h" #include "xlib.h"
#include "scheme48.h" #include "scheme48.h"
s48_value Free_Cursor(s48_value Xdisplay, s48_value Xcursor) { s48_value scx_Free_Cursor(s48_value Xdisplay, s48_value Xcursor) {
XFreeCursor(EXTRACT_DISPLAY(Xdisplay), XFreeCursor(SCX_EXTRACT_DISPLAY(Xdisplay),
EXTRACT_CURSOR(Xcursor)); SCX_EXTRACT_CURSOR(Xcursor));
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Create_Pixmap_Cursor(s48_value Xdisplay, s48_value scx_Create_Pixmap_Cursor(s48_value Xdisplay,
s48_value src, s48_value mask, s48_value x, s48_value src, s48_value mask, s48_value x,
s48_value y, s48_value foreground, s48_value y, s48_value foreground,
s48_value background) { s48_value background) {
Cursor xc = XCreatePixmapCursor(EXTRACT_DISPLAY(Xdisplay), Cursor xc = XCreatePixmapCursor(SCX_EXTRACT_DISPLAY(Xdisplay),
EXTRACT_PIXMAP(src), SCX_EXTRACT_PIXMAP(src),
EXTRACT_PIXMAP(mask), SCX_EXTRACT_PIXMAP(mask),
EXTRACT_COLOR(foreground), SCX_EXTRACT_COLOR(foreground),
EXTRACT_COLOR(background), SCX_EXTRACT_COLOR(background),
s48_extract_integer(x), s48_extract_integer(x),
s48_extract_integer(y)); s48_extract_integer(y));
return ENTER_CURSOR(xc); return SCX_ENTER_CURSOR(xc);
} }
s48_value Create_Glyph_Cursor(s48_value Xdisplay, s48_value scx_Create_Glyph_Cursor(s48_value Xdisplay,
s48_value src, s48_value srcc, s48_value src, s48_value srcc,
s48_value mask, s48_value maskc, s48_value mask, s48_value maskc,
s48_value foreground, s48_value background) { s48_value foreground, s48_value background) {
Cursor xc = XCreateGlyphCursor(EXTRACT_DISPLAY(Xdisplay), Cursor xc = XCreateGlyphCursor(SCX_EXTRACT_DISPLAY(Xdisplay),
EXTRACT_FONT(src), SCX_EXTRACT_FONT(src),
EXTRACT_FONT(mask), SCX_EXTRACT_FONT(mask),
s48_extract_integer(srcc), s48_extract_integer(srcc),
s48_extract_integer(maskc), s48_extract_integer(maskc),
EXTRACT_COLOR(foreground), SCX_EXTRACT_COLOR(foreground),
EXTRACT_COLOR(background)); SCX_EXTRACT_COLOR(background));
return ENTER_CURSOR(xc); return SCX_ENTER_CURSOR(xc);
} }
s48_value Recolor_Cursor(s48_value Xdisplay, s48_value Xcursor, s48_value scx_Recolor_Cursor(s48_value Xdisplay, s48_value Xcursor,
s48_value f, s48_value b) { s48_value f, s48_value b) {
XRecolorCursor(EXTRACT_DISPLAY(Xdisplay), XRecolorCursor(SCX_EXTRACT_DISPLAY(Xdisplay),
EXTRACT_CURSOR(Xcursor), SCX_EXTRACT_CURSOR(Xcursor),
EXTRACT_COLOR(f), SCX_EXTRACT_COLOR(f),
EXTRACT_COLOR(b)); SCX_EXTRACT_COLOR(b));
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_init_cursor() { void scx_init_cursor(void) {
S48_EXPORT_FUNCTION(Free_Cursor); S48_EXPORT_FUNCTION(scx_Free_Cursor);
S48_EXPORT_FUNCTION(Create_Pixmap_Cursor); S48_EXPORT_FUNCTION(scx_Create_Pixmap_Cursor);
S48_EXPORT_FUNCTION(Create_Glyph_Cursor); S48_EXPORT_FUNCTION(scx_Create_Glyph_Cursor);
S48_EXPORT_FUNCTION(Recolor_Cursor); S48_EXPORT_FUNCTION(scx_Recolor_Cursor);
} }

192
c/xlib/display.c
View File

@ -3,25 +3,24 @@
#include <sys/time.h> #include <sys/time.h>
// Open_Display(name) name should be a string or S48_FALSE (=> Null) // Open_Display(name) name should be a string or S48_FALSE (=> Null)
s48_value Open_Display (s48_value name) { s48_value scx_Open_Display (s48_value name) {
char* cname = (char*)0; char* cname = (char*)0;
if (!S48_FALSE_P(name)) if (!S48_FALSE_P(name))
cname = s48_extract_string(name); cname = s48_extract_string(name);
return ENTER_DISPLAY(XOpenDisplay(cname)); return SCX_ENTER_DISPLAY(XOpenDisplay(cname));
} }
// Close_Display( Xdisplay ) Xdisplay should be a pointer to the X-lib struct // Close_Display( Xdisplay ) Xdisplay should be a pointer to the X-lib struct
// cast into a Scheme-Integer. // cast into a Scheme-Integer.
s48_value Close_Display(s48_value Xdisplay) { s48_value scx_Close_Display(s48_value Xdisplay) {
XCloseDisplay(EXTRACT_DISPLAY(Xdisplay)); XCloseDisplay(SCX_EXTRACT_DISPLAY(Xdisplay));
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
// This funktion selects the fd field of the Display-struct. One shouldn't do // This function returns the file destriptor of the message-channel.
// that usually, but we need it. s48_value scx_Display_Message_fd(s48_value Xdisplay) {
s48_value Display_Message_fd(s48_value Xdisplay) { int fd = ConnectionNumber(SCX_EXTRACT_DISPLAY(Xdisplay));
int fd = ConnectionNumber(EXTRACT_DISPLAY(Xdisplay));
/* struct timeval timeout; /* struct timeval timeout;
fd_set fdset; fd_set fdset;
@ -40,142 +39,141 @@ s48_value Display_Message_fd(s48_value Xdisplay) {
// The following procedure mainly wrap a corresponding XLib macro without // The following procedure mainly wrap a corresponding XLib macro without
// underscores... // underscores...
s48_value Display_Default_Root_Window(s48_value Xdisplay) { s48_value scx_Display_Default_Root_Window(s48_value Xdisplay) {
Window wnd = DefaultRootWindow(EXTRACT_DISPLAY(Xdisplay)); Window wnd = DefaultRootWindow(SCX_EXTRACT_DISPLAY(Xdisplay));
return ENTER_WINDOW(wnd); return SCX_ENTER_WINDOW(wnd);
} }
s48_value Display_Default_Colormap(s48_value Xdisplay) { s48_value scx_Display_Default_Colormap(s48_value Xdisplay) {
Display* dpy = EXTRACT_DISPLAY(Xdisplay); Display* dpy = SCX_EXTRACT_DISPLAY(Xdisplay);
Colormap cmp = DefaultColormap(dpy, DefaultScreen(dpy)); Colormap cmp = DefaultColormap(dpy, DefaultScreen(dpy));
return ENTER_COLORMAP(cmp); return SCX_ENTER_COLORMAP(cmp);
} }
s48_value Display_Default_Gcontext(s48_value Xdisplay) { s48_value scx_Display_Default_Gcontext(s48_value Xdisplay) {
Display* dpy = EXTRACT_DISPLAY(Xdisplay); Display* dpy = SCX_EXTRACT_DISPLAY(Xdisplay);
GC gc = DefaultGC(dpy, DefaultScreen(dpy)); GC gc = DefaultGC(dpy, DefaultScreen(dpy));
return ENTER_GCONTEXT(gc); return SCX_ENTER_GCONTEXT(gc);
} }
s48_value Display_Default_Depth(s48_value Xdisplay) { s48_value scx_Display_Default_Depth(s48_value Xdisplay) {
Display* dpy = EXTRACT_DISPLAY(Xdisplay); Display* dpy = SCX_EXTRACT_DISPLAY(Xdisplay);
int depth = DefaultDepth(dpy, DefaultScreen(dpy)); int depth = DefaultDepth(dpy, DefaultScreen(dpy));
return s48_enter_integer(depth); return s48_enter_integer(depth);
} }
s48_value Display_Default_Screen_Number(s48_value Xdisplay) { s48_value scx_Display_Default_Screen_Number(s48_value Xdisplay) {
return s48_enter_integer(DefaultScreen(EXTRACT_DISPLAY(Xdisplay))); return s48_enter_integer(DefaultScreen(SCX_EXTRACT_DISPLAY(Xdisplay)));
} }
s48_value Display_Cells(s48_value Xdisplay, s48_value ScrNum) { s48_value scx_Display_Cells(s48_value Xdisplay, s48_value ScrNum) {
int num = (int)s48_extract_integer(ScrNum); int num = (int)s48_extract_integer(ScrNum);
return s48_enter_integer(DisplayCells(EXTRACT_DISPLAY(Xdisplay), num)); return s48_enter_integer(DisplayCells(SCX_EXTRACT_DISPLAY(Xdisplay), num));
} }
s48_value Display_Planes(s48_value Xdisplay, s48_value ScrNum) { s48_value scx_Display_Planes(s48_value Xdisplay, s48_value ScrNum) {
int num = (int)s48_extract_integer(ScrNum); int num = (int)s48_extract_integer(ScrNum);
return s48_enter_integer(DisplayPlanes(EXTRACT_DISPLAY(Xdisplay), num)); return s48_enter_integer(DisplayPlanes(SCX_EXTRACT_DISPLAY(Xdisplay), num));
} }
s48_value Display_String(s48_value Xdisplay) { s48_value scx_Display_String(s48_value Xdisplay) {
char* s = DisplayString(EXTRACT_DISPLAY(Xdisplay)); char* s = DisplayString(SCX_EXTRACT_DISPLAY(Xdisplay));
return s48_enter_string(s); return s48_enter_string(s);
} }
s48_value Display_Vendor(s48_value Xdisplay) { s48_value scx_Display_Vendor(s48_value Xdisplay) {
Display* dpy = EXTRACT_DISPLAY(Xdisplay); Display* dpy = SCX_EXTRACT_DISPLAY(Xdisplay);
char* s = ServerVendor(dpy); char* s = ServerVendor(dpy);
int i = VendorRelease(dpy); int i = VendorRelease(dpy);
return s48_cons( s48_enter_string(s), return s48_cons( s48_enter_string(s),
s48_enter_integer(i) ); s48_enter_integer(i) );
} }
s48_value Display_Protocol_Version(s48_value Xdisplay) { s48_value scx_Display_Protocol_Version(s48_value Xdisplay) {
Display* dpy = EXTRACT_DISPLAY(Xdisplay); Display* dpy = SCX_EXTRACT_DISPLAY(Xdisplay);
int maj = ProtocolVersion(dpy); int maj = ProtocolVersion(dpy);
int min = ProtocolRevision(dpy); int min = ProtocolRevision(dpy);
return s48_cons( s48_enter_integer(maj), return s48_cons( s48_enter_integer(maj),
s48_enter_integer(min) ); s48_enter_integer(min) );
} }
s48_value Display_Screen_Count(s48_value Xdisplay) { s48_value scx_Display_Screen_Count(s48_value Xdisplay) {
int cnt = ScreenCount(EXTRACT_DISPLAY(Xdisplay)); int cnt = ScreenCount(SCX_EXTRACT_DISPLAY(Xdisplay));
return s48_enter_integer(cnt); return s48_enter_integer(cnt);
} }
s48_value Display_Image_Byte_Order(s48_value Xdisplay) { s48_value scx_Display_Image_Byte_Order(s48_value Xdisplay) {
Display* dpy = EXTRACT_DISPLAY(Xdisplay); Display* dpy = SCX_EXTRACT_DISPLAY(Xdisplay);
return Bits_To_Symbols( (unsigned long)ImageByteOrder(dpy), return Bits_To_Symbols( (unsigned long)ImageByteOrder(dpy),
Byte_Order_Syms ); Byte_Order_Syms );
} }
s48_value Display_Bitmap_Unit(s48_value Xdisplay) { s48_value scx_Display_Bitmap_Unit(s48_value Xdisplay) {
int bu = BitmapUnit(EXTRACT_DISPLAY(Xdisplay)); int bu = BitmapUnit(SCX_EXTRACT_DISPLAY(Xdisplay));
return s48_enter_integer(bu); return s48_enter_integer(bu);
} }
s48_value Display_Bitmap_Bit_Order(s48_value Xdisplay) { s48_value scx_Display_Bitmap_Bit_Order(s48_value Xdisplay) {
Display* dpy = EXTRACT_DISPLAY(Xdisplay); Display* dpy = SCX_EXTRACT_DISPLAY(Xdisplay);
return Bits_To_Symbols( (unsigned long)BitmapBitOrder(dpy), return Bits_To_Symbols( (unsigned long)BitmapBitOrder(dpy),
Byte_Order_Syms ); Byte_Order_Syms );
} }
s48_value Display_Bitmap_Pad(s48_value Xdisplay) { s48_value scx_Display_Bitmap_Pad(s48_value Xdisplay) {
int bp = BitmapPad(EXTRACT_DISPLAY(Xdisplay)); int bp = BitmapPad(SCX_EXTRACT_DISPLAY(Xdisplay));
return s48_enter_integer(bp); return s48_enter_integer(bp);
} }
s48_value Display_Width(s48_value Xdisplay) { s48_value scx_Display_Width(s48_value Xdisplay) {
Display* dpy = EXTRACT_DISPLAY(Xdisplay); Display* dpy = SCX_EXTRACT_DISPLAY(Xdisplay);
return s48_enter_integer(DisplayWidth(dpy, DefaultScreen(dpy))); return s48_enter_integer(DisplayWidth(dpy, DefaultScreen(dpy)));
} }
s48_value Display_Height(s48_value Xdisplay) { s48_value scx_Display_Height(s48_value Xdisplay) {
Display* dpy = EXTRACT_DISPLAY(Xdisplay); Display* dpy = SCX_EXTRACT_DISPLAY(Xdisplay);
return s48_enter_integer(DisplayHeight(dpy, DefaultScreen(dpy))); return s48_enter_integer(DisplayHeight(dpy, DefaultScreen(dpy)));
} }
s48_value Display_Width_Mm (s48_value Xdisplay) { s48_value scx_Display_Width_Mm (s48_value Xdisplay) {
Display* dpy = EXTRACT_DISPLAY(Xdisplay); Display* dpy = SCX_EXTRACT_DISPLAY(Xdisplay);
return s48_enter_integer(DisplayWidthMM(dpy, DefaultScreen(dpy))); return s48_enter_integer(DisplayWidthMM(dpy, DefaultScreen(dpy)));
} }
s48_value Display_Height_Mm (s48_value Xdisplay) { s48_value scx_Display_Height_Mm (s48_value Xdisplay) {
Display* dpy = EXTRACT_DISPLAY(Xdisplay); Display* dpy = SCX_EXTRACT_DISPLAY(Xdisplay);
return s48_enter_integer(DisplayHeightMM(dpy, DefaultScreen(dpy))); return s48_enter_integer(DisplayHeightMM(dpy, DefaultScreen(dpy)));
} }
s48_value Display_Motion_Buffer_Size(s48_value Xdisplay) { s48_value scx_Display_Motion_Buffer_Size(s48_value Xdisplay) {
int mbs = XDisplayMotionBufferSize(EXTRACT_DISPLAY(Xdisplay)); int mbs = XDisplayMotionBufferSize(SCX_EXTRACT_DISPLAY(Xdisplay));
return s48_enter_integer(mbs); return s48_enter_integer(mbs);
} }
s48_value Display_Flush_Output (s48_value Xdisplay) { s48_value scx_Display_Flush_Output (s48_value Xdisplay) {
XFlush (EXTRACT_DISPLAY(Xdisplay)); XFlush (SCX_EXTRACT_DISPLAY(Xdisplay));
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Display_Wait_Output (s48_value Xdisplay, s48_value discard) { s48_value scx_Display_Wait_Output (s48_value Xdisplay, s48_value discard) {
XSync (EXTRACT_DISPLAY(Xdisplay), !S48_FALSE_P(discard)); XSync (SCX_EXTRACT_DISPLAY(Xdisplay), !S48_FALSE_P(discard));
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value No_Op (s48_value Xdisplay) { s48_value scx_No_Op (s48_value Xdisplay) {
XNoOp(EXTRACT_DISPLAY(Xdisplay)); XNoOp(SCX_EXTRACT_DISPLAY(Xdisplay));
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value List_Depths (s48_value Xdisplay, s48_value scr) { s48_value scx_List_Depths (s48_value Xdisplay, s48_value scr) {
int i, num; int i, num;
int* p; int* p;
s48_value ret; s48_value ret = S48_FALSE;
S48_DECLARE_GC_PROTECT(1); S48_DECLARE_GC_PROTECT(1);
p = XListDepths(EXTRACT_DISPLAY(Xdisplay), s48_extract_integer(scr), &num); p = XListDepths(SCX_EXTRACT_DISPLAY(Xdisplay),
if (!p) s48_extract_integer(scr), &num);
ret = S48_FALSE; if (p) {
else {
S48_GC_PROTECT_1(ret); S48_GC_PROTECT_1(ret);
ret = s48_make_vector(num, S48_NULL); ret = s48_make_vector(num, S48_NULL);
for (i = 0; i < num; i++) for (i = 0; i < num; i++)
@ -187,17 +185,15 @@ s48_value List_Depths (s48_value Xdisplay, s48_value scr) {
return ret; return ret;
} }
s48_value List_Pixmap_Formats (s48_value Xdisplay) { s48_value scx_List_Pixmap_Formats (s48_value Xdisplay) {
int num, i; int num, i;
XPixmapFormatValues* p; XPixmapFormatValues* p;
s48_value ret, t; s48_value ret = S48_FALSE, t = S48_FALSE;
S48_DECLARE_GC_PROTECT(2); S48_DECLARE_GC_PROTECT(2);
p = XListPixmapFormats(EXTRACT_DISPLAY(Xdisplay), &num); p = XListPixmapFormats(SCX_EXTRACT_DISPLAY(Xdisplay), &num);
if (!p) if (p) {
ret = S48_FALSE;
else {
S48_GC_PROTECT_2(ret, t); S48_GC_PROTECT_2(ret, t);
ret = s48_make_vector (num, S48_FALSE); ret = s48_make_vector (num, S48_FALSE);
for (i = 0; i < num; i++) { for (i = 0; i < num; i++) {
@ -214,33 +210,33 @@ s48_value List_Pixmap_Formats (s48_value Xdisplay) {
return ret; return ret;
} }
void s48_init_display(void) { void scx_init_display(void) {
S48_EXPORT_FUNCTION(Open_Display); S48_EXPORT_FUNCTION(scx_Open_Display);
S48_EXPORT_FUNCTION(Close_Display); S48_EXPORT_FUNCTION(scx_Close_Display);
S48_EXPORT_FUNCTION(Display_Message_fd); S48_EXPORT_FUNCTION(scx_Display_Message_fd);
S48_EXPORT_FUNCTION(Display_Default_Root_Window); S48_EXPORT_FUNCTION(scx_Display_Default_Root_Window);
S48_EXPORT_FUNCTION(Display_Default_Colormap); S48_EXPORT_FUNCTION(scx_Display_Default_Colormap);
S48_EXPORT_FUNCTION(Display_Default_Gcontext); S48_EXPORT_FUNCTION(scx_Display_Default_Gcontext);
S48_EXPORT_FUNCTION(Display_Default_Depth); S48_EXPORT_FUNCTION(scx_Display_Default_Depth);
S48_EXPORT_FUNCTION(Display_Default_Screen_Number); S48_EXPORT_FUNCTION(scx_Display_Default_Screen_Number);
S48_EXPORT_FUNCTION(Display_Cells); S48_EXPORT_FUNCTION(scx_Display_Cells);
S48_EXPORT_FUNCTION(Display_Planes); S48_EXPORT_FUNCTION(scx_Display_Planes);
S48_EXPORT_FUNCTION(Display_String); S48_EXPORT_FUNCTION(scx_Display_String);
S48_EXPORT_FUNCTION(Display_Vendor); S48_EXPORT_FUNCTION(scx_Display_Vendor);
S48_EXPORT_FUNCTION(Display_Protocol_Version); S48_EXPORT_FUNCTION(scx_Display_Protocol_Version);
S48_EXPORT_FUNCTION(Display_Screen_Count); S48_EXPORT_FUNCTION(scx_Display_Screen_Count);
S48_EXPORT_FUNCTION(Display_Image_Byte_Order); S48_EXPORT_FUNCTION(scx_Display_Image_Byte_Order);
S48_EXPORT_FUNCTION(Display_Bitmap_Unit); S48_EXPORT_FUNCTION(scx_Display_Bitmap_Unit);
S48_EXPORT_FUNCTION(Display_Bitmap_Bit_Order); S48_EXPORT_FUNCTION(scx_Display_Bitmap_Bit_Order);
S48_EXPORT_FUNCTION(Display_Bitmap_Pad); S48_EXPORT_FUNCTION(scx_Display_Bitmap_Pad);
S48_EXPORT_FUNCTION(Display_Width); S48_EXPORT_FUNCTION(scx_Display_Width);
S48_EXPORT_FUNCTION(Display_Height); S48_EXPORT_FUNCTION(scx_Display_Height);
S48_EXPORT_FUNCTION(Display_Width_Mm); S48_EXPORT_FUNCTION(scx_Display_Width_Mm);
S48_EXPORT_FUNCTION(Display_Height_Mm); S48_EXPORT_FUNCTION(scx_Display_Height_Mm);
S48_EXPORT_FUNCTION(Display_Motion_Buffer_Size); S48_EXPORT_FUNCTION(scx_Display_Motion_Buffer_Size);
S48_EXPORT_FUNCTION(Display_Flush_Output); S48_EXPORT_FUNCTION(scx_Display_Flush_Output);
S48_EXPORT_FUNCTION(Display_Wait_Output); S48_EXPORT_FUNCTION(scx_Display_Wait_Output);
S48_EXPORT_FUNCTION(No_Op); S48_EXPORT_FUNCTION(scx_No_Op);
S48_EXPORT_FUNCTION(List_Depths); S48_EXPORT_FUNCTION(scx_List_Depths);
S48_EXPORT_FUNCTION(List_Pixmap_Formats); S48_EXPORT_FUNCTION(scx_List_Pixmap_Formats);
} }

112
c/xlib/event.c
View File

@ -6,7 +6,7 @@
#define SET(i, v) S48_VECTOR_SET(r, i, v) #define SET(i, v) S48_VECTOR_SET(r, i, v)
#define SETSIZE(i) r = s48_make_vector(sidx+i, S48_FALSE) #define SETSIZE(i) r = s48_make_vector(sidx+i, S48_FALSE)
s48_value enter_event(XEvent* e) { s48_value scx_enter_event(XEvent* e) {
s48_value r = S48_FALSE; s48_value r = S48_FALSE;
s48_value temp = S48_FALSE; s48_value temp = S48_FALSE;
int i; int i;
@ -21,9 +21,9 @@ s48_value enter_event(XEvent* e) {
ECAST(q, XKeyEvent); ECAST(q, XKeyEvent);
SETSIZE(10); SETSIZE(10);
// all equal in the beginning // all equal in the beginning
SET(sidx+0, ENTER_WINDOW(q->root)); SET(sidx+0, SCX_ENTER_WINDOW(q->root));
SET(sidx+1, ENTER_WINDOW(q->subwindow)); SET(sidx+1, SCX_ENTER_WINDOW(q->subwindow));
SET(sidx+2, ENTER_TIME(q->time)); SET(sidx+2, SCX_ENTER_TIME(q->time));
SET(sidx+3, s48_enter_integer(q->x)); SET(sidx+3, s48_enter_integer(q->x));
SET(sidx+4, s48_enter_integer(q->y)); SET(sidx+4, s48_enter_integer(q->y));
SET(sidx+5, s48_enter_integer(q->x_root)); SET(sidx+5, s48_enter_integer(q->x_root));
@ -51,9 +51,9 @@ s48_value enter_event(XEvent* e) {
case EnterNotify : case LeaveNotify : { case EnterNotify : case LeaveNotify : {
ECAST(q, XCrossingEvent); ECAST(q, XCrossingEvent);
SETSIZE(12); SETSIZE(12);
SET(sidx+0, ENTER_WINDOW(q->root)); SET(sidx+0, SCX_ENTER_WINDOW(q->root));
SET(sidx+1, ENTER_WINDOW(q->subwindow)); SET(sidx+1, SCX_ENTER_WINDOW(q->subwindow));
SET(sidx+2, ENTER_TIME(q->time)); SET(sidx+2, SCX_ENTER_TIME(q->time));
SET(sidx+3, s48_enter_integer(q->x)); SET(sidx+3, s48_enter_integer(q->x));
SET(sidx+4, s48_enter_integer(q->y)); SET(sidx+4, s48_enter_integer(q->y));
SET(sidx+5, s48_enter_integer(q->x_root)); SET(sidx+5, s48_enter_integer(q->x_root));
@ -121,7 +121,7 @@ s48_value enter_event(XEvent* e) {
case CreateNotify : { case CreateNotify : {
ECAST(q, XCreateWindowEvent); ECAST(q, XCreateWindowEvent);
SETSIZE(7); SETSIZE(7);
SET(sidx+0, ENTER_WINDOW(q->window)); SET(sidx+0, SCX_ENTER_WINDOW(q->window));
SET(sidx+1, s48_enter_integer(q->x)); SET(sidx+1, s48_enter_integer(q->x));
SET(sidx+2, s48_enter_integer(q->y)); SET(sidx+2, s48_enter_integer(q->y));
SET(sidx+3, s48_enter_integer(q->width)); SET(sidx+3, s48_enter_integer(q->width));
@ -133,34 +133,34 @@ s48_value enter_event(XEvent* e) {
case DestroyNotify : { case DestroyNotify : {
ECAST(q, XDestroyWindowEvent); ECAST(q, XDestroyWindowEvent);
SETSIZE(1); SETSIZE(1);
SET(sidx+0, ENTER_WINDOW(q->window)); SET(sidx+0, SCX_ENTER_WINDOW(q->window));
} break; } break;
case UnmapNotify : { case UnmapNotify : {
ECAST(q, XUnmapEvent); ECAST(q, XUnmapEvent);
SETSIZE(2); SETSIZE(2);
SET(sidx+0, ENTER_WINDOW(q->window)); SET(sidx+0, SCX_ENTER_WINDOW(q->window));
SET(sidx+1, S48_ENTER_BOOLEAN(q->from_configure)); SET(sidx+1, S48_ENTER_BOOLEAN(q->from_configure));
} break; } break;
case MapNotify : { case MapNotify : {
ECAST(q, XMapEvent); ECAST(q, XMapEvent);
SETSIZE(2); SETSIZE(2);
SET(sidx+0, ENTER_WINDOW(q->window)); SET(sidx+0, SCX_ENTER_WINDOW(q->window));
SET(sidx+1, S48_ENTER_BOOLEAN(q->override_redirect)); SET(sidx+1, S48_ENTER_BOOLEAN(q->override_redirect));
} break; } break;
case MapRequest : { case MapRequest : {
ECAST(q, XMapRequestEvent); ECAST(q, XMapRequestEvent);
SETSIZE(1); SETSIZE(1);
SET(sidx+0, ENTER_WINDOW(q->window)); SET(sidx+0, SCX_ENTER_WINDOW(q->window));
} break; } break;
case ReparentNotify : { case ReparentNotify : {
ECAST(q, XReparentEvent); ECAST(q, XReparentEvent);
SETSIZE(5); SETSIZE(5);
SET(sidx+0, ENTER_WINDOW(q->window)); SET(sidx+0, SCX_ENTER_WINDOW(q->window));
SET(sidx+1, ENTER_WINDOW(q->parent)); SET(sidx+1, SCX_ENTER_WINDOW(q->parent));
SET(sidx+2, s48_enter_integer(q->x)); SET(sidx+2, s48_enter_integer(q->x));
SET(sidx+3, s48_enter_integer(q->y)); SET(sidx+3, s48_enter_integer(q->y));
SET(sidx+4, S48_ENTER_BOOLEAN(q->override_redirect)); SET(sidx+4, S48_ENTER_BOOLEAN(q->override_redirect));
@ -169,26 +169,26 @@ s48_value enter_event(XEvent* e) {
case ConfigureNotify : { case ConfigureNotify : {
ECAST(q, XConfigureEvent); ECAST(q, XConfigureEvent);
SETSIZE(8); SETSIZE(8);
SET(sidx+0, ENTER_WINDOW(q->window)); SET(sidx+0, SCX_ENTER_WINDOW(q->window));
SET(sidx+1, s48_enter_integer(q->x)); SET(sidx+1, s48_enter_integer(q->x));
SET(sidx+2, s48_enter_integer(q->y)); SET(sidx+2, s48_enter_integer(q->y));
SET(sidx+3, s48_enter_integer(q->width)); SET(sidx+3, s48_enter_integer(q->width));
SET(sidx+4, s48_enter_integer(q->height)); SET(sidx+4, s48_enter_integer(q->height));
SET(sidx+5, s48_enter_integer(q->border_width)); SET(sidx+5, s48_enter_integer(q->border_width));
SET(sidx+6, ENTER_WINDOW(q->above)); SET(sidx+6, SCX_ENTER_WINDOW(q->above));
SET(sidx+7, S48_ENTER_BOOLEAN(q->override_redirect)); SET(sidx+7, S48_ENTER_BOOLEAN(q->override_redirect));
} break; } break;
case ConfigureRequest : { case ConfigureRequest : {
ECAST(q, XConfigureRequestEvent); ECAST(q, XConfigureRequestEvent);
SETSIZE(9); SETSIZE(9);
SET(sidx+0, ENTER_WINDOW(q->window)); SET(sidx+0, SCX_ENTER_WINDOW(q->window));
SET(sidx+1, s48_enter_integer(q->x)); SET(sidx+1, s48_enter_integer(q->x));
SET(sidx+2, s48_enter_integer(q->y)); SET(sidx+2, s48_enter_integer(q->y));
SET(sidx+3, s48_enter_integer(q->width)); SET(sidx+3, s48_enter_integer(q->width));
SET(sidx+4, s48_enter_integer(q->height)); SET(sidx+4, s48_enter_integer(q->height));
SET(sidx+5, s48_enter_integer(q->border_width)); SET(sidx+5, s48_enter_integer(q->border_width));
SET(sidx+6, ENTER_WINDOW(q->above)); SET(sidx+6, SCX_ENTER_WINDOW(q->above));
SET(sidx+7, Bit_To_Symbol(q->detail, Stack_Mode_Syms)); SET(sidx+7, Bit_To_Symbol(q->detail, Stack_Mode_Syms));
SET(sidx+8, s48_enter_integer(q->value_mask)); SET(sidx+8, s48_enter_integer(q->value_mask));
} break; } break;
@ -196,7 +196,7 @@ s48_value enter_event(XEvent* e) {
case GravityNotify : { case GravityNotify : {
ECAST(q, XGravityEvent); ECAST(q, XGravityEvent);
SETSIZE(3); SETSIZE(3);
SET(sidx+0, ENTER_WINDOW(q->window)); SET(sidx+0, SCX_ENTER_WINDOW(q->window));
SET(sidx+1, s48_enter_integer(q->x)); SET(sidx+1, s48_enter_integer(q->x));
SET(sidx+2, s48_enter_integer(q->y)); SET(sidx+2, s48_enter_integer(q->y));
} break; } break;
@ -211,48 +211,48 @@ s48_value enter_event(XEvent* e) {
case CirculateRequest : { case CirculateRequest : {
ECAST(q, XCirculateEvent); ECAST(q, XCirculateEvent);
SETSIZE(2); SETSIZE(2);
SET(sidx+0, ENTER_WINDOW(q->window)); SET(sidx+0, SCX_ENTER_WINDOW(q->window));
SET(sidx+1, Bit_To_Symbol(q->place, Place_Syms)); SET(sidx+1, Bit_To_Symbol(q->place, Place_Syms));
} break; } break;
case PropertyNotify : { case PropertyNotify : {
ECAST(q, XPropertyEvent); ECAST(q, XPropertyEvent);
SETSIZE(3); SETSIZE(3);
SET(sidx+0, ENTER_ATOM(q->atom)); SET(sidx+0, SCX_ENTER_ATOM(q->atom));
SET(sidx+1, ENTER_TIME(q->time)); SET(sidx+1, SCX_ENTER_TIME(q->time));
SET(sidx+2, Bit_To_Symbol(q->state, Prop_Syms)); SET(sidx+2, Bit_To_Symbol(q->state, Prop_Syms));
} break; } break;
case SelectionClear : { case SelectionClear : {
ECAST(q, XSelectionClearEvent); ECAST(q, XSelectionClearEvent);
SETSIZE(2); SETSIZE(2);
SET(sidx+0, ENTER_ATOM(q->selection)); SET(sidx+0, SCX_ENTER_ATOM(q->selection));
SET(sidx+1, ENTER_TIME(q->time)); SET(sidx+1, SCX_ENTER_TIME(q->time));
} break; } break;
case SelectionRequest : { case SelectionRequest : {
ECAST(q, XSelectionRequestEvent); ECAST(q, XSelectionRequestEvent);
SETSIZE(5); SETSIZE(5);
SET(sidx+0, ENTER_WINDOW(q->requestor)); SET(sidx+0, SCX_ENTER_WINDOW(q->requestor));
SET(sidx+1, ENTER_ATOM(q->selection)); SET(sidx+1, SCX_ENTER_ATOM(q->selection));
SET(sidx+2, ENTER_ATOM(q->target)); SET(sidx+2, SCX_ENTER_ATOM(q->target));
SET(sidx+3, ENTER_ATOM(q->property)); SET(sidx+3, SCX_ENTER_ATOM(q->property));
SET(sidx+4, ENTER_TIME(q->time)); SET(sidx+4, SCX_ENTER_TIME(q->time));
} break; } break;
case SelectionNotify : { case SelectionNotify : {
ECAST(q, XSelectionEvent); ECAST(q, XSelectionEvent);
SETSIZE(4); SETSIZE(4);
SET(sidx+0, ENTER_ATOM(q->selection)); SET(sidx+0, SCX_ENTER_ATOM(q->selection));
SET(sidx+1, ENTER_ATOM(q->target)); SET(sidx+1, SCX_ENTER_ATOM(q->target));
SET(sidx+2, ENTER_ATOM(q->property)); SET(sidx+2, SCX_ENTER_ATOM(q->property));
SET(sidx+3, ENTER_TIME(q->time)); SET(sidx+3, SCX_ENTER_TIME(q->time));
} break; } break;
case ColormapNotify : { case ColormapNotify : {
ECAST(q, XColormapEvent); ECAST(q, XColormapEvent);
SETSIZE(3); SETSIZE(3);
SET(sidx+0, ENTER_COLORMAP(q->colormap)); SET(sidx+0, SCX_ENTER_COLORMAP(q->colormap));
SET(sidx+1, S48_ENTER_BOOLEAN(q->new)); SET(sidx+1, S48_ENTER_BOOLEAN(q->new));
SET(sidx+2, q->state == ColormapInstalled ? S48_TRUE : S48_FALSE); SET(sidx+2, q->state == ColormapInstalled ? S48_TRUE : S48_FALSE);
} break; } break;
@ -260,7 +260,7 @@ s48_value enter_event(XEvent* e) {
case ClientMessage : { case ClientMessage : {
ECAST(q, XClientMessageEvent); ECAST(q, XClientMessageEvent);
SETSIZE(2); SETSIZE(2);
SET(sidx+0, ENTER_ATOM(q->message_type)); SET(sidx+0, SCX_ENTER_ATOM(q->message_type));
switch (q->format) { switch (q->format) {
case 8 : { case 8 : {
temp = s48_make_string(20, (char)0); temp = s48_make_string(20, (char)0);
@ -298,8 +298,8 @@ s48_value enter_event(XEvent* e) {
ECAST(q, XAnyEvent); ECAST(q, XAnyEvent);
SET(0, s48_enter_integer(q->serial)); SET(0, s48_enter_integer(q->serial));
SET(1, S48_ENTER_BOOLEAN(q->send_event)); SET(1, S48_ENTER_BOOLEAN(q->send_event));
SET(2, ENTER_DISPLAY(q->display)); SET(2, SCX_ENTER_DISPLAY(q->display));
SET(3, ENTER_WINDOW(q->window)); SET(3, SCX_ENTER_WINDOW(q->window));
} }
// more?? // more??
@ -310,36 +310,36 @@ s48_value enter_event(XEvent* e) {
return r; return r;
} }
s48_value Next_Event(s48_value Xdisplay) { s48_value scx_Next_Event(s48_value Xdisplay) {
XEvent e; XEvent e;
XNextEvent(EXTRACT_DISPLAY(Xdisplay), &e); XNextEvent(SCX_EXTRACT_DISPLAY(Xdisplay), &e);
return enter_event(&e); return scx_enter_event(&e);
} }
s48_value Peek_Event(s48_value Xdisplay) { s48_value scx_Peek_Event(s48_value Xdisplay) {
XEvent e; XEvent e;
XPeekEvent(EXTRACT_DISPLAY(Xdisplay), &e); XPeekEvent(SCX_EXTRACT_DISPLAY(Xdisplay), &e);
return enter_event(&e); return scx_enter_event(&e);
} }
s48_value Events_Pending(s48_value Xdisplay) { s48_value scx_Events_Pending(s48_value Xdisplay) {
return s48_enter_integer(XPending(EXTRACT_DISPLAY(Xdisplay))); return s48_enter_integer(XPending(SCX_EXTRACT_DISPLAY(Xdisplay)));
} }
s48_value Get_Motion_Events(s48_value Xdisplay, s48_value Xwindow, s48_value scx_Get_Motion_Events(s48_value Xdisplay, s48_value Xwindow,
s48_value from, s48_value to) { s48_value from, s48_value to) {
int n,i; int n,i;
XTimeCoord *p = XGetMotionEvents(EXTRACT_DISPLAY(Xdisplay), XTimeCoord *p = XGetMotionEvents(SCX_EXTRACT_DISPLAY(Xdisplay),
EXTRACT_WINDOW(Xwindow), SCX_EXTRACT_WINDOW(Xwindow),
EXTRACT_TIME(from), SCX_EXTRACT_TIME(from),
EXTRACT_TIME(to), SCX_EXTRACT_TIME(to),
&n); &n);
s48_value v = s48_make_vector(n, S48_FALSE); s48_value v = s48_make_vector(n, S48_FALSE);
s48_value l = S48_NULL; s48_value l = S48_NULL;
S48_DECLARE_GC_PROTECT(2); S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(v,l); S48_GC_PROTECT_2(v,l);
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
l = s48_cons(ENTER_TIME(p[i].time), l = s48_cons(SCX_ENTER_TIME(p[i].time),
s48_cons(s48_enter_integer(p[i].x), s48_cons(s48_enter_integer(p[i].x),
s48_cons(s48_enter_integer(p[i].y), S48_NULL))); s48_cons(s48_enter_integer(p[i].y), S48_NULL)));
S48_VECTOR_SET(v, i, l); S48_VECTOR_SET(v, i, l);
@ -349,10 +349,10 @@ s48_value Get_Motion_Events(s48_value Xdisplay, s48_value Xwindow,
return v; return v;
} }
void s48_init_event(void) { void scx_init_event(void) {
S48_EXPORT_FUNCTION(Next_Event); S48_EXPORT_FUNCTION(scx_Next_Event);
S48_EXPORT_FUNCTION(Peek_Event); S48_EXPORT_FUNCTION(scx_Peek_Event);
S48_EXPORT_FUNCTION(Events_Pending); S48_EXPORT_FUNCTION(scx_Events_Pending);
S48_EXPORT_FUNCTION(Get_Motion_Events); S48_EXPORT_FUNCTION(scx_Get_Motion_Events);
} }

96
c/xlib/font.c
View File

@ -2,35 +2,35 @@
#include "scheme48.h" #include "scheme48.h"
s48_value Load_Font(s48_value Xdisplay, s48_value font_name) { s48_value scx_Load_Font(s48_value Xdisplay, s48_value font_name) {
return ENTER_FONTSTRUCT(XLoadQueryFont(EXTRACT_DISPLAY(Xdisplay), return SCX_ENTER_FONTSTRUCT(XLoadQueryFont(SCX_EXTRACT_DISPLAY(Xdisplay),
s48_extract_string(font_name))); s48_extract_string(font_name)));
} }
s48_value Free_Font(s48_value Xdisplay, s48_value Xfontstruct) { s48_value scx_Free_Font(s48_value Xdisplay, s48_value Xfontstruct) {
XFreeFont(EXTRACT_DISPLAY(Xdisplay), XFreeFont(SCX_EXTRACT_DISPLAY(Xdisplay),
EXTRACT_FONTSTRUCT(Xfontstruct)); SCX_EXTRACT_FONTSTRUCT(Xfontstruct));
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Get_Xfont(s48_value Xfontstruct) { s48_value scx_Get_Xfont(s48_value Xfontstruct) {
return ENTER_FONT((EXTRACT_FONTSTRUCT(Xfontstruct))->fid); return SCX_ENTER_FONT((SCX_EXTRACT_FONTSTRUCT(Xfontstruct))->fid);
} }
s48_value GContext_Font(s48_value Xdisplay, s48_value Xgcontext) { s48_value scx_GContext_Font(s48_value Xdisplay, s48_value Xgcontext) {
GContext gc = XGContextFromGC(EXTRACT_GCONTEXT(Xgcontext)); GContext gc = XGContextFromGC(SCX_EXTRACT_GCONTEXT(Xgcontext));
Display* dpy = EXTRACT_DISPLAY(Xdisplay); Display* dpy = SCX_EXTRACT_DISPLAY(Xdisplay);
return ENTER_FONTSTRUCT(XQueryFont(dpy, gc)); return SCX_ENTER_FONTSTRUCT(XQueryFont(dpy, gc));
} }
s48_value Font_Path(s48_value Xdisplay) { s48_value scx_Font_Path(s48_value Xdisplay) {
int n, i; int n, i;
char** sa; char** sa;
s48_value ret; s48_value ret = S48_FALSE;
S48_DECLARE_GC_PROTECT(1); S48_DECLARE_GC_PROTECT(1);
// Enable/Disable Interrupts ?? // Enable/Disable Interrupts ??
sa = XGetFontPath(EXTRACT_DISPLAY(Xdisplay), &n); sa = XGetFontPath(SCX_EXTRACT_DISPLAY(Xdisplay), &n);
ret = s48_make_vector(n, S48_FALSE); ret = s48_make_vector(n, S48_FALSE);
S48_GC_PROTECT_1(ret); S48_GC_PROTECT_1(ret);
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
@ -42,25 +42,25 @@ s48_value Font_Path(s48_value Xdisplay) {
return ret; return ret;
} }
s48_value Set_Font_Path(s48_value Xdisplay, s48_value path) { s48_value scx_Set_Font_Path(s48_value Xdisplay, s48_value path) {
int i, n = S48_VECTOR_LENGTH(path); int i, n = S48_VECTOR_LENGTH(path);
char* sa[n]; char* sa[n];
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
sa[i] = s48_extract_string(S48_VECTOR_REF(path, i)); sa[i] = s48_extract_string(S48_VECTOR_REF(path, i));
} }
XSetFontPath(EXTRACT_DISPLAY(Xdisplay), sa, n); XSetFontPath(SCX_EXTRACT_DISPLAY(Xdisplay), sa, n);
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value List_Font_Names(s48_value Xdisplay, s48_value pattern) { s48_value scx_List_Font_Names(s48_value Xdisplay, s48_value pattern) {
char** sa; char** sa;
int i,n; int i,n;
s48_value v; s48_value v = S48_FALSE;
S48_DECLARE_GC_PROTECT(1); S48_DECLARE_GC_PROTECT(1);
XListFonts(EXTRACT_DISPLAY(Xdisplay), XListFonts(SCX_EXTRACT_DISPLAY(Xdisplay),
s48_extract_string(pattern), s48_extract_string(pattern),
65535, 65535,
&n); &n);
@ -76,14 +76,14 @@ s48_value List_Font_Names(s48_value Xdisplay, s48_value pattern) {
return v; return v;
} }
s48_value List_Fonts(s48_value Xdisplay, s48_value pattern) { s48_value scx_List_Fonts(s48_value Xdisplay, s48_value pattern) {
char** sa; char** sa;
XFontStruct* fsa; XFontStruct* fsa;
int i,n; int i,n;
s48_value v; s48_value v = S48_FALSE;
S48_DECLARE_GC_PROTECT(1); S48_DECLARE_GC_PROTECT(1);
XListFontsWithInfo(EXTRACT_DISPLAY(Xdisplay), XListFontsWithInfo(SCX_EXTRACT_DISPLAY(Xdisplay),
s48_extract_string(pattern), s48_extract_string(pattern),
65535, 65535,
&n, &n,
@ -93,7 +93,7 @@ s48_value List_Fonts(s48_value Xdisplay, s48_value pattern) {
S48_GC_PROTECT_1(v); S48_GC_PROTECT_1(v);
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
S48_VECTOR_SET(v, i, s48_cons(s48_enter_string(sa[i]), S48_VECTOR_SET(v, i, s48_cons(s48_enter_string(sa[i]),
ENTER_FONTSTRUCT(&fsa[i]))); SCX_ENTER_FONTSTRUCT(&fsa[i])));
} }
S48_GC_UNPROTECT(); S48_GC_UNPROTECT();
XFreeFontNames(sa); XFreeFontNames(sa);
@ -101,10 +101,10 @@ s48_value List_Fonts(s48_value Xdisplay, s48_value pattern) {
return v; return v;
} }
s48_value Font_Properties(s48_value Xfontstruct) { s48_value scx_Font_Properties(s48_value Xfontstruct) {
s48_value v; s48_value v = S48_FALSE;
int i,n; int i,n;
XFontStruct* fs = EXTRACT_FONTSTRUCT(Xfontstruct); XFontStruct* fs = SCX_EXTRACT_FONTSTRUCT(Xfontstruct);
XFontProp* p; XFontProp* p;
S48_DECLARE_GC_PROTECT(1); S48_DECLARE_GC_PROTECT(1);
@ -114,25 +114,25 @@ s48_value Font_Properties(s48_value Xfontstruct) {
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
p = fs->properties+i; p = fs->properties+i;
S48_VECTOR_SET(v, i, s48_cons( ENTER_ATOM(p->name), S48_VECTOR_SET(v, i, s48_cons( SCX_ENTER_ATOM(p->name),
s48_enter_integer(p->card32) )); s48_enter_integer(p->card32) ));
} }
S48_GC_UNPROTECT(); S48_GC_UNPROTECT();
return v; return v;
} }
s48_value Font_Property(s48_value Xfontstruct, s48_value Xatom) { s48_value scx_Font_Property(s48_value Xfontstruct, s48_value Xatom) {
unsigned long val; unsigned long val;
if (XGetFontProperty(EXTRACT_FONTSTRUCT(Xfontstruct), if (XGetFontProperty(SCX_EXTRACT_FONTSTRUCT(Xfontstruct),
EXTRACT_ATOM(Xatom), SCX_EXTRACT_ATOM(Xatom),
&val)) &val))
return s48_enter_integer(val); return s48_enter_integer(val);
else else
return S48_FALSE; return S48_FALSE;
} }
s48_value Font_Info(s48_value Xfontstruct) { s48_value scx_Font_Info(s48_value Xfontstruct) {
XFontStruct* fs = EXTRACT_FONTSTRUCT(Xfontstruct); XFontStruct* fs = SCX_EXTRACT_FONTSTRUCT(Xfontstruct);
s48_value v = s48_make_vector(9, S48_FALSE); s48_value v = s48_make_vector(9, S48_FALSE);
S48_DECLARE_GC_PROTECT(1); S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(v); S48_GC_PROTECT_1(v);
@ -151,11 +151,11 @@ s48_value Font_Info(s48_value Xfontstruct) {
return v; return v;
} }
static s48_value Char_Info(s48_value Xfontstruct, s48_value index) { s48_value scx_Char_Info(s48_value Xfontstruct, s48_value index) {
// index must be an integer, #f for 'min or #t for 'max // index must be an integer, #f for 'min or #t for 'max
XCharStruct* cp; XCharStruct* cp;
XFontStruct* p = EXTRACT_FONTSTRUCT(Xfontstruct); XFontStruct* p = SCX_EXTRACT_FONTSTRUCT(Xfontstruct);
s48_value v; s48_value v = S48_FALSE;
S48_DECLARE_GC_PROTECT(1); S48_DECLARE_GC_PROTECT(1);
if (S48_FALSE_P(index)) if (S48_FALSE_P(index))
@ -178,17 +178,17 @@ static s48_value Char_Info(s48_value Xfontstruct, s48_value index) {
return v; return v;
} }
s48_init_font() { void scx_init_font(void) {
S48_EXPORT_FUNCTION(Load_Font); S48_EXPORT_FUNCTION(scx_Load_Font);
S48_EXPORT_FUNCTION(Free_Font); S48_EXPORT_FUNCTION(scx_Free_Font);
S48_EXPORT_FUNCTION(Get_Xfont); S48_EXPORT_FUNCTION(scx_Get_Xfont);
S48_EXPORT_FUNCTION(GContext_Font); S48_EXPORT_FUNCTION(scx_GContext_Font);
S48_EXPORT_FUNCTION(Font_Path); S48_EXPORT_FUNCTION(scx_Font_Path);
S48_EXPORT_FUNCTION(Set_Font_Path); S48_EXPORT_FUNCTION(scx_Set_Font_Path);
S48_EXPORT_FUNCTION(Font_Property); S48_EXPORT_FUNCTION(scx_Font_Property);
S48_EXPORT_FUNCTION(Font_Properties); S48_EXPORT_FUNCTION(scx_Font_Properties);
S48_EXPORT_FUNCTION(List_Fonts); S48_EXPORT_FUNCTION(scx_List_Fonts);
S48_EXPORT_FUNCTION(List_Font_Names); S48_EXPORT_FUNCTION(scx_List_Font_Names);
S48_EXPORT_FUNCTION(Font_Info); S48_EXPORT_FUNCTION(scx_Font_Info);
S48_EXPORT_FUNCTION(Char_Info); S48_EXPORT_FUNCTION(scx_Char_Info);
} }

88
c/xlib/gcontext.c
View File

@ -17,13 +17,13 @@ unsigned long AList_To_GCValues(s48_value alist, XGCValues* GCV) {
GCV->function = Symbol_To_Bit(value, Func_Syms); GCV->function = Symbol_To_Bit(value, Func_Syms);
mask |= GCFunction; mask |= GCFunction;
} else if (strcmp(cname, "plane-mask") == 0) { } else if (strcmp(cname, "plane-mask") == 0) {
GCV->plane_mask = EXTRACT_PIXEL(value); GCV->plane_mask = SCX_EXTRACT_PIXEL(value);
mask |= GCPlaneMask; mask |= GCPlaneMask;
} else if (strcmp(cname, "foreground") == 0) { } else if (strcmp(cname, "foreground") == 0) {
GCV->foreground = EXTRACT_PIXEL(value); GCV->foreground = SCX_EXTRACT_PIXEL(value);
mask |= GCForeground; mask |= GCForeground;
} else if (strcmp(cname, "background") == 0) { } else if (strcmp(cname, "background") == 0) {
GCV->background = EXTRACT_PIXEL(value); GCV->background = SCX_EXTRACT_PIXEL(value);
mask |= GCBackground; mask |= GCBackground;
} else if (strcmp(cname, "line-width") == 0) { } else if (strcmp(cname, "line-width") == 0) {
GCV->line_width = s48_extract_integer(value); GCV->line_width = s48_extract_integer(value);
@ -47,10 +47,10 @@ unsigned long AList_To_GCValues(s48_value alist, XGCValues* GCV) {
GCV->arc_mode = Symbol_To_Bit(value, Arc_Mode_Syms); GCV->arc_mode = Symbol_To_Bit(value, Arc_Mode_Syms);
mask |= GCArcMode; mask |= GCArcMode;
} else if (strcmp(cname, "tile") == 0) { } else if (strcmp(cname, "tile") == 0) {
GCV->tile = EXTRACT_PIXMAP(value); GCV->tile = SCX_EXTRACT_PIXMAP(value);
mask |= GCTile; mask |= GCTile;
} else if (strcmp(cname, "stipple") == 0) { } else if (strcmp(cname, "stipple") == 0) {
GCV->stipple = EXTRACT_PIXMAP(value); GCV->stipple = SCX_EXTRACT_PIXMAP(value);
mask |= GCStipple; mask |= GCStipple;
} else if (strcmp(cname, "ts-x") == 0) { } else if (strcmp(cname, "ts-x") == 0) {
GCV->ts_x_origin = s48_extract_integer(value); GCV->ts_x_origin = s48_extract_integer(value);
@ -59,7 +59,7 @@ unsigned long AList_To_GCValues(s48_value alist, XGCValues* GCV) {
GCV->ts_y_origin = s48_extract_integer(value); GCV->ts_y_origin = s48_extract_integer(value);
mask |= GCTileStipYOrigin; mask |= GCTileStipYOrigin;
} else if (strcmp(cname, "font") == 0) { } else if (strcmp(cname, "font") == 0) {
GCV->font = EXTRACT_FONT(value); GCV->font = SCX_EXTRACT_FONT(value);
mask |= GCFont; mask |= GCFont;
} else if (strcmp(cname, "subwindow-mode") == 0) { } else if (strcmp(cname, "subwindow-mode") == 0) {
GCV->subwindow_mode = Symbol_To_Bit(value, Subwin_Mode_Syms); GCV->subwindow_mode = Symbol_To_Bit(value, Subwin_Mode_Syms);
@ -74,7 +74,7 @@ unsigned long AList_To_GCValues(s48_value alist, XGCValues* GCV) {
GCV->clip_y_origin = s48_extract_integer(value); GCV->clip_y_origin = s48_extract_integer(value);
mask |= GCClipYOrigin; mask |= GCClipYOrigin;
} else if (strcmp(cname, "clip-mask") == 0) { } else if (strcmp(cname, "clip-mask") == 0) {
GCV->clip_mask = EXTRACT_PIXMAP(value); GCV->clip_mask = SCX_EXTRACT_PIXMAP(value);
mask |= GCClipMask; mask |= GCClipMask;
} else if (strcmp(cname, "dash-offset") == 0) { } else if (strcmp(cname, "dash-offset") == 0) {
GCV->dash_offset = s48_extract_integer(value); GCV->dash_offset = s48_extract_integer(value);
@ -89,25 +89,25 @@ unsigned long AList_To_GCValues(s48_value alist, XGCValues* GCV) {
return mask; return mask;
} }
s48_value Create_Gc(s48_value Xdisplay, s48_value Xdrawable, s48_value args) { s48_value scx_Create_Gc(s48_value Xdisplay, s48_value Xdrawable, s48_value args) {
XGCValues GCV; XGCValues GCV;
unsigned long mask = AList_To_GCValues(args, &GCV); unsigned long mask = AList_To_GCValues(args, &GCV);
GC Xgcontext = XCreateGC(EXTRACT_DISPLAY(Xdisplay), GC Xgcontext = XCreateGC(SCX_EXTRACT_DISPLAY(Xdisplay),
EXTRACT_DRAWABLE(Xdrawable), SCX_EXTRACT_DRAWABLE(Xdrawable),
mask, &GCV); mask, &GCV);
return ENTER_GCONTEXT(Xgcontext); return SCX_ENTER_GCONTEXT(Xgcontext);
} }
s48_value Copy_Gc(s48_value Xdisplay, s48_value Xsource, s48_value Xdest) { s48_value scx_Copy_Gc(s48_value Xdisplay, s48_value Xsource, s48_value Xdest) {
XCopyGC(EXTRACT_DISPLAY(Xdisplay), EXTRACT_GCONTEXT(Xsource), XCopyGC(SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_GCONTEXT(Xsource),
~0L, EXTRACT_GCONTEXT(Xdest)); ~0L, SCX_EXTRACT_GCONTEXT(Xdest));
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Free_Gc(s48_value Xgcontext, s48_value Xdisplay) { s48_value scx_Free_Gc(s48_value Xgcontext, s48_value Xdisplay) {
XFreeGC(EXTRACT_DISPLAY(Xdisplay), EXTRACT_GCONTEXT(Xgcontext)); XFreeGC(SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_GCONTEXT(Xgcontext));
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
@ -118,14 +118,15 @@ s48_value Free_Gc(s48_value Xgcontext, s48_value Xdisplay) {
GCSubwindowMode | GCGraphicsExposures | GCClipXOrigin | GCClipYOrigin |\ GCSubwindowMode | GCGraphicsExposures | GCClipXOrigin | GCClipYOrigin |\
GCDashOffset | GCArcMode) GCDashOffset | GCArcMode)
s48_value Get_Gc_Values (s48_value Xgcontext, s48_value Xdisplay) { s48_value scx_Get_Gc_Values (s48_value Xgcontext, s48_value Xdisplay) {
unsigned long mask = ValidGCValuesBits; unsigned long mask = ValidGCValuesBits;
XGCValues GCV; XGCValues GCV;
s48_value res; s48_value res = S48_FALSE;
S48_DECLARE_GC_PROTECT(1); S48_DECLARE_GC_PROTECT(1);
if (!XGetGCValues (EXTRACT_DISPLAY(Xdisplay), EXTRACT_GCONTEXT(Xgcontext), if (!XGetGCValues (SCX_EXTRACT_DISPLAY(Xdisplay),
SCX_EXTRACT_GCONTEXT(Xgcontext),
mask, &GCV)) mask, &GCV))
res = S48_FALSE; res = S48_FALSE;
else { else {
@ -133,9 +134,9 @@ s48_value Get_Gc_Values (s48_value Xgcontext, s48_value Xdisplay) {
S48_GC_PROTECT_1(res); S48_GC_PROTECT_1(res);
S48_VECTOR_SET(res, 0, Bit_To_Symbol(GCV.function, Func_Syms)); S48_VECTOR_SET(res, 0, Bit_To_Symbol(GCV.function, Func_Syms));
S48_VECTOR_SET(res, 1, ENTER_PIXEL(GCV.plane_mask)); S48_VECTOR_SET(res, 1, SCX_ENTER_PIXEL(GCV.plane_mask));
S48_VECTOR_SET(res, 2, ENTER_PIXEL(GCV.foreground)); S48_VECTOR_SET(res, 2, SCX_ENTER_PIXEL(GCV.foreground));
S48_VECTOR_SET(res, 3, ENTER_PIXEL(GCV.background)); S48_VECTOR_SET(res, 3, SCX_ENTER_PIXEL(GCV.background));
S48_VECTOR_SET(res, 4, s48_enter_integer(GCV.line_width)); S48_VECTOR_SET(res, 4, s48_enter_integer(GCV.line_width));
S48_VECTOR_SET(res, 5, Bit_To_Symbol(GCV.line_style, Line_Style_Syms)); S48_VECTOR_SET(res, 5, Bit_To_Symbol(GCV.line_style, Line_Style_Syms));
S48_VECTOR_SET(res, 6, Bit_To_Symbol(GCV.cap_style, Cap_Style_Syms)); S48_VECTOR_SET(res, 6, Bit_To_Symbol(GCV.cap_style, Cap_Style_Syms));
@ -143,17 +144,17 @@ s48_value Get_Gc_Values (s48_value Xgcontext, s48_value Xdisplay) {
S48_VECTOR_SET(res, 8, Bit_To_Symbol(GCV.fill_style, Fill_Style_Syms)); S48_VECTOR_SET(res, 8, Bit_To_Symbol(GCV.fill_style, Fill_Style_Syms));
S48_VECTOR_SET(res, 9, Bit_To_Symbol(GCV.fill_rule, Fill_Rule_Syms)); S48_VECTOR_SET(res, 9, Bit_To_Symbol(GCV.fill_rule, Fill_Rule_Syms));
S48_VECTOR_SET(res, 10, Bit_To_Symbol(GCV.arc_mode, Arc_Mode_Syms)); S48_VECTOR_SET(res, 10, Bit_To_Symbol(GCV.arc_mode, Arc_Mode_Syms));
S48_VECTOR_SET(res, 11, ENTER_PIXMAP(GCV.tile)); S48_VECTOR_SET(res, 11, SCX_ENTER_PIXMAP(GCV.tile));
S48_VECTOR_SET(res, 12, ENTER_PIXMAP(GCV.stipple)); S48_VECTOR_SET(res, 12, SCX_ENTER_PIXMAP(GCV.stipple));
S48_VECTOR_SET(res, 13, s48_enter_integer(GCV.ts_x_origin)); S48_VECTOR_SET(res, 13, s48_enter_integer(GCV.ts_x_origin));
S48_VECTOR_SET(res, 14, s48_enter_integer(GCV.ts_y_origin)); S48_VECTOR_SET(res, 14, s48_enter_integer(GCV.ts_y_origin));
S48_VECTOR_SET(res, 15, ENTER_FONT(GCV.font)); S48_VECTOR_SET(res, 15, SCX_ENTER_FONT(GCV.font));
S48_VECTOR_SET(res, 16, Bit_To_Symbol(GCV.subwindow_mode, S48_VECTOR_SET(res, 16, Bit_To_Symbol(GCV.subwindow_mode,
Subwin_Mode_Syms)); Subwin_Mode_Syms));
S48_VECTOR_SET(res, 17, GCV.graphics_exposures ? S48_TRUE : S48_FALSE); S48_VECTOR_SET(res, 17, GCV.graphics_exposures ? S48_TRUE : S48_FALSE);
S48_VECTOR_SET(res, 18, s48_enter_integer(GCV.clip_x_origin)); S48_VECTOR_SET(res, 18, s48_enter_integer(GCV.clip_x_origin));
S48_VECTOR_SET(res, 19, s48_enter_integer(GCV.clip_y_origin)); S48_VECTOR_SET(res, 19, s48_enter_integer(GCV.clip_y_origin));
S48_VECTOR_SET(res, 20, ENTER_PIXMAP(GCV.clip_mask)); S48_VECTOR_SET(res, 20, SCX_ENTER_PIXMAP(GCV.clip_mask));
S48_VECTOR_SET(res, 21, s48_enter_integer(GCV.dash_offset)); S48_VECTOR_SET(res, 21, s48_enter_integer(GCV.dash_offset));
S48_VECTOR_SET(res, 22, s48_enter_integer(GCV.dashes)); S48_VECTOR_SET(res, 22, s48_enter_integer(GCV.dashes));
} }
@ -161,17 +162,17 @@ s48_value Get_Gc_Values (s48_value Xgcontext, s48_value Xdisplay) {
return res; return res;
} }
s48_value Change_Gc (s48_value Xgcontext, s48_value Xdisplay, s48_value args) { s48_value scx_Change_Gc (s48_value Xgcontext, s48_value Xdisplay, s48_value args) {
XGCValues GCV; XGCValues GCV;
unsigned long mask = AList_To_GCValues(args, &GCV); unsigned long mask = AList_To_GCValues(args, &GCV);
XChangeGC(EXTRACT_DISPLAY(Xdisplay), EXTRACT_GCONTEXT(Xgcontext), XChangeGC(SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_GCONTEXT(Xgcontext),
mask, &GCV); mask, &GCV);
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Set_Gcontext_Dashlist(s48_value Xgcontext, s48_value Xdisplay, s48_value scx_Set_Gcontext_Dashlist(s48_value Xgcontext, s48_value Xdisplay,
s48_value dashoffset, s48_value dashlist) { s48_value dashoffset, s48_value dashlist) {
int n = S48_VECTOR_LENGTH(dashlist); int n = S48_VECTOR_LENGTH(dashlist);
char v[n]; char v[n];
@ -180,13 +181,13 @@ s48_value Set_Gcontext_Dashlist(s48_value Xgcontext, s48_value Xdisplay,
v[i] = (char)s48_extract_integer(S48_VECTOR_REF(dashlist, i)); v[i] = (char)s48_extract_integer(S48_VECTOR_REF(dashlist, i));
} }
XSetDashes( EXTRACT_DISPLAY(Xdisplay), EXTRACT_GCONTEXT(Xgcontext), XSetDashes( SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_GCONTEXT(Xgcontext),
s48_extract_integer(dashoffset), v, n); s48_extract_integer(dashoffset), v, n);
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Set_Gcontext_Clip_Rectangles (s48_value Xgcontext, s48_value scx_Set_Gcontext_Clip_Rectangles (s48_value Xgcontext,
s48_value Xdisplay, s48_value x, s48_value Xdisplay, s48_value x,
s48_value y, s48_value v, s48_value y, s48_value v,
s48_value ord) { s48_value ord) {
@ -209,7 +210,8 @@ s48_value Set_Gcontext_Clip_Rectangles (s48_value Xgcontext,
} }
XSetClipRectangles (EXTRACT_DISPLAY(Xdisplay), EXTRACT_GCONTEXT(Xgcontext), XSetClipRectangles (SCX_EXTRACT_DISPLAY(Xdisplay),
SCX_EXTRACT_GCONTEXT(Xgcontext),
(int)s48_extract_integer (x), (int)s48_extract_integer (x),
(int)s48_extract_integer (y), p, n, (int)s48_extract_integer (y), p, n,
Symbol_To_Bit(ord, Ordering_Syms)); Symbol_To_Bit(ord, Ordering_Syms));
@ -217,11 +219,11 @@ s48_value Set_Gcontext_Clip_Rectangles (s48_value Xgcontext,
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Query_Best_Size (s48_value Xdisplay, s48_value width, s48_value scx_Query_Best_Size (s48_value Xdisplay, s48_value width,
s48_value height, s48_value shape) { s48_value height, s48_value shape) {
unsigned int rw, rh; unsigned int rw, rh;
Display* dpy = EXTRACT_DISPLAY(Xdisplay); Display* dpy = SCX_EXTRACT_DISPLAY(Xdisplay);
if (!XQueryBestSize (dpy, if (!XQueryBestSize (dpy,
Symbol_To_Bit (shape, Shape_Syms), Symbol_To_Bit (shape, Shape_Syms),
@ -235,13 +237,13 @@ s48_value Query_Best_Size (s48_value Xdisplay, s48_value width,
} }
void s48_init_gcontext(void) { void scx_init_gcontext(void) {
S48_EXPORT_FUNCTION(Create_Gc); S48_EXPORT_FUNCTION(scx_Create_Gc);
S48_EXPORT_FUNCTION(Free_Gc); S48_EXPORT_FUNCTION(scx_Free_Gc);
S48_EXPORT_FUNCTION(Copy_Gc); S48_EXPORT_FUNCTION(scx_Copy_Gc);
S48_EXPORT_FUNCTION(Get_Gc_Values); S48_EXPORT_FUNCTION(scx_Get_Gc_Values);
S48_EXPORT_FUNCTION(Change_Gc); S48_EXPORT_FUNCTION(scx_Change_Gc);
S48_EXPORT_FUNCTION(Set_Gcontext_Dashlist); S48_EXPORT_FUNCTION(scx_Set_Gcontext_Dashlist);
S48_EXPORT_FUNCTION(Set_Gcontext_Clip_Rectangles); S48_EXPORT_FUNCTION(scx_Set_Gcontext_Clip_Rectangles);
S48_EXPORT_FUNCTION(Query_Best_Size); S48_EXPORT_FUNCTION(scx_Query_Best_Size);
} }

138
c/xlib/graphics.c
View File

@ -8,10 +8,10 @@ extern XDrawArcs(), XFillArcs(), XFillPolygon();
*/ */
s48_value Clear_Area(s48_value Xwindow, s48_value Xdisplay, s48_value x, s48_value scx_Clear_Area(s48_value Xwindow, s48_value Xdisplay, s48_value x,
s48_value y, s48_value w, s48_value h, s48_value e){ s48_value y, s48_value w, s48_value h, s48_value e){
Window win = EXTRACT_WINDOW(Xwindow); Window win = SCX_EXTRACT_WINDOW(Xwindow);
Display* dpy = EXTRACT_DISPLAY(Xdisplay); Display* dpy = SCX_EXTRACT_DISPLAY(Xdisplay);
XClearArea (dpy, win, (int)s48_extract_integer (x), XClearArea (dpy, win, (int)s48_extract_integer (x),
(int)s48_extract_integer (y), (int)s48_extract_integer (w), (int)s48_extract_integer (y), (int)s48_extract_integer (w),
@ -22,13 +22,13 @@ s48_value Clear_Area(s48_value Xwindow, s48_value Xdisplay, s48_value x,
} }
s48_value Copy_Area(s48_value Xdisplay, s48_value scx_Copy_Area(s48_value Xdisplay,
s48_value srcXdrawable,s48_value Xgcontext,s48_value srcx, s48_value srcXdrawable,s48_value Xgcontext,s48_value srcx,
s48_value srcy, s48_value width, s48_value height, s48_value srcy, s48_value width, s48_value height,
s48_value destXdrawable, s48_value destx,s48_value desty){ s48_value destXdrawable, s48_value destx,s48_value desty){
XCopyArea (EXTRACT_DISPLAY(Xdisplay), EXTRACT_DRAWABLE(srcXdrawable), XCopyArea (SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_DRAWABLE(srcXdrawable),
EXTRACT_DRAWABLE(destXdrawable), EXTRACT_GCONTEXT(Xgcontext), SCX_EXTRACT_DRAWABLE(destXdrawable), SCX_EXTRACT_GCONTEXT(Xgcontext),
(int)s48_extract_integer(srcx), (int)s48_extract_integer(srcy), (int)s48_extract_integer(srcx), (int)s48_extract_integer(srcy),
(int)s48_extract_integer(width), (int)s48_extract_integer(height), (int)s48_extract_integer(width), (int)s48_extract_integer(height),
(int)s48_extract_integer(destx), (int)s48_extract_integer(desty)); (int)s48_extract_integer(destx), (int)s48_extract_integer(desty));
@ -45,7 +45,7 @@ s48_value Copy_Area(s48_value Xdisplay,
*/ */
s48_value Copy_Plane(s48_value Xdisplay, s48_value srcXdrawable, s48_value scx_Copy_Plane(s48_value Xdisplay, s48_value srcXdrawable,
s48_value Xgcontext, s48_value plane, s48_value srcx, s48_value Xgcontext, s48_value plane, s48_value srcx,
s48_value srcy, s48_value width, s48_value height, s48_value srcy, s48_value width, s48_value height,
s48_value destXdrawable, s48_value destx, s48_value desty){ s48_value destXdrawable, s48_value destx, s48_value desty){
@ -53,8 +53,8 @@ s48_value Copy_Plane(s48_value Xdisplay, s48_value srcXdrawable,
// Note: plane must have been set exactly one bit to 1. // Note: plane must have been set exactly one bit to 1.
// For further details, see the man-page. // For further details, see the man-page.
unsigned long p = (unsigned long)s48_extract_integer(plane); unsigned long p = (unsigned long)s48_extract_integer(plane);
XCopyPlane(EXTRACT_DISPLAY(Xdisplay), EXTRACT_DRAWABLE(srcXdrawable), XCopyPlane(SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_DRAWABLE(srcXdrawable),
EXTRACT_DRAWABLE(destXdrawable), EXTRACT_GCONTEXT(Xgcontext), SCX_EXTRACT_DRAWABLE(destXdrawable), SCX_EXTRACT_GCONTEXT(Xgcontext),
(int)s48_extract_integer(srcx), (int)s48_extract_integer(srcy), (int)s48_extract_integer(srcx), (int)s48_extract_integer(srcy),
(int)s48_extract_integer(width), (int)s48_extract_integer(height), (int)s48_extract_integer(width), (int)s48_extract_integer(height),
(int)s48_extract_integer(destx), (int)s48_extract_integer(desty), (int)s48_extract_integer(destx), (int)s48_extract_integer(desty),
@ -65,11 +65,11 @@ s48_value Copy_Plane(s48_value Xdisplay, s48_value srcXdrawable,
s48_value Draw_Point(s48_value Xdisplay, s48_value Xdrawable, s48_value scx_Draw_Point(s48_value Xdisplay, s48_value Xdrawable,
s48_value Xgcontext, s48_value x, s48_value y){ s48_value Xgcontext, s48_value x, s48_value y){
XDrawPoint(EXTRACT_DISPLAY(Xdisplay), EXTRACT_DRAWABLE(Xdrawable), XDrawPoint(SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_DRAWABLE(Xdrawable),
EXTRACT_GCONTEXT(Xgcontext), (int)s48_extract_integer(x), SCX_EXTRACT_GCONTEXT(Xgcontext), (int)s48_extract_integer(x),
(int)s48_extract_integer (y)); (int)s48_extract_integer (y));
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
@ -87,7 +87,7 @@ void Vector_To_XPoints(s48_value vec, XPoint* p, int n){
} }
s48_value Draw_Points (s48_value Xdisplay, s48_value Xdrawable, s48_value scx_Draw_Points (s48_value Xdisplay, s48_value Xdrawable,
s48_value Xgcontext, s48_value vec, s48_value relative){ s48_value Xgcontext, s48_value vec, s48_value relative){
// First, create a new XPoint from the vector of pairs... // First, create a new XPoint from the vector of pairs...
@ -96,40 +96,40 @@ s48_value Draw_Points (s48_value Xdisplay, s48_value Xdrawable,
int mode; int mode;
Vector_To_XPoints(vec, p, n); Vector_To_XPoints(vec, p, n);
mode = !S48_FALSE_P(relative) ? CoordModePrevious : CoordModeOrigin; mode = !S48_FALSE_P(relative) ? CoordModePrevious : CoordModeOrigin;
XDrawPoints(EXTRACT_DISPLAY(Xdisplay), EXTRACT_DRAWABLE(Xdrawable), XDrawPoints(SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_DRAWABLE(Xdrawable),
EXTRACT_GCONTEXT(Xgcontext), p, n, mode); SCX_EXTRACT_GCONTEXT(Xgcontext), p, n, mode);
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Draw_Line (s48_value Xdisplay,s48_value Xdrawable, s48_value scx_Draw_Line (s48_value Xdisplay,s48_value Xdrawable,
s48_value Xgcontext, s48_value x1, s48_value y1, s48_value Xgcontext, s48_value x1, s48_value y1,
s48_value x2, s48_value y2){ s48_value x2, s48_value y2){
XDrawLine (EXTRACT_DISPLAY(Xdisplay),EXTRACT_DRAWABLE(Xdrawable), XDrawLine (SCX_EXTRACT_DISPLAY(Xdisplay),SCX_EXTRACT_DRAWABLE(Xdrawable),
EXTRACT_GCONTEXT(Xgcontext), (int)s48_extract_integer(x1), SCX_EXTRACT_GCONTEXT(Xgcontext), (int)s48_extract_integer(x1),
(int)s48_extract_integer (y1), (int)s48_extract_integer (x2), (int)s48_extract_integer (y1), (int)s48_extract_integer (x2),
(int)s48_extract_integer (y2)); (int)s48_extract_integer (y2));
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Draw_Lines(s48_value Xdisplay, s48_value Xdrawalbe, s48_value scx_Draw_Lines(s48_value Xdisplay, s48_value Xdrawalbe,
s48_value Xgcontext, s48_value vec, s48_value relative){ s48_value Xgcontext, s48_value vec, s48_value relative){
int n = S48_VECTOR_LENGTH(vec); int n = S48_VECTOR_LENGTH(vec);
XPoint p[n]; XPoint p[n];
int mode; int mode;
Vector_To_XPoints(vec, p, n); Vector_To_XPoints(vec, p, n);
mode = !S48_FALSE_P(relative) ? CoordModePrevious : CoordModeOrigin; mode = !S48_FALSE_P(relative) ? CoordModePrevious : CoordModeOrigin;
XDrawLines(EXTRACT_DISPLAY(Xdisplay), EXTRACT_DRAWABLE(Xdrawalbe), XDrawLines(SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_DRAWABLE(Xdrawalbe),
EXTRACT_GCONTEXT(Xgcontext), p, n, mode); SCX_EXTRACT_GCONTEXT(Xgcontext), p, n, mode);
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Draw_Segments (s48_value Xdisplay, s48_value Xdrawable, s48_value scx_Draw_Segments (s48_value Xdisplay, s48_value Xdrawable,
s48_value Xgcontext, s48_value vec){ s48_value Xgcontext, s48_value vec){
int i; int i;
int n = S48_VECTOR_LENGTH(vec); int n = S48_VECTOR_LENGTH(vec);
@ -141,18 +141,18 @@ s48_value Draw_Segments (s48_value Xdisplay, s48_value Xdrawable,
p[i].x2 = (int)s48_extract_integer (S48_CAR (seg)); seg = S48_CDR (seg); p[i].x2 = (int)s48_extract_integer (S48_CAR (seg)); seg = S48_CDR (seg);
p[i].y2 = (int)s48_extract_integer (S48_CAR (seg)); p[i].y2 = (int)s48_extract_integer (S48_CAR (seg));
} }
XDrawSegments (EXTRACT_DISPLAY(Xdisplay), EXTRACT_DRAWABLE(Xdrawable), XDrawSegments (SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_DRAWABLE(Xdrawable),
EXTRACT_GCONTEXT(Xgcontext), p, n); SCX_EXTRACT_GCONTEXT(Xgcontext), p, n);
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Draw_Rectangle(s48_value Xdisplay, s48_value Xdrawable, s48_value scx_Draw_Rectangle(s48_value Xdisplay, s48_value Xdrawable,
s48_value Xgcontext, s48_value x, s48_value y, s48_value Xgcontext, s48_value x, s48_value y,
s48_value w, s48_value h){ s48_value w, s48_value h){
XDrawRectangle (EXTRACT_DISPLAY(Xdisplay), EXTRACT_DRAWABLE(Xdrawable), XDrawRectangle (SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_DRAWABLE(Xdrawable),
EXTRACT_GCONTEXT(Xgcontext), (int)s48_extract_integer(x), SCX_EXTRACT_GCONTEXT(Xgcontext), (int)s48_extract_integer(x),
(int)s48_extract_integer(y), (int)s48_extract_integer(w), (int)s48_extract_integer(y), (int)s48_extract_integer(w),
(int)s48_extract_integer(h)); (int)s48_extract_integer(h));
@ -160,11 +160,11 @@ s48_value Draw_Rectangle(s48_value Xdisplay, s48_value Xdrawable,
} }
s48_value Fill_Rectangle (s48_value Xdisplay, s48_value Xdrawable, s48_value scx_Fill_Rectangle (s48_value Xdisplay, s48_value Xdrawable,
s48_value Xgcontext, s48_value x, s48_value y, s48_value Xgcontext, s48_value x, s48_value y,
s48_value w, s48_value h){ s48_value w, s48_value h){
XFillRectangle(EXTRACT_DISPLAY(Xdisplay), EXTRACT_DRAWABLE(Xdrawable), XFillRectangle(SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_DRAWABLE(Xdrawable),
EXTRACT_GCONTEXT(Xgcontext), (int)s48_extract_integer(x), SCX_EXTRACT_GCONTEXT(Xgcontext), (int)s48_extract_integer(x),
(int)s48_extract_integer(y), (int)s48_extract_integer(w), (int)s48_extract_integer(y), (int)s48_extract_integer(w),
(int)s48_extract_integer(h)); (int)s48_extract_integer(h));
@ -188,35 +188,35 @@ void Vector_To_XRectangle(s48_value vec, XRectangle* p, int n){
} }
s48_value Draw_Rectangles (s48_value Xdisplay, s48_value Xdrawable, s48_value scx_Draw_Rectangles (s48_value Xdisplay, s48_value Xdrawable,
s48_value Xgcontext, s48_value vec){ s48_value Xgcontext, s48_value vec){
int n = S48_VECTOR_LENGTH(vec); int n = S48_VECTOR_LENGTH(vec);
XRectangle p[n]; XRectangle p[n];
Vector_To_XRectangle(vec, p, n); Vector_To_XRectangle(vec, p, n);
XDrawRectangles(EXTRACT_DISPLAY(Xdisplay), EXTRACT_DRAWABLE(Xdrawable), XDrawRectangles(SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_DRAWABLE(Xdrawable),
EXTRACT_GCONTEXT(Xgcontext), p, n); SCX_EXTRACT_GCONTEXT(Xgcontext), p, n);
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Fill_Rectangles (s48_value Xdisplay, s48_value Xdrawable, s48_value scx_Fill_Rectangles (s48_value Xdisplay, s48_value Xdrawable,
s48_value Xgcontext, s48_value vec){ s48_value Xgcontext, s48_value vec){
int n = S48_VECTOR_LENGTH(vec); int n = S48_VECTOR_LENGTH(vec);
XRectangle p[n]; XRectangle p[n];
Vector_To_XRectangle(vec, p, n); Vector_To_XRectangle(vec, p, n);
XFillRectangles(EXTRACT_DISPLAY(Xdisplay), EXTRACT_DRAWABLE(Xdrawable), XFillRectangles(SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_DRAWABLE(Xdrawable),
EXTRACT_GCONTEXT(Xgcontext), p, n); SCX_EXTRACT_GCONTEXT(Xgcontext), p, n);
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Draw_Arc (s48_value Xdisplay, s48_value Xdrawable, s48_value scx_Draw_Arc (s48_value Xdisplay, s48_value Xdrawable,
s48_value Xgcontext, s48_value x,s48_value y, s48_value w, s48_value Xgcontext, s48_value x,s48_value y, s48_value w,
s48_value h, s48_value a1, s48_value a2){ s48_value h, s48_value a1, s48_value a2){
XDrawArc(EXTRACT_DISPLAY(Xdisplay), EXTRACT_DRAWABLE(Xdrawable), XDrawArc(SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_DRAWABLE(Xdrawable),
EXTRACT_GCONTEXT(Xgcontext), (int)s48_extract_integer(x), SCX_EXTRACT_GCONTEXT(Xgcontext), (int)s48_extract_integer(x),
(int)s48_extract_integer(y), (int)s48_extract_integer(w), (int)s48_extract_integer(y), (int)s48_extract_integer(w),
(int)s48_extract_integer(h), (int)s48_extract_integer(a1), (int)s48_extract_integer(h), (int)s48_extract_integer(a1),
(int)s48_extract_integer(a2)); (int)s48_extract_integer(a2));
@ -225,11 +225,11 @@ s48_value Draw_Arc (s48_value Xdisplay, s48_value Xdrawable,
} }
s48_value Fill_Arc (s48_value Xdisplay, s48_value Xdrawable, s48_value scx_Fill_Arc (s48_value Xdisplay, s48_value Xdrawable,
s48_value Xgcontext, s48_value x,s48_value y, s48_value w, s48_value Xgcontext, s48_value x,s48_value y, s48_value w,
s48_value h, s48_value a1, s48_value a2){ s48_value h, s48_value a1, s48_value a2){
XFillArc(EXTRACT_DISPLAY(Xdisplay), EXTRACT_DRAWABLE(Xdrawable), XFillArc(SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_DRAWABLE(Xdrawable),
EXTRACT_GCONTEXT(Xgcontext), (int)s48_extract_integer(x), SCX_EXTRACT_GCONTEXT(Xgcontext), (int)s48_extract_integer(x),
(int)s48_extract_integer(y), (int)s48_extract_integer(w), (int)s48_extract_integer(y), (int)s48_extract_integer(w),
(int)s48_extract_integer(h), (int)s48_extract_integer(a1), (int)s48_extract_integer(h), (int)s48_extract_integer(a1),
(int)s48_extract_integer(a2)); (int)s48_extract_integer(a2));
@ -257,31 +257,31 @@ void Vector_To_XArc(s48_value vec, XArc* p, int n){
} }
s48_value Draw_Arcs (s48_value Xdisplay, s48_value Xdrawable, s48_value scx_Draw_Arcs (s48_value Xdisplay, s48_value Xdrawable,
s48_value Xgcontext, s48_value vec){ s48_value Xgcontext, s48_value vec){
int n = S48_VECTOR_LENGTH(vec); int n = S48_VECTOR_LENGTH(vec);
XArc p[n]; XArc p[n];
Vector_To_XArc(vec, p, n); Vector_To_XArc(vec, p, n);
XDrawArcs(EXTRACT_DISPLAY(Xdisplay), EXTRACT_DRAWABLE(Xdrawable), XDrawArcs(SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_DRAWABLE(Xdrawable),
EXTRACT_GCONTEXT(Xgcontext), p, n); SCX_EXTRACT_GCONTEXT(Xgcontext), p, n);
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Fill_Arcs (s48_value Xdisplay, s48_value Xdrawable, s48_value scx_Fill_Arcs (s48_value Xdisplay, s48_value Xdrawable,
s48_value Xgcontext, s48_value vec){ s48_value Xgcontext, s48_value vec){
int n = S48_VECTOR_LENGTH(vec); int n = S48_VECTOR_LENGTH(vec);
XArc p[n]; XArc p[n];
Vector_To_XArc(vec, p, n); Vector_To_XArc(vec, p, n);
XFillArcs(EXTRACT_DISPLAY(Xdisplay), EXTRACT_DRAWABLE(Xdrawable), XFillArcs(SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_DRAWABLE(Xdrawable),
EXTRACT_GCONTEXT(Xgcontext), p, n); SCX_EXTRACT_GCONTEXT(Xgcontext), p, n);
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Fill_Polygon (s48_value Xdisplay, s48_value Xdrawable, s48_value scx_Fill_Polygon (s48_value Xdisplay, s48_value Xdrawable,
s48_value Xgcontext, s48_value vec, s48_value Xgcontext, s48_value vec,
s48_value relative, s48_value shape){ s48_value relative, s48_value shape){
int n = S48_VECTOR_LENGTH(vec); int n = S48_VECTOR_LENGTH(vec);
@ -290,29 +290,29 @@ s48_value Fill_Polygon (s48_value Xdisplay, s48_value Xdrawable,
XPoint p[n]; XPoint p[n];
Vector_To_XPoints(vec, p, n); Vector_To_XPoints(vec, p, n);
mode = !S48_FALSE_P(relative) ? CoordModePrevious : CoordModeOrigin; mode = !S48_FALSE_P(relative) ? CoordModePrevious : CoordModeOrigin;
XFillPolygon(EXTRACT_DISPLAY(Xdisplay), EXTRACT_DRAWABLE(Xdrawable), XFillPolygon(SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_DRAWABLE(Xdrawable),
EXTRACT_GCONTEXT(Xgcontext), p, n, sh, mode); SCX_EXTRACT_GCONTEXT(Xgcontext), p, n, sh, mode);
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
void s48_init_graphics(void) { void scx_init_graphics(void) {
S48_EXPORT_FUNCTION(Clear_Area); S48_EXPORT_FUNCTION(scx_Clear_Area);
S48_EXPORT_FUNCTION(Copy_Area); S48_EXPORT_FUNCTION(scx_Copy_Area);
S48_EXPORT_FUNCTION(Copy_Plane); S48_EXPORT_FUNCTION(scx_Copy_Plane);
S48_EXPORT_FUNCTION(Draw_Point); S48_EXPORT_FUNCTION(scx_Draw_Point);
S48_EXPORT_FUNCTION(Draw_Points); S48_EXPORT_FUNCTION(scx_Draw_Points);
S48_EXPORT_FUNCTION(Draw_Line); S48_EXPORT_FUNCTION(scx_Draw_Line);
S48_EXPORT_FUNCTION(Draw_Lines); S48_EXPORT_FUNCTION(scx_Draw_Lines);
S48_EXPORT_FUNCTION(Draw_Segments); S48_EXPORT_FUNCTION(scx_Draw_Segments);
S48_EXPORT_FUNCTION(Draw_Rectangle); S48_EXPORT_FUNCTION(scx_Draw_Rectangle);
S48_EXPORT_FUNCTION(Fill_Rectangle); S48_EXPORT_FUNCTION(scx_Fill_Rectangle);
S48_EXPORT_FUNCTION(Draw_Rectangles); S48_EXPORT_FUNCTION(scx_Draw_Rectangles);
S48_EXPORT_FUNCTION(Fill_Rectangles); S48_EXPORT_FUNCTION(scx_Fill_Rectangles);
S48_EXPORT_FUNCTION(Draw_Arc); S48_EXPORT_FUNCTION(scx_Draw_Arc);
S48_EXPORT_FUNCTION(Fill_Arc); S48_EXPORT_FUNCTION(scx_Fill_Arc);
S48_EXPORT_FUNCTION(Draw_Arcs); S48_EXPORT_FUNCTION(scx_Draw_Arcs);
S48_EXPORT_FUNCTION(Fill_Arcs); S48_EXPORT_FUNCTION(scx_Fill_Arcs);
S48_EXPORT_FUNCTION(Fill_Polygon); S48_EXPORT_FUNCTION(scx_Fill_Polygon);
} }

54
c/xlib/main.c
View File

@ -1,30 +1,38 @@
#include "scheme48.h" #include "scheme48.h"
extern void s48_init_window(); extern void scx_init_window();
extern void s48_init_display(); extern void scx_init_display();
extern void s48_init_type(); extern void scx_init_type();
extern void s48_init_color(); extern void scx_init_color();
extern void s48_init_colormap(); extern void scx_init_colormap();
extern void s48_init_pixel(); extern void scx_init_pixel();
extern void s48_init_gcontext(); extern void scx_init_gcontext();
extern void s48_init_event(); extern void scx_init_event();
extern void s48_init_pixmap(); extern void scx_init_pixmap();
extern void s48_init_graphics(); extern void scx_init_graphics();
extern void s48_init_font(); extern void scx_init_font();
extern void scx_init_cursor();
extern void scx_init_text();
extern void scx_init_property();
extern void scx_init_wm();
int main(){ int main(){
s48_add_external_init(s48_init_window); s48_add_external_init(scx_init_window);
s48_add_external_init(s48_init_display); s48_add_external_init(scx_init_display);
s48_add_external_init(s48_init_type); s48_add_external_init(scx_init_type);
s48_add_external_init(s48_init_color); s48_add_external_init(scx_init_color);
s48_add_external_init(s48_init_color); s48_add_external_init(scx_init_color);
s48_add_external_init(s48_init_colormap); s48_add_external_init(scx_init_colormap);
s48_add_external_init(s48_init_pixel); s48_add_external_init(scx_init_pixel);
s48_add_external_init(s48_init_gcontext); s48_add_external_init(scx_init_gcontext);
s48_add_external_init(s48_init_event); s48_add_external_init(scx_init_event);
s48_add_external_init(s48_init_pixmap); s48_add_external_init(scx_init_pixmap);
s48_add_external_init(s48_init_graphics); s48_add_external_init(scx_init_graphics);
s48_add_external_init(s48_init_font); s48_add_external_init(scx_init_font);
s48_add_external_init(scx_init_text);
s48_add_external_init(scx_init_property);
s48_add_external_init(scx_init_cursor);
s48_add_external_init(scx_init_wm);
s48_main(8000000, 64000, s48_main(8000000, 64000,
"/afs/wsi/home/dfreese/i386_fbsd43/scsh-0.6/lib/scheme48/scsh.image", "/afs/wsi/home/dfreese/i386_fbsd43/scsh-0.6/lib/scheme48/scsh.image",

18
c/xlib/pixel.c
View File

@ -1,17 +1,17 @@
#include "xlib.h" #include "xlib.h"
#include "scheme48.h" #include "scheme48.h"
s48_value Black_Pixel(s48_value Xdisplay) { s48_value scx_Black_Pixel(s48_value Xdisplay) {
Display* dpy = EXTRACT_DISPLAY(Xdisplay); Display* dpy = SCX_EXTRACT_DISPLAY(Xdisplay);
return ENTER_PIXEL( BlackPixel(dpy, DefaultScreen(dpy)) ); return SCX_ENTER_PIXEL( BlackPixel(dpy, DefaultScreen(dpy)) );
} }
s48_value White_Pixel(s48_value Xdisplay) { s48_value scx_White_Pixel(s48_value Xdisplay) {
Display* dpy = EXTRACT_DISPLAY(Xdisplay); Display* dpy = SCX_EXTRACT_DISPLAY(Xdisplay);
return ENTER_PIXEL( WhitePixel(dpy, DefaultScreen(dpy)) ); return SCX_ENTER_PIXEL( WhitePixel(dpy, DefaultScreen(dpy)) );
} }
void s48_init_pixel(void) { void scx_init_pixel(void) {
S48_EXPORT_FUNCTION(Black_Pixel); S48_EXPORT_FUNCTION(scx_Black_Pixel);
S48_EXPORT_FUNCTION(White_Pixel); S48_EXPORT_FUNCTION(scx_White_Pixel);
} }

62
c/xlib/pixmap.c
View File

@ -2,56 +2,56 @@
#include "scheme48.h" #include "scheme48.h"
s48_value scx_Free_Pixmap (s48_value Xdisplay, s48_value Xpixmap){
s48_value Free_Pixmap (s48_value Xdisplay, s48_value Xpixmap){ XFreePixmap (SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_PIXMAP(Xpixmap));
XFreePixmap (EXTRACT_DISPLAY(Xdisplay), EXTRACT_PIXMAP(Xpixmap));
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Create_Pixmap (s48_value Xdisplay, s48_value Xdrawable, s48_value w, s48_value scx_Create_Pixmap (s48_value Xdisplay, s48_value Xdrawable, s48_value w,
s48_value h, s48_value depth){ s48_value h, s48_value depth){
Pixmap pm = XCreatePixmap (EXTRACT_DISPLAY(Xdisplay), Pixmap pm = XCreatePixmap (SCX_EXTRACT_DISPLAY(Xdisplay),
EXTRACT_DRAWABLE(Xdrawable), SCX_EXTRACT_DRAWABLE(Xdrawable),
(int)s48_extract_integer (w), (int)s48_extract_integer (w),
(int)s48_extract_integer (h), (int)s48_extract_integer (h),
(int)s48_extract_integer (depth)); (int)s48_extract_integer (depth));
return S48_ENTER_PIXMAP(pm); return SCX_ENTER_PIXMAP(pm);
} }
s48_value Create_Bitmap_From_Data (s48_value Xdisplay, s48_value Xdrawable, s48_value scx_Create_Bitmap_From_Data (s48_value Xdisplay, s48_value Xdrawable,
s48_value data, s48_value w, s48_value h){ s48_value data, s48_value w, s48_value h){
Pixmap pm = XCreateBitmapFromData (EXTRACT_DISPLAY(Xdisplay), Pixmap pm = XCreateBitmapFromData (SCX_EXTRACT_DISPLAY(Xdisplay),
EXTRACT_DRAWABLE(Xdrawable), SCX_EXTRACT_DRAWABLE(Xdrawable),
s48_extract_string(data), s48_extract_string(data),
s48_extract_integer(w), s48_extract_integer(w),
s48_extract_integer(h)); s48_extract_integer(h));
return S48_ENTER_PIXMAP(pm); return SCX_ENTER_PIXMAP(pm);
} }
s48_value Create_Pixmap_From_Bitmap_Data (s48_value Xdisplay, s48_value scx_Create_Pixmap_From_Bitmap_Data (s48_value Xdisplay,
s48_value Xdrawable, s48_value data, s48_value Xdrawable, s48_value data,
s48_value w,s48_value h, s48_value f, s48_value w,s48_value h, s48_value f,
s48_value b, s48_value d){ s48_value b, s48_value d){
Pixmap pm = XCreatePixmapFromBitmapData (EXTRACT_DISPLAY(Xdisplay), Pixmap pm = XCreatePixmapFromBitmapData (SCX_EXTRACT_DISPLAY(Xdisplay),
EXTRACT_DRAWABLE(Xdrawable), SCX_EXTRACT_DRAWABLE(Xdrawable),
s48_extract_string(data), s48_extract_string(data),
(int)s48_extract_integer(w), (int)s48_extract_integer(w),
(int)s48_extract_integer(h), (int)s48_extract_integer(h),
s48_extract_integer(f), s48_extract_integer(f),
s48_extract_intgeger(b), s48_extract_integer(b),
(int)s48_extract_integer(d)); (int)s48_extract_integer(d));
return S48_ENTER_PIXMAP(pm); return SCX_ENTER_PIXMAP(pm);
} }
s48_value Read_Bitmap_File (s48_value Xdisplay, s48_value Xdrawable, s48_value file){ s48_value scx_Read_Bitmap_File (s48_value Xdisplay, s48_value Xdrawable,
s48_value file){
unsigned width, height; unsigned width, height;
int res, xhot, yhot; int res, xhot, yhot;
Pixmap bitmap; Pixmap bitmap;
s48_value ret; s48_value ret = S48_FALSE;
S48_DECLARE_GC_PROTECT(1); S48_DECLARE_GC_PROTECT(1);
// Not used: Disable_Interrupts; // Not used: Disable_Interrupts;
res = XReadBitmapFile (EXTRACT_DISPLAY(Xdisplay), EXTRACT_DRAWABLE(Xdrawable), res = XReadBitmapFile (SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_DRAWABLE(Xdrawable),
s48_extract_string(file), &width, &height, &bitmap, s48_extract_string(file), &width, &height, &bitmap,
&xhot, &yhot); &xhot, &yhot);
// Not used: Enable_Interrupts; // Not used: Enable_Interrupts;
@ -63,20 +63,22 @@ s48_value Read_Bitmap_File (s48_value Xdisplay, s48_value Xdrawable, s48_value f
ret = s48_cons (s48_enter_integer(xhot), ret); ret = s48_cons (s48_enter_integer(xhot), ret);
ret = s48_cons (s48_enter_integer(height), ret); ret = s48_cons (s48_enter_integer(height), ret);
ret = s48_cons (s48_enter_integer(width), ret); ret = s48_cons (s48_enter_integer(width), ret);
ret = s48_cons (S48_ENTER_PIXMAP(bitmap), ret); ret = s48_cons (SCX_ENTER_PIXMAP(bitmap), ret);
S48_GC_UNPROTECT(); S48_GC_UNPROTECT();
return ret; return ret;
} }
s48_value Write_Bitmap_File (s48_value Xdisplay, s48_value file, s48_value scx_Write_Bitmap_File (s48_value Xdisplay, s48_value file,
s48_value Xbitmap, s48_value w, s48_value h, s48_value Xbitmap, s48_value w, s48_value h,
s48_value x, s48_value y){ s48_value x, s48_value y){
int ret; int ret;
// Not used: Disable_Interrupts; // Not used: Disable_Interrupts;
ret = XWriteBitmapFile (EXTRACT_DISPLAY(Xdisplay), s48_extract_string(file), ret = XWriteBitmapFile (SCX_EXTRACT_DISPLAY(Xdisplay),
EXTRACT_PIXMAP(Xbitmap), (int)s48_extract_integer(w), s48_extract_string(file),
SCX_EXTRACT_PIXMAP(Xbitmap),
(int)s48_extract_integer(w),
(int)s48_extract_integer(h), (int)s48_extract_integer(h),
(int)s48_extract_integer(x), (int)s48_extract_integer(x),
(int)s48_extract_integer(y)); (int)s48_extract_integer(y));
@ -85,12 +87,12 @@ s48_value Write_Bitmap_File (s48_value Xdisplay, s48_value file,
} }
void s48_init_pixmap(void) { void scx_init_pixmap(void) {
S48_EXPORT_FUNCTION(Free_Pixmap); S48_EXPORT_FUNCTION(scx_Free_Pixmap);
S48_EXPORT_FUNCTION(Create_Pixmap); S48_EXPORT_FUNCTION(scx_Create_Pixmap);
S48_EXPORT_FUNCTION(Create_Bitmap_From_Data); S48_EXPORT_FUNCTION(scx_Create_Bitmap_From_Data);
S48_EXPORT_FUNCTION(Create_Pixmap_From_Bitmap_Data); S48_EXPORT_FUNCTION(scx_Create_Pixmap_From_Bitmap_Data);
S48_EXPORT_FUNCTION(Read_Bitmap_File); S48_EXPORT_FUNCTION(scx_Read_Bitmap_File);
S48_EXPORT_FUNCTION(Write_Bitmap_File); S48_EXPORT_FUNCTION(scx_Write_Bitmap_File);
} }

104
c/xlib/property.c
View File

@ -1,37 +1,37 @@
#include "xlib.h" #include "xlib.h"
#include "scheme48.h" #include "scheme48.h"
s48_value Sym_Now;
/* Should be used with care */ /* Should be used with care */
s48_value Intern_Atom (s48_value Xdisplay, s48_value name){ s48_value scx_Intern_Atom (s48_value Xdisplay, s48_value name){
Atom a = XInternAtom(EXTRACT_DISPLAY(Xdisplay), s48_extract_string(name), 0); Atom a = XInternAtom(SCX_EXTRACT_DISPLAY(Xdisplay),
return ENTER_ATOM(a); s48_extract_string(name), 0);
return SCX_ENTER_ATOM(a);
} }
s48_value Find_Atom (s48_value Xdisplay, s48_value name){ s48_value scx_Find_Atom (s48_value Xdisplay, s48_value name){
Atom a = XInternAtom (EXTRACT_DISPLAY(Xdisplay), s48_extract_string(name), 1); Atom a = XInternAtom (SCX_EXTRACT_DISPLAY(Xdisplay),
return ENTER_ATOM(a); s48_extract_string(name), 1);
return SCX_ENTER_ATOM(a);
} }
s48_value Atom_Name (s48_value Xdisplay, s48_value a) { s48_value scx_Atom_Name (s48_value Xdisplay, s48_value a) {
register char *s; register char *s;
// not used: Disalbe_Interrupts // not used: Disalbe_Interrupts
s = XGetAtomName (EXTRACT_DISPLAY(Xdisplay), a); s = XGetAtomName (SCX_EXTRACT_DISPLAY(Xdisplay), a);
// not used: Enable_Interrupts // not used: Enable_Interrupts
return s48_enter_string (s); return s48_enter_string (s);
} }
s48_value List_Properties (s48_value Xwindow, s48_value Xdisplay){ s48_value scx_List_Properties (s48_value Xwindow, s48_value Xdisplay){
int n, i; int n, i;
Atom *ap; Atom *ap;
s48_value v; s48_value v = S48_FALSE;
S48_DECLARE_GC_PROTECT(1); S48_DECLARE_GC_PROTECT(1);
//not used: Disable_Interrupts //not used: Disable_Interrupts
ap = XListProperties (EXTRACT_DISPLAY(Xdisplay), ap = XListProperties (SCX_EXTRACT_DISPLAY(Xdisplay),
EXTRACT_WINDOW(Xwindow), &n); SCX_EXTRACT_WINDOW(Xwindow), &n);
//not used: Enable_Interrupts //not used: Enable_Interrupts
v = s48_make_vector (n, S48_NULL); v = s48_make_vector (n, S48_NULL);
S48_GC_PROTECT_1 (v); S48_GC_PROTECT_1 (v);
@ -44,23 +44,26 @@ s48_value List_Properties (s48_value Xwindow, s48_value Xdisplay){
} }
s48_value Get_Property(s48_value Xwindow, s48_value Xdisplay, s48_value Xatom_prop, s48_value scx_Get_Property(s48_value Xwindow, s48_value Xdisplay,
s48_value Xatom_prop,
s48_value Xatom_type, s48_value start, s48_value len, s48_value Xatom_type, s48_value start, s48_value len,
s48_value deletep) { s48_value deletep) {
Atom req_type = AnyPropertyType, actual_type_ret; Atom req_type = AnyPropertyType, actual_type_ret;
int format_ret, i; int format_ret, i;
unsigned long nitems_ret, bytes_left_ret; unsigned long nitems_ret, bytes_left_ret;
unsigned char* prop_ret; unsigned char* prop_ret;
s48_value ret, x, v; s48_value ret = S48_FALSE, x, v = S48_FALSE;
S48_DECLARE_GC_PROTECT(2); S48_DECLARE_GC_PROTECT(2);
if (!S48_EQ_P(Xatom_type, S48_FALSE)){ if (!S48_FALSE_P(Xatom_type)){
req_type = s48_extract_integer(Xatom_type); req_type = s48_extract_integer(Xatom_type);
} }
//not used: Disable_Interrupts //not used: Disable_Interrupts
XGetWindowProperty (EXTRACT_DISPLAY(Xdisplay), EXTRACT_WINDOW(Xwindow), XGetWindowProperty (SCX_EXTRACT_DISPLAY(Xdisplay),
s48_extract_integer(Xatom_prop), s48_extract_integer (start), SCX_EXTRACT_WINDOW(Xwindow),
s48_extract_integer(Xatom_prop),
s48_extract_integer (start),
s48_extract_integer (len), S48_EXTRACT_BOOLEAN(deletep), s48_extract_integer (len), S48_EXTRACT_BOOLEAN(deletep),
req_type, &actual_type_ret, &format_ret, &nitems_ret, req_type, &actual_type_ret, &format_ret, &nitems_ret,
&bytes_left_ret, &prop_ret); &bytes_left_ret, &prop_ret);
@ -93,7 +96,7 @@ s48_value Get_Property(s48_value Xwindow, s48_value Xdisplay, s48_value Xatom_pr
} }
s48_value Change_Property(s48_value Xdisplay, s48_value Xwindow, s48_value scx_Change_Property(s48_value Xdisplay, s48_value Xwindow,
s48_value Xatom_prop, s48_value Xatom_type, s48_value Xatom_prop, s48_value Xatom_type,
s48_value format, s48_value mode, s48_value format, s48_value mode,
s48_value data){ s48_value data){
@ -110,75 +113,76 @@ s48_value Change_Property(s48_value Xdisplay, s48_value Xwindow,
nitems = S48_VECTOR_LENGTH(data); nitems = S48_VECTOR_LENGTH(data);
// Alloca (buf, char*, nitems * (f / sizeof (char))); // Alloca (buf, char*, nitems * (f / sizeof (char)));
for (i = 0; i < nitems; i++) { for (i = 0; i < nitems; i++) {
x = (int)s48_extract_integer(s48_VECTOR_REF(data, nitems)); x = (int)s48_extract_integer(S48_VECTOR_REF(data, nitems));
if (f == 16) { if (f == 16) {
*((short *)buf + i) = x; /* Assumes short is 16 bits */ *((short *)buf + i) = x; /* Assumes short is 16 bits */
}else *((int *)buf + i) = x; }else *((int *)buf + i) = x;
} /* and int is 32 bits. */ } /* and int is 32 bits. */
break; break;
} }
XChangeProperty (EXTRACT_DISPLAY(Xdisplay), EXTRACT_WINDOW(Xwindow), XChangeProperty (SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_WINDOW(Xwindow),
EXTRACT_ATOM(Xatom_prop), EXTRACT_ATOM(Xatom_type), SCX_EXTRACT_ATOM(Xatom_prop), SCX_EXTRACT_ATOM(Xatom_type),
f, m, (unsigned char *)buf, nitems); f, m, (unsigned char *)buf, nitems);
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Delete_Property (s48_value Xdisplay, s48_value Xwindow, s48_value scx_Delete_Property (s48_value Xdisplay, s48_value Xwindow,
s48_value Xatom_prop){ s48_value Xatom_prop){
XDeleteProperty (EXTRACT_DISPLAY(Xdisplay), EXTRACT_WINDOW(Xwindow), XDeleteProperty (SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_WINDOW(Xwindow),
EXTRACT_ATOM(Xatom_prop)); SCX_EXTRACT_ATOM(Xatom_prop));
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Rotate_Properties (s48_value Xdisplay, s48_value Xwindow, s48_value scx_Rotate_Properties (s48_value Xdisplay, s48_value Xwindow,
s48_value Xatom_vec, s48_value delta){ s48_value Xatom_vec, s48_value delta){
int n = S48_VECTOR_LENGTH(Xatom_vec), i; int n = S48_VECTOR_LENGTH(Xatom_vec), i;
Atom p[n]; Atom p[n];
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
p[i] = s48_extract_integer(S48_VECTOR_REF(Xatom_vec, i)); p[i] = s48_extract_integer(S48_VECTOR_REF(Xatom_vec, i));
} }
XRotateWindowProperties(EXTRACT_DISPLAY(Xdisplay), EXTRACT_WINDOW(Xwindow), XRotateWindowProperties(SCX_EXTRACT_DISPLAY(Xdisplay),
SCX_EXTRACT_WINDOW(Xwindow),
p, n, (int)s48_extract_integer(delta)); p, n, (int)s48_extract_integer(delta));
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Set_Selection_Owner (s48_value Xdisplay, s48_value Xatom_s, s48_value scx_Set_Selection_Owner (s48_value Xdisplay, s48_value Xatom_s,
s48_value Xwindow_owner, s48_value time){ s48_value Xwindow_owner, s48_value time){
XSetSelectionOwner (EXTRACT_DISPLAY(Xdisplay), EXTRACT_ATOM(Xatom_s), XSetSelectionOwner (SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_ATOM(Xatom_s),
EXTRACT_WINDOW(Xwindow_owner), EXTRACT_TIME(time)); SCX_EXTRACT_WINDOW(Xwindow_owner), SCX_EXTRACT_TIME(time));
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Get_Selection_Owner (s48_value Xdisplay, s48_value Xatom_s){ s48_value scx_Get_Selection_Owner (s48_value Xdisplay, s48_value Xatom_s){
return ENTER_WINDOW (XGetSelectionOwner (EXTRACT_DISPLAY(Xdisplay), return SCX_ENTER_WINDOW (XGetSelectionOwner (SCX_EXTRACT_DISPLAY(Xdisplay),
EXTRACT_ATOM(Xatom_s))); SCX_EXTRACT_ATOM(Xatom_s)));
} }
s48_value Convert_Selection (s48_value Xdisplay, s48_value Xatom_s, s48_value scx_Convert_Selection (s48_value Xdisplay, s48_value Xatom_s,
s48_value Xatom_t, s48_value Xatom_p, s48_value Xatom_t, s48_value Xatom_p,
s48_value Xwindow, s48_value time){ s48_value Xwindow, s48_value time){
XConvertSelection(EXTRACT_DISPLAY(Xdisplay), EXTRACT_ATOM(Xatom_s), XConvertSelection(SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_ATOM(Xatom_s),
EXTRACT_ATOM(Xatom_t), EXTRACT_ATOM(Xatom_p), SCX_EXTRACT_ATOM(Xatom_t), SCX_EXTRACT_ATOM(Xatom_p),
EXTRACT_WINDOW(Xwindow), EXTRACT_TIME(time)); SCX_EXTRACT_WINDOW(Xwindow), SCX_EXTRACT_TIME(time));
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
void s48_init_property(void) { void scx_init_property(void) {
S48_EXPORT_FUNCTION(Intern_Atom); S48_EXPORT_FUNCTION(scx_Intern_Atom);
S48_EXPORT_FUNCTION(Find_Atom); S48_EXPORT_FUNCTION(scx_Find_Atom);
S48_EXPORT_FUNCTION(Atom_Name); S48_EXPORT_FUNCTION(scx_Atom_Name);
S48_EXPORT_FUNCTION(List_Properties); S48_EXPORT_FUNCTION(scx_List_Properties);
S48_EXPORT_FUNCTION(Get_Property); S48_EXPORT_FUNCTION(scx_Get_Property);
S48_EXPORT_FUNCTION(Change_Property); S48_EXPORT_FUNCTION(scx_Change_Property);
S48_EXPORT_FUNCTION(Delete_Property); S48_EXPORT_FUNCTION(scx_Delete_Property);
S48_EXPORT_FUNCTION(Rotate_Properties); S48_EXPORT_FUNCTION(scx_Rotate_Properties);
S48_EXPORT_FUNCTION(Set_Selection_Owner); S48_EXPORT_FUNCTION(scx_Set_Selection_Owner);
S48_EXPORT_FUNCTION(Get_Selection_Owner); S48_EXPORT_FUNCTION(scx_Get_Selection_Owner);
S48_EXPORT_FUNCTION(Convert_Selection); S48_EXPORT_FUNCTION(scx_Convert_Selection);
} }

BIN
c/xlib/test
View File

Binary file not shown.

36
c/xlib/text.c
View File

@ -3,9 +3,6 @@
extern XDrawText(), XDrawText16(); extern XDrawText(), XDrawText16();
/* Calculation of text widths and extents should not be done using /* Calculation of text widths and extents should not be done using
* the Xlib functions. For instance, the values returned by * the Xlib functions. For instance, the values returned by
* XTextExtents() are only shorts and can therefore overflow for * XTextExtents() are only shorts and can therefore overflow for
@ -16,8 +13,8 @@ extern XDrawText(), XDrawText16();
s48_value Text_Width(s48_value Xfontstruct, s48_value text, s48_value format){ s48_value Text_Width(s48_value Xfontstruct, s48_value text, s48_value format){
char* s; char* s;
XChar2b* s2; XChar2b* s2;
XFontStruct* font = EXTRACT_XFONTSTRUCT(Xfontstruct); XFontStruct* font = SCX_EXTRACT_FONTSTRUCT(Xfontstruct);
int len = (int)S48_VECTOR_LENGHT(text), i, tmp; int len = (int)S48_VECTOR_LENGTH(text), i, tmp;
if (s48_extract_integer(format) == 2){ if (s48_extract_integer(format) == 2){
for (i = 0; i < len; i++){ for (i = 0; i < len; i++){
tmp = (int)s48_extract_integer(S48_VECTOR_REF(text, i)); tmp = (int)s48_extract_integer(S48_VECTOR_REF(text, i));
@ -28,7 +25,7 @@ s48_value Text_Width(s48_value Xfontstruct, s48_value text, s48_value format){
} }
else{ else{
for (i = 0; i < len; i++){ for (i = 0; i < len; i++){
s[i] = (int)S48_extract_integer(S48_VECTOR_REF(text, i)); s[i] = (int)s48_extract_integer(S48_VECTOR_REF(text, i));
} }
i = XTextWidth(font, s, len); i = XTextWidth(font, s, len);
} }
@ -40,9 +37,9 @@ s48_value Extents_Text (s48_value Xfontstruct, s48_value text,
s48_value format, s48_value which){ s48_value format, s48_value which){
char* s; char* s;
XChar2b* s2; XChar2b* s2;
XFontStruct* font = EXTRACT_XFONTSTRUCT(Xfontstruct); XFontStruct* font = SCX_EXTRACT_FONTSTRUCT(Xfontstruct);
XCharStruct CI; XCharStruct CI;
int len = (int)S48_VECTOR_LENGHT(text), i, tmp, dir, fasc, fdesc; int len = (int)S48_VECTOR_LENGTH(text), i, tmp, dir, fasc, fdesc;
if (s48_extract_integer(format) == 2){ if (s48_extract_integer(format) == 2){
for (i = 0; i < len; i++){ for (i = 0; i < len; i++){
tmp = (int)s48_extract_integer(S48_VECTOR_REF(text, i)); tmp = (int)s48_extract_integer(S48_VECTOR_REF(text, i));
@ -86,16 +83,16 @@ s48_value Draw_Image_Text (s48_value Xdisplay, s48_value Xdrawable,
s2[i].byte1 = (tmp >> 8) & 0xff; s2[i].byte1 = (tmp >> 8) & 0xff;
s2[i].byte2 = tmp & 0xff; s2[i].byte2 = tmp & 0xff;
} }
XDrawImageString16 (EXTRACT_DISPLAY(Xdisplay), EXTRACT_DRAWABLE(Xdrawable), XDrawImageString16 (SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_DRAWABLE(Xdrawable),
EXTRACT_GCONTEXT(Xgcontext), SCX_EXTRACT_GCONTEXT(Xgcontext),
(int)s48_extract_integer(x), (int)s48_extract_integer(x),
(int)s48_extract_integer(y), s2, len); (int)s48_extract_integer(y), s2, len);
}else{ }else{
for (i = 0; i < len; i++){ for (i = 0; i < len; i++){
s[i] = (int)s48_extract_integer(S48_VECTOR_REF(text, i)); s[i] = (int)s48_extract_integer(S48_VECTOR_REF(text, i));
} }
XDrawImageString (EXTRACT_DISPLAY(Xdisplay), EXTRACT_INTEGER(Xdrawable), XDrawImageString (SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_DRAWABLE(Xdrawable),
EXTRACT_GCONTEXT(Xgcontext), SCX_EXTRACT_GCONTEXT(Xgcontext),
(int)s48_extract_integer(x), (int)s48_extract_integer(x),
(int)s48_extract_integer(y), s, len); (int)s48_extract_integer(y), s, len);
} }
@ -112,10 +109,11 @@ s48_value Draw_Poly_Text (s48_value Xdisplay, s48_value Xdrawable,
int twobyte = (int)s48_extract_integer(format); int twobyte = (int)s48_extract_integer(format);
len = S48_VECTOR_LENGTH(text); len = S48_VECTOR_LENGTH(text);
if (!len){ if (len == 0){
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
// count the strings in text: // count the strings in text:
for (i = 0; i < len; i++){ for (i = 0; i < len; i++){
if (S48_VECTOR_P(S48_VECTOR_REF(text, i))){ if (S48_VECTOR_P(S48_VECTOR_REF(text, i))){
nitems++; nitems++;
@ -149,17 +147,17 @@ s48_value Draw_Poly_Text (s48_value Xdisplay, s48_value Xdrawable,
} }
set++; set++;
}else{ }else{
item[set].font = EXTRACT_XFONT(S48_VECTOR_REF(text, i)); item[set].font = SCX_EXTRACT_FONT(S48_VECTOR_REF(text, i));
item[set].delta = 0; item[set].delta = 0;
} }
} }
if (twobyte){ if (twobyte){
XDrawText16(EXTRACT_DISPLAY(Xdisplay), EXTRACT_DRAWABLE(Xdrawable), XDrawText16(SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_DRAWABLE(Xdrawable),
EXTRACT_GCONTEXT(Xgcontext), (int)s48_extract_integer(x), SCX_EXTRACT_GCONTEXT(Xgcontext), (int)s48_extract_integer(x),
(int)s48_extract_integer(y), (XTextItem16*) item, nitems); (int)s48_extract_integer(y), (XTextItem16*) item, nitems);
}else{ }else{
XDrawText(EXTRACT_DISPLAY(Xdisplay), EXTRACT_DRAWABLE(Xdrawable), XDrawText(SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_DRAWABLE(Xdrawable),
EXTRACT_GCONTEXT(Xgcontext), (int)s48_extract_integer(x), SCX_EXTRACT_GCONTEXT(Xgcontext), (int)s48_extract_integer(x),
(int)s48_extract_integer(y), item, nitems); (int)s48_extract_integer(y), item, nitems);
} }
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
@ -167,7 +165,7 @@ s48_value Draw_Poly_Text (s48_value Xdisplay, s48_value Xdrawable,
void s48_init_text(void) { void scx_init_text(void) {
S48_EXPORT_FUNCTION(Text_Width); S48_EXPORT_FUNCTION(Text_Width);
S48_EXPORT_FUNCTION(Extents_Text); S48_EXPORT_FUNCTION(Extents_Text);
S48_EXPORT_FUNCTION(Draw_Image_Text); S48_EXPORT_FUNCTION(Draw_Image_Text);

4
c/xlib/type.c
View File

@ -11,7 +11,7 @@ char* s48_extract_symbol(s48_value sym) {
} }
s48_value string_to_symbol_binding; s48_value string_to_symbol_binding = S48_FALSE;
s48_value s48_enter_symbol(char* name) { s48_value s48_enter_symbol(char* name) {
return s48_call_scheme(S48_SHARED_BINDING_REF(string_to_symbol_binding), return s48_call_scheme(S48_SHARED_BINDING_REF(string_to_symbol_binding),
@ -927,7 +927,7 @@ elk_init_xlib_type () {
*/ */
void s48_init_type(void) { void scx_init_type(void) {
S48_GC_PROTECT_GLOBAL(string_to_symbol_binding); S48_GC_PROTECT_GLOBAL(string_to_symbol_binding);
string_to_symbol_binding = s48_get_imported_binding("string->symbol"); string_to_symbol_binding = s48_get_imported_binding("string->symbol");
// string_to_symbol_binding = S48_SHARED_BINDING_REF(string_to_symbol_binding); // string_to_symbol_binding = S48_SHARED_BINDING_REF(string_to_symbol_binding);

129
c/xlib/window.c
View File

@ -74,7 +74,7 @@ int extract_background(s48_value value) {
return ParentRelative; return ParentRelative;
//else // error ... //else // error ...
} }
return EXTRACT_PIXMAP(value); return SCX_EXTRACT_PIXMAP(value);
} }
int extract_border(s48_value value) { int extract_border(s48_value value) {
@ -87,7 +87,7 @@ int extract_border(s48_value value) {
return s48_extract_integer(value); return s48_extract_integer(value);
} }
s48_value Create_Window (s48_value Xdisplay, s48_value Xparent, s48_value x, 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 y, s48_value width, s48_value height,
s48_value border_width, s48_value attrAlist) { s48_value border_width, s48_value attrAlist) {
@ -95,7 +95,7 @@ s48_value Create_Window (s48_value Xdisplay, s48_value Xparent, s48_value x,
unsigned long mask = AList_To_XSetWindowAttributes( attrAlist, &Xattrs ); unsigned long mask = AList_To_XSetWindowAttributes( attrAlist, &Xattrs );
Window win; Window win;
win = XCreateWindow( EXTRACT_DISPLAY(Xdisplay), EXTRACT_WINDOW(Xparent), win = XCreateWindow( SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_WINDOW(Xparent),
(int)s48_extract_integer(x), (int)s48_extract_integer(x),
(int)s48_extract_integer(y), (int)s48_extract_integer(y),
(int)s48_extract_integer (width), (int)s48_extract_integer (width),
@ -106,33 +106,33 @@ s48_value Create_Window (s48_value Xdisplay, s48_value Xparent, s48_value x,
CopyFromParent, CopyFromParent,
mask, mask,
&Xattrs ); &Xattrs );
return ENTER_WINDOW(win); return SCX_ENTER_WINDOW(win);
} }
s48_value Destroy_Window (s48_value Xdisplay, s48_value Xwindow) { s48_value scx_Destroy_Window (s48_value Xdisplay, s48_value Xwindow) {
XDestroyWindow (EXTRACT_DISPLAY(Xdisplay), EXTRACT_WINDOW(Xwindow)); XDestroyWindow (SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_WINDOW(Xwindow));
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Change_Window_Attributes(s48_value Xwindow, s48_value Xdisplay, s48_value scx_Change_Window_Attributes(s48_value Xwindow, s48_value Xdisplay,
s48_value attrAlist) { s48_value attrAlist) {
XSetWindowAttributes Xattrs; XSetWindowAttributes Xattrs;
unsigned long mask = AList_To_XSetWindowAttributes( attrAlist, &Xattrs ); unsigned long mask = AList_To_XSetWindowAttributes( attrAlist, &Xattrs );
XChangeWindowAttributes(EXTRACT_DISPLAY(Xdisplay), EXTRACT_WINDOW(Xwindow), XChangeWindowAttributes(SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_WINDOW(Xwindow),
mask, &Xattrs); mask, &Xattrs);
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Get_Window_Attributes(s48_value Xdisplay, s48_value Xwindow) { s48_value scx_Get_Window_Attributes(s48_value Xdisplay, s48_value Xwindow) {
XWindowAttributes WA; XWindowAttributes WA;
S48_DECLARE_GC_PROTECT(1); S48_DECLARE_GC_PROTECT(1);
s48_value res = S48_NULL; s48_value res = S48_NULL;
if (!XGetWindowAttributes(EXTRACT_DISPLAY(Xdisplay),EXTRACT_WINDOW(Xwindow), if (!XGetWindowAttributes(SCX_EXTRACT_DISPLAY(Xdisplay),SCX_EXTRACT_WINDOW(Xwindow),
&WA)) &WA))
res = S48_FALSE; res = S48_FALSE;
else { else {
@ -146,17 +146,17 @@ s48_value Get_Window_Attributes(s48_value Xdisplay, s48_value Xwindow) {
S48_VECTOR_SET(res, 3, s48_enter_integer(WA.height)); 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, 4, s48_enter_integer(WA.border_width));
S48_VECTOR_SET(res, 5, s48_enter_integer(WA.depth)); S48_VECTOR_SET(res, 5, s48_enter_integer(WA.depth));
S48_VECTOR_SET(res, 6, ENTER_VISUAL(WA.visual)); S48_VECTOR_SET(res, 6, SCX_ENTER_VISUAL(WA.visual));
S48_VECTOR_SET(res, 7, ENTER_WINDOW(WA.root)); 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, 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, 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, 10, Bit_To_Symbol(WA.win_gravity, Grav_Syms));
S48_VECTOR_SET(res, 11, Bit_To_Symbol(WA.backing_store, S48_VECTOR_SET(res, 11, Bit_To_Symbol(WA.backing_store,
Backing_Store_Syms)); Backing_Store_Syms));
S48_VECTOR_SET(res, 12, s48_enter_integer(WA.backing_planes)); S48_VECTOR_SET(res, 12, s48_enter_integer(WA.backing_planes));
S48_VECTOR_SET(res, 13, ENTER_PIXEL(WA.backing_pixel)); 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, 14, WA.save_under ? S48_TRUE : S48_FALSE );
S48_VECTOR_SET(res, 15, ENTER_COLORMAP( WA.colormap )); 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, 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, 17, Bit_To_Symbol( WA.map_state, Map_State_Syms));
S48_VECTOR_SET(res, 18, Bits_To_Symbols( WA.all_event_masks, S48_VECTOR_SET(res, 18, Bits_To_Symbols( WA.all_event_masks,
@ -174,7 +174,7 @@ s48_value Get_Window_Attributes(s48_value Xdisplay, s48_value Xwindow) {
return res; return res;
} }
s48_value Configure_Window (s48_value Xwindow, s48_value Xdisplay, s48_value scx_Configure_Window (s48_value Xwindow, s48_value Xdisplay,
s48_value alist) { s48_value alist) {
unsigned long mask = 0; unsigned long mask = 0;
XWindowChanges WC; XWindowChanges WC;
@ -214,39 +214,39 @@ s48_value Configure_Window (s48_value Xwindow, s48_value Xdisplay,
} }
} // for } // for
XConfigureWindow (EXTRACT_DISPLAY(Xdisplay),EXTRACT_WINDOW(Xwindow), XConfigureWindow (SCX_EXTRACT_DISPLAY(Xdisplay),SCX_EXTRACT_WINDOW(Xwindow),
mask, &WC); mask, &WC);
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Map_Window(s48_value Xwindow, s48_value Xdisplay) { s48_value scx_Map_Window(s48_value Xwindow, s48_value Xdisplay) {
XMapWindow(EXTRACT_DISPLAY(Xdisplay), EXTRACT_WINDOW(Xwindow)); XMapWindow(SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_WINDOW(Xwindow));
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Unmap_Window(s48_value Xwindow, s48_value Xdisplay) { s48_value scx_Unmap_Window(s48_value Xwindow, s48_value Xdisplay) {
XUnmapWindow(EXTRACT_DISPLAY(Xdisplay), EXTRACT_WINDOW(Xwindow)); XUnmapWindow(SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_WINDOW(Xwindow));
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Destroy_Subwindows (s48_value Xwindow, s48_value Xdisplay) { s48_value scx_Destroy_Subwindows (s48_value Xwindow, s48_value Xdisplay) {
XDestroySubwindows(EXTRACT_DISPLAY(Xdisplay), EXTRACT_WINDOW(Xwindow)); XDestroySubwindows(SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_WINDOW(Xwindow));
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Map_Subwindows (s48_value Xwindow, s48_value Xdisplay) { s48_value scx_Map_Subwindows (s48_value Xwindow, s48_value Xdisplay) {
XMapSubwindows(EXTRACT_DISPLAY(Xdisplay), EXTRACT_WINDOW(Xwindow)); XMapSubwindows(SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_WINDOW(Xwindow));
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Unmap_Subwindows (s48_value Xwindow, s48_value Xdisplay) { s48_value scx_Unmap_Subwindows (s48_value Xwindow, s48_value Xdisplay) {
XUnmapSubwindows(EXTRACT_DISPLAY(Xdisplay), EXTRACT_WINDOW(Xwindow)); XUnmapSubwindows(SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_WINDOW(Xwindow));
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Circulate_Subwindows(s48_value Xwindow, s48_value Xdisplay, s48_value scx_Circulate_Subwindows(s48_value Xwindow, s48_value Xdisplay,
s48_value dir) { s48_value dir) {
XCirculateSubwindows(EXTRACT_DISPLAY(Xdisplay), EXTRACT_WINDOW(Xwindow), XCirculateSubwindows(SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_WINDOW(Xwindow),
S48_FALSE_P(dir) ? RaiseLowest : LowerHighest); S48_FALSE_P(dir) ? RaiseLowest : LowerHighest);
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
@ -267,15 +267,15 @@ static s48_value P_Get_Geometry (d) s48_value d; {
*/ */
s48_value Query_Tree (s48_value Xwindow, s48_value Xdisplay) { s48_value scx_Query_Tree (s48_value Xwindow, s48_value Xdisplay) {
Window root, parent, *children; Window root, parent, *children;
int i; int i;
unsigned n; unsigned n;
s48_value v, ret; s48_value v = S48_FALSE, ret = S48_FALSE;
S48_DECLARE_GC_PROTECT(2); S48_DECLARE_GC_PROTECT(2);
XQueryTree (EXTRACT_DISPLAY(Xdisplay), EXTRACT_WINDOW(Xwindow), XQueryTree (SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_WINDOW(Xwindow),
&root, &parent, &children, &n); &root, &parent, &children, &n);
ret = s48_make_vector(3, S48_FALSE); ret = s48_make_vector(3, S48_FALSE);
@ -286,18 +286,18 @@ s48_value Query_Tree (s48_value Xwindow, s48_value Xdisplay) {
// vector of child-windows // vector of child-windows
v = s48_make_vector (n, S48_FALSE); v = s48_make_vector (n, S48_FALSE);
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
S48_VECTOR_SET(v, i, ENTER_WINDOW(children[i])); S48_VECTOR_SET(v, i, SCX_ENTER_WINDOW(children[i]));
} }
S48_VECTOR_SET(ret, 0, ENTER_WINDOW(root)); S48_VECTOR_SET(ret, 0, SCX_ENTER_WINDOW(root));
S48_VECTOR_SET(ret, 1, ENTER_WINDOW(parent)); S48_VECTOR_SET(ret, 1, SCX_ENTER_WINDOW(parent));
S48_VECTOR_SET(ret, 2, v); S48_VECTOR_SET(ret, 2, v);
S48_GC_UNPROTECT(); S48_GC_UNPROTECT();
return ret; return ret;
} }
s48_value Translate_Coordinates (s48_value Xdisplay, s48_value srcXwindow, s48_value scx_Translate_Coordinates (s48_value Xdisplay, s48_value srcXwindow,
s48_value x, s48_value y, s48_value x, s48_value y,
s48_value dstXwindow) { s48_value dstXwindow) {
int rx, ry; int rx, ry;
@ -306,9 +306,9 @@ s48_value Translate_Coordinates (s48_value Xdisplay, s48_value srcXwindow,
S48_DECLARE_GC_PROTECT(1); S48_DECLARE_GC_PROTECT(1);
if (!XTranslateCoordinates (EXTRACT_DISPLAY(Xdisplay), if (!XTranslateCoordinates (SCX_EXTRACT_DISPLAY(Xdisplay),
EXTRACT_WINDOW(srcXwindow), SCX_EXTRACT_WINDOW(srcXwindow),
EXTRACT_WINDOW(dstXwindow), SCX_EXTRACT_WINDOW(dstXwindow),
(int)s48_extract_integer (x), (int)s48_extract_integer (x),
(int)s48_extract_integer (y), (int)s48_extract_integer (y),
&rx, &ry, &child)) &rx, &ry, &child))
@ -319,22 +319,22 @@ s48_value Translate_Coordinates (s48_value Xdisplay, s48_value srcXwindow,
v = s48_make_vector(3, S48_FALSE); v = s48_make_vector(3, S48_FALSE);
S48_VECTOR_SET(v, 0, s48_enter_integer(rx)); S48_VECTOR_SET(v, 0, s48_enter_integer(rx));
S48_VECTOR_SET(v, 1, s48_enter_integer(ry)); S48_VECTOR_SET(v, 1, s48_enter_integer(ry));
S48_VECTOR_SET(v, 2, ENTER_WINDOW(child)); S48_VECTOR_SET(v, 2, SCX_ENTER_WINDOW(child));
S48_GC_UNPROTECT(); S48_GC_UNPROTECT();
return v; return v;
} }
s48_value Query_Pointer (s48_value Xdisplay, s48_value Xwindow) { s48_value scx_Query_Pointer (s48_value Xdisplay, s48_value Xwindow) {
s48_value v; s48_value v = S48_FALSE;
Bool ret; Bool ret;
Window root, child; Window root, child;
int r_x, r_y, x, y; int r_x, r_y, x, y;
unsigned int mask; unsigned int mask;
S48_DECLARE_GC_PROTECT(1); S48_DECLARE_GC_PROTECT(1);
ret = XQueryPointer (EXTRACT_DISPLAY(Xdisplay), EXTRACT_WINDOW(Xwindow), ret = XQueryPointer (SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_WINDOW(Xwindow),
&root, &child, &r_x, &r_y, &x, &y, &mask); &root, &child, &r_x, &r_y, &x, &y, &mask);
v = s48_make_vector(8, S48_FALSE); v = s48_make_vector(8, S48_FALSE);
@ -343,28 +343,28 @@ s48_value Query_Pointer (s48_value Xdisplay, s48_value Xwindow) {
S48_VECTOR_SET(v, 0, s48_enter_integer(x)); S48_VECTOR_SET(v, 0, s48_enter_integer(x));
S48_VECTOR_SET(v, 1, s48_enter_integer(y)); S48_VECTOR_SET(v, 1, s48_enter_integer(y));
S48_VECTOR_SET(v, 2, ret ? S48_TRUE : S48_FALSE); S48_VECTOR_SET(v, 2, ret ? S48_TRUE : S48_FALSE);
S48_VECTOR_SET(v, 3, ENTER_WINDOW(root)); S48_VECTOR_SET(v, 3, SCX_ENTER_WINDOW(root));
S48_VECTOR_SET(v, 4, s48_enter_integer(r_x)); S48_VECTOR_SET(v, 4, s48_enter_integer(r_x));
S48_VECTOR_SET(v, 5, s48_enter_integer(r_y)); S48_VECTOR_SET(v, 5, s48_enter_integer(r_y));
S48_VECTOR_SET(v, 6, ENTER_WINDOW(child)); S48_VECTOR_SET(v, 6, SCX_ENTER_WINDOW(child));
S48_VECTOR_SET(v, 7, Bits_To_Symbols ((unsigned long)mask, State_Syms)); S48_VECTOR_SET(v, 7, Bits_To_Symbols ((unsigned long)mask, State_Syms));
S48_GC_UNPROTECT(); S48_GC_UNPROTECT();
return v; return v;
} }
s48_value Get_Geometry(s48_value Xdisplay, s48_value Xdrawable) { s48_value scx_Get_Geometry(s48_value Xdisplay, s48_value Xdrawable) {
s48_value v; s48_value v = S48_FALSE;
Window root; Window root;
unsigned int x,y,width,height,border_width,depth; unsigned int x,y,width,height,border_width,depth;
S48_DECLARE_GC_PROTECT(1); S48_DECLARE_GC_PROTECT(1);
XGetGeometry(EXTRACT_DISPLAY(Xdisplay), EXTRACT_DRAWABLE(Xdrawable), XGetGeometry(SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_DRAWABLE(Xdrawable),
&root, &x, &y, &width, &height, &border_width, &depth); &root, &x, &y, &width, &height, &border_width, &depth);
v = s48_make_vector(7, S48_FALSE); v = s48_make_vector(7, S48_FALSE);
S48_GC_PROTECT_1(v); S48_GC_PROTECT_1(v);
S48_VECTOR_SET(v, 0, ENTER_WINDOW(root)); S48_VECTOR_SET(v, 0, SCX_ENTER_WINDOW(root));
S48_VECTOR_SET(v, 1, s48_enter_integer(x)); S48_VECTOR_SET(v, 1, s48_enter_integer(x));
S48_VECTOR_SET(v, 2, s48_enter_integer(y)); S48_VECTOR_SET(v, 2, s48_enter_integer(y));
S48_VECTOR_SET(v, 3, s48_enter_integer(width)); S48_VECTOR_SET(v, 3, s48_enter_integer(width));
@ -375,21 +375,20 @@ s48_value Get_Geometry(s48_value Xdisplay, s48_value Xdrawable) {
return v; return v;
} }
void s48_init_window(void) { void scx_init_window(void) {
S48_EXPORT_FUNCTION(Create_Window); S48_EXPORT_FUNCTION(scx_Create_Window);
S48_EXPORT_FUNCTION(Destroy_Window); S48_EXPORT_FUNCTION(scx_Destroy_Window);
S48_EXPORT_FUNCTION(Change_Window_Attributes); S48_EXPORT_FUNCTION(scx_Change_Window_Attributes);
S48_EXPORT_FUNCTION(Get_Window_Attributes); S48_EXPORT_FUNCTION(scx_Get_Window_Attributes);
S48_EXPORT_FUNCTION(Configure_Window); S48_EXPORT_FUNCTION(scx_Configure_Window);
S48_EXPORT_FUNCTION(Map_Window); S48_EXPORT_FUNCTION(scx_Map_Window);
S48_EXPORT_FUNCTION(Unmap_Window); S48_EXPORT_FUNCTION(scx_Unmap_Window);
S48_EXPORT_FUNCTION(Destroy_Subwindows); S48_EXPORT_FUNCTION(scx_Destroy_Subwindows);
S48_EXPORT_FUNCTION(Map_Subwindows); S48_EXPORT_FUNCTION(scx_Map_Subwindows);
S48_EXPORT_FUNCTION(Unmap_Subwindows); S48_EXPORT_FUNCTION(scx_Unmap_Subwindows);
S48_EXPORT_FUNCTION(Circulate_Subwindows); S48_EXPORT_FUNCTION(scx_Circulate_Subwindows);
S48_EXPORT_FUNCTION(Query_Tree); S48_EXPORT_FUNCTION(scx_Query_Tree);
S48_EXPORT_FUNCTION(Translate_Coordinates); S48_EXPORT_FUNCTION(scx_Translate_Coordinates);
S48_EXPORT_FUNCTION(Query_Pointer); S48_EXPORT_FUNCTION(scx_Query_Pointer);
S48_EXPORT_FUNCTION(Get_Geometry); S48_EXPORT_FUNCTION(scx_Get_Geometry);
} }

106
c/xlib/wm.c
View File

@ -1,80 +1,81 @@
#include "xlib.h" #include "xlib.h"
#include "scheme48.h" #include "scheme48.h"
s48_value Reparent_Window(s48_value Xdisplay, s48_value Xwindow, s48_value scx_Reparent_Window(s48_value Xdisplay, s48_value Xwindow,
s48_value Xwindow_parent, s48_value x, s48_value Xwindow_parent, s48_value x,
s48_value y) { s48_value y) {
XReparentWindow(EXTRACT_DISPLAY(Xdisplay), XReparentWindow(SCX_EXTRACT_DISPLAY(Xdisplay),
EXTRACT_WINDOW(Xwindow), SCX_EXTRACT_WINDOW(Xwindow),
EXTRACT_WINDOW(Xwindow_parent), SCX_EXTRACT_WINDOW(Xwindow_parent),
(int)s48_extract_integer (x), (int)s48_extract_integer (y)); (int)s48_extract_integer (x), (int)s48_extract_integer (y));
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Install_Colormap(s48_value Xdisplay, s48_value Xcolormap) { s48_value scx_Install_Colormap(s48_value Xdisplay, s48_value Xcolormap) {
XInstallColormap(EXTRACT_DISPLAY(Xdisplay), EXTRACT_COLORMAP(Xcolormap)); XInstallColormap(SCX_EXTRACT_DISPLAY(Xdisplay),
SCX_EXTRACT_COLORMAP(Xcolormap));
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Uninstall_Colormap(s48_value Xdisplay, s48_value Xcolormap) { s48_value scx_Uninstall_Colormap(s48_value Xdisplay, s48_value Xcolormap) {
XUninstallColormap(EXTRACT_DISPLAY(Xdisplay), EXTRACT_COLORMAP(Xcolormap)); XUninstallColormap(SCX_EXTRACT_DISPLAY(Xdisplay),
SCX_EXTRACT_COLORMAP(Xcolormap));
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value List_Installed_Colormaps(s48_value Xdisplay, s48_value Xwindow) { s48_value scx_List_Installed_Colormaps(s48_value Xdisplay, s48_value Xwindow) {
int i, n; int i, n;
Colormap *ret; Colormap *ret;
s48_value v; s48_value v = S48_FALSE;
S48_DECLARE_GC_PROTECT(1); S48_DECLARE_GC_PROTECT(1);
ret = XListInstalledColormaps(EXTRACT_DISPLAY(Xdisplay), ret = XListInstalledColormaps(SCX_EXTRACT_DISPLAY(Xdisplay),
EXTRACT_WINDOW(Xwindow), SCX_EXTRACT_WINDOW(Xwindow),
&n); &n);
v = s48_make_vector (n, S48_FALSE); v = s48_make_vector (n, S48_FALSE);
S48_GC_PROTECT_1 (v); S48_GC_PROTECT_1 (v);
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
S48_VECTOR_SET(v, i, ENTER_COLORMAP(ret[i])); S48_VECTOR_SET(v, i, SCX_ENTER_COLORMAP(ret[i]));
} }
XFree ((char *)ret); XFree ((char *)ret);
S48_GC_UNPROTECT(); S48_GC_UNPROTECT();
return v; return v;
} }
s48_value Set_Input_Focus(s48_value Xdisplay, s48_value Xwindow, s48_value scx_Set_Input_Focus(s48_value Xdisplay, s48_value Xwindow,
s48_value revert_to, s48_value time) { s48_value revert_to, s48_value time) {
Window focus = PointerRoot; Window focus = PointerRoot;
if (!S48_SYMBOL_P(Xwindow)) if (!S48_SYMBOL_P(Xwindow))
focus = EXTRACT_WINDOW(Xwindow); focus = SCX_EXTRACT_WINDOW(Xwindow);
XSetInputFocus (EXTRACT_DISPLAY(Xdisplay), focus, XSetInputFocus (SCX_EXTRACT_DISPLAY(Xdisplay), focus,
Symbol_To_Bit (revert_to, Revert_Syms), Symbol_To_Bit (revert_to, Revert_Syms),
EXTRACT_TIME(time)); SCX_EXTRACT_TIME(time));
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Input_Focus (s48_value Xdisplay) { s48_value scx_Input_Focus (s48_value Xdisplay) {
Window win; Window win;
int revert_to; int revert_to;
s48_value ret, x; s48_value ret = S48_FALSE;
S48_DECLARE_GC_PROTECT(1); S48_DECLARE_GC_PROTECT(1);
XGetInputFocus (EXTRACT_DISPLAY(Xdisplay), &win, &revert_to); XGetInputFocus (SCX_EXTRACT_DISPLAY(Xdisplay), &win, &revert_to);
ret = s48_cons (S48_NULL, S48_NULL); ret = s48_cons (S48_NULL, S48_NULL);
S48_GC_PROTECT_1 (ret); S48_GC_PROTECT_1 (ret);
x = ENTER_WINDOW(win); S48_SET_CAR(ret, x); S48_SET_CAR(ret, SCX_ENTER_WINDOW(win));
x = Bit_To_Symbol((unsigned long)revert_to, Revert_Syms); S48_SET_CDR(ret, Bit_To_Symbol((unsigned long)revert_to, Revert_Syms));
S48_SET_CDR(ret, x);
S48_GC_UNPROTECT(); S48_GC_UNPROTECT();
return ret; return ret;
} }
s48_value General_Warp_Pointer(s48_value dpy, s48_value dst, s48_value dstx, s48_value scx_General_Warp_Pointer(s48_value dpy, s48_value dst, s48_value dstx,
s48_value dsty, s48_value src, s48_value srcx, s48_value dsty, s48_value src, s48_value srcx,
s48_value srcy, s48_value srcw, s48_value srch) { s48_value srcy, s48_value srcw, s48_value srch) {
XWarpPointer (EXTRACT_DISPLAY(dpy), XWarpPointer (SCX_EXTRACT_DISPLAY(dpy),
EXTRACT_WINDOW(src), EXTRACT_WINDOW(dst), SCX_EXTRACT_WINDOW(src), SCX_EXTRACT_WINDOW(dst),
(int)s48_extract_integer (srcx), (int)s48_extract_integer (srcx),
(int)s48_extract_integer (srcy), (int)s48_extract_integer (srcy),
(int)s48_extract_integer (srcw), (int)s48_extract_integer (srcw),
@ -84,42 +85,43 @@ s48_value General_Warp_Pointer(s48_value dpy, s48_value dst, s48_value dstx,
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Bell(s48_value Xdisplay, s48_value percent) { s48_value scx_Bell(s48_value Xdisplay, s48_value percent) {
int p = (int)s48_extract_integer(percent); int p = (int)s48_extract_integer(percent);
XBell (EXTRACT_DISPLAY(Xdisplay), p); XBell (SCX_EXTRACT_DISPLAY(Xdisplay), p);
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Set_Access_Control(s48_value Xdisplay, s48_value on) { s48_value scx_Set_Access_Control(s48_value Xdisplay, s48_value on) {
XSetAccessControl (EXTRACT_DISPLAY(Xdisplay), !S48_FALSE_P(on)); XSetAccessControl (SCX_EXTRACT_DISPLAY(Xdisplay), !S48_FALSE_P(on));
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Change_Save_Set(s48_value Xdisplay, s48_value win, s48_value mode) { s48_value scx_Change_Save_Set(s48_value Xdisplay, s48_value win,
XChangeSaveSet(EXTRACT_DISPLAY(Xdisplay), EXTRACT_WINDOW(win), s48_value mode) {
XChangeSaveSet(SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_WINDOW(win),
Symbol_To_Bit(mode, Saveset_Syms)); Symbol_To_Bit(mode, Saveset_Syms));
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
s48_value Set_Close_Down_Mode(s48_value Xdisplay, s48_value mode) { s48_value scx_Set_Close_Down_Mode(s48_value Xdisplay, s48_value mode) {
XSetCloseDownMode(EXTRACT_DISPLAY(Xdisplay), XSetCloseDownMode(SCX_EXTRACT_DISPLAY(Xdisplay),
Symbol_To_Bit (mode, Closemode_Syms)); Symbol_To_Bit (mode, Closemode_Syms));
return S48_UNSPECIFIC; return S48_UNSPECIFIC;
} }
static s48_value Get_Pointer_Mapping(s48_value Xdisplay) { s48_value scx_Get_Pointer_Mapping(s48_value Xdisplay) {
unsigned char map[256]; unsigned char map[256];
int i, n; int i, n;
s48_value ret; s48_value ret;
n = XGetPointerMapping (EXTRACT_DISPLAY(Xdisplay), map, 256); n = XGetPointerMapping (SCX_EXTRACT_DISPLAY(Xdisplay), map, 256);
ret = s48_make_vector (n, S48_NULL); ret = s48_make_vector (n, S48_NULL);
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
S48_VECTOR_SET(ret, i, s48_enter_integer (map[i])); S48_VECTOR_SET(ret, i, s48_enter_integer (map[i]));
return ret; return ret;
} }
s48_value Set_Pointer_Mapping (s48_value Xdisplay, s48_value map) { s48_value scx_Set_Pointer_Mapping (s48_value Xdisplay, s48_value map) {
int i, n = S48_VECTOR_LENGTH(map); int i, n = S48_VECTOR_LENGTH(map);
unsigned char p[n]; unsigned char p[n];
int ret; int ret;
@ -127,22 +129,22 @@ s48_value Set_Pointer_Mapping (s48_value Xdisplay, s48_value map) {
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
p[i] = (int)s48_extract_integer(S48_VECTOR_REF(map, i)); p[i] = (int)s48_extract_integer(S48_VECTOR_REF(map, i));
ret = XSetPointerMapping (EXTRACT_DISPLAY(Xdisplay), p, n); ret = XSetPointerMapping (SCX_EXTRACT_DISPLAY(Xdisplay), p, n);
return (ret == MappingSuccess) ? S48_TRUE : S48_FALSE; return (ret == MappingSuccess) ? S48_TRUE : S48_FALSE;
} }
void s48_init_wm(void) { void scx_init_wm(void) {
S48_EXPORT_FUNCTION(Reparent_Window); S48_EXPORT_FUNCTION(scx_Reparent_Window);
S48_EXPORT_FUNCTION(Install_Colormap); S48_EXPORT_FUNCTION(scx_Install_Colormap);
S48_EXPORT_FUNCTION(Uninstall_Colormap); S48_EXPORT_FUNCTION(scx_Uninstall_Colormap);
S48_EXPORT_FUNCTION(List_Installed_Colormaps); S48_EXPORT_FUNCTION(scx_List_Installed_Colormaps);
S48_EXPORT_FUNCTION(Set_Input_Focus); S48_EXPORT_FUNCTION(scx_Set_Input_Focus);
S48_EXPORT_FUNCTION(Input_Focus); S48_EXPORT_FUNCTION(scx_Input_Focus);
S48_EXPORT_FUNCTION(General_Warp_Pointer); S48_EXPORT_FUNCTION(scx_General_Warp_Pointer);
S48_EXPORT_FUNCTION(Bell); S48_EXPORT_FUNCTION(scx_Bell);
S48_EXPORT_FUNCTION(Set_Access_Control); S48_EXPORT_FUNCTION(scx_Set_Access_Control);
S48_EXPORT_FUNCTION(Change_Save_Set); S48_EXPORT_FUNCTION(scx_Change_Save_Set);
S48_EXPORT_FUNCTION(Set_Close_Down_Mode); S48_EXPORT_FUNCTION(scx_Set_Close_Down_Mode);
S48_EXPORT_FUNCTION(Get_Pointer_Mapping); S48_EXPORT_FUNCTION(scx_Get_Pointer_Mapping);
S48_EXPORT_FUNCTION(Set_Pointer_Mapping); S48_EXPORT_FUNCTION(scx_Set_Pointer_Mapping);
} }

48
c/xlib/xlib.h
View File

@ -29,30 +29,32 @@ extern char* s48_extract_symbol(s48_value);
/* Extraction-Macros for the new types, from their s48_value wrapping. /* Extraction-Macros for the new types, from their s48_value wrapping.
*/ */
#define EXTRACT_DISPLAY(x) (Display*)s48_extract_integer(x) #define SCX_EXTRACT_DISPLAY(x) (Display*)s48_extract_integer(x)
#define ENTER_DISPLAY(x) s48_enter_integer((long)x) #define SCX_ENTER_DISPLAY(x) s48_enter_integer((long)x)
#define EXTRACT_WINDOW(x) (Window)s48_extract_integer(x) #define SCX_EXTRACT_WINDOW(x) (Window)s48_extract_integer(x)
#define ENTER_WINDOW(x) s48_enter_integer((long)x) #define SCX_ENTER_WINDOW(x) s48_enter_integer((long)x)
#define EXTRACT_COLOR(x) (XColor*)S48_EXTRACT_VALUE_POINTER(x, XColor) #define SCX_EXTRACT_COLOR(x) (XColor*)S48_EXTRACT_VALUE_POINTER(x, XColor)
#define EXTRACT_COLORMAP(x) (Colormap)s48_extract_integer(x) #define SCX_EXTRACT_COLORMAP(x) (Colormap)s48_extract_integer(x)
#define ENTER_COLORMAP(x) s48_enter_integer((long)x) #define SCX_ENTER_COLORMAP(x) s48_enter_integer((long)x)
#define EXTRACT_PIXEL(x) (unsigned long)s48_extract_integer(x) #define SCX_EXTRACT_PIXEL(x) (unsigned long)s48_extract_integer(x)
#define ENTER_PIXEL(x) s48_enter_integer((long)x) #define SCX_ENTER_PIXEL(x) s48_enter_integer((long)x)
#define EXTRACT_GCONTEXT(x) (GC)s48_extract_integer(x) #define SCX_EXTRACT_GCONTEXT(x) (GC)s48_extract_integer(x)
#define ENTER_GCONTEXT(x) s48_enter_integer((long)x) #define SCX_ENTER_GCONTEXT(x) s48_enter_integer((long)x)
#define EXTRACT_PIXMAP(x) (Pixmap)s48_extract_integer(x) #define SCX_ENTER_PIXMAP(x) s48_enter_integer((long)x)
#define ENTER_PIXMAP(x) s48_enter_integer((long)x) #define SCX_EXTRACT_PIXMAP(x) (Pixmap)s48_extract_integer(x)
#define EXTRACT_DRAWABLE(x) (Drawable)s48_extract_integer(x) #define SCX_EXTRACT_DRAWABLE(x) (Drawable)s48_extract_integer(x)
#define ENTER_ATOM(x) s48_enter_integer((long)x) #define SCX_ENTER_ATOM(x) s48_enter_integer((long)x)
#define EXTRACT_ATOM(x) (Atom)s48_extract_integer(x) #define SCX_EXTRACT_ATOM(x) (Atom)s48_extract_integer(x)
#define ENTER_TIME(x) x == CurrentTime ? s48_enter_symbol("now") : s48_enter_integer(x) #define SCX_ENTER_TIME(x) x == CurrentTime ? s48_enter_symbol("now") : s48_enter_integer(x)
#define EXTRACT_TIME(x) S48_SYMBOL_P(x) ? CurrentTime : (int)s48_extract_integer(x) #define SCX_EXTRACT_TIME(x) S48_SYMBOL_P(x) ? CurrentTime : (int)s48_extract_integer(x)
#define SCX_EXTRACT_CURSOR(x) (Cursor)s48_extract_integer(x)
#define SCX_ENTER_CURSOR(x) s48_enter_integer((long)x)
#define SCX_ENTER_FONT(x) s48_enter_integer((long)x)
#define SCX_EXTRACT_FONT(x) (Font)s48_extract_integer(x)
#define SCX_ENTER_FONTSTRUCT(x) s48_enter_integer((long)x)
#define SCX_EXTRACT_FONTSTRUCT(x) (XFontStruct*)s48_extract_integer(x)
// TODO: // TODO:
#define ENTER_VISUAL(x) S48_FALSE #define SCX_ENTER_VISUAL(x) S48_FALSE
#define ENTER_FONT(x) s48_enter_integer((long)x)
#define EXTRACT_FONT(x) (Font)s48_extract_integer(x)
#define ENTER_FONTSTRUCT(x) s48_enter_integer((long)x)
#define EXTRACT_FONTSTRUCT(x) (XFontStruct*)s48_extract_integer(x)
/* /*