lcx11.c File Reference

#include "lcconfig.h"
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <math.h>
#include "lcstring.h"
#include "lcintl.h"
#include "fileutil.h"
#include "lclib.h"
#include <X11/Xlib.h>
#include <X11/Xatom.h>
#include <X11/Xutil.h>
#include <X11/keysym.h>
#include <X11/keysymdef.h>
#include "lin-city.h"
#include "lctypes.h"
#include "cliglobs.h"
#include "lcx11.h"
#include "pixmap.h"
#include "mouse.h"
#include "screen.h"

Go to the source code of this file.

Defines
#define	USE_IMAGES   1
#define	DEBUG_X11_MOUSE
#define	NO_RESIZABLE_WINDOWS   1
Functions
void	set_pointer_confinement (void)
int	confine_pointer (int x, int y, int w, int h)
void	unconfine_pointer (void)
void	setcustompalette (void)
void	open_setcustompalette (XColor *inpal)
void	do_setcustompalette (XColor *inpal)
void	Fgl_setfontcolors (int bg, int fg)
void	Fgl_setfont (int fw, int fh, void *fp)
void	parse_xargs (int argc, char **argv, char **geometry)
void	Create_Window (char *geometry)
void	unlock_window_size (void)
void	HandleError (char *description, int degree)
void	Fgl_setpixel (int x, int y, int col)
int	Fgl_getpixel (int x, int y)
void	Fgl_hline (int x1, int y1, int x2, int col)
void	Fgl_line (int x1, int y1, int dummy, int y2, int col)
void	Fgl_write (int x, int y, char *s)
void	open_write (int x, int y, char *s)
void	my_x_putchar (int xx, int yy, unsigned char c)
void	open_x_putchar (int xx, int yy, unsigned char c)
void	Fgl_fillbox (int x1, int y1, int w, int h, int col)
int	clamp (int x, int low, int high)
void	Fgl_putbox_low (Drawable dst, int x0, int y0, int x1, int y1, int w, int h, unsigned char *src, int bpl, int src_x, int src_y)
void	Fgl_putbox (int x, int y, int w, int h, void *buf)
void	Fgl_getbox (int x1, int y1, int w, int h, void *buf)
void	HandleEvent (XEvent *event)
void	refresh_screen (int x1, int y1, int x2, int y2)
void	Fgl_enableclipping (void)
void	Fgl_setclippingwindow (int x1, int y1, int x2, int y2)
void	Fgl_disableclipping (void)
void	do_call_event (int wait)
void	call_event (void)
void	call_wait_event (void)
int	lc_get_keystroke (void)
void	init_x_mouse (void)
void	draw_border (void)
Variables
int	pointer_confined

---

Define Documentation

#define DEBUG_X11_MOUSE

Definition at line 35 of file lcx11.c.

#define NO_RESIZABLE_WINDOWS   1

#define USE_IMAGES   1

Definition at line 33 of file lcx11.c.

---

Function Documentation

void call_event (  void   )

Definition at line 1010 of file lcx11.c. { do_call_event (0); }

void call_wait_event (  void   )

Definition at line 1016 of file lcx11.c. { do_call_event (1); }

int clamp (  int  x, int  low, int  high )  [static]

Definition at line 626 of file lcx11.c. { if (x < low) x = low; else if (x > high) x = high; return x; }

int confine_pointer (  int  x, int  y, int  w, int  h )

Definition at line 54 of file lcx11.c. { if (display.pointer_confined) return 0; display.confinewin = XCreateSimpleWindow(display.dpy, display.win, 10, 10, w, h, 0, 0, 0); XMapWindow(display.dpy, display.confinewin); XGrabPointer(display.dpy, display.root, 1, ButtonPressMask | ButtonReleaseMask | PointerMotionMask, GrabModeAsync, GrabModeAsync, display.confinewin, None, CurrentTime); display.pointer_confined = 1; return 1; }

void Create_Window (  char *  geometry  )

Definition at line 333 of file lcx11.c. { short q; Visual *vid; XSetWindowAttributes xswa; XSizeHints sizehint; XWMHints wmhints; int depth; unsigned char wname[256]; /* Window Name */ unsigned long vmask = CWEventMask | CWBackPixel | CWBackingStore; depth = DefaultDepth (display.dpy, display.screen); xswa.event_mask = 0; xswa.background_pixel = display.bg; xswa.backing_store = Always; debug_printf ("DefaultVisual id=%d bp-rgb=%d map-entries=%d\n", (int) (*DefaultVisual (display.dpy, display.screen)).visualid, (*DefaultVisual (display.dpy, display.screen)).bits_per_rgb, (*DefaultVisual (display.dpy, display.screen)).map_entries); vid = DefaultVisual (display.dpy, display.screen); display.cmap = XDefaultColormap (display.dpy, display.screen); display.win = XCreateWindow (display.dpy, display.root, winX, winY, display.winW, display.winH, 0, depth, InputOutput, /* vid , */ DefaultVisual (display.dpy, display.screen), /* PseudoColor, */ vmask, &xswa); sizehint.x = winX - 100; sizehint.y = winY; sizehint.width = display.winW; sizehint.height = display.winH; sizehint.min_width = display.winW; sizehint.min_height = display.winH; sizehint.max_width = display.winW; sizehint.max_height = display.winH; /* GCS FIX: Be careful about resizing the opening screen */ /* WCK: Fixed. We lock it now, and unlock it after the opening screen. not gorgeous, but it works for now. Still need to clean up.*/ #define NO_RESIZABLE_WINDOWS 1 if (geometry != NULL) { #if defined (NO_RESIZABLE_WINDOWS) sizehint.flags = USPosition | USSize | PMinSize | PMaxSize; #else sizehint.flags = USPosition | USSize | PMinSize; #endif } else { #if defined (NO_RESIZABLE_WINDOWS) sizehint.flags = PPosition | PSize | PMinSize | PMaxSize; #else sizehint.flags = PPosition | PSize | PMinSize; #endif } XSetNormalHints (display.dpy, display.win, &sizehint); display.protocol_atom = XInternAtom (display.dpy, "WM_PROTOCOLS", False); display.kill_atom = XInternAtom (display.dpy, "WM_DELETE_WINDOW", False); /* Title */ sprintf ((char *) wname, _("xlincity, Version %s, " "(Copyright) IJ Peters - copying policy GNU GPL"), VERSION); XChangeProperty (display.dpy, display.win, XA_WM_NAME, XA_STRING, 8, PropModeReplace, wname, strlen ((char *) wname)); /* Window Manager Hints (This is supposed to make input work.) */ wmhints.flags = InputHint; wmhints.input = True; XSetWMHints (display.dpy, display.win, &wmhints); /* GCS - 2003/08/15 - Cygwin doesn't generate the MapEvent unless the mask enabled before XMapWindow is called. Therefore, XSelectInput needs to be called before XMapWindow */ XSelectInput (display.dpy, display.win, KeyPressMask | ButtonPressMask | ButtonReleaseMask | ExposureMask | StructureNotifyMask); XMapWindow (display.dpy, display.win); for (q = 0; q < 256; q++) { display.pixcolour_gc[q] = XCreateGC (display.dpy ,display.win, 0, NULL); XSetForeground (display.dpy, display.pixcolour_gc[q], q); XSetBackground (display.dpy, display.pixcolour_gc[q], display.bg); XSetGraphicsExposures (display.dpy, display.pixcolour_gc[q], False); } }

void do_call_event (  int  wait  )

Definition at line 973 of file lcx11.c. { int dummy_int, x, y; Window dummy_win; XEvent xev; if (XPending (display.dpy)) { XNextEvent (display.dpy, &xev); HandleEvent (&xev); } else if (wait) lc_usleep (1000); /* WCK: this could possibly be better handled with a MotionEvent */ XQueryPointer (display.dpy, display.win, &dummy_win, &dummy_win ,&dummy_int, &dummy_int, &x, &y, (unsigned int *) &dummy_int); #ifdef ALLOW_PIX_DOUBLING if (pix_double) { x /= 2; y /= 2; } else { #endif x -= borderx; y -= bordery; #ifdef ALLOW_PIX_DOUBLING } #endif if (x != cs_mouse_x || y != cs_mouse_y) cs_mouse_handler (0, x - cs_mouse_x, y - cs_mouse_y); /* WCK: no longer passing mouse_button, 0 used instead. Presses are handled in the event loop */ }

void do_setcustompalette (  XColor *  inpal  )

Definition at line 144 of file lcx11.c. { int i, n, me = 0, flag[256], vid; int depth; long unsigned int plane_masks[3]; XColor pal[256]; int writeable_p; display.cmap = XDefaultColormap (display.dpy, display.screen); depth = DefaultDepth (display.dpy, display.screen); /* Decide, if the colormap is writable */ { Visual *visual = DefaultVisual (display.dpy, display.screen); #if defined(__cplusplus) || defined(c_plusplus) int visual_class = visual->c_class; #else int visual_class = visual->class; #endif writeable_p = (visual_class == PseudoColor || visual_class == GrayScale); } if (writeable_p) { if (XAllocColorCells (display.dpy, display.cmap, 0 ,plane_masks, 0, colour_table, 256) == 0) { me = (*DefaultVisual (display.dpy, display.screen)).map_entries; vid = (*DefaultVisual (display.dpy, display.screen)).visualid; display.cmap = XCreateColormap (display.dpy, display.win ,DefaultVisual (display.dpy, display.screen) /* ,PseudoColor */ ,AllocNone); if (me == 256 && depth != 24) { if (XAllocColorCells (display.dpy, display.cmap, 0 ,plane_masks, 0, colour_table, 256) != 0) { /* printf ("Allocated 256 cells\n"); */ } else { printf ("Couldn't allocate 256 cells\n"); } } else for (i = 0; i < 256; i++) colour_table[i] = i; } if (!display.cmap) HandleError ("No default colour map", FATAL); } for (i = 0; i < 256; i++) flag[i] = 0; for (n = 0; n < 256; n++) { pal[n].red = inpal[n].red << 10; pal[n].green = inpal[n].green << 10; pal[n].blue = inpal[n].blue << 10; pal[n].flags = DoRed | DoGreen | DoBlue; if (writeable_p) pal[n].pixel = colour_table[n]; else { if (XAllocColor (display.dpy ,display.cmap, &(pal[n])) == 0) HandleError ("alloc colour failed" ,FATAL); colour_table[n] = pal[n].pixel; XSetForeground (display.dpy ,display.pixcolour_gc[n] ,colour_table[n]); } flag[n] = 1; } if (writeable_p) { XStoreColors (display.dpy, display.cmap, pal, 256); XFlush (display.dpy); } XSetWindowColormap (display.dpy, display.win, display.cmap); }

void draw_border (  void   )

Definition at line 1045 of file lcx11.c. { int col = TEXT_BG_COLOUR & 0xff; int pd = pix_double + 1; if (borderx > 0) { XFillRectangle (display.dpy, display.win, display.pixcolour_gc[col], 0, bordery, borderx, display.winH - 2*bordery); XFillRectangle (display.dpy, display.win, display.pixcolour_gc[col], display.winW - borderx, bordery, borderx, display.winH - 2*bordery); } if (bordery > 0) { XFillRectangle (display.dpy, display.win, display.pixcolour_gc[col], 0, 0, display.winW, bordery); XFillRectangle (display.dpy, display.win, display.pixcolour_gc[col], 0, display.winH - bordery, display.winW, bordery); } }

void Fgl_disableclipping (  void   )

Definition at line 967 of file lcx11.c. { clipping_flag = 0; }

void Fgl_enableclipping (  void   )

Definition at line 952 of file lcx11.c. { clipping_flag = 1; }

void Fgl_fillbox (  int  x1, int  y1, int  w, int  h, int  col )

Definition at line 590 of file lcx11.c. { if (clipping_flag) { if (x1 < xclip_x1) x1 = xclip_x1; if (x1 + w - 1 > xclip_x2) w = xclip_x2 - x1 + 1; if (y1 < xclip_y1) y1 = xclip_y1; if (y1 + h - 1 > xclip_y2) h = xclip_y2 - y1 + 1; } col &= 0xff; pixmap_fillbox (x1, y1, w, h, col); #ifdef ALLOW_PIX_DOUBLING if (pix_double) XFillRectangle (display.dpy, display.win, display.pixcolour_gc[col], x1 * 2, y1 * 2, w * 2, h * 2); else #endif XFillRectangle (display.dpy, display.win, display.pixcolour_gc[col], x1 + borderx, y1 + bordery, w, h); }

void Fgl_getbox (  int  x1, int  y1, int  w, int  h, void *  buf )

Definition at line 731 of file lcx11.c. { unsigned char *b; int x, y; b = (unsigned char *) buf; for (y = y1; y < y1 + h; y++) for (x = x1; x < x1 + w; x++) *(b++) = (unsigned char) Fgl_getpixel (x, y); }

int Fgl_getpixel (  int  x, int  y )

Definition at line 497 of file lcx11.c. { return pixmap_getpixel (x, y); }

void Fgl_hline (  int  x1, int  y1, int  x2, int  col )

Definition at line 503 of file lcx11.c. { col &= 0xff; pixmap_hline (x1, y1, x2, col); #ifdef ALLOW_PIX_DOUBLING if (pix_double) XFillRectangle (display.dpy, display.win ,display.pixcolour_gc[col], x1 * 2, y1 * 2 ,(x2 - x1) * 2 + 1, 2); else #endif XDrawLine (display.dpy, display.win ,display.pixcolour_gc[col], x1 + borderx ,y1 + bordery, x2 + borderx, y1 + bordery); }

void Fgl_line (  int  x1, int  y1, int  dummy, int  y2, int  col )

Definition at line 520 of file lcx11.c. { col &= 0xff; pixmap_vline (x1, y1, y2, col); #ifdef ALLOW_PIX_DOUBLING if (pix_double) XFillRectangle (display.dpy, display.win ,display.pixcolour_gc[col], x1 * 2, y1 * 2 ,2, (y2 - y1) * 2 + 1); else #endif XDrawLine (display.dpy, display.win ,display.pixcolour_gc[col], x1 + borderx ,y1 + bordery, x1 + borderx, y2 + bordery); }

void Fgl_putbox (  int  x, int  y, int  w, int  h, void *  buf )

Definition at line 699 of file lcx11.c. { int c_x0 = clipping_flag ? xclip_x1 : 0; int c_x1 = clipping_flag ? xclip_x2 : display.winW - 1; int c_y0 = clipping_flag ? xclip_y1 : 0; int c_y1 = clipping_flag ? xclip_y2 : display.winH - 1; int x1 = clamp (x, c_x0, c_x1); int y1 = clamp (y, c_y0, c_y1); int x2 = clamp (x + w, c_x0, c_x1 + 1); int y2 = clamp (y + h, c_y0, c_y1 + 1); if (x2 > x1 && y2 > y1) Fgl_putbox_low (display.win, borderx, bordery, x1, y1, x2 - x1, y2 - y1, (unsigned char *) buf, w, x1 - x, y1 - y); }

void Fgl_putbox_low (  Drawable  dst, int  x0, int  y0, int  x1, int  y1, int  w, int  h, unsigned char *  src, int  bpl, int  src_x, int  src_y )

Definition at line 644 of file lcx11.c. { XImage *im; int x, y; #ifdef ALLOW_PIX_DOUBLING const int pmult = pix_double ? 2 : 1; #else const int pmult = 1; #endif im = XCreateImage (display.dpy, 0, /* display and visual */ DefaultDepth (display.dpy, display.screen), /* depth */ ZPixmap, /* format */ 0, /* offset */ 0, /* data */ pmult * w, pmult * h, /* width and height */ 32, 0); /* bitmap_pad and bytes_per_line */ /* XXX: assert is not the right way to check for errors - wck */ assert (im != 0); im->data = (char *) malloc (im->bytes_per_line * pmult * h); assert (im->data != 0); src += src_x + src_y * bpl; if (pmult == 1) { for (y = 0; y < h; y++) for (x = 0; x < w; x++) XPutPixel (im, x, y, colour_table[src[x + y * bpl]]); } else { for (y = 0; y < h; y++) for (x = 0; x < w; x++) { unsigned long c = colour_table[src[x + y * bpl]]; XPutPixel (im, 2 * x + 0, 2 * y + 0, c); XPutPixel (im, 2 * x + 0, 2 * y + 1, c); XPutPixel (im, 2 * x + 1, 2 * y + 0, c); XPutPixel (im, 2 * x + 1, 2 * y + 1, c); } } if (dst == display.win) { pixmap_putbox (src, 0, 0, bpl, x1, y1, w, h); } XPutImage (display.dpy, dst, display.pixcolour_gc[0], im, 0, 0, x0 + pmult * x1, y0 + pmult * y1, pmult * w, pmult * h); XDestroyImage (im); }

void Fgl_setclippingwindow (  int  x1, int  y1, int  x2, int  y2 )

Definition at line 958 of file lcx11.c. { xclip_x1 = x1; xclip_y1 = y1; xclip_x2 = x2; xclip_y2 = y2; }

void Fgl_setfont (  int  fw, int  fh, void *  fp )

Definition at line 250 of file lcx11.c. { open_font = fp; open_font_height = fh; }

void Fgl_setfontcolors (  int  bg, int  fg )

Definition at line 243 of file lcx11.c. { text_fg = fg; text_bg = bg; }

void Fgl_setpixel (  int  x, int  y, int  col )

Definition at line 465 of file lcx11.c. { int i; if (clipping_flag) if (x < xclip_x1 || x > xclip_x2 || y < xclip_y1 || y > xclip_y2) return; col &= 0xff; i = pixmap_index(x,y); #ifdef ALLOW_PIX_DOUBLING if (pix_double) { if ((int) pixmap[i] != col) { pixmap[i] = (unsigned char) col; XFillRectangle (display.dpy, display.win, display.pixcolour_gc[col], x * 2, y * 2, 2, 2); } } else { #endif if ((int) pixmap[i] != col) { pixmap[i] = (unsigned char) col; XDrawPoint (display.dpy, display.win, display.pixcolour_gc[col], x + borderx, y + bordery); } #ifdef ALLOW_PIX_DOUBLING } #endif }

void Fgl_write (  int  x, int  y, char *  s )

Definition at line 538 of file lcx11.c. { int i; for (i = 0; i < (int) (strlen (s)); i++) my_x_putchar (x + i * 8, y, s[i]); }

void HandleError (  char *  description, int  degree )

Definition at line 452 of file lcx11.c. { fprintf (stderr, _("An error has occurred. The description is below...\n")); fprintf (stderr, "%s\n", description); if (degree == FATAL) { fprintf (stderr, _("Program aborting...\n")); exit (-1); } }

void HandleEvent (  XEvent *  event  )

Definition at line 742 of file lcx11.c. { XEvent loop_ev; /* for clearing the queue of events */ switch (event->type) { case KeyPress: { XKeyEvent *key_event = (XKeyEvent *) event; char buf[128]; KeySym ks; XComposeStatus status; XLookupString (key_event, buf, 128, &ks, &status); x_key_shifted = ShiftMask & key_event->state; x_key_value = buf[0]; switch (ks) { case XK_Left: x_key_value = 1; break; case XK_Down: x_key_value = 2; break; case XK_Up: x_key_value = 3; break; case XK_Right: x_key_value = 4; break; #if defined (commentout) /* GCS: What the hell is this??? */ case 'C': if (!confine_pointer(-10,-10,200,200)) unconfine_pointer(); break; #endif case XK_BackSpace: case XK_Delete: x_key_value = 127; break; } } break; case MotionNotify: { XMotionEvent *ev = (XMotionEvent *) event; while (XCheckMaskEvent(display.dpy,PointerMotionMask,&loop_ev)) { ev = (XMotionEvent *) &loop_ev; } #ifdef DEBUG_X11_MOUSE printf("pointer motion event\n"); #endif if (ev->state & Button2Mask) drag_screen(); } break; case ButtonPress: { XButtonEvent *ev = (XButtonEvent *) event; if ((ev->state & ShiftMask) != 0) cs_mouse_shifted = 1; else cs_mouse_shifted = 0; #ifdef DEBUG_X11_MOUSE printf("button press: ev->button = %d\n",ev->button); #endif #if defined (commentout) mouse_button = ev->button; #endif switch (ev->button) { case Button1: mouse_button = LC_MOUSE_LEFTBUTTON | LC_MOUSE_PRESS; break; case Button2: mouse_button = LC_MOUSE_MIDDLEBUTTON | LC_MOUSE_PRESS; break; case Button3: mouse_button = LC_MOUSE_RIGHTBUTTON | LC_MOUSE_PRESS; break; /* Wheel mouse support Move further for Shift (in main.c: process_keystrokes() ), left to right instead of up and down for Control */ case Button4: /* Up (3); Left (1) if Control */ x_key_shifted = ShiftMask & ev->state; x_key_value = (ControlMask & ev->state) ? 1 : 3; break; case Button5: /* Down (4); Right (2) if control */ x_key_shifted = ShiftMask & ev->state; x_key_value = (ControlMask & ev->state) ? 4 : 2; break; /* XFree86-3 only supports 5 buttons, no Button6 or higher */ } cs_mouse_handler (mouse_button, 0, 0); mouse_button = 0; } break; case ButtonRelease: { XButtonEvent *ev = (XButtonEvent *) event; mouse_button = ev->button; #ifdef DEBUG_X11_MOUSE printf("button release: ev->button = %d\n",ev->button); #endif switch (ev->button) { case Button1: mouse_button = LC_MOUSE_LEFTBUTTON | LC_MOUSE_RELEASE; break; case Button2: mouse_button = LC_MOUSE_MIDDLEBUTTON | LC_MOUSE_RELEASE; break; case Button3: mouse_button = LC_MOUSE_RIGHTBUTTON | LC_MOUSE_RELEASE; break; } cs_mouse_handler (mouse_button, 0, 0); mouse_button = 0; } break; case Expose: { XExposeEvent *ev = (XExposeEvent *) event; int gx1,gy1,gx2,gy2; gx1 = ev->x; gy1 = ev->y; gx2 = ev->x + ev->width; gy2 = ev->y + ev->height; /* Coalesce waiting exposes into single redraw */ while (XCheckMaskEvent(display.dpy,ExposureMask,&loop_ev)) { ev = (XExposeEvent *) &loop_ev; gx1 = min_int (gx1,ev->x); gy1 = min_int (gy1,ev->y); gx2 = max_int (gx2,ev->x + ev->width); gy2 = max_int (gy2,ev->y + ev->height); } if (suppress_next_expose) { suppress_next_expose = 0; break; } refresh_screen (gx1,gy1,gx2,gy2); } break; case ConfigureNotify: { XConfigureEvent *ev = (XConfigureEvent *) event; while (XCheckTypedEvent(display.dpy, ConfigureNotify, &loop_ev)) { ev = (XConfigureEvent *) &loop_ev; } resize_geometry (ev->width, ev->height); } break; } //fprintf(stderr,"Handler fell through, event->type = %d\n",event->type); }

void init_x_mouse (  void   )

Definition at line 1037 of file lcx11.c. { XSelectInput (display.dpy, display.win, KeyPressMask | ButtonPressMask | ButtonReleaseMask | ExposureMask | StructureNotifyMask | ButtonMotionMask); }

int lc_get_keystroke (  void   )

Definition at line 1022 of file lcx11.c. { int q; call_event (); q = x_key_value; x_key_value = 0; return q; }

void my_x_putchar (  int  xx, int  yy, unsigned char  c )

Definition at line 554 of file lcx11.c. { int x, y, b; for (y = 0; y < 8; y++) { b = main_font[c * 8 + y]; for (x = 0; x < 8; x++) { if ((b & 0x80) == 0) Fgl_setpixel (xx + x, yy + y, text_bg); else Fgl_setpixel (xx + x, yy + y, text_fg); b = b << 1; } } }

void open_setcustompalette (  XColor *  inpal  )

Definition at line 138 of file lcx11.c. { do_setcustompalette (inpal); }

void open_write (  int  x, int  y, char *  s )

Definition at line 546 of file lcx11.c. { int i; for (i = 0; i < (int) (strlen (s)); i++) open_x_putchar (x + i * 8, y, s[i]); }

void open_x_putchar (  int  xx, int  yy, unsigned char  c )

Definition at line 572 of file lcx11.c. { int x, y, b; for (y = 0; y < open_font_height; y++) { b = open_font[c * open_font_height + y]; for (x = 0; x < 8; x++) { if ((b & 0x80) == 0) Fgl_setpixel (xx + x, yy + y, text_bg); else Fgl_setpixel (xx + x, yy + y, text_fg); b = b << 1; } } }

void parse_xargs (  int  argc, char **  argv, char **  geometry )

Definition at line 257 of file lcx11.c. { int option; extern char *optarg; #ifdef ALLOW_PIX_DOUBLING char* option_string = "vbrndg:wR:G:B:D"; #else char* option_string = "vbrng:wR:G:B:D"; #endif while ((option = getopt (argc, argv, option_string)) != EOF) { switch (option) { case 'v': verbose = TRUE; break; case 'g': *geometry = optarg; break; #ifdef ALLOW_PIX_DOUBLING case 'd': pix_double = 1; /* Fall through. We are not allowed a border with pix doubling */ #endif case 'b': borderx = 0; bordery = 0; break; case 'r': borderx = BORDERX; bordery = BORDERY; break; case 'n': no_init_help = TRUE; break; case 'w': gamma_correct_red = GAMMA_CORRECT_RED; gamma_correct_green = GAMMA_CORRECT_GREEN; gamma_correct_blue = GAMMA_CORRECT_BLUE; break; case 'R': sscanf (optarg, "%f", &gamma_correct_red); break; case 'G': sscanf (optarg, "%f", &gamma_correct_green); break; case 'B': sscanf (optarg, "%f", &gamma_correct_blue); break; case 'D': command_line_debug = 1; break; } } if (verbose) printf (_("Version %s\n"), VERSION); if (!(display.dpy = XOpenDisplay (display.dname))) { printf (" Can't open the dispay!\n"); HandleError ("Cannot open display.\n", FATAL); exit (-1); } /* Record the screen number and root window. */ display.screen = DefaultScreen (display.dpy); display.root = RootWindow (display.dpy, display.screen); display.winW = WINWIDTH + borderx * 2 + pix_double * WINWIDTH; display.winH = WINHEIGHT + bordery * 2 + pix_double * WINHEIGHT; winX = (DisplayWidth (display.dpy, display.screen) - display.winW) / 2; winY = (DisplayHeight (display.dpy, display.screen) - display.winH) / 2; if (*geometry != NULL) XParseGeometry (*geometry, &winX, &winY, &display.winW, &display.winH); }

void refresh_screen (  int  x1, int  y1, int  x2, int  y2 )

Definition at line 911 of file lcx11.c. { #ifdef USE_IMAGES int wx1 = x1-borderx < 0 ? 0 : x1-borderx; int wy1 = y1-bordery < 0 ? 0 : y1-bordery; int wx2 = x2-borderx > pixmap_width ? pixmap_width : x2-borderx; int wy2 = y2-bordery > pixmap_height ? pixmap_height : y2-bordery; if (wx2-wx1 <= 0 || wy2-wy1 <= 0) { /* Note: the "< 0" part can happen for when x1 is in the right border, or when y1 is in the left border. */ return; } Fgl_putbox_low (display.win, borderx, bordery, wx1, wy1, wx2 - wx1, wy2 - wy1, (unsigned char*) pixmap, pixmap_width, wx1, wy1); #else int x, y; #ifdef ALLOW_PIX_DOUBLING if (pix_double) { for (y = y1; y < y2; y++) for (x = x1; x < x2; x++) XFillRectangle (display.dpy, display.win ,display.pixcolour_gc[*(pixmap + x + y * (640 + BORDERX)) & 0xff], x * 2, y * 2, 2, 2); } else { #endif for (y = y1; y < y2; y++) for (x = x1; x < x2; x++) XDrawPoint (display.dpy, display.win ,display.pixcolour_gc[*(pixmap + x + y * (640 + BORDERX)) & 0xff], x, y); #ifdef ALLOW_PIX_DOUBLING } #endif /* ALLOW_PIX_DOUBLING */ #endif /* USE_IMAGES */ }

void set_pointer_confinement (  void   )

Definition at line 39 of file lcx11.c. { if (confine_flag) { XGrabPointer (display.dpy, display.win, 0, ButtonPressMask | ButtonReleaseMask | PointerMotionMask, GrabModeAsync, GrabModeAsync, display.win, None, CurrentTime); } else { XUngrabPointer (display.dpy, CurrentTime); } }

void setcustompalette (  void   )

Definition at line 88 of file lcx11.c. { char s[100]; int n, r, g, b, i, flag[256]; XColor pal[256]; FILE *inf; for (i = 0; i < 256; i++) flag[i] = 0; if ((inf = fopen (colour_pal_file, "r")) == 0) HandleError ("Can't find the colour pallet file", FATAL); while (feof (inf) == 0) { fgets (s, 99, inf); if (sscanf (s, "%d %d %d %d", &n, &r, &g, &b) == 4) { pal[n].red = r; pal[n].green = g; pal[n].blue = b; pal[n].flags = DoRed | DoGreen | DoBlue; pal[n].pixel = colour_table[n]; /* ??? */ flag[n] = 1; } } fclose (inf); for (i = 0; i < 256; i++) { if (flag[i] == 0) { printf ("Colour %d not loaded\n", i); HandleError ("Can't continue", FATAL); } pal[i].red = (unsigned char) ((pal[i].red * (1 - gamma_correct_red)) + (64 * sin ((float) pal[i].red * M_PI / 128)) * gamma_correct_red); pal[i].green = (unsigned char) ((pal[i].green * (1 - gamma_correct_green)) + (64 * sin ((float) pal[i].green * M_PI / 128)) * gamma_correct_green); pal[i].blue = (unsigned char) ((pal[i].blue * (1 - gamma_correct_blue)) + (64 * sin ((float) pal[i].blue * M_PI / 128)) * gamma_correct_blue); } do_setcustompalette (pal); }

void unconfine_pointer (  void   )

Definition at line 80 of file lcx11.c. { XUngrabPointer(display.dpy, CurrentTime); XDestroyWindow(display.dpy, display.confinewin); display.pointer_confined = 0; }

void unlock_window_size (  void   )

Definition at line 431 of file lcx11.c. { XSizeHints sizehint; sizehint.x = winX - 100; sizehint.y = winY; sizehint.width = display.winW; sizehint.height = display.winH; sizehint.min_width = display.winW; sizehint.min_height = display.winH; sizehint.max_width = display.winW; sizehint.max_height = display.winH; sizehint.flags = USPosition | USSize | PMinSize; XSetNormalHints (display.dpy, display.win, &sizehint); }

---

Variable Documentation

int pointer_confined [static]

Definition at line 51 of file lcx11.c.

---