示例#1
0
/* 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);
}
示例#2
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);
}
示例#3
0
文件: apc_pointer.c 项目: dk/Prima
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;
}
示例#4
0
文件: nenu.c 项目: mytchel/nenu
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!");
}
示例#5
0
文件: extinitwin.c 项目: Limsik/e17
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;
}
示例#6
0
文件: util.c 项目: Asmodean-/PCSXR
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);
    }
}
示例#7
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);
}
示例#8
0
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 );
}
示例#9
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);
    }
}
示例#11
0
文件: ble.c 项目: dhn/ble
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;
}
示例#12
0
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 ;
}
示例#13
0
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);
}
示例#14
0
文件: main.c 项目: bartman/wmii
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);
}
示例#15
0
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;
}
示例#16
0
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 */
}
示例#17
0
文件: x11_init.c 项目: csulmone/glfw
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;
}
示例#18
0
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 */
}
示例#19
0
/*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);
}
示例#21
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;
}
示例#23
0
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);
}
示例#24
0
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;
}
示例#25
0
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;
}
示例#26
0
文件: cursor.c 项目: iquiw/xsrc
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);
}
示例#27
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);
}
示例#28
0
文件: cursorswitch.c 项目: 8l/sam
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);
}
示例#29
0
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;
}
示例#30
0
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;
}