static ECursor *
ECursorRealize(ECursor * ec)
{
Pixmap pmap, mask;
int xh, yh;
unsigned int w, h, ww, hh;
char *img, msk[FILEPATH_LEN_MAX];
if (ec->file)
{
img = ThemeFileFind(ec->file, FILE_TYPE_CURSOR);
_EFREE(ec->file); /* Ok or not - we never need file again */
if (!img)
goto done;
Esnprintf(msk, sizeof(msk), "%s.mask", img);
pmap = 0;
mask = 0;
xh = 0;
yh = 0;
XReadBitmapFile(disp, WinGetXwin(VROOT), msk, &w, &h, &mask, &xh, &yh);
XReadBitmapFile(disp, WinGetXwin(VROOT), img, &w, &h, &pmap, &xh, &yh);
XQueryBestCursor(disp, WinGetXwin(VROOT), w, h, &ww, &hh);
if ((w <= ww) && (h <= hh) && (pmap))
{
if (xh < 0 || xh >= (int)w)
xh = (int)w / 2;
if (yh < 0 || yh >= (int)h)
yh = (int)h / 2;
ec->cursor =
ECreatePixmapCursor(pmap, mask, w, h, xh, yh, ec->fg, ec->bg);
}
if (ec->cursor == NoXID)
{
Eprintf("*** Failed to create cursor \"%s\" from %s,%s\n",
ec->name, img, msk);
}
if (pmap)
EFreePixmap(pmap);
if (mask)
EFreePixmap(mask);
Efree(img);
}
else
{
ec->cursor = (ec->native_id == 999) ?
None : XCreateFontCursor(disp, ec->native_id);
}
done:
if (ec->cursor == NoXID)
{
ECursorDestroy(ec);
ec = NULL;
}
return ec;
}
Cursor _Delay::hourglass_cursor()
{
if (hourglass_cache != 0)
return hourglass_cache;
Display *display = XtDisplay(widget);
#if SMALL_HOURGLASS_CURSOR || LARGE_HORGLASS_CURSOR
Screen *screen = XtScreen(widget);
Window rootWindow = RootWindowOfScreen(screen);
unsigned char *cursor_bits = time16_bits;
unsigned char *cursor_mask_bits = time16m_bits;
unsigned int cursor_width = time16_width;
unsigned int cursor_height = time16_height;
unsigned int cursor_x_hot = time16_x_hot;
unsigned int cursor_y_hot = time16_y_hot;
#if LARGE_HOURGLASS_CURSOR
// Fetch cursor shape
unsigned int width, height;
XQueryBestCursor(display, rootWindow, 32, 32, &width, &height);
Boolean largeCursors = (width >= 32 && height >= 32);
if (largeCursors)
{
cursor_bits = time32_bits;
cursor_mask_bits = time32m_bits;
cursor_width = time32_width;
cursor_height = time32_height;
cursor_x_hot = time32_x_hot;
cursor_y_hot = time32_y_hot;
}
#endif
Pixmap cursor_pixmap =
XCreateBitmapFromData(display, rootWindow, (char *)cursor_bits,
cursor_width, cursor_height);
Pixmap cursor_mask_pixmap =
XCreateBitmapFromData(display, rootWindow, (char *)cursor_mask_bits,
cursor_width, cursor_height);
XColor cursor_colors[2];
cursor_colors[0].pixel = BlackPixelOfScreen(screen);
cursor_colors[1].pixel = WhitePixelOfScreen(screen);
XQueryColors(display, DefaultColormapOfScreen(screen),
cursor_colors, 2);
hourglass_cache =
XCreatePixmapCursor(display, cursor_pixmap, cursor_mask_pixmap,
cursor_colors, cursor_colors + 1,
cursor_x_hot, cursor_y_hot);
#else // Watch cursor
hourglass_cache =
XCreateFontCursor(display, XC_watch);
#endif
return hourglass_cache;
}
JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_LinuxDisplay_nGetMaxCursorSize
(JNIEnv *env, jclass clazz, jlong display, jlong window_ptr)
{
Display *disp = (Display *)(intptr_t)display;
Window window = (Window)window_ptr;
unsigned int width_return = 0;
unsigned int height_return = 0;
XQueryBestCursor(disp, window, 0xffffffff, 0xffffffff, &width_return, &height_return);
return width_return > height_return ? height_return : width_return;
}
static PyObject *
tkwin_QueryBestCursor(TkWinObject * self, PyObject * args)
{
unsigned int width, height, ret_width, ret_height;
if (!PyArg_ParseTuple(args, "ii", &width, &height))
return NULL;
XQueryBestCursor(Tk_Display(self->tkwin), Tk_WindowId(self->tkwin),
width, height, &ret_width, &ret_height);
return Py_BuildValue("ii", ret_width, ret_height);
}
Cursor MotifUI::InitHourGlassCursor()
{
unsigned int width;
unsigned int height;
unsigned int xHotspot;
unsigned int yHotspot;
Pixmap pixmap;
Pixmap maskPixmap;
XColor xcolors[2];
char * bits;
char * maskBits;
Cursor cursor = None;
if (XQueryBestCursor(display, root, 32, 32, &width, &height))
{
if ((width >= 32) && (height >= 32))
{
width = time32_width;
height = time32_height;
bits = (char *)time32_bits;
maskBits = (char *)time32m_bits;
xHotspot = time32_x_hot;
yHotspot = time32_y_hot;
}
else
{
width = time16_width;
height = time16_height;
bits = (char *)time16_bits;
maskBits = (char *)time16m_bits;
xHotspot = time16_x_hot;
yHotspot = time16_y_hot;
}
pixmap = XCreateBitmapFromData(display, root, bits, width, height);
maskPixmap = XCreateBitmapFromData(display, root, maskBits,
width, height);
xcolors[0].pixel = black;
xcolors[1].pixel = white;
XQueryColors(display,
DefaultColormapOfScreen(DefaultScreenOfDisplay (display)),
xcolors, 2);
cursor = XCreatePixmapCursor(display, pixmap, maskPixmap,
&(xcolors[0]), &(xcolors[1]), xHotspot, yHotspot);
XFreePixmap(display, pixmap);
XFreePixmap(display, maskPixmap);
}
return cursor;
}
int OglInitWindow(int x, int y){
if (gameStates.ogl.bInitialized){
XResizeWindow(dpy,win,x,y);
set_wm_hints(gameStates.ogl.bFullScreen);
}else {
glxcontext=glXCreateContext(dpy,visinfo,0,GL_TRUE);
//create colormap
swa.colormap=XCreateColormap(dpy,RootWindow(dpy,visinfo->screen),visinfo->visual,AllocNone);
//create window
swa.border_pixel=0;
swa.event_mask=ExposureMask | StructureNotifyMask | KeyPressMask | KeyReleaseMask| ButtonPressMask | ButtonReleaseMask | PointerMotionMask;
//win = XCreateWindow(dpy,RootWindow(dpy,visinfo->screen),0,0,x,y,0,visinfo->depth,InputOutput,visinfo->visual,CWBorderPixel|CWColormap|CWEventMask,&swa);
win = XCreateWindow(dpy,RootWindow(dpy,visinfo->screen),0,0,x,y,0,visinfo->depth,InputOutput,visinfo->visual,CWColormap|CWEventMask,&swa);
XStoreName(dpy,win,DESCENT_VERSION);
// XStoreName(dpy,win,"agry");
XMapWindow(dpy,win);
glXMakeCurrent(dpy,win,glxcontext);
set_wm_hints(gameStates.ogl.bFullScreen);
gameStates.ogl.bInitialized=1;
{
XColor blankcolor;
unsigned char *blankdata;
int w,h;
XQueryBestCursor(dpy,win,1,1,&w,&h);
blankdata=D2_ALLOC(w*h/8);
memset(blankdata,0,w*h/8);
memset(&blankcolor,0,sizeof(XColor);
blankpixmap=XCreateBitmapFromData(dpy,win,blankdata,w,h);
blankcursor=XCreatePixmapCursor(dpy,blankpixmap,blankpixmap,&blankcolor,&blankcolor,w,h);
D2_FREE(blankdata);
// sleep(1);
}
if (gameStates.ogl.bFullScreen)
OglDoFullScreenInternal();
// GrDoFullScreen(gameStates.ogl.bFullScreen);
}
#ifdef GII_XWIN
init_gii_xwin(dpy,win);
#endif
return 0;
}
/*
* Class: sun_awt_motif_MCustomCursor
* Method: queryBestCursor
* Signature: (Ljava/awt/Dimension;)V
*/
JNIEXPORT void JNICALL Java_sun_awt_motif_MCustomCursor_queryBestCursor
(JNIEnv *env, jclass cls, jobject dimension)
{
Window root;
uint32_t width, height;
AWT_LOCK();
root = RootWindow(awt_display, DefaultScreen(awt_display));
XQueryBestCursor(awt_display, root,
(*env)->GetIntField(env, dimension, widthID),
(*env)->GetIntField(env, dimension, heightID),
&width, &height);
(*env)->SetIntField(env, dimension, widthID, (int32_t) width);
(*env)->SetIntField(env, dimension, heightID, (int32_t) height);
AWT_UNLOCK();
}
JNIEXPORT jlong JNICALL Java_org_lwjgl_opengl_LinuxDisplay_nCreateBlankCursor(JNIEnv *env, jclass unused, jlong display_ptr, jlong window_ptr) {
Display *disp = (Display *)(intptr_t)display_ptr;
Window win = (Window)window_ptr;
unsigned int best_width, best_height;
if (XQueryBestCursor(disp, win, 1, 1, &best_width, &best_height) == 0) {
throwException(env, "Could not query best cursor size");
return false;
}
Pixmap mask = XCreatePixmap(disp, win, best_width, best_height, 1);
XGCValues gc_values;
gc_values.foreground = 0;
GC gc = XCreateGC(disp, mask, GCForeground, &gc_values);
XFillRectangle(disp, mask, gc, 0, 0, best_width, best_height);
XFreeGC(disp, gc);
XColor dummy_color;
Cursor cursor = XCreatePixmapCursor(disp, mask, mask, &dummy_color, &dummy_color, 0, 0);
XFreePixmap(disp, mask);
return cursor;
}
Cursor MakeImageCursor (Display *display, Drawable screen)
/* make custom cursor for image display window if possible else return NULL */
{
unsigned int width, height;
Pixmap csource, cmask;
int xhot = ImageCursor_x_hot, yhot = ImageCursor_y_hot;
XColor cfore, cback;
Cursor cursor;
/* see if this display wants a 16x16 cursor, if not return Null */
XQueryBestCursor (display, screen, ImageCursor_width, ImageCursor_height,
&width, &height);
if ((width!=ImageCursor_width) || (height!=ImageCursor_height)) return 0;
/* set colors (should do this from resource file)*/
/* foreground */
cfore.red=0; cfore.green=65535; cfore.blue = 65535;
cfore.flags = DoRed | DoGreen | DoBlue;
/* background */
cback.red=65535; cback.green=65535; cback.blue = 0;
cback.flags = DoRed | DoGreen | DoBlue;
/* make pixmaps */
csource = XCreateBitmapFromData(display, screen,
(const char *)ImageCursor_bits,
width, height);
if (!csource) return 0;
cmask = XCreateBitmapFromData(display, screen,
(const char *)ImageCursorMask_bits,
width, height);
if (!cmask) return 0;
/* make cursor */
cursor = XCreatePixmapCursor (display, csource, cmask, &cfore, &cback,
xhot, yhot);
/* delete pixmaps */
XFreePixmap(display, csource);
XFreePixmap(display, cmask);
return cursor;
} /* end MakeImageCursor */
/*
* Creates the playing windows.
* Returns 0 on success, -1 on error.
*/
int Init_playing_windows(void)
{
unsigned w, h;
Pixmap pix;
GC cursorGC;
if (!topWindow) {
if (Init_top())
return -1;
}
Scale_dashes();
draw_width = top_width - (256 + 2);
draw_height = top_height;
drawWindow = XCreateSimpleWindow(dpy, topWindow, 258, 0,
draw_width, draw_height,
0, 0, colors[BLACK].pixel);
radarWindow = XCreateSimpleWindow(dpy, topWindow, 0, 0,
256, RadarHeight, 0, 0,
colors[BLACK].pixel);
radar_score_mapped = true;
/* Create buttons */
#define BUTTON_WIDTH 84
ButtonHeight = buttonFont->ascent + buttonFont->descent + 2*BTN_BORDER;
button_form
= Widget_create_form(0, topWindow,
0, (int)RadarHeight,
256, ButtonHeight + 2,
0);
Widget_create_activate(button_form,
0 + 0*BUTTON_WIDTH, 0,
BUTTON_WIDTH, ButtonHeight,
1, "QUIT",
Quit_callback, NULL);
Widget_create_activate(button_form,
1 + 1*BUTTON_WIDTH, 0,
BUTTON_WIDTH, ButtonHeight,
1, "ABOUT",
About_callback, NULL);
menu_button
= Widget_create_menu(button_form,
2 + 2*BUTTON_WIDTH, 0,
BUTTON_WIDTH, ButtonHeight,
1, "MENU");
Widget_add_pulldown_entry(menu_button,
"KEYS", Keys_callback, NULL);
Widget_add_pulldown_entry(menu_button,
"CONFIG", Config_callback, NULL);
Widget_add_pulldown_entry(menu_button,
"COLORS", Colors_callback, NULL);
Widget_add_pulldown_entry(menu_button,
"SCORE", Score_callback, NULL);
Widget_add_pulldown_entry(menu_button,
"PLAYER", Player_callback, NULL);
Widget_add_pulldown_entry(menu_button,
"MOTD", Motd_callback, NULL);
Widget_map_sub(button_form);
/* Create score list window */
players_width = RadarWidth;
players_height = top_height - (RadarHeight + ButtonHeight + 2);
playersWindow
= XCreateSimpleWindow(dpy, topWindow,
0, (int)RadarHeight + ButtonHeight + 2,
players_width, players_height,
0, 0,
colors[windowColor].pixel);
/*
* Selecting the events we can handle.
*/
XSelectInput(dpy, radarWindow, ExposureMask);
XSelectInput(dpy, playersWindow, ExposureMask);
XSelectInput(dpy, drawWindow, ButtonPressMask | ButtonReleaseMask);
/*
* Initialize misc. pixmaps if we're not color switching.
* (This could be in dbuff_init_buffer completely IMHO, -- Metalite)
*/
switch (dbuf_state->type) {
case PIXMAP_COPY:
radarPixmap
= XCreatePixmap(dpy, radarWindow, 256, RadarHeight, dispDepth);
radarPixmap2
= XCreatePixmap(dpy, radarWindow, 256, RadarHeight, dispDepth);
drawPixmap
= XCreatePixmap(dpy, drawWindow, draw_width, draw_height,
dispDepth);
break;
case MULTIBUFFER:
radarPixmap
= XCreatePixmap(dpy, radarWindow, 256, RadarHeight, dispDepth);
radarPixmap2
= XCreatePixmap(dpy, radarWindow, 256, RadarHeight, dispDepth);
dbuff_init_buffer(dbuf_state);
break;
case COLOR_SWITCH:
radarPixmap2 = radarWindow;
radarPixmap = radarWindow;
drawPixmap = drawWindow;
Paint_sliding_radar();
break;
default:
assert(0 && "Init_playing_windows: unknown dbuf state type.");
break;
}
XAutoRepeatOff(dpy); /* We don't want any autofire, yet! */
if (kdpy)
XAutoRepeatOff(kdpy);
/*
* Define a blank cursor for use with pointer control
*/
XQueryBestCursor(dpy, drawWindow, 1, 1, &w, &h);
pix = XCreatePixmap(dpy, drawWindow, w, h, 1);
cursorGC = XCreateGC(dpy, pix, 0, NULL);
XSetForeground(dpy, cursorGC, 0);
XFillRectangle(dpy, pix, cursorGC, 0, 0, w, h);
XFreeGC(dpy, cursorGC);
pointerControlCursor = XCreatePixmapCursor(dpy, pix, pix, &colors[BLACK],
&colors[BLACK], 0, 0);
XFreePixmap(dpy, pix);
/*
* Maps the windows, makes the visible. Voila!
*/
XMapSubwindows(dpy, topWindow);
XMapWindow(dpy, topWindow);
XSync(dpy, False);
if (kdpy) {
XMapWindow(kdpy, keyboardWindow);
XSync(kdpy, False);
}
Init_spark_colors();
return 0;
}
/*************************************<->*************************************
*
* Cursor _DtHelpGetHourGlassCursor ()
*
*
* Description:
* -----------
* Builds and returns the appropriate Hourglass cursor
*
*
* Inputs:
* ------
* dpy = display
*
* Outputs:
* -------
* Return = cursor.
*
* Comments:
* --------
* None. (None doesn't count as a comment)
*
*************************************<->***********************************/
Cursor
_DtHelpGetHourGlassCursor(
Display *dpy )
{
char *bits;
char *maskBits;
unsigned int width;
unsigned int height;
unsigned int xHotspot;
unsigned int yHotspot;
Pixmap pixmap;
Pixmap maskPixmap;
XColor xcolors[2];
unsigned int cWidth;
unsigned int cHeight;
int useLargeCursors = 0;
static Cursor waitCursor=0;
if (waitCursor != 0)
return(waitCursor);
if (XQueryBestCursor (dpy, DefaultRootWindow(dpy),
32, 32, &cWidth, &cHeight))
{
if ((cWidth >= 32) && (cHeight >= 32))
{
useLargeCursors = 1;
}
}
if (useLargeCursors)
{
width = time32_width;
height = time32_height;
bits = (char *) time32_bits;
maskBits = (char *) time32m_bits;
xHotspot = time32_x_hot;
yHotspot = time32_y_hot;
}
else
{
width = time16_width;
height = time16_height;
bits = (char *) time16_bits;
maskBits = (char *) time16m_bits;
xHotspot = time16_x_hot;
yHotspot = time16_y_hot;
}
pixmap = XCreateBitmapFromData (dpy,
DefaultRootWindow(dpy), bits,
width, height);
maskPixmap = XCreateBitmapFromData (dpy,
DefaultRootWindow(dpy), maskBits,
width, height);
xcolors[0].pixel = BlackPixelOfScreen(DefaultScreenOfDisplay(dpy));
xcolors[1].pixel = WhitePixelOfScreen(DefaultScreenOfDisplay(dpy));
XQueryColors (dpy,
DefaultColormapOfScreen(DefaultScreenOfDisplay
(dpy)), xcolors, 2);
waitCursor = XCreatePixmapCursor (dpy, pixmap, maskPixmap,
&(xcolors[0]), &(xcolors[1]),
xHotspot, yHotspot);
XFreePixmap (dpy, pixmap);
XFreePixmap (dpy, maskPixmap);
return (waitCursor);
}
void INTERNAL_init_cursor(GC gc_pixmap)
{
unsigned long valuemask = 0;
XGCValues values;
Cursor cursor;
Pixmap hand, handmask;
Pixmap updown, updownmask;
unsigned long fg, bg;
unsigned int width, height;
unsigned int hot_x, hot_y, hot2_x, hot2_y;
int i;
Colormap cmap;
XColor black, white;
init_store_cursor();
for (i=0;i<G_MAXWINDOW;i++)
INTERNAL_reset_cursor(i);
gc_pix = gc_pixmap;
gc_crosshair= XCreateGC(INTERNAL_display,INTERNAL_rootwin,valuemask,&values);
valuemask = GCLineStyle | GCLineWidth | GCCapStyle | GCJoinStyle;
XGetGCValues(INTERNAL_display,gc_pix,valuemask,&values);
XSetLineAttributes(INTERNAL_display,
gc_pix,
0,
values.line_style,
values.cap_style,
values.join_style);
XSetLineAttributes(INTERNAL_display,
gc_crosshair,
0,
values.line_style,
values.cap_style,
values.join_style);
XSetFunction(INTERNAL_display, gc_crosshair, GXxor);
XSetForeground(INTERNAL_display, gc_crosshair,
WhitePixel(INTERNAL_display, INTERNAL_screen) ^
BlackPixel(INTERNAL_display, INTERNAL_screen));
cur_cross = XCreateFontCursor(INTERNAL_display, XC_crosshair);
cur_wait = XCreateFontCursor(INTERNAL_display, XC_watch);
XQueryBestCursor(INTERNAL_display, INTERNAL_rootwin, 32, 32, &width, &height);
fg = 1;
bg = 0;
if (width >= 32 && height >= 32) {
hand = XCreatePixmapFromBitmapData(INTERNAL_display, INTERNAL_rootwin,
(char*)hand32_bits, hand32_width, hand32_height, fg, bg, 1);
handmask = XCreatePixmapFromBitmapData(INTERNAL_display, INTERNAL_rootwin,
(char*)handm32_bits, handm32_width, handm32_height, fg, bg, 1);
hot_x = 8;
hot_y = 12;
updown = XCreatePixmapFromBitmapData(INTERNAL_display, INTERNAL_rootwin,
(char*)updown32_bits, updown32_width, updown32_height, fg, bg, 1);
updownmask = XCreatePixmapFromBitmapData(INTERNAL_display, INTERNAL_rootwin,
(char*)updownmask32_bits, updownmask32_width, updownmask32_height, fg, bg, 1);
hot2_x = 16;
hot2_y = 16;
}
else {
hand = XCreatePixmapFromBitmapData(INTERNAL_display, INTERNAL_rootwin,
(char*)hand_bits, hand_width, hand_height, fg, bg, 1);
handmask = XCreatePixmapFromBitmapData(INTERNAL_display, INTERNAL_rootwin,
(char*)handmask_bits, handmask_width, handmask_height, fg, bg, 1);
hot_x = 4;
hot_y = 6;
updown = XCreatePixmapFromBitmapData(INTERNAL_display, INTERNAL_rootwin,
(char*)updown_bits, updown_width, updown_height, fg, bg, 1);
updownmask = XCreatePixmapFromBitmapData(INTERNAL_display, INTERNAL_rootwin,
(char*)updownmask_bits, updownmask_width, updownmask_height, fg, bg, 1);
hot2_x = 8;
hot2_y = 8;
}
cmap = DefaultColormap(INTERNAL_display,INTERNAL_screen);
XParseColor(INTERNAL_display, cmap, "black", &black);
XAllocColor(INTERNAL_display, cmap, &black);
XParseColor(INTERNAL_display, cmap, "white", &white);
XAllocColor(INTERNAL_display, cmap, &white);
cur_hand = XCreatePixmapCursor(INTERNAL_display, hand, handmask,
&black, &white, hot_x, hot_y);
cur_updown = XCreatePixmapCursor(INTERNAL_display, updown, updownmask,
&black, &white, hot2_x, hot2_y);
XFreePixmap(INTERNAL_display, hand);
XFreePixmap(INTERNAL_display, handmask);
}
static Bool
init_x11( char * error_buf )
{
/*XXX*/ /* Namely, support for -display host:0.0 etc. */
XrmQuark common_quarks_list[20]; /*XXX change number of elements if necessary */
XrmQuarkList ql = common_quarks_list;
XGCValues gcv;
char *common_quarks =
"String."
"Blinkinvisibletime.blinkinvisibletime."
"Blinkvisibletime.blinkvisibletime."
"Clicktimeframe.clicktimeframe."
"Doubleclicktimeframe.doubleclicktimeframe."
"Wheeldown.wheeldown."
"Wheelup.wheelup."
"Submenudelay.submenudelay."
"Scrollfirst.scrollfirst."
"Scrollnext.scrollnext";
char * atom_names[AI_count] = {
"RESOLUTION_X",
"RESOLUTION_Y",
"PIXEL_SIZE",
"SPACING",
"RELATIVE_WEIGHT",
"FOUNDRY",
"AVERAGE_WIDTH",
"CHARSET_REGISTRY",
"CHARSET_ENCODING",
"CREATE_EVENT",
"WM_DELETE_WINDOW",
"WM_PROTOCOLS",
"WM_TAKE_FOCUS",
"_NET_WM_STATE",
"_NET_WM_STATE_SKIP_TASKBAR",
"_NET_WM_STATE_MAXIMIZED_VERT",
"_NET_WM_STATE_MAXIMIZED_HORZ",
"_NET_WM_NAME",
"_NET_WM_ICON_NAME",
"UTF8_STRING",
"TARGETS",
"INCR",
"PIXEL",
"FOREGROUND",
"BACKGROUND",
"_MOTIF_WM_HINTS",
"_NET_WM_STATE_MODAL",
"_NET_SUPPORTED",
"_NET_WM_STATE_MAXIMIZED_HORIZ",
"text/plain;charset=UTF-8",
"_NET_WM_STATE_STAYS_ON_TOP",
"_NET_CURRENT_DESKTOP",
"_NET_WORKAREA",
"_NET_WM_STATE_ABOVE"
};
char hostname_buf[256], *hostname = hostname_buf;
guts. click_time_frame = 200;
guts. double_click_time_frame = 200;
guts. visible_timeout = 500;
guts. invisible_timeout = 500;
guts. insert = true;
guts. last_time = CurrentTime;
guts. ri_head = guts. ri_tail = 0;
DISP = XOpenDisplay( do_display);
if (!DISP) {
char * disp = getenv("DISPLAY");
snprintf( error_buf, 256, "Error: Can't open display '%s'",
do_display ? do_display : (disp ? disp : ""));
free( do_display);
do_display = nil;
return false;
}
free( do_display);
do_display = nil;
XSetErrorHandler( x_error_handler);
guts.main_error_handler = x_error_handler;
(void)x_io_error_handler;
XCHECKPOINT;
guts.connection = ConnectionNumber( DISP);
{
struct sockaddr name;
unsigned int l = sizeof( name);
guts. local_connection = getsockname( guts.connection, &name, &l) >= 0 && l == 0;
}
#ifdef HAVE_X11_EXTENSIONS_SHAPE_H
if ( XShapeQueryExtension( DISP, &guts.shape_event, &guts.shape_error)) {
guts. shape_extension = true;
} else {
guts. shape_extension = false;
}
#else
guts. shape_extension = false;
#endif
#ifdef USE_MITSHM
if ( !do_no_shmem && XShmQueryExtension( DISP)) {
guts. shared_image_extension = true;
guts. shared_image_completion_event = XShmGetEventBase( DISP) + ShmCompletion;
} else {
guts. shared_image_extension = false;
guts. shared_image_completion_event = -1;
}
#else
guts. shared_image_extension = false;
guts. shared_image_completion_event = -1;
#endif
guts. randr_extension = false;
#ifdef HAVE_X11_EXTENSIONS_XRANDR_H
{
int dummy;
if ( XRRQueryExtension( DISP, &dummy, &dummy))
guts. randr_extension = true;
}
#endif
#ifdef HAVE_X11_EXTENSIONS_XRENDER_H
{
int dummy;
if ( XRenderQueryExtension( DISP, &dummy, &dummy))
guts. render_extension = true;
}
#endif
#ifdef HAVE_X11_EXTENSIONS_XCOMPOSITE_H
{
int dummy;
if (XQueryExtension(DISP, COMPOSITE_NAME, &guts.composite_opcode, &dummy, &dummy))
guts. composite_extension = true;
}
#endif
XrmInitialize();
guts.db = get_database();
XrmStringToQuarkList( common_quarks, common_quarks_list);
guts.qString = *ql++;
guts.qBlinkinvisibletime = *ql++;
guts.qblinkinvisibletime = *ql++;
guts.qBlinkvisibletime = *ql++;
guts.qblinkvisibletime = *ql++;
guts.qClicktimeframe = *ql++;
guts.qclicktimeframe = *ql++;
guts.qDoubleclicktimeframe = *ql++;
guts.qdoubleclicktimeframe = *ql++;
guts.qWheeldown = *ql++;
guts.qwheeldown = *ql++;
guts.qWheelup = *ql++;
guts.qwheelup = *ql++;
guts.qSubmenudelay = *ql++;
guts.qsubmenudelay = *ql++;
guts.qScrollfirst = *ql++;
guts.qscrollfirst = *ql++;
guts.qScrollnext = *ql++;
guts.qscrollnext = *ql++;
guts. mouse_buttons = XGetPointerMapping( DISP, guts. buttons_map, 256);
XCHECKPOINT;
guts. limits. request_length = XMaxRequestSize( DISP);
guts. limits. XDrawLines = guts. limits. request_length - 3;
guts. limits. XFillPolygon = guts. limits. request_length - 4;
guts. limits. XDrawSegments = (guts. limits. request_length - 3) / 2;
guts. limits. XDrawRectangles = (guts. limits. request_length - 3) / 2;
guts. limits. XFillRectangles = (guts. limits. request_length - 3) / 2;
guts. limits. XFillArcs =
guts. limits. XDrawArcs = (guts. limits. request_length - 3) / 3;
XCHECKPOINT;
SCREEN = DefaultScreen( DISP);
/* XXX - return code? */
guts. root = RootWindow( DISP, SCREEN);
guts. displaySize. x = DisplayWidth( DISP, SCREEN);
guts. displaySize. y = DisplayHeight( DISP, SCREEN);
XQueryBestCursor( DISP, guts. root,
guts. displaySize. x, /* :-) */
guts. displaySize. y,
&guts. cursor_width,
&guts. cursor_height);
XCHECKPOINT;
TAILQ_INIT( &guts.paintq);
TAILQ_INIT( &guts.peventq);
TAILQ_INIT( &guts.bitmap_gc_pool);
TAILQ_INIT( &guts.screen_gc_pool);
TAILQ_INIT( &guts.argb_gc_pool);
guts. currentFocusTime = CurrentTime;
guts. windows = hash_create();
guts. menu_windows = hash_create();
guts. ximages = hash_create();
gcv. graphics_exposures = false;
guts. menugc = XCreateGC( DISP, guts. root, GCGraphicsExposures, &gcv);
guts. resolution. x = 25.4 * guts. displaySize. x / DisplayWidthMM( DISP, SCREEN) + .5;
guts. resolution. y = 25.4 * DisplayHeight( DISP, SCREEN) / DisplayHeightMM( DISP, SCREEN) + .5;
guts. depth = DefaultDepth( DISP, SCREEN);
guts. idepth = get_idepth();
if ( guts.depth == 1) guts. qdepth = 1; else
if ( guts.depth <= 4) guts. qdepth = 4; else
if ( guts.depth <= 8) guts. qdepth = 8; else
guts. qdepth = 24;
guts. byte_order = ImageByteOrder( DISP);
guts. bit_order = BitmapBitOrder( DISP);
if ( BYTEORDER == LSB32 || BYTEORDER == LSB64)
guts. machine_byte_order = LSBFirst;
else if ( BYTEORDER == MSB32 || BYTEORDER == MSB64)
guts. machine_byte_order = MSBFirst;
else {
sprintf( error_buf, "UAA_001: weird machine byte order: %08x", BYTEORDER);
return false;
}
XInternAtoms( DISP, atom_names, AI_count, 0, guts. atoms);
guts. null_pointer = nilHandle;
guts. pointer_invisible_count = 0;
guts. files = plist_create( 16, 16);
prima_rebuild_watchers();
guts. wm_event_timeout = 100;
guts. menu_timeout = 200;
guts. scroll_first = 200;
guts. scroll_next = 50;
apc_timer_create( CURSOR_TIMER);
apc_timer_set_timeout(CURSOR_TIMER, 2);
apc_timer_create( MENU_TIMER);
apc_timer_set_timeout( MENU_TIMER, guts. menu_timeout);
apc_timer_create( MENU_UNFOCUS_TIMER);
apc_timer_set_timeout( MENU_UNFOCUS_TIMER, 50);
if ( !prima_init_clipboard_subsystem( error_buf)) return false;
if ( !prima_init_color_subsystem( error_buf)) return false;
if ( !prima_init_font_subsystem( error_buf)) return false;
#ifdef WITH_GTK2
if (!prima_gtk_init()) return false;
#endif
bzero( &guts. cursor_gcv, sizeof( guts. cursor_gcv));
guts. cursor_gcv. cap_style = CapButt;
guts. cursor_gcv. function = GXcopy;
gethostname( hostname, 256);
hostname[255] = '\0';
XStringListToTextProperty((char **)&hostname, 1, &guts. hostname);
guts. net_wm_maximization = prima_wm_net_state_read_maximization( guts. root, NET_SUPPORTED);
if ( do_sync) XSynchronize( DISP, true);
return true;
}
Bool HandleXCursor(int xhot, int yhot, int width, int height)
{
rfbXCursorColors colors;
size_t bytesPerRow, bytesData;
char *buf = NULL;
XColor bg, fg;
Drawable dr;
unsigned int wret = 0, hret = 0;
Pixmap source, mask;
Cursor cursor;
int i;
bytesPerRow = (width + 7) / 8;
bytesData = bytesPerRow * height;
dr = DefaultRootWindow(dpy);
if (width * height) {
if (!ReadFromRFBServer((char *)&colors, sz_rfbXCursorColors))
return False;
buf = malloc(bytesData * 2);
if (buf == NULL)
return False;
if (!ReadFromRFBServer(buf, bytesData * 2)) {
free(buf);
return False;
}
XQueryBestCursor(dpy, dr, width, height, &wret, &hret);
}
if (width * height == 0 || (int) wret < width || (int) hret < height) {
/* Free resources */
if (buf != NULL)
free(buf);
FreeX11Cursor();
return True;
}
bg.red = (unsigned short)colors.backRed << 8 | colors.backRed;
bg.green = (unsigned short)colors.backGreen << 8 | colors.backGreen;
bg.blue = (unsigned short)colors.backBlue << 8 | colors.backBlue;
fg.red = (unsigned short)colors.foreRed << 8 | colors.foreRed;
fg.green = (unsigned short)colors.foreGreen << 8 | colors.foreGreen;
fg.blue = (unsigned short)colors.foreBlue << 8 | colors.foreBlue;
for (i = 0; (size_t) i < bytesData * 2; i++)
buf[i] = (char)_reverse_byte[(int)buf[i] & 0xFF];
source = XCreateBitmapFromData(dpy, dr, buf, width, height);
mask = XCreateBitmapFromData(dpy, dr, &buf[bytesData], width, height);
cursor = XCreatePixmapCursor(dpy, source, mask, &fg, &bg, xhot, yhot);
XFreePixmap(dpy, source);
XFreePixmap(dpy, mask);
free(buf);
XDefineCursor(dpy, desktopWin, cursor);
FreeX11Cursor();
prevXCursor = cursor;
prevXCursorSet = True;
return True;
}
