/* set up needed bitmaps in the server */ static void initCursors(void) { Pixmap p, m; XColor mc, bc; mc.pixel = app_resources.mouseground; bc.pixel = app_resources.bg_pixel; mc.flags = DoRed | DoGreen | DoBlue; bc.flags = DoRed | DoGreen | DoBlue; XQueryColor(dpy, DefaultColormap(dpy, screen), &mc); XQueryColor(dpy, DefaultColormap(dpy, screen), &bc); m = XCreateBitmapFromData(dpy, mwWindow, (char *)ratMask_bits, ratMask_width, ratMask_height); p = XCreateBitmapFromData(dpy, mwWindow, (char *)rat_bits, rat_width, rat_height); ratCursor = XCreatePixmapCursor(dpy, p, m, &mc, &bc, rat_x_hot, rat_y_hot); m = XCreateBitmapFromData(dpy, mwWindow, (char *)dRatMask_bits, dRatMask_width, dRatMask_height); p = XCreateBitmapFromData(dpy, mwWindow, (char *)dRat_bits, dRat_width, dRat_height); deadRatCursor = XCreatePixmapCursor(dpy, p, m, &mc, &bc, 0, 0); p = XCreateBitmapFromData(dpy, mwWindow, (char *)cup_bits, cup_width, cup_height); hourGlassCursor = XCreatePixmapCursor(dpy, p, p, &mc, &bc, 0, 0); }
/* ** BeginWait/EndWait ** ** Display/Remove a watch cursor over topCursorWidget and its descendents */ void BeginWait(Widget topCursorWidget) { Display *display = XtDisplay(topCursorWidget); Pixmap pixmap; Pixmap maskPixmap; XColor xcolors[2]; static Cursor waitCursor = 0; /* if the watch cursor hasn't been created yet, create it */ if (!waitCursor) { pixmap = XCreateBitmapFromData(display, DefaultRootWindow(display), (char *)watch_bits, watch_width, watch_height); maskPixmap = XCreateBitmapFromData(display, DefaultRootWindow(display), (char *)watch_mask_bits, watch_width, watch_height); xcolors[0].pixel = BlackPixelOfScreen(DefaultScreenOfDisplay(display)); xcolors[1].pixel = WhitePixelOfScreen(DefaultScreenOfDisplay(display)); XQueryColors(display, DefaultColormapOfScreen( DefaultScreenOfDisplay(display)), xcolors, 2); waitCursor = XCreatePixmapCursor(display, pixmap, maskPixmap, &xcolors[0], &xcolors[1], watch_x_hot, watch_y_hot); XFreePixmap(display, pixmap); XFreePixmap(display, maskPixmap); } /* display the cursor */ XDefineCursor(display, XtWindow(topCursorWidget), waitCursor); }
Cursor prima_null_pointer( void) { if ( guts. null_pointer == nilHandle) { Handle nullc = ( Handle) create_object( "Prima::Icon", "", nil); PIcon n = ( PIcon) nullc; Pixmap xor, and; XColor xc; if ( nullc == nilHandle) { warn("Error creating icon object"); return nilHandle; } n-> self-> create_empty( nullc, 16, 16, imBW); memset( n-> mask, 0xFF, n-> maskSize); if ( !prima_create_icon_pixmaps( nullc, &xor, &and)) { warn( "Error creating null cursor pixmaps"); Object_destroy( nullc); return nilHandle; } Object_destroy( nullc); xc. red = xc. green = xc. blue = 0; xc. pixel = guts. monochromeMap[0]; xc. flags = DoRed | DoGreen | DoBlue; guts. null_pointer = XCreatePixmapCursor( DISP, xor, and, &xc, &xc, 0, 0); XCHECKPOINT; XFreePixmap( DISP, xor); XFreePixmap( DISP, and); if ( !guts. null_pointer) { warn( "Error creating null cursor from pixmaps"); return nilHandle; } } return guts. null_pointer; }
void grab_keyboard_pointer() { int i, p = 1, k = 1; XColor dummycolor; Cursor nullcursor; nullpixmap = XCreatePixmap(display, root, 1, 1, 1); nullcursor = XCreatePixmapCursor(display, nullpixmap, nullpixmap, &dummycolor, &dummycolor, 0, 0); if (!grab) return; /* Keep trying for pointer. */ for (; p; ) { if (XGrabPointer(display, root, False, ButtonPressMask|ButtonReleaseMask, GrabModeAsync, GrabModeAsync, win, nullcursor, CurrentTime) == GrabSuccess) p = 0; usleep(10000); } /* Because we won't grab keyboard until pointer has been * gotten. Then only try a few times for keyboard */ for (i = 0; k && i < 1000; i++) { if (XGrabKeyboard(display, root, True, GrabModeAsync, GrabModeAsync, CurrentTime) == GrabSuccess) k = 0; usleep(1000); } if (k) die("Failed to grab keyboard!"); }
static EiwLoopFunc * _eiw_window_init(Window win, EiwData * d) { Pixmap pmap, mask; GC gc; XColor cl; d->cwin = XCreateWindow(disp, win, 0, 0, 32, 32, 0, CopyFromParent, InputOutput, CopyFromParent, CWOverrideRedirect | CWBackingStore | CWColormap | CWBackPixel | CWBorderPixel, &d->attr); pmap = XCreatePixmap(disp, d->cwin, 16, 16, 1); gc = XCreateGC(disp, pmap, 0, NULL); XSetForeground(disp, gc, 0); XFillRectangle(disp, pmap, gc, 0, 0, 16, 16); XFreeGC(disp, gc); mask = XCreatePixmap(disp, d->cwin, 16, 16, 1); gc = XCreateGC(disp, mask, 0, NULL); XSetForeground(disp, gc, 0); XFillRectangle(disp, mask, gc, 0, 0, 16, 16); XFreeGC(disp, gc); d->curs = XCreatePixmapCursor(disp, pmap, mask, &cl, &cl, 0, 0); XDefineCursor(disp, win, d->curs); XDefineCursor(disp, d->cwin, d->curs); return _eiw_window_loop; }
void showCursor(Display *dpy, Window win, int show) { if(!show) { Pixmap bm_no; Colormap cmap; Cursor no_ptr; XColor black, dummy; char bm_no_data[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; cmap = DefaultColormap(dpy, DefaultScreen(dpy)); XAllocNamedColor(dpy, cmap, "black", &black, &dummy); bm_no = XCreateBitmapFromData(dpy, win, bm_no_data, 8, 8); no_ptr = XCreatePixmapCursor(dpy, bm_no, bm_no, &black, &black, 0, 0); XDefineCursor(dpy, win, no_ptr); XFreeCursor(dpy, no_ptr); XFreePixmap(dpy, bm_no); XFreeColors(dpy, cmap, &black.pixel, 1, 0); } else { XDefineCursor(dpy, win, 0); } }
void X11Window::setMouseCursor(const std::string& file, const Point& hotSpot) { std::stringstream fin; g_resources.loadFile(file, fin); apng_data apng; if(load_apng(fin, &apng) != 0) { g_logger.traceError(stdext::format("unable to load png file %s", file)); return; } if(apng.bpp != 4) { g_logger.error("the cursor png must have 4 channels"); free_apng(&apng); return; } if(apng.width != 32|| apng.height != 32) { g_logger.error("the cursor png must have 32x32 dimension"); free_apng(&apng); return; } if(m_cursor != None) restoreMouseCursor(); int width = apng.width; int height = apng.height; int numbits = width * height; int numbytes = (width * height)/8; XColor bg, fg; bg.red = 255 << 8; bg.green = 255 << 8; bg.blue = 255 << 8; fg.red = 0; fg.green = 0; fg.blue = 0; std::vector<uchar> mapBits(numbytes, 0); std::vector<uchar> maskBits(numbytes, 0); for(int i=0;i<numbits;++i) { uint32 rgba = stdext::readLE32(apng.pdata + i*4); if(rgba == 0xffffffff) { //white, background LSB_BIT_SET(maskBits, i); } else if(rgba == 0xff000000) { //black, foreground LSB_BIT_SET(mapBits, i); LSB_BIT_SET(maskBits, i); } //otherwise 0x00000000 => alpha } free_apng(&apng); Pixmap cp = XCreateBitmapFromData(m_display, m_window, (char*)&mapBits[0], width, height); Pixmap mp = XCreateBitmapFromData(m_display, m_window, (char*)&maskBits[0], width, height); m_cursor = XCreatePixmapCursor(m_display, cp, mp, &fg, &bg, hotSpot.x, hotSpot.y); XDefineCursor(m_display, m_window, m_cursor); XFreePixmap(m_display, cp); XFreePixmap(m_display, mp); }
void clViewport::RecreateViewport() { if ( FWindow ) { XDestroyWindow( FDisplay, *FWindow ); } if ( FFullscreen ) { } else { } static char EmptyData[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; FBlackColor.red = 0; FBlackColor.green = 0; FBlackColor.blue = 0; FBitmapEmptyData = XCreateBitmapFromData( FDisplay, *FWindow, EmptyData, 8, 8 ); FLeftArrowCursor = XCreateFontCursor( FDisplay, XC_left_ptr ); FInvisibleCursor = XCreatePixmapCursor( FDisplay, FBitmapEmptyData, FBitmapEmptyData, &FBlackColor, &FBlackColor, 0, 0 ); }
void gl_mousepointer (int action) { if (action==2) hide_mouse ^= 1; else hide_mouse = action ? 1 : 0; if (hide_mouse) { /* hide */ Cursor no_ptr; Pixmap bm_no; XColor black, dummy; Colormap colormap; static char bm_no_data[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; colormap = DefaultColormap (_gl_display, _gl_screen); if (!XAllocNamedColor (_gl_display, colormap, "black", &black, &dummy) ) return; bm_no = XCreateBitmapFromData (_gl_display, _gl_win, bm_no_data, 8, 8); no_ptr = XCreatePixmapCursor (_gl_display, bm_no, bm_no, &black, &black, 0, 0); XDefineCursor (_gl_display, _gl_win, no_ptr); XFreeCursor (_gl_display, no_ptr); if (bm_no != None) XFreePixmap (_gl_display, bm_no); XFreeColors (_gl_display,colormap, &black.pixel, 1, 0); } else { /* show */ XDefineCursor(_gl_display, _gl_win, 0); } }
void X11Device::showCursor(bool enabled) { X11Session *session = static_cast<X11Session *>(getSession()); if (enabled) { if (m_cursor != None) { XFreeCursor(session->m_display, m_cursor); m_cursor = None; } XUndefineCursor(session->m_display, m_window); XSync(session->m_display, False); } else { if (m_cursor == None) { /* Create a transparent cursor */ char bm[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; Pixmap pix = XCreateBitmapFromData(session->m_display, m_window, bm, 8, 8); XColor black; memset(&black, 0, sizeof(XColor)); black.flags = DoRed | DoGreen | DoBlue; m_cursor = XCreatePixmapCursor(session->m_display, pix, pix, &black, &black, 0, 0); XFreePixmap(session->m_display, pix); } XDefineCursor(session->m_display, m_window, m_cursor); XSync(session->m_display, False); } }
Lock * lockscreen(Display *dpy, int screen) { /* Thanks suckless - slock */ char curs[] = {0, 0, 0, 0, 0, 0, 0, 0}; Lock *lock; XColor black, dummy; XSetWindowAttributes wa; Cursor invisible; if (dpy == NULL || screen < 0) return NULL; lock = malloc(sizeof(Lock)); if (lock == NULL) return NULL; lock->screen = screen; lock->root = RootWindow(dpy, lock->screen); /* init */ wa.override_redirect = 1; wa.background_pixel = BlackPixel(dpy, lock->screen); lock->win = XCreateWindow(dpy, lock->root, 0, 0, DisplayWidth(dpy, lock->screen), DisplayHeight(dpy, lock->screen), 0, DefaultDepth(dpy, lock->screen), CopyFromParent, DefaultVisual(dpy, lock->screen), CWOverrideRedirect | CWBackPixel, &wa); XAllocNamedColor(dpy, DefaultColormap(dpy, lock->screen), "black", &black, &dummy); lock->pmap = XCreateBitmapFromData(dpy, lock->win, curs, 8, 8); invisible = XCreatePixmapCursor(dpy, lock->pmap, lock->pmap, &black, &black, 0, 0); XDefineCursor(dpy, lock->win, invisible); XMapRaised(dpy, lock->win); return lock; }
static void InitPointerBlank(Widget w) { DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w; DtTermPrimData tpd = tw->term.tpd; XColor fg = { 0, 0, 0, 0, DoRed | DoGreen | DoBlue, 0 }; XColor bg = { 0, 0, 0, 0, DoRed | DoGreen | DoBlue, 0 }; Pixmap noPointerBitmap; /* ** set a pointer motion handler... */ tpd->pointerTimeoutID = 0 ; tpd->pointerFrozen = True ; fg.pixel = bg.pixel = BlackPixelOfScreen(XtScreen(w)); noPointerBitmap = XCreateBitmapFromData(XtDisplay(w),XtWindow(tw), whiteBits, whiteW, whiteH); tpd->noPointer = XCreatePixmapCursor(XtDisplay(tw), noPointerBitmap, /* source bitmap */ noPointerBitmap, /* mask bitmap */ &fg, &bg, /* Do not care */ 0, 0); /* hotspot */ XFreePixmap(XtDisplay(w), noPointerBitmap); XtAddEventHandler((Widget)tw, PointerMotionMask, FALSE, PointerMoved, (XtPointer)NULL); tpd->pointerFirst = False ; }
static Cursor XbrCursorCreate(Display *display, Screen *screen, char *bits, int xhot, int yhot, int width, int height) { Cursor cursor; XColor colours[2]; Pixmap pixmap; Colormap colourmap = DefaultColormapOfScreen(screen); Window root = RootWindowOfScreen(screen); /* Find out the black & white pixel values */ XbrGfxBWPixels(display, screen, colourmap, &colours[0], &colours[1]); /* Convert the bitmap to a pixmap - we could use XbrReadBitmap but that requires a GC, so we use the normal X routine. */ pixmap = XCreatePixmapFromBitmapData(display, root, bits, width, height, colours[1].pixel, colours[0].pixel, 1); /* Create a cursor from the pixmap */ cursor = XCreatePixmapCursor(display, pixmap, pixmap, &colours[0], &colours[1], xhot, yhot); /* Free the pixmap now */ XFreePixmap(display, pixmap); return(cursor); }
static void init_cursors(void) { static char zchar[1]; Pixmap pix; XColor black, dummy; create_cursor(CurNormal, XC_left_ptr); create_cursor(CurNECorner, XC_top_right_corner); create_cursor(CurNWCorner, XC_top_left_corner); create_cursor(CurSECorner, XC_bottom_right_corner); create_cursor(CurSWCorner, XC_bottom_left_corner); create_cursor(CurMove, XC_fleur); create_cursor(CurDHArrow, XC_sb_h_double_arrow); create_cursor(CurDVArrow, XC_sb_v_double_arrow); create_cursor(CurInput, XC_xterm); create_cursor(CurSizing, XC_sizing); create_cursor(CurIcon, XC_icon); create_cursor(CurTCross, XC_tcross); XAllocNamedColor(display, scr.colormap, "black", &black, &dummy); pix = XCreateBitmapFromData( display, scr.root.xid, zchar, 1, 1); cursor[CurNone] = XCreatePixmapCursor(display, pix, pix, &black, &black, 0, 0); XFreePixmap(display, pix); }
Cursor cursorCreateSpinning (Display * dpy) { Pixmap cursor; Pixmap mask; XColor fg, bg; Cursor xcursor; fg.pixel = 0; fg.red = 0; fg.green = 0; fg.blue = 0; fg.flags = 0xf; bg.pixel = 0xffffffff; bg.red = 0xffff; bg.green = 0xffff; bg.blue = 0xffff; bg.flags = 0xf; cursor = XCreatePixmapFromBitmapData (dpy, DefaultRootWindow(dpy), (char *) xlib_spinning_bits, 32, 32, 0xffffffff, 0x0, 1); mask = XCreatePixmapFromBitmapData (dpy, DefaultRootWindow(dpy), (char *) xlib_spinning_mask_bits, 32, 32, 0xffffffff, 0x0, 1); xcursor = XCreatePixmapCursor (dpy, cursor, mask, &fg, &bg, 2, 2); XFreePixmap (dpy, mask); XFreePixmap (dpy, cursor); return xcursor; }
void init_cursor(void) { register Display *d = tool_d; register Pixmap mag_pixmap; arrow_cursor = XCreateFontCursor(d, XC_left_ptr); bull_cursor = XCreateFontCursor(d, XC_circle); buster_cursor = XCreateFontCursor(d, XC_pirate); crosshair_cursor = XCreateFontCursor(d, XC_crosshair); null_cursor = XCreateFontCursor(d, XC_tcross); text_cursor = XCreateFontCursor(d, XC_xterm); pick15_cursor = XCreateFontCursor(d, XC_dotbox); pick9_cursor = XCreateFontCursor(d, XC_hand1); wait_cursor = XCreateFontCursor(d, XC_watch); panel_cursor = XCreateFontCursor(d, XC_icon); lr_arrow_cursor = XCreateFontCursor(d, XC_sb_h_double_arrow); l_arrow_cursor = XCreateFontCursor(d, XC_sb_left_arrow); r_arrow_cursor = XCreateFontCursor(d, XC_sb_right_arrow); ud_arrow_cursor = XCreateFontCursor(d, XC_sb_v_double_arrow); u_arrow_cursor = XCreateFontCursor(d, XC_sb_up_arrow); d_arrow_cursor = XCreateFontCursor(d, XC_sb_down_arrow); /* we must make our on magnifying glass cursor as there is none in the cursor font */ mag_pixmap = XCreateBitmapFromData(tool_d, DefaultRootWindow(tool_d), (char *) magnify_bits, magnify_width, magnify_height); magnify_cursor = XCreatePixmapCursor(d, mag_pixmap, mag_pixmap, &x_fg_color, &x_bg_color, magnify_x_hot, magnify_y_hot); XFreePixmap(tool_d, mag_pixmap); cur_cursor = arrow_cursor; /* current cursor */ }
static Cursor createNULLCursor(void) { Pixmap cursormask; XGCValues xgc; GC gc; XColor col; Cursor cursor; // TODO: Add error checks cursormask = XCreatePixmap(_glfw.x11.display, _glfw.x11.root, 1, 1, 1); xgc.function = GXclear; gc = XCreateGC(_glfw.x11.display, cursormask, GCFunction, &xgc); XFillRectangle(_glfw.x11.display, cursormask, gc, 0, 0, 1, 1); col.pixel = 0; col.red = 0; col.flags = 4; cursor = XCreatePixmapCursor(_glfw.x11.display, cursormask, cursormask, &col, &col, 0, 0); XFreePixmap(_glfw.x11.display, cursormask); XFreeGC(_glfw.x11.display, gc); return cursor; }
static Cursor makeBlankCursor(void) { #if !defined(WIN32) static char data[1] = {0}; Cursor cursor; Pixmap blank; XColor dummy; blank = XCreateBitmapFromData(__glutDisplay, __glutRoot, data, 1, 1); if (blank == None) __glutFatalError("out of memory."); cursor = XCreatePixmapCursor(__glutDisplay, blank, blank, &dummy, &dummy, 0, 0); XFreePixmap(__glutDisplay, blank); return cursor; #else /* we could kludge up an XCreateBitmapFromData, XCreatePixmapCursor and XFreePixmap that worked for just this case, but I dunno if it is worth it, hence the #ifdefs instead. */ return NULL; #endif /* !WIN32 */ }
/*Sets up the cursors data for a dnd. * display - X display * rw - the root window */ void xdndCursorInit(Display *display, Window rw) { Pixmap ip,mp; XdndCursor *cursorPtr; XColor black, white; /* gets color info */ black.pixel = BlackPixel(display, DefaultScreen (display)); XQueryColor(display, DefaultColormap (display, DefaultScreen(display)), &black); white.pixel = WhitePixel(display, DefaultScreen (display)); XQueryColor(display, DefaultColormap (display, DefaultScreen(display)), &white); /* now initialize the cursors */ for (cursorPtr = &xdndCursors[0];cursorPtr->w != 0;cursorPtr++) { ip = XCreateBitmapFromData(display, rw, (char *) cursorPtr->imageData, cursorPtr->w, cursorPtr->h); mp = XCreateBitmapFromData(display, rw, (char *) cursorPtr->maskData, cursorPtr->w, cursorPtr->h); cursorPtr->cursor = XCreatePixmapCursor (display, ip, mp, &black, &white, cursorPtr->x, cursorPtr->y); XFreePixmap (display, ip); XFreePixmap (display, mp); cursorPtr->action = XInternAtom (display, cursorPtr->actionStr, False); } }
/** * @brief Show the cursor on a window of type Ecore_X_Window. * @param win The window for which the cursor will be showed. * @param show Enables the show of the cursor on the window if equals EINA_TRUE, disables if equals EINA_FALSE. */ EAPI void ecore_x_window_cursor_show(Ecore_X_Window win, Eina_Bool show) { LOGFN(__FILE__, __LINE__, __FUNCTION__); if (win == 0) win = DefaultRootWindow(_ecore_x_disp); if (!show) { Cursor c; XColor cl; Pixmap p, m; GC gc; XGCValues gcv; p = XCreatePixmap(_ecore_x_disp, win, 1, 1, 1); m = XCreatePixmap(_ecore_x_disp, win, 1, 1, 1); gc = XCreateGC(_ecore_x_disp, m, 0, &gcv); XSetForeground(_ecore_x_disp, gc, 0); XDrawPoint(_ecore_x_disp, m, gc, 0, 0); XFreeGC(_ecore_x_disp, gc); c = XCreatePixmapCursor(_ecore_x_disp, p, m, &cl, &cl, 0, 0); XDefineCursor(_ecore_x_disp, win, c); XFreeCursor(_ecore_x_disp, c); XFreePixmap(_ecore_x_disp, p); XFreePixmap(_ecore_x_disp, m); } else XDefineCursor(_ecore_x_disp, win, 0); }
// Create a blank cursor (for locked mouse mode) // static Cursor createNULLCursor(void) { Pixmap cursormask; XGCValues xgc; GC gc; XColor col; Cursor cursor; _glfwGrabXErrorHandler(); cursormask = XCreatePixmap(_glfw.x11.display, _glfw.x11.root, 1, 1, 1); xgc.function = GXclear; gc = XCreateGC(_glfw.x11.display, cursormask, GCFunction, &xgc); XFillRectangle(_glfw.x11.display, cursormask, gc, 0, 0, 1, 1); col.pixel = 0; col.red = 0; col.flags = 4; cursor = XCreatePixmapCursor(_glfw.x11.display, cursormask, cursormask, &col, &col, 0, 0); XFreePixmap(_glfw.x11.display, cursormask); XFreeGC(_glfw.x11.display, gc); _glfwReleaseXErrorHandler(); if (cursor == None) { _glfwInputXError(GLFW_PLATFORM_ERROR, "X11: Failed to create null cursor"); } return cursor; }
void PsychHideCursor(int screenNumber) { // Static "Cursor" object which defines a completely transparent - and therefore invisible // X11 cursor for the mouse-pointer. static Cursor nullCursor = -1; // Check for valid screenNumber: if(screenNumber>=numDisplays) PsychErrorExitMsg(PsychError_internal, "screenNumber passed to PsychHideCursor() is out of range"); //also checked within SCREENPixelSizes // nullCursor already ready? if( nullCursor == (Cursor) -1 ) { // Create one: Pixmap cursormask; XGCValues xgc; GC gc; XColor dummycolour; cursormask = XCreatePixmap(displayCGIDs[screenNumber], RootWindow(displayCGIDs[screenNumber], PsychGetXScreenIdForScreen(screenNumber)), 1, 1, 1/*depth*/); xgc.function = GXclear; gc = XCreateGC(displayCGIDs[screenNumber], cursormask, GCFunction, &xgc ); XFillRectangle(displayCGIDs[screenNumber], cursormask, gc, 0, 0, 1, 1 ); dummycolour.pixel = 0; dummycolour.red = 0; dummycolour.flags = 04; nullCursor = XCreatePixmapCursor(displayCGIDs[screenNumber], cursormask, cursormask, &dummycolour, &dummycolour, 0, 0 ); XFreePixmap(displayCGIDs[screenNumber], cursormask ); XFreeGC(displayCGIDs[screenNumber], gc ); } // Attach nullCursor to our onscreen window: XDefineCursor(displayCGIDs[screenNumber], RootWindow(displayCGIDs[screenNumber], PsychGetXScreenIdForScreen(screenNumber)), nullCursor ); XFlush(displayCGIDs[screenNumber]); return; }
void input_show_cursor(bool show) { Cursor cur; Pixmap pix; XColor black; static char cursor_data[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; black.red = black.green = black.blue = 0; if (show) { cur = XCreateFontCursor(x_display, XC_left_ptr); XDefineCursor(x_display, x11_active_window, cur); XFreeCursor(x_display, cur); cursor_state |= (uint8_t)1 << CURSOR_VISIBLE; } else { pix = XCreateBitmapFromData(x_display, x11_active_window, cursor_data, 8, 8); cur = XCreatePixmapCursor(x_display, pix, pix, &black, &black, 0, 0); XDefineCursor(x_display, x11_active_window, cur); XFreeCursor(x_display, cur); XFreePixmap(x_display, pix); cursor_state &= ~((uint8_t)1 << CURSOR_VISIBLE); } XFlush(x_display); }
gboolean cb_hide_pointer(GtkWidget *widget, GdkEvent *event, gpointer data) { static Cursor cursor = 0; XColor colour; Pixmap cursorPixmap; colour.pixel = WhitePixel(GDK_WINDOW_XDISPLAY(GTK_WIDGET(widget)->window), DefaultScreen(GDK_WINDOW_XDISPLAY(GTK_WIDGET(widget)->window))); XQueryColor(GDK_WINDOW_XDISPLAY(GTK_WIDGET(widget)->window), DefaultColormap(GDK_WINDOW_XDISPLAY(GTK_WIDGET(widget)->window), DefaultScreen(GDK_WINDOW_XDISPLAY(GTK_WIDGET(widget)->window))), &colour); if(cursor) { XFreeCursor(GDK_WINDOW_XDISPLAY(GTK_WIDGET(widget)->window), cursor); } cursorPixmap = XCreatePixmap(GDK_WINDOW_XDISPLAY(GTK_WIDGET(widget)->window), GDK_WINDOW_XWINDOW(GTK_WIDGET(widget)->window), 1, 1, 1); cursor = XCreatePixmapCursor(GDK_WINDOW_XDISPLAY(GTK_WIDGET(widget)->window), cursorPixmap, cursorPixmap, &colour, &colour, 0, 0); if(cursorPixmap) { XFreePixmap(GDK_WINDOW_XDISPLAY(GTK_WIDGET(widget)->window), cursorPixmap); } XDefineCursor(GDK_WINDOW_XDISPLAY(GTK_WIDGET(widget)->window), GDK_WINDOW_XWINDOW(GTK_WIDGET(widget)->window), cursor); return TRUE; }
Cursor UXViewport::GetNullCursor() { guard(UXViewport::GetNullCursor); Pixmap NullCursor; XGCValues _XGC; GC _Context; XColor Nothing; Cursor Result; NullCursor = XCreatePixmap(XDisplay, XWindow, 1, 1, 1); _XGC.function = GXclear; _Context = XCreateGC(XDisplay, NullCursor, GCFunction, &_XGC); XFillRectangle(XDisplay, NullCursor, _Context, 0, 0, 1, 1); Nothing.pixel = 0; Nothing.red = 0; Nothing.flags = 04; Result = XCreatePixmapCursor(XDisplay, NullCursor, NullCursor, &Nothing, &Nothing, 0, 0); XFreePixmap(XDisplay, NullCursor); XFreeGC(XDisplay, _Context); return Result; unguard; }
int NewBitmapCursor(Cursor *cp, char *source, char *mask) { XColor fore, back; int hotx, hoty; int sx, sy, mx, my; unsigned int sw, sh, mw, mh; Pixmap spm, mpm; Colormap cmap = Scr->RootColormaps.cwins[0]->colormap->c; fore.pixel = Scr->Black; XQueryColor(dpy, cmap, &fore); back.pixel = Scr->White; XQueryColor(dpy, cmap, &back); spm = GetBitmap(source); if ((hotx = HotX) < 0) hotx = 0; if ((hoty = HotY) < 0) hoty = 0; mpm = GetBitmap(mask); /* make sure they are the same size */ XGetGeometry(dpy, spm, &JunkRoot, &sx, &sy, &sw, &sh, &JunkBW,&JunkDepth); XGetGeometry(dpy, mpm, &JunkRoot, &mx, &my, &mw, &mh, &JunkBW,&JunkDepth); if (sw != mw || sh != mh) { fprintf (stderr, "%s: cursor bitmaps \"%s\" and \"%s\" not the same size\n", ProgramName, source, mask); return (1); } *cp = XCreatePixmapCursor(dpy, spm, mpm, &fore, &back, hotx,hoty); return (0); }
void _xsetcursor(Cursor *c) { XColor fg, bg; XCursor xc; Pixmap xsrc, xmask; int i; uchar src[2*16], mask[2*16]; if(c == nil){ xcursorarrow(); return; } for(i=0; i<2*16; i++){ src[i] = revbyte(c->set[i]); mask[i] = revbyte(c->set[i] | c->clr[i]); } fg = _x.map[0]; bg = _x.map[255]; xsrc = XCreateBitmapFromData(_x.display, _x.drawable, (char*)src, 16, 16); xmask = XCreateBitmapFromData(_x.display, _x.drawable, (char*)mask, 16, 16); xc = XCreatePixmapCursor(_x.display, xsrc, xmask, &fg, &bg, -c->offset.x, -c->offset.y); if(xc != 0) { XDefineCursor(_x.display, _x.drawable, xc); if(_x.cursor != 0) XFreeCursor(_x.display, _x.cursor); _x.cursor = xc; } XFreePixmap(_x.display, xsrc); XFreePixmap(_x.display, xmask); XFlush(_x.display); }
void cursorswitch(Cursor *c) { if(c == 0) c = &arrow; if(c->id == 0){ if(bsrc == 0){ bsrc = balloc(crect, 0); bmask = balloc(crect, 0); } /* * Cursor should have fg where "set" is 1, * and bg where "clr" is 1 and "set" is 0, * and should leave places alone where "set" and "clr" are both 0 */ wrbitmap(bsrc, 0, 16, c->set); #ifdef CURSORBUG /* * Some X servers (e.g., Sun X-on-news for some color * monitors) don't do XCreatePixmapCursor properly: * only the mask gets displayed, all black */ wrbitmap(bmask, 0, 16, c->set); #else wrbitmap(bmask, 0, 16, c->clr); bitblt(bmask, Pt(0,0), bsrc, crect, S|D); #endif c->id = (int) XCreatePixmapCursor(_dpy, (Pixmap)bsrc->id, (Pixmap)bmask->id, &_fgcolor, &_bgcolor, -c->offset.x, -c->offset.y); } XDefineCursor(_dpy, (Window)screen.id, (xCursor)c->id); }
static Cursor create_bitmap_cursor( const char * source, const char * mask, int w, int h, int hotx, int hoty ) { Pixmap s, m = None; XColor fg, bg; Cursor cur; Window win = fl_root; s = XCreateBitmapFromData( flx->display, win, source, w, h ); if ( mask ) m = XCreateBitmapFromData( flx->display, win, mask, w, h ); fg.red = fg.green = fg.blue = 0; bg.red = bg.green = bg.blue = 0xffff; cur = XCreatePixmapCursor( flx->display, s, m, &fg, &bg, hotx, hoty ); return cur; }
TkCursor * TkCreateCursorFromData( Tk_Window tkwin, /* Window in which cursor will be used. */ const char *source, /* Bitmap data for cursor shape. */ const char *mask, /* Bitmap data for cursor mask. */ int width, int height, /* Dimensions of cursor. */ int xHot, int yHot, /* Location of hot-spot in cursor. */ XColor fgColor, /* Foreground color for cursor. */ XColor bgColor) /* Background color for cursor. */ { Cursor cursor; Pixmap sourcePixmap, maskPixmap; TkUnixCursor *cursorPtr = NULL; Display *display = Tk_Display(tkwin); sourcePixmap = XCreateBitmapFromData(display, RootWindowOfScreen(Tk_Screen(tkwin)), source, (unsigned) width, (unsigned) height); maskPixmap = XCreateBitmapFromData(display, RootWindowOfScreen(Tk_Screen(tkwin)), mask, (unsigned) width, (unsigned) height); cursor = XCreatePixmapCursor(display, sourcePixmap, maskPixmap, &fgColor, &bgColor, (unsigned) xHot, (unsigned) yHot); Tk_FreePixmap(display, sourcePixmap); Tk_FreePixmap(display, maskPixmap); if (cursor != None) { cursorPtr = ckalloc(sizeof(TkUnixCursor)); cursorPtr->info.cursor = (Tk_Cursor) cursor; cursorPtr->display = display; } return (TkCursor *) cursorPtr; }