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; }