int main(int argc, char **argv) { char curs[] = {0, 0, 0, 0, 0, 0, 0, 0}; char buf[32], passwd[256]; int num, screen; #ifndef HAVE_BSD_AUTH const char *pws; #endif unsigned int len; Bool running = True; Cursor invisible; Display *dpy; KeySym ksym; Pixmap pmap; Window root, w; XColor black, dummy; XEvent ev; XSetWindowAttributes wa; if((argc == 2) && !strcmp("-v", argv[1])) die("slock-"VERSION", © 2006-2008 Anselm R Garbe\n"); else if(argc != 1) die("usage: slock [-vb]\n"); backlight_of(); #ifndef HAVE_BSD_AUTH pws = get_password(); #endif if(!(dpy = XOpenDisplay(0))) die("slock: cannot open display\n"); screen = DefaultScreen(dpy); root = RootWindow(dpy, screen); /* init */ wa.override_redirect = 1; wa.background_pixel = BlackPixel(dpy, screen); w = XCreateWindow(dpy, root, 0, 0, DisplayWidth(dpy, screen), DisplayHeight(dpy, screen), 0, DefaultDepth(dpy, screen), CopyFromParent, DefaultVisual(dpy, screen), CWOverrideRedirect | CWBackPixel, &wa); XAllocNamedColor(dpy, DefaultColormap(dpy, screen), "black", &black, &dummy); pmap = XCreateBitmapFromData(dpy, w, curs, 8, 8); invisible = XCreatePixmapCursor(dpy, pmap, pmap, &black, &black, 0, 0); XDefineCursor(dpy, w, invisible); XMapRaised(dpy, w); for(len = 1000; len; len--) { if(XGrabPointer(dpy, root, False, ButtonPressMask | ButtonReleaseMask | PointerMotionMask, GrabModeAsync, GrabModeAsync, None, invisible, CurrentTime) == GrabSuccess) break; usleep(1000); } if((running = running && (len > 0))) { for(len = 1000; len; len--) { if(XGrabKeyboard(dpy, root, True, GrabModeAsync, GrabModeAsync, CurrentTime) == GrabSuccess) break; usleep(1000); } running = (len > 0); } len = 0; XSync(dpy, False); /* main event loop */ while(running && !XNextEvent(dpy, &ev)) { if(len == 0 && DPMSCapable(dpy)) { DPMSEnable(dpy); DPMSForceLevel(dpy, DPMSModeOff); } if(ev.type == KeyPress) { buf[0] = 0; num = XLookupString(&ev.xkey, buf, sizeof buf, &ksym, 0); if(IsKeypadKey(ksym)) { if(ksym == XK_KP_Enter) ksym = XK_Return; else if(ksym >= XK_KP_0 && ksym <= XK_KP_9) ksym = (ksym - XK_KP_0) + XK_0; } if(IsFunctionKey(ksym) || IsKeypadKey(ksym) || IsMiscFunctionKey(ksym) || IsPFKey(ksym) || IsPrivateKeypadKey(ksym)) continue; switch(ksym) { case XK_Return: passwd[len] = 0; #ifdef HAVE_BSD_AUTH running = !auth_userokay(getlogin(), NULL, "auth-xlock", passwd); #else running = strcmp(crypt(passwd, pws), pws); #endif if (running != 0) XBell(dpy, 100); len = 0; break; case XK_Escape: len = 0; break; case XK_BackSpace: if(len) --len; break; default: if(num && !iscntrl((int) buf[0]) && (len + num < sizeof passwd)) { memcpy(passwd + len, buf, num); len += num; } break; } } } XUngrabPointer(dpy, CurrentTime); XFreePixmap(dpy, pmap); XDestroyWindow(dpy, w); XCloseDisplay(dpy); backlight_on(); return 0; }
void drw_free(Drw *drw) { XFreePixmap(drw->dpy, drw->drawable); XFreeGC(drw->dpy, drw->gc); free(drw); }
gfxXlibSurface::~gfxXlibSurface() { if (mPixmapTaken) { XFreePixmap (mDisplay, mDrawable); } }
static void glxtest() { // we want to redirect to /dev/null stdout, stderr, and while we're at it, // any PR logging file descriptors. To that effect, we redirect all positive // file descriptors up to what open() returns here. In particular, 1 is stdout and 2 is stderr. int fd = open("/dev/null", O_WRONLY); for (int i = 1; i < fd; i++) dup2(fd, i); close(fd); ///// Open libGL and load needed symbols ///// #ifdef __OpenBSD__ #define LIBGL_FILENAME "libGL.so" #else #define LIBGL_FILENAME "libGL.so.1" #endif void *libgl = dlopen(LIBGL_FILENAME, RTLD_LAZY); if (!libgl) fatal_error("Unable to load " LIBGL_FILENAME); typedef void* (* PFNGLXGETPROCADDRESS) (const char *); PFNGLXGETPROCADDRESS glXGetProcAddress = cast<PFNGLXGETPROCADDRESS>(dlsym(libgl, "glXGetProcAddress")); if (!glXGetProcAddress) fatal_error("Unable to find glXGetProcAddress in " LIBGL_FILENAME); typedef GLXFBConfig* (* PFNGLXQUERYEXTENSION) (Display *, int *, int *); PFNGLXQUERYEXTENSION glXQueryExtension = cast<PFNGLXQUERYEXTENSION>(glXGetProcAddress("glXQueryExtension")); typedef GLXFBConfig* (* PFNGLXQUERYVERSION) (Display *, int *, int *); PFNGLXQUERYVERSION glXQueryVersion = cast<PFNGLXQUERYVERSION>(dlsym(libgl, "glXQueryVersion")); typedef GLXFBConfig* (* PFNGLXCHOOSEFBCONFIG) (Display *, int, const int *, int *); PFNGLXCHOOSEFBCONFIG glXChooseFBConfig = cast<PFNGLXCHOOSEFBCONFIG>(glXGetProcAddress("glXChooseFBConfig")); typedef XVisualInfo* (* PFNGLXGETVISUALFROMFBCONFIG) (Display *, GLXFBConfig); PFNGLXGETVISUALFROMFBCONFIG glXGetVisualFromFBConfig = cast<PFNGLXGETVISUALFROMFBCONFIG>(glXGetProcAddress("glXGetVisualFromFBConfig")); typedef GLXPixmap (* PFNGLXCREATEPIXMAP) (Display *, GLXFBConfig, Pixmap, const int *); PFNGLXCREATEPIXMAP glXCreatePixmap = cast<PFNGLXCREATEPIXMAP>(glXGetProcAddress("glXCreatePixmap")); typedef GLXContext (* PFNGLXCREATENEWCONTEXT) (Display *, GLXFBConfig, int, GLXContext, Bool); PFNGLXCREATENEWCONTEXT glXCreateNewContext = cast<PFNGLXCREATENEWCONTEXT>(glXGetProcAddress("glXCreateNewContext")); typedef Bool (* PFNGLXMAKECURRENT) (Display*, GLXDrawable, GLXContext); PFNGLXMAKECURRENT glXMakeCurrent = cast<PFNGLXMAKECURRENT>(glXGetProcAddress("glXMakeCurrent")); typedef void (* PFNGLXDESTROYPIXMAP) (Display *, GLXPixmap); PFNGLXDESTROYPIXMAP glXDestroyPixmap = cast<PFNGLXDESTROYPIXMAP>(glXGetProcAddress("glXDestroyPixmap")); typedef void (* PFNGLXDESTROYCONTEXT) (Display*, GLXContext); PFNGLXDESTROYCONTEXT glXDestroyContext = cast<PFNGLXDESTROYCONTEXT>(glXGetProcAddress("glXDestroyContext")); typedef GLubyte* (* PFNGLGETSTRING) (GLenum); PFNGLGETSTRING glGetString = cast<PFNGLGETSTRING>(glXGetProcAddress("glGetString")); if (!glXQueryExtension || !glXQueryVersion || !glXChooseFBConfig || !glXGetVisualFromFBConfig || !glXCreatePixmap || !glXCreateNewContext || !glXMakeCurrent || !glXDestroyPixmap || !glXDestroyContext || !glGetString) { fatal_error("glXGetProcAddress couldn't find required functions"); } ///// Open a connection to the X server ///// Display *dpy = XOpenDisplay(NULL); if (!dpy) fatal_error("Unable to open a connection to the X server"); ///// Check that the GLX extension is present ///// if (!glXQueryExtension(dpy, NULL, NULL)) fatal_error("GLX extension missing"); ///// Check that the GLX version is >= 1.3, needed for glXCreatePixmap, bug 659932 ///// int majorVersion, minorVersion; if (!glXQueryVersion(dpy, &majorVersion, &minorVersion)) fatal_error("Unable to query GLX version"); if (majorVersion < 1 || (majorVersion == 1 && minorVersion < 3)) fatal_error("GLX version older than the required 1.3"); XSetErrorHandler(x_error_handler); ///// Get a FBConfig and a visual ///// int attribs[] = { GLX_DRAWABLE_TYPE, GLX_PIXMAP_BIT, GLX_X_RENDERABLE, True, 0 }; int numReturned; GLXFBConfig *fbConfigs = glXChooseFBConfig(dpy, DefaultScreen(dpy), attribs, &numReturned ); if (!fbConfigs) fatal_error("No FBConfigs found"); XVisualInfo *vInfo = glXGetVisualFromFBConfig(dpy, fbConfigs[0]); if (!vInfo) fatal_error("No visual found for first FBConfig"); ///// Get a Pixmap and a GLXPixmap ///// Pixmap pixmap = XCreatePixmap(dpy, RootWindow(dpy, vInfo->screen), 4, 4, vInfo->depth); GLXPixmap glxpixmap = glXCreatePixmap(dpy, fbConfigs[0], pixmap, NULL); ///// Get a GL context and make it current ////// GLXContext context = glXCreateNewContext(dpy, fbConfigs[0], GLX_RGBA_TYPE, NULL, True); glXMakeCurrent(dpy, glxpixmap, context); ///// Look for this symbol to determine texture_from_pixmap support ///// void* glXBindTexImageEXT = glXGetProcAddress("glXBindTexImageEXT"); ///// Get GL vendor/renderer/versions strings ///// enum { bufsize = 1024 }; char buf[bufsize]; const GLubyte *vendorString = glGetString(GL_VENDOR); const GLubyte *rendererString = glGetString(GL_RENDERER); const GLubyte *versionString = glGetString(GL_VERSION); if (!vendorString || !rendererString || !versionString) fatal_error("glGetString returned null"); int length = snprintf(buf, bufsize, "VENDOR\n%s\nRENDERER\n%s\nVERSION\n%s\nTFP\n%s\n", vendorString, rendererString, versionString, glXBindTexImageEXT ? "TRUE" : "FALSE"); if (length >= bufsize) fatal_error("GL strings length too large for buffer size"); ///// Clean up. Indeed, the parent process might fail to kill us (e.g. if it doesn't need to check GL info) ///// so we might be staying alive for longer than expected, so it's important to consume as little memory as ///// possible. Also we want to check that we're able to do that too without generating X errors. glXMakeCurrent(dpy, None, NULL); // must release the GL context before destroying it glXDestroyContext(dpy, context); glXDestroyPixmap(dpy, glxpixmap); XFreePixmap(dpy, pixmap); XCloseDisplay(dpy); dlclose(libgl); ///// Finally write data to the pipe write(write_end_of_the_pipe, buf, length); }
gboolean myDisplayTestXrender (DisplayInfo *display, gdouble min_time) { #ifdef HAVE_RENDER GTimeVal t1, t2; gdouble dt; Display *dpy; Picture picture1, picture2, picture3; XRenderPictFormat *format_src, *format_dst; Pixmap fillPixmap, rootPixmap; XRenderPictureAttributes pa; XSetWindowAttributes attrs; XImage *ximage; Window output; XRenderColor c; Visual *visual; Screen *screen; int x, y, w, h; int screen_number; int depth; int iterations; g_return_val_if_fail (display != NULL, FALSE); TRACE ("entering myDisplayTesxrender"); c.alpha = 0x7FFF; c.red = 0xFFFF; c.green = 0xFFFF; c.blue = 0xFFFF; dpy = display->dpy; screen_number = DefaultScreen (dpy); screen = DefaultScreenOfDisplay (dpy); visual = DefaultVisual (dpy, screen_number); depth = DefaultDepth (dpy, screen_number); w = WidthOfScreen(screen) / 16; h = HeightOfScreen(screen) / 16; x = (WidthOfScreen(screen) - w); y = (HeightOfScreen(screen) - h); format_dst = XRenderFindVisualFormat (dpy, visual); g_return_val_if_fail (format_dst != NULL , FALSE); format_src = XRenderFindStandardFormat (dpy, PictStandardA8); g_return_val_if_fail (format_src != NULL , FALSE); ximage = XGetImage (dpy, DefaultRootWindow(dpy), x, y, w, h, AllPlanes, ZPixmap); g_return_val_if_fail (ximage != NULL , FALSE); rootPixmap = XCreatePixmap (dpy, DefaultRootWindow(dpy), w, h, depth); XPutImage (dpy, rootPixmap, DefaultGC (dpy, screen_number), ximage, 0, 0, 0, 0, w, h); XDestroyImage (ximage); attrs.override_redirect = TRUE; output = XCreateWindow (dpy, DefaultRootWindow(dpy), x, y, w, h, 0, CopyFromParent, CopyFromParent, (Visual *) CopyFromParent, CWOverrideRedirect, &attrs); XMapRaised (dpy, output); fillPixmap = XCreatePixmap (dpy, DefaultRootWindow(dpy), 1, 1, 8); g_get_current_time (&t1); pa.repeat = TRUE; picture1 = XRenderCreatePicture (dpy, rootPixmap, format_dst, 0, NULL); picture2 = XRenderCreatePicture (dpy, fillPixmap, format_src, CPRepeat, &pa); picture3 = XRenderCreatePicture (dpy, output, format_dst, 0, NULL); XRenderComposite (dpy, PictOpSrc, picture1, None, picture3, 0, 0, 0, 0, 0, 0, w, h); XRenderFillRectangle (dpy, PictOpSrc, picture2, &c, 0, 0, 1, 1); for (iterations = 0; iterations < 10; iterations++) { XRenderComposite (dpy, PictOpOver, picture1, picture2, picture3, 0, 0, 0, 0, 0, 0, w, h); ximage = XGetImage (dpy, output, 0, 0, 1, 1, AllPlanes, ZPixmap); if (ximage) { XDestroyImage (ximage); } } XRenderFreePicture (dpy, picture1); XRenderFreePicture (dpy, picture2); XRenderFreePicture (dpy, picture3); XFreePixmap (dpy, fillPixmap); XFreePixmap (dpy, rootPixmap); XDestroyWindow (dpy, output); g_get_current_time (&t2); dt = (gdouble) (t2.tv_sec - t1.tv_sec) * G_USEC_PER_SEC + (gdouble) (t2.tv_usec - t1.tv_usec) / 1000.0; if (dt < min_time) { TRACE ("XRender test passed (target %3.4f sec., measured %3.4f sec.).", min_time, dt); return TRUE; } g_print ("XRender test failed (target %3.4f sec., measured %3.4f sec.).\n", min_time, dt); return FALSE; #else /* HAVE_RENDER */ return FALSE; #endif /* HAVE_RENDER */ }
static cairo_test_status_t do_test (const cairo_test_context_t *ctx, Display *dpy, unsigned char *reference_data, unsigned char *test_data, unsigned char *diff_data, cairo_bool_t use_pixmap, cairo_bool_t set_size, cairo_bool_t offscreen) { cairo_surface_t *surface; cairo_surface_t *test_surface; cairo_t *test_cr; buffer_diff_result_t result; Drawable drawable; int screen = DefaultScreen (dpy); if (use_pixmap && offscreen) return CAIRO_TEST_SUCCESS; if (use_pixmap) { drawable = XCreatePixmap (dpy, DefaultRootWindow (dpy), SIZE, SIZE, DefaultDepth (dpy, screen)); } else { XSetWindowAttributes xwa; int x, y; xwa.override_redirect = True; if (offscreen) { x = - OFFSCREEN_OFFSET; y = - OFFSCREEN_OFFSET; } else { x = 0; y = 0; } drawable = XCreateWindow (dpy, DefaultRootWindow (dpy), x, y, SIZE, SIZE, 0, DefaultDepth (dpy, screen), InputOutput, DefaultVisual (dpy, screen), CWOverrideRedirect, &xwa); XMapWindow (dpy, drawable); } surface = cairo_xlib_surface_create (dpy, drawable, DefaultVisual (dpy, screen), SIZE, SIZE); if (! surface_compare_visual_and_format (surface)) return CAIRO_TEST_FAILURE; if (set_size) { cairo_xlib_surface_set_size (surface, SIZE, SIZE); if (cairo_xlib_surface_get_width (surface) != SIZE || cairo_xlib_surface_get_height (surface) != SIZE) return CAIRO_TEST_FAILURE; } if (! check_similar_visual_and_format (surface)) return CAIRO_TEST_FAILURE; draw_pattern (surface); test_surface = cairo_image_surface_create_for_data (test_data, CAIRO_FORMAT_RGB24, SIZE, SIZE, SIZE * 4); test_cr = cairo_create (test_surface); cairo_set_source_surface (test_cr, surface, 0, 0); cairo_paint (test_cr); cairo_destroy (test_cr); cairo_surface_destroy (test_surface); /* We erase the surface to black in case we get the same * memory back again for the pixmap case. */ erase_pattern (surface); cairo_surface_destroy (surface); if (use_pixmap) XFreePixmap (dpy, drawable); else XDestroyWindow (dpy, drawable); if (offscreen) { size_t offset = 4 * (SIZE * OFFSCREEN_OFFSET + OFFSCREEN_OFFSET); buffer_diff_noalpha (reference_data + offset, test_data + offset, diff_data + offset, SIZE - OFFSCREEN_OFFSET, SIZE - OFFSCREEN_OFFSET, 4 * SIZE, &result); } else { buffer_diff_noalpha (reference_data, test_data, diff_data, SIZE, SIZE, 4 * SIZE, &result); } cairo_test_log (ctx, "xlib-surface: %s, %s, %s: %s\n", set_size ? " size" : "no-size", use_pixmap ? "pixmap" : "window", use_pixmap ? " " : (offscreen ? ", offscreen" : ", onscreen"), image_diff_is_failure (&result, 0) ? "FAIL" : "PASS"); if (image_diff_is_failure (&result, 0)) return CAIRO_TEST_FAILURE; else return CAIRO_TEST_SUCCESS; }
void init_puzzle(ModeInfo * mi) { Display *display = MI_DISPLAY(mi); Window window = MI_WINDOW(mi); puzzlestruct *pp; int x, y; XPoint size; if (puzzles == NULL) { if ((puzzles = (puzzlestruct *) calloc(MI_NUM_SCREENS(mi), sizeof (puzzlestruct))) == NULL) return; } pp = &puzzles[MI_SCREEN(mi)]; if (pp->painted && pp->windowsize.x == MI_WIDTH(mi) && pp->windowsize.y == MI_HEIGHT(mi)) return; /* Debounce since refresh_puzzle is init_puzzle */ #ifdef HAVE_XPM if (pp->graphics_format >= IS_XPM) { /* This is needed when another program changes the colormap. */ free_puzzle(display, pp); } #endif if (!init_stuff(mi)) return; pp->excount = MI_COUNT(mi); if (pp->excount < 0) { if (pp->fixbuff != NULL) { free(pp->fixbuff); pp->fixbuff = (int *) NULL; } pp->excount = NRAND(-pp->excount) + 1; } pp->lastbox = -1; pp->moves = 0; pp->movingBox = False; pp->windowsize.x = MI_WIDTH(mi); pp->windowsize.y = MI_HEIGHT(mi); if (pp->windowsize.x < 7) pp->windowsize.x = 7; if (pp->windowsize.y < 7) pp->windowsize.y = 7; pp->forward = 1; pp->prev = 0; /* don't want any exposure events from XCopyArea */ XSetGraphicsExposures(display, pp->backGC, False); MI_CLEARWINDOWCOLORMAP(mi, pp->backGC, pp->black); if (pp->logo) { size.x = (pp->logo->width < pp->windowsize.x) ? pp->logo->width : pp->windowsize.x; size.y = (pp->logo->height < pp->windowsize.y) ? pp->logo->height : pp->windowsize.y; } else { size.x = pp->windowsize.x; size.y = pp->windowsize.y; } pp->boxsize.y = NRAND(1 + size.y / 4) + 6; pp->boxsize.x = NRAND(1 + size.x / 4) + 6; if ((pp->boxsize.x > 4 * pp->boxsize.y) || pp->boxsize.y > 4 * pp->boxsize.x) pp->boxsize.x = pp->boxsize.y = 2 * MIN(pp->boxsize.x, pp->boxsize.y); pp->count.x = size.x / pp->boxsize.x; pp->count.y = size.y / pp->boxsize.y; if (pp->bufferBox != None) { XFreePixmap(display, pp->bufferBox); pp->bufferBox = None; } pp->usablewindow.x = pp->count.x * pp->boxsize.x; pp->usablewindow.y = pp->count.y * pp->boxsize.y; pp->offsetwindow.x = (pp->windowsize.x - pp->usablewindow.x) / 2; pp->offsetwindow.y = (pp->windowsize.y - pp->usablewindow.y) / 2; pp->incrementOfMove = MIN(pp->usablewindow.x, pp->usablewindow.y) / 20; pp->incrementOfMove = MAX(pp->incrementOfMove, 1); if (pp->logo) { pp->randompos.x = NRAND(MAX((pp->windowsize.x - pp->logo->width), 2 * pp->offsetwindow.x + 1)); pp->randompos.y = NRAND(MAX((pp->windowsize.y - pp->logo->height), 2 * pp->offsetwindow.y + 1)); if (MI_NPIXELS(mi) <= 2) XSetForeground(display, pp->backGC, MI_WHITE_PIXEL(mi)); else XSetForeground(display, pp->backGC, MI_PIXEL(mi, NRAND(MI_NPIXELS(mi)))); (void) XPutImage(display, window, pp->backGC, pp->logo, (int) (NRAND(MAX(1, (pp->logo->width - pp->usablewindow.x)))), (int) (NRAND(MAX(1, (pp->logo->height - pp->usablewindow.y)))), pp->randompos.x, pp->randompos.y, pp->usablewindow.x, pp->usablewindow.y); XSetForeground(display, pp->backGC, pp->black); for (x = 0; x <= pp->count.x; x++) { int tempx = x * pp->boxsize.x; XDrawLine(display, window, pp->backGC, tempx + pp->randompos.x, pp->randompos.y, tempx + pp->randompos.x, pp->usablewindow.y + pp->randompos.y); XDrawLine(display, window, pp->backGC, tempx + pp->randompos.x - 1, pp->randompos.y, tempx + pp->randompos.x - 1, pp->usablewindow.y + pp->randompos.y); } for (y = 0; y <= pp->count.y; y++) { int tempy = y * pp->boxsize.y; XDrawLine(display, window, pp->backGC, pp->randompos.x, tempy + pp->randompos.y, pp->usablewindow.x + pp->randompos.x, tempy + pp->randompos.y); XDrawLine(display, window, pp->backGC, pp->randompos.x, tempy + pp->randompos.y - 1, pp->usablewindow.x + pp->randompos.x, tempy + pp->randompos.y - 1); } } #ifdef NUMBERED else { if (pp->image) (void) XDestroyImage(pp->image); pp->randompos.x = pp->offsetwindow.x; pp->randompos.y = pp->offsetwindow.y; if (!NumberScreen(mi)) { release_puzzles(mi); return; } if ((pp->image = XGetImage(display, window, pp->offsetwindow.x, pp->offsetwindow.y, pp->usablewindow.x, pp->usablewindow.y, AllPlanes, (MI_NPIXELS(mi) <= 2) ? XYPixmap : ZPixmap)) == None) { free_puzzle(display, pp); return; } } pp->row = pp->count.y - 1; pp->col = pp->count.x - 1; #else pp->row = NRAND(pp->count.y); pp->col = NRAND(pp->count.x); #endif if ((pp->excount) && (pp->fixbuff == NULL)) if ((pp->fixbuff = (int *) calloc(pp->excount, sizeof (int))) == NULL) { free_puzzle(display, pp); return; } pp->painted = True; }
/*ARGSUSED*/ void XmuCvtStringToCursor(XrmValuePtr args, Cardinal *num_args, XrmValuePtr fromVal, XrmValuePtr toVal) { static Cursor cursor; /* static for cvt magic */ char *name = (char *)fromVal->addr; Screen *screen; register int i; char maskname[PATH_MAX]; Pixmap source, mask = 0; /* XXX - make fg/bg resources */ static XColor bgColor = {0, 0xffff, 0xffff, 0xffff}; static XColor fgColor = {0, 0, 0, 0}; int xhot, yhot; int len; if (*num_args != 1) XtErrorMsg("wrongParameters","cvtStringToCursor","XtToolkitError", "String to cursor conversion needs screen argument", (String *)NULL, (Cardinal *)NULL); if (XmuCompareISOLatin1(name, "None") == 0) { cursor = None; done(&cursor, Cursor); return; } screen = *((Screen **) args[0].addr); if (0 == strncmp(FONTSPECIFIER, name, strlen(FONTSPECIFIER))) { char source_name[PATH_MAX], mask_name[PATH_MAX]; int source_char, mask_char, fields = 0; Font source_font, mask_font; XrmValue fromString, toFont; XrmValue cvtArg; Boolean success; Display *dpy = DisplayOfScreen(screen); char *strspec = NULL; int strspeclen; #ifdef XMU_KLUDGE Cardinal num; #endif strspeclen = strlen("FONT %s %d %s %d") + 21; strspec = XtMalloc(strspeclen); if (strspec != NULL) { snprintf(strspec, strspeclen, "FONT %%%lds %%d %%%lds %%d", (unsigned long)sizeof(source_name) - 1, (unsigned long)sizeof(mask_name) - 1); fields = sscanf(name, strspec, source_name, &source_char, mask_name, &mask_char); XtFree(strspec); } if (fields < 2) { XtStringConversionWarning(name, XtRCursor); return; } fromString.addr = source_name; fromString.size = strlen(source_name) + 1; toFont.addr = (XPointer) &source_font; toFont.size = sizeof(Font); cvtArg.addr = (XPointer) &dpy; cvtArg.size = sizeof(Display *); /* XXX using display of screen argument as message display */ #ifdef XMU_KLUDGE /* XXX Sacrifice caching */ num = 1; success = XtCvtStringToFont(dpy, &cvtArg, &num, &fromString, &toFont, NULL); #else success = XtCallConverter(dpy, XtCvtStringToFont, &cvtArg, (Cardinal)1, &fromString, &toFont, NULL); #endif if (!success) { XtStringConversionWarning(name, XtRCursor); return; } switch (fields) { case 2: /* defaulted mask font & char */ mask_font = source_font; mask_char = source_char; break; case 3: /* defaulted mask font */ mask_font = source_font; mask_char = atoi(mask_name); break; case 4: /* specified mask font & char */ fromString.addr = mask_name; fromString.size = strlen(mask_name) + 1; toFont.addr = (XPointer) &mask_font; toFont.size = sizeof(Font); /* XXX using display of screen argument as message display */ #ifdef XMU_KLUDGE /* XXX Sacrifice caching */ num = 1; success = XtCvtStringToFont(dpy, &cvtArg, &num, &fromString, &toFont, NULL); #else success = XtCallConverter(dpy, XtCvtStringToFont, &cvtArg, (Cardinal)1, &fromString, &toFont, NULL); #endif if (!success) { XtStringConversionWarning(name, XtRCursor); return; } } cursor = XCreateGlyphCursor( DisplayOfScreen(screen), source_font, mask_font, source_char, mask_char, &fgColor, &bgColor ); done(&cursor, Cursor); return; } i = XmuCursorNameToIndex (name); if (i != -1) { cursor = XCreateFontCursor (DisplayOfScreen(screen), i); done(&cursor, Cursor); return; } if ((source = XmuLocateBitmapFile (screen, name, maskname, (sizeof maskname) - 4, NULL, NULL, &xhot, &yhot)) == None) { XtStringConversionWarning (name, XtRCursor); cursor = None; done(&cursor, Cursor); return; } len = strlen (maskname); for (i = 0; i < 2; i++) { strcpy (maskname + len, i == 0 ? "Mask" : "msk"); if ((mask = XmuLocateBitmapFile (screen, maskname, NULL, 0, NULL, NULL, NULL, NULL)) != None) break; } cursor = XCreatePixmapCursor( DisplayOfScreen(screen), source, mask, &fgColor, &bgColor, xhot, yhot ); XFreePixmap( DisplayOfScreen(screen), source ); if (mask != None) XFreePixmap( DisplayOfScreen(screen), mask ); done(&cursor, Cursor); }
enum piglit_result piglit_glx_iterate_pixmap_fbconfigs(enum piglit_result (*draw)(Display *dpy, GLXFBConfig config)) { int screen; GLXFBConfig *configs; int n_configs; int i; bool any_fail = false; bool any_pass = false; Window root_win; Display *dpy = XOpenDisplay(NULL); if (!dpy) { fprintf(stderr, "couldn't open display\n"); piglit_report_result(PIGLIT_FAIL); } screen = DefaultScreen(dpy); root_win = RootWindow(dpy, screen); configs = glXGetFBConfigs(dpy, screen, &n_configs); if (!configs) { fprintf(stderr, "No GLX FB configs\n"); piglit_report_result(PIGLIT_SKIP); } for (i = 0; i < n_configs; i++) { GLXFBConfig config = configs[i]; enum piglit_result result; GLXContext ctx; Pixmap pix; GLXPixmap glx_pix; int draw_types; int depth; glXGetFBConfigAttrib(dpy, config, GLX_DRAWABLE_TYPE, &draw_types); if (!(draw_types & GLX_PIXMAP_BIT)) continue; glXGetFBConfigAttrib(dpy, config, GLX_BUFFER_SIZE, &depth); ctx = glXCreateNewContext(dpy, config, GLX_RGBA_TYPE, NULL, true); pix = XCreatePixmap(dpy, root_win, piglit_width, piglit_height, depth); glx_pix = glXCreatePixmap(dpy, config, pix, NULL); glXMakeCurrent(dpy, glx_pix, ctx); result = draw(dpy, config); if (result == PIGLIT_FAIL) any_fail = true; else if (result == PIGLIT_PASS) any_pass = true; XFreePixmap(dpy, pix); glXDestroyContext(dpy, ctx); } if (any_fail) return PIGLIT_FAIL; else if (any_pass) return PIGLIT_PASS; else return PIGLIT_SKIP; }
int SetRootWindow(char *tline) { Pixmap shapeMask = None, temp_pix = None, alpha = None; int w, h; int depth; int nalloc_pixels = 0; Pixel *alloc_pixels = NULL; char *file_path; FvwmPictureAttributes fpa; if (use_our_color_limit) { PictureColorLimitOption colorLimitop = {-1, -1, -1, -1, -1}; colorLimitop.color_limit = opt_color_limit; PictureInitCMapRoot( dpy, !NoColorLimit, &colorLimitop, True, True); } else { /* this use the default visual (not the fvwm one) as * getenv("FVWM_VISUALID") is NULL in any case. But this use * the same color limit than fvwm. * This is "broken" when fvwm use depth <= 8 and a private * color map (i.e., fvwm is started with the -visual{ID} * option), because when fvwm use a private color map the * default color limit is 244. There is no way to know here if * getenv("FVWM_VISUALID") !=NULL. * So, in this unfortunate case the user should use the * --color-limit option */ PictureInitCMap(dpy); } flib_init_graphics(dpy); /* try built-in image path first, but not before pwd */ PictureSetImagePath(".:+"); file_path = PictureFindImageFile(tline, NULL, R_OK); if (file_path == NULL) { file_path = tline; } fpa.mask = FPAM_NO_ALLOC_PIXELS | FPAM_NO_ALPHA; if (Pdepth <= 8 && !NoDither) { fpa.mask |= FPAM_DITHER; } else if (Pdepth <= 16 && Dither) { fpa.mask |= FPAM_DITHER; } if (NoColorLimit) { fpa.mask |= FPAM_NO_COLOR_LIMIT; } if (!PImageLoadPixmapFromFile( dpy, root, file_path, &temp_pix, &shapeMask, &alpha, &w, &h, &depth, &nalloc_pixels, &alloc_pixels, 0, fpa)) { fprintf( stderr, "[fvwm-root] failed to load image file '%s'\n", tline); return -1; } if (depth == Pdepth) { rootImage = temp_pix; } else { XGCValues gcv; GC gc; gcv.background= WhitePixel(dpy, screen); gcv.foreground= BlackPixel(dpy, screen); gc = fvwmlib_XCreateGC( dpy, root, GCForeground | GCBackground, &gcv); rootImage = XCreatePixmap(dpy, root, w, h, Pdepth); XCopyPlane(dpy, temp_pix, rootImage, gc, 0, 0, w, h, 0, 0, 1); XFreePixmap(dpy, temp_pix); XFreeGC(dpy, gc); } XSetWindowBackgroundPixmap(dpy, root, rootImage); save_colors = 1; XClearWindow(dpy, root); return 0; }
ENTRYPOINT void init_flow (ModeInfo * mi) { flowstruct *sp; char *name; if (flows == NULL) { if ((flows = (flowstruct *) calloc(MI_NUM_SCREENS(mi), sizeof (flowstruct))) == NULL) return; } sp = &flows[MI_SCREEN(mi)]; sp->count2 = 0; sp->taillen = MI_SIZE(mi); if (sp->taillen < -MINTRAIL) { /* Change by sqrt so it seems more variable */ sp->taillen = NRAND((int)sqrt((double) (-sp->taillen - MINTRAIL + 1))); sp->taillen = sp->taillen * sp->taillen + MINTRAIL; } else if (sp->taillen < MINTRAIL) { sp->taillen = MINTRAIL; } if(!rotatep && !ridep) rotatep = True; /* We need at least one viewpoint */ /* Start camera at Orbit or Bee */ if(rotatep) { sp->chaseto = ORBIT; } else { sp->chaseto = BEE; } sp->chasetime = 1; /* Go directly to target */ sp->lyap = 0; sp->yperiod = 0; sp->step2 = INITIALSTEP; /* Zero parameter set */ memset(sp->par2, 0, N_PARS * sizeof(dvector)); /* Set up standard examples */ switch (NRAND((periodicp) ? 5 : 3)) { case 0: /* x' = a(y - x) y' = x(b - z) - y z' = xy - cz */ name = "Lorentz"; sp->par2[Y].x = 10 + balance_rand(5*0); /* a */ sp->par2[X].x = - sp->par2[Y].x; /* -a */ sp->par2[X].y = 28 + balance_rand(5*0); /* b */ sp->par2[XZ].y = -1; sp->par2[Y].y = -1; sp->par2[XY].z = 1; sp->par2[Z].z = - 2 + balance_rand(1*0); /* -c */ break; case 1: /* x' = -(y + az) y' = x + by z' = c + z(x - 5.7) */ name = "Rossler"; sp->par2[Y].x = -1; sp->par2[Z].x = -2 + balance_rand(1); /* a */ sp->par2[X].y = 1; sp->par2[Y].y = 0.2 + balance_rand(0.1); /* b */ sp->par2[C].z = 0.2 + balance_rand(0.1); /* c */ sp->par2[XZ].z = 1; sp->par2[Z].z = -5.7; break; case 2: /* x' = -(y + az) y' = x + by - cz^2 z' = 0.2 + z(x - 5.7) */ name = "RosslerCone"; sp->par2[Y].x = -1; sp->par2[Z].x = -2; /* a */ sp->par2[X].y = 1; sp->par2[Y].y = 0.2; /* b */ sp->par2[ZZ].y = -0.331 + balance_rand(0.01); /* c */ sp->par2[C].z = 0.2; sp->par2[XZ].z = 1; sp->par2[Z].z = -5.7; break; case 3: /* x' = -z + b sin(y) y' = c z' = 0.7x + az(0.1 - x^2) */ name = "Birkhoff"; sp->par2[Z].x = -1; sp->par2[SINY].x = 0.35 + balance_rand(0.25); /* b */ sp->par2[C].y = 1.57; /* c */ sp->par2[X].z = 0.7; sp->par2[Z].z = 1 + balance_rand(0.5); /* a/10 */ sp->par2[XXZ].z = -10 * sp->par2[Z].z; /* -a */ sp->yperiod = 2 * M_PI; break; default: /* x' = -ax - z/2 - z^3/8 + b sin(y) y' = c z' = 2x */ name = "Duffing"; sp->par2[X].x = -0.2 + balance_rand(0.1); /* a */ sp->par2[Z].x = -0.5; sp->par2[ZZZ].x = -0.125; sp->par2[SINY].x = 27.0 + balance_rand(3.0); /* b */ sp->par2[C].y = 1.33; /* c */ sp->par2[X].z = 2; sp->yperiod = 2 * M_PI; break; } sp->range.x = 5; sp->range.z = 5; if(sp->yperiod > 0) { sp->ODE = Periodic; /* periodic flows show either uniform distribution or a snapshot on the 'time' axis */ sp->range.y = NRAND(2)? sp->yperiod : 0; } else { sp->range.y = 5; sp->ODE = Cubic; } /* Run discoverer to set up bounding box, etc. Lyapunov will probably be innaccurate, since we're only running it once, but we're using known strange attractors so it should be ok. */ discover(mi); if(MI_IS_VERBOSE(mi)) fprintf(stdout, "flow: Lyapunov exponent: %g, step: %g, size: %g (%s)\n", sp->lyap2, sp->step2, sp->size2, name); /* Install new params */ sp->lyap = sp->lyap2; sp->size = sp->size2; sp->mid = sp->mid2; sp->step = sp->step2; memcpy(sp->par, sp->par2, sizeof(sp->par2)); sp->count2 = 0; /* Reset search */ free_flow(sp); sp->beecount = MI_COUNT(mi); if (sp->beecount < 0) { /* random variations */ sp->beecount = NRAND(-sp->beecount) + 1; /* Minimum 1 */ } # ifdef HAVE_COCOA /* Don't second-guess Quartz's double-buffering */ dbufp = False; # endif if(dbufp) { /* Set up double buffer */ if (sp->buffer != None) XFreePixmap(MI_DISPLAY(mi), sp->buffer); sp->buffer = XCreatePixmap(MI_DISPLAY(mi), MI_WINDOW(mi), MI_WIDTH(mi), MI_HEIGHT(mi), MI_DEPTH(mi)); } else { sp->buffer = MI_WINDOW(mi); } /* no "NoExpose" events from XCopyArea wanted */ XSetGraphicsExposures(MI_DISPLAY(mi), MI_GC(mi), False); /* Make sure we're using 'thin' lines */ XSetLineAttributes(MI_DISPLAY(mi), MI_GC(mi), 0, LineSolid, CapNotLast, JoinMiter); /* Clear the background (may be slow depending on user prefs). */ MI_CLEARWINDOW(mi); /* Allocate memory. */ if (sp->csegs == NULL) { allocate(sp->csegs, XSegment, (sp->beecount + BOX_L) * MI_NPIXELS(mi) * sp->taillen); allocate(sp->cnsegs, int, MI_NPIXELS(mi)); allocate(sp->old_segs, XSegment, sp->beecount * sp->taillen); allocate(sp->p, dvector, sp->beecount * sp->taillen); }
PlatformFont::CharInfo &x86UNIXFont::getCharInfo(const UTF16 ch) const { Display *display = XOpenDisplay(getenv("DISPLAY")); if (!display ) AssertFatal(false, "createFont: cannot connect to X server"); static PlatformFont::CharInfo c; dMemset(&c, 0, sizeof(c)); c.bitmapIndex = 0; c.xOffset = 0; c.yOffset = 0; XftFont *fontInfo = XftFontOpenName(display, DefaultScreen(display), mFontName); if (!fontInfo) AssertFatal(false, "createFont: cannot load font"); int screen = DefaultScreen(display); // Create the pixmap to draw on. Drawable pixmap = XCreatePixmap(display, DefaultRootWindow(display), fontInfo->max_advance_width, fontInfo->height, DefaultDepth(display, screen)); // And the Xft wrapper around it. XftDraw *draw = XftDrawCreate(display, pixmap, DefaultVisual(display, screen), DefaultColormap(display, screen)); // Allocate some colors, we don't use XftColorAllocValue here as that // Don't appear to function correctly (or I'm using it wrong) As we only do // this twice per new un cached font it isn't that big of a penalty. (Each // call to XftColorAllocName involves a round trip to the X Server) XftColor black, white; XftColorAllocName(display, DefaultVisual(display, screen), DefaultColormap(display, screen), "black", &black); // White XftColorAllocName(display, DefaultVisual(display, screen), DefaultColormap(display, screen), "white", &white); XGlyphInfo charinfo; XftTextExtents16(display, fontInfo, &ch, 1, &charinfo); c.height = fontInfo->height; c.xOrigin = 0; c.yOrigin = fontInfo->ascent; c.xIncrement = charinfo.xOff; c.width = charinfo.xOff; // kick out early if the character is undrawable if( c.width == 0 || c.height == 0) return c; // allocate a greyscale bitmap and clear it. int bitmapDataSize = c.width * c.height; c.bitmapData = new U8[bitmapDataSize]; dMemset(c.bitmapData, 0, bitmapDataSize); XftDrawRect (draw, &black, 0, 0, fontInfo->max_advance_width, fontInfo->height); XftDrawString16 (draw, &white, fontInfo, 0, fontInfo->ascent, &ch, 1); // grab the pixmap image XImage *ximage = XGetImage(display, pixmap, 0, 0, charinfo.xOff, fontInfo->height, AllPlanes, XYPixmap); if (!ximage) AssertFatal(false, "cannot get x image"); int x, y; // grab each pixel and store it in the scratchPad for(y = 0; y < fontInfo->height; y++) { for(x = 0; x < charinfo.xOff; x++) c.bitmapData[y * charinfo.xOff + x] = static_cast<U8>(XGetPixel(ximage, x, y)); } XDestroyImage(ximage); XftColorFree(display, DefaultVisual(display, screen), DefaultColormap(display, screen), &black); XftColorFree(display, DefaultVisual(display, screen), DefaultColormap(display, screen), &white); XftDrawDestroy(draw); XFreePixmap(display, pixmap); XCloseDisplay(display); return c; }
static void _destroy_pixmap (void *closure) { XFreePixmap (_get_display(), (Pixmap) closure); }
static void scalefilterRenderFilterText (CompScreen *s) { CompDisplay *d = s->display; CompTextAttrib tA; int stride; void* data; int x1, x2, y1, y2; int width, height; REGION reg; char buffer[2 * MAX_FILTER_STRING_LEN]; FILTER_SCREEN (s); if (!fs->filterInfo) return; x1 = s->outputDev[fs->filterInfo->outputDevice].region.extents.x1; x2 = s->outputDev[fs->filterInfo->outputDevice].region.extents.x2; y1 = s->outputDev[fs->filterInfo->outputDevice].region.extents.y1; y2 = s->outputDev[fs->filterInfo->outputDevice].region.extents.y2; reg.rects = ®.extents; reg.numRects = 1; /* damage the old draw rectangle */ width = fs->filterInfo->textWidth + (2 * scalefilterGetBorderSize (s)); height = fs->filterInfo->textHeight + (2 * scalefilterGetBorderSize (s)); reg.extents.x1 = x1 + ((x2 - x1) / 2) - (width / 2) - 1; reg.extents.x2 = reg.extents.x1 + width + 1; reg.extents.y1 = y1 + ((y2 - y1) / 2) - (height / 2) - 1; reg.extents.y2 = reg.extents.y1 + height + 1; damageScreenRegion (s, ®); scalefilterFreeFilterText (s); if (!scalefilterGetFilterDisplay (s)) return; if (fs->filterInfo->filterStringLength == 0) return; tA.maxwidth = x2 - x1 - (2 * scalefilterGetBorderSize (s)); tA.maxheight = y2 - y1 - (2 * scalefilterGetBorderSize (s)); tA.screen = s; tA.size = scalefilterGetFontSize (s); tA.color[0] = scalefilterGetFontColorRed (s); tA.color[1] = scalefilterGetFontColorGreen (s); tA.color[2] = scalefilterGetFontColorBlue (s); tA.color[3] = scalefilterGetFontColorAlpha (s); tA.style = (scalefilterGetFontBold (s)) ? TEXT_STYLE_BOLD : TEXT_STYLE_NORMAL; tA.family = "Sans"; tA.ellipsize = TRUE; wcstombs (buffer, fs->filterInfo->filterString, MAX_FILTER_STRING_LEN); tA.renderMode = TextRenderNormal; tA.data = (void*)buffer; if ((*d->fileToImage) (s->display, TEXT_ID, (char *)&tA, &fs->filterInfo->textWidth, &fs->filterInfo->textHeight, &stride, &data)) { fs->filterInfo->textPixmap = (Pixmap)data; if (!bindPixmapToTexture (s, &fs->filterInfo->textTexture, fs->filterInfo->textPixmap, fs->filterInfo->textWidth, fs->filterInfo->textHeight, 32)) { compLogMessage (d, "scalefilterinfo", CompLogLevelError, "Bind Pixmap to Texture failure"); XFreePixmap (d->display, fs->filterInfo->textPixmap); fs->filterInfo->textPixmap = None; return; } } else { fs->filterInfo->textPixmap = None; fs->filterInfo->textWidth = 0; fs->filterInfo->textHeight = 0; } /* damage the new draw rectangle */ width = fs->filterInfo->textWidth + (2 * scalefilterGetBorderSize (s)); height = fs->filterInfo->textHeight + (2 * scalefilterGetBorderSize (s)); reg.extents.x1 = x1 + ((x2 - x1) / 2) - (width / 2) - 1; reg.extents.x2 = reg.extents.x1 + width + 1; reg.extents.y1 = y1 + ((y2 - y1) / 2) - (height / 2) - 1; reg.extents.y2 = reg.extents.y1 + height + 1; damageScreenRegion (s, ®); }
/* create a pixmap suitable for plonking on the background of a part of a * window */ Pixmap CreateOffsetBackgroundPixmap( Display *dpy, Window win, int x, int y, int width, int height, colorset_t *colorset, unsigned int depth, GC gc, Bool is_shape_mask) { Pixmap pixmap = None; Pixmap cs_pixmap = None; XGCValues xgcv; static GC shape_gc = None; GC fill_gc = None; /* not static as dpy may change (FvwmBacker) */ int cs_width; int cs_height; Bool cs_keep_aspect; Bool cs_stretch_x; Bool cs_stretch_y; if (colorset->pixmap == ParentRelative && !is_shape_mask && colorset->tint_percent > 0) { FvwmRenderAttributes fra; fra.mask = FRAM_DEST_IS_A_WINDOW | FRAM_HAVE_TINT; fra.tint = colorset->tint; fra.tint_percent = colorset->tint_percent; MyXGrabServer(dpy); pixmap = PGraphicsCreateTransparency( dpy, win, &fra, gc, x, y, width, height, True); MyXUngrabServer(dpy); if (pixmap == None) { return ParentRelative; } return pixmap; } else if (colorset->pixmap == ParentRelative && !is_shape_mask) { return ParentRelative; } else if (CSETS_IS_TRANSPARENT_ROOT(colorset) && colorset->pixmap && !is_shape_mask) { int sx,sy; int h,w; XID dummy; cs_pixmap = colorset->pixmap; cs_width = colorset->width; cs_height = colorset->height; if (CSETS_IS_TRANSPARENT_ROOT_PURE(colorset)) { /* check if it is still here */ union { XID junk; unsigned int ui_junk; int i_junk; } XID_int; /* a priori we should grab the server, but this * cause PositiveWrite error when you move a * window with a transparent title bar */ if (!XGetGeometry( dpy, colorset->pixmap, &XID_int.junk, &XID_int.i_junk, &XID_int.i_junk, (unsigned int *)&w, (unsigned int *)&h, &XID_int.ui_junk, &XID_int.ui_junk) || w != cs_width || h != cs_height) { return None; } } XTranslateCoordinates( dpy, win, DefaultRootWindow(dpy), x, y, &sx, &sy, &dummy); pixmap = XCreatePixmap(dpy, win, width, height, Pdepth); if (!pixmap) { return None; } /* make sx and sy positif */ while (sx < 0) { sx = sx + cs_width; } while (sy < 0) { sy = sy + cs_height; } /* make sx and sy in (0,0,cs_width,cs_height) */ while (sx >= cs_width) { sx = sx - cs_width; } while (sy >= cs_height) { sy = sy - cs_height; } xgcv.fill_style = FillTiled; xgcv.tile = cs_pixmap; xgcv.ts_x_origin = cs_width-sx; xgcv.ts_y_origin = cs_height-sy; fill_gc = fvwmlib_XCreateGC( dpy, win, GCTile | GCTileStipXOrigin | GCTileStipYOrigin | GCFillStyle, &xgcv); if (fill_gc == None) { XFreePixmap(dpy, pixmap); return None; } XSync(dpy, False); is_bad_gc = 0; ferror_set_temp_error_handler(BadGCErrorHandler); XFillRectangle(dpy, pixmap, fill_gc, 0, 0, width, height); if ( is_bad_gc == 0 && CSETS_IS_TRANSPARENT_ROOT_PURE(colorset) && colorset->tint_percent > 0) { FvwmRenderAttributes fra; fra.mask = FRAM_HAVE_TINT; fra.tint = colorset->tint; fra.tint_percent = colorset->tint_percent; PGraphicsRenderPixmaps( dpy, win, pixmap, None, None, Pdepth, &fra, pixmap, fill_gc, None, None, 0, 0, width, height, 0, 0, width, height, False); } XSync(dpy, False); ferror_reset_temp_error_handler(); if (is_bad_gc == 1) { is_bad_gc = 0; XFreePixmap(dpy, pixmap); pixmap = None; } XFreeGC(dpy,fill_gc); return pixmap; } if (!is_shape_mask) { cs_pixmap = colorset->pixmap; cs_width = colorset->width; cs_height = colorset->height; cs_keep_aspect = (colorset->pixmap_type == PIXMAP_STRETCH_ASPECT); cs_stretch_x = (colorset->pixmap_type == PIXMAP_STRETCH_X) || (colorset->pixmap_type == PIXMAP_STRETCH); cs_stretch_y = (colorset->pixmap_type == PIXMAP_STRETCH_Y) || (colorset->pixmap_type == PIXMAP_STRETCH); } else { /* In spite of the name, win contains the pixmap */ cs_pixmap = colorset->shape_mask; win = colorset->shape_mask; if (shape_gc == None) { xgcv.foreground = 1; xgcv.background = 0; /* create a gc for 1 bit depth */ shape_gc = fvwmlib_XCreateGC( dpy, win, GCForeground|GCBackground, &xgcv); } gc = shape_gc; cs_width = colorset->shape_width; cs_height = colorset->shape_height; cs_keep_aspect = (colorset->shape_type == SHAPE_STRETCH_ASPECT); cs_stretch_x = !(colorset->shape_type == SHAPE_TILED); cs_stretch_y = !(colorset->shape_type == SHAPE_TILED); } if (cs_pixmap == None) { xgcv.foreground = colorset->bg; fill_gc = fvwmlib_XCreateGC(dpy, win, GCForeground, &xgcv); /* create a solid pixmap - not very useful most of the time */ pixmap = XCreatePixmap(dpy, win, 1, 1, depth); XFillRectangle(dpy, pixmap, fill_gc, 0, 0, 1, 1); XFreeGC(dpy,fill_gc); } else if (cs_keep_aspect) { Bool trim_side; int big_width, big_height; Pixmap big_pixmap; int x, y; /* make a pixmap big enough to cover the destination but with * the aspect ratio of the cs_pixmap */ trim_side = get_aspect_dimensions( &big_width, &big_height, width, height, cs_width, cs_height); big_pixmap = CreateStretchPixmap( dpy, cs_pixmap, cs_width, cs_height, depth, big_width, big_height, gc); /* work out where to trim */ x = trim_side ? (big_width - width) / 2 : 0; y = trim_side ? 0 : (big_height - height) / 2; pixmap = XCreatePixmap(dpy, cs_pixmap, width, height, depth); if (pixmap && big_pixmap) { XCopyArea( dpy, big_pixmap, pixmap, gc, x, y, width, height, 0, 0); } if (big_pixmap) { XFreePixmap(dpy, big_pixmap); } } else if (!cs_stretch_x && !cs_stretch_y) { /* it's a tiled pixmap, create an unstretched one */ if (!is_shape_mask) { pixmap = XCreatePixmap( dpy, cs_pixmap, cs_width, cs_height, depth); if (pixmap) { XCopyArea( dpy, cs_pixmap, pixmap, gc, 0, 0, cs_width, cs_height, 0, 0); } } else { /* can't tile masks, create a tiled version of the * mask */ pixmap = CreateTiledPixmap( dpy, cs_pixmap, cs_width, cs_height, width, height, 1, gc); } } else if (!cs_stretch_x) { /* it's an HGradient */ pixmap = CreateStretchYPixmap( dpy, cs_pixmap, cs_width, cs_height, depth, height, gc); } else if (!cs_stretch_y) { /* it's a VGradient */ pixmap = CreateStretchXPixmap( dpy, cs_pixmap, cs_width, cs_height, depth, width, gc); } else { /* It's a full window pixmap */ pixmap = CreateStretchPixmap( dpy, cs_pixmap, cs_width, cs_height, depth, width, height, gc); } if (x != 0 || y != 0) { Pixmap p2; p2 = ScrollPixmap( dpy, pixmap, gc, x, y, width, height, depth); if (p2 != None && p2 != ParentRelative && p2 != pixmap) { XFreePixmap(dpy, pixmap); pixmap = p2; } } return pixmap; }
void OS_X11::initialize(const VideoMode& p_desired,int p_video_driver,int p_audio_driver) { last_button_state=0; dpad_last[0]=0; dpad_last[1]=0; xmbstring=NULL; event_id=0; x11_window=0; last_click_ms=0; args=OS::get_singleton()->get_cmdline_args(); current_videomode=p_desired; main_loop=NULL; last_timestamp=0; last_mouse_pos_valid=false; last_keyrelease_time=0; if (get_render_thread_mode()==RENDER_SEPARATE_THREAD) { XInitThreads(); } /** XLIB INITIALIZATION **/ x11_display = XOpenDisplay(NULL); char * modifiers = XSetLocaleModifiers ("@im=none"); ERR_FAIL_COND( modifiers == NULL ); xim = XOpenIM (x11_display, NULL, NULL, NULL); if (xim == NULL) { WARN_PRINT("XOpenIM failed"); xim_style=NULL; } else { ::XIMStyles *xim_styles=NULL; xim_style=0; char *imvalret=NULL; imvalret = XGetIMValues(xim, XNQueryInputStyle, &xim_styles, NULL); if (imvalret != NULL || xim_styles == NULL) { fprintf (stderr, "Input method doesn't support any styles\n"); } if (xim_styles) { xim_style = 0; for (int i=0;i<xim_styles->count_styles;i++) { if (xim_styles->supported_styles[i] == (XIMPreeditNothing | XIMStatusNothing)) { xim_style = xim_styles->supported_styles[i]; break; } } XFree (xim_styles); } } /* char* windowid = getenv("GODOT_WINDOWID"); if (windowid) { //freopen("/home/punto/stdout", "w", stdout); //reopen("/home/punto/stderr", "w", stderr); x11_window = atol(windowid); XWindowAttributes xwa; XGetWindowAttributes(x11_display,x11_window,&xwa); current_videomode.width = xwa.width; current_videomode.height = xwa.height; }; */ // maybe contextgl wants to be in charge of creating the window //print_line("def videomode "+itos(current_videomode.width)+","+itos(current_videomode.height)); #if defined(OPENGL_ENABLED) || defined(LEGACYGL_ENABLED) context_gl = memnew( ContextGL_X11( x11_display, x11_window,current_videomode, false ) ); context_gl->initialize(); if (true) { rasterizer = memnew( RasterizerGLES2 ); } else { //rasterizer = memnew( RasterizerGLES1 ); }; #endif visual_server = memnew( VisualServerRaster(rasterizer) ); if (get_render_thread_mode()!=RENDER_THREAD_UNSAFE) { visual_server =memnew(VisualServerWrapMT(visual_server,get_render_thread_mode()==RENDER_SEPARATE_THREAD)); } // borderless fullscreen window mode if (current_videomode.fullscreen) { // needed for lxde/openbox, possibly others Hints hints; Atom property; hints.flags = 2; hints.decorations = 0; property = XInternAtom(x11_display, "_MOTIF_WM_HINTS", True); XChangeProperty(x11_display, x11_window, property, property, 32, PropModeReplace, (unsigned char *)&hints, 5); XMapRaised(x11_display, x11_window); XWindowAttributes xwa; XGetWindowAttributes(x11_display, DefaultRootWindow(x11_display), &xwa); XMoveResizeWindow(x11_display, x11_window, 0, 0, xwa.width, xwa.height); // code for netwm-compliants XEvent xev; Atom wm_state = XInternAtom(x11_display, "_NET_WM_STATE", False); Atom fullscreen = XInternAtom(x11_display, "_NET_WM_STATE_FULLSCREEN", False); memset(&xev, 0, sizeof(xev)); xev.type = ClientMessage; xev.xclient.window = x11_window; xev.xclient.message_type = wm_state; xev.xclient.format = 32; xev.xclient.data.l[0] = 1; xev.xclient.data.l[1] = fullscreen; xev.xclient.data.l[2] = 0; XSendEvent(x11_display, DefaultRootWindow(x11_display), False, SubstructureNotifyMask, &xev); } // disable resizeable window if (!current_videomode.resizable) { XSizeHints *xsh; xsh = XAllocSizeHints(); xsh->flags = PMinSize | PMaxSize; XWindowAttributes xwa; if (current_videomode.fullscreen) { XGetWindowAttributes(x11_display,DefaultRootWindow(x11_display),&xwa); } else { XGetWindowAttributes(x11_display,x11_window,&xwa); } xsh->min_width = xwa.width; xsh->max_width = xwa.width; xsh->min_height = xwa.height; xsh->max_height = xwa.height; XSetWMNormalHints(x11_display, x11_window, xsh); } AudioDriverManagerSW::get_driver(p_audio_driver)->set_singleton(); if (AudioDriverManagerSW::get_driver(p_audio_driver)->init()!=OK) { ERR_PRINT("Initializing audio failed."); } sample_manager = memnew( SampleManagerMallocSW ); audio_server = memnew( AudioServerSW(sample_manager) ); audio_server->init(); spatial_sound_server = memnew( SpatialSoundServerSW ); spatial_sound_server->init(); spatial_sound_2d_server = memnew( SpatialSound2DServerSW ); spatial_sound_2d_server->init(); ERR_FAIL_COND(!visual_server); ERR_FAIL_COND(x11_window==0); XSetWindowAttributes new_attr; new_attr.event_mask=KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask | Button1MotionMask | Button2MotionMask | Button3MotionMask | Button4MotionMask | Button5MotionMask | ButtonMotionMask | KeymapStateMask | ExposureMask | VisibilityChangeMask | StructureNotifyMask | SubstructureNotifyMask | SubstructureRedirectMask | FocusChangeMask | PropertyChangeMask | ColormapChangeMask | OwnerGrabButtonMask; XChangeWindowAttributes(x11_display, x11_window,CWEventMask,&new_attr); XClassHint* classHint; /* set the titlebar name */ XStoreName(x11_display, x11_window, "Godot"); /* set the name and class hints for the window manager to use */ classHint = XAllocClassHint(); if (classHint) { classHint->res_name = "Godot"; classHint->res_class = "Godot"; } XSetClassHint(x11_display, x11_window, classHint); XFree(classHint); wm_delete = XInternAtom(x11_display, "WM_DELETE_WINDOW", true); XSetWMProtocols(x11_display, x11_window, &wm_delete, 1); if (xim && xim_style) { xic = XCreateIC (xim,XNInputStyle, xim_style,XNClientWindow,x11_window,XNFocusWindow, x11_window, (char*)NULL); } else { xic=NULL; WARN_PRINT("XCreateIC couldn't create xic"); } XcursorSetTheme(x11_display,"default"); cursor_size = XcursorGetDefaultSize(x11_display); cursor_theme = XcursorGetTheme(x11_display); if (!cursor_theme) { print_line("not found theme"); cursor_theme="default"; } for(int i=0;i<CURSOR_MAX;i++) { cursors[i]=None; } current_cursor=CURSOR_ARROW; if (cursor_theme) { //print_line("cursor theme: "+String(cursor_theme)); for(int i=0;i<CURSOR_MAX;i++) { static const char *cursor_file[]={ "left_ptr", "xterm", "hand2", "cross", "watch", "left_ptr_watch", "fleur", "hand1", "X_cursor", "sb_v_double_arrow", "sb_h_double_arrow", "size_bdiag", "size_fdiag", "hand1", "sb_v_double_arrow", "sb_h_double_arrow", "question_arrow" }; XcursorImage *img = XcursorLibraryLoadImage(cursor_file[i],cursor_theme,cursor_size); if (img) { cursors[i]=XcursorImageLoadCursor(x11_display,img); //print_line("found cursor: "+String(cursor_file[i])+" id "+itos(cursors[i])); } else { if (OS::is_stdout_verbose()) print_line("failed cursor: "+String(cursor_file[i])); } } } { Pixmap cursormask; XGCValues xgc; GC gc; XColor col; Cursor cursor; cursormask = XCreatePixmap(x11_display, RootWindow(x11_display,DefaultScreen(x11_display)), 1, 1, 1); xgc.function = GXclear; gc = XCreateGC(x11_display, cursormask, GCFunction, &xgc); XFillRectangle(x11_display, cursormask, gc, 0, 0, 1, 1); col.pixel = 0; col.red = 0; col.flags = 4; cursor = XCreatePixmapCursor(x11_display, cursormask, cursormask, &col, &col, 0, 0); XFreePixmap(x11_display, cursormask); XFreeGC(x11_display, gc); if (cursor == None) { ERR_PRINT("FAILED CREATING CURSOR"); } null_cursor=cursor; } set_cursor_shape(CURSOR_BUSY); visual_server->init(); // physics_server = memnew( PhysicsServerSW ); physics_server->init(); physics_2d_server = memnew( Physics2DServerSW ); physics_2d_server->init(); input = memnew( InputDefault ); probe_joystick(); _ensure_data_dir(); net_wm_icon = XInternAtom(x11_display, "_NET_WM_ICON", False); //printf("got map notify\n"); }
/* Draws a colorset background into the specified rectangle in the target * drawable. */ void SetClippedRectangleBackground( Display *dpy, Window win, int x, int y, int width, int height, XRectangle *clip, colorset_t *colorset, unsigned int depth, GC gc) { GC draw_gc; Pixmap pixmap2; Pixmap pixmap = None; static int last_depth = -1; static GC last_gc = None; XGCValues xgcv; Pixmap clipmask = None; GC clip_gc = None; Bool keep_aspect = (colorset->pixmap_type == PIXMAP_STRETCH_ASPECT); Bool stretch_x = (colorset->pixmap_type == PIXMAP_STRETCH_X) || (colorset->pixmap_type == PIXMAP_STRETCH); Bool stretch_y = (colorset->pixmap_type == PIXMAP_STRETCH_Y) || (colorset->pixmap_type == PIXMAP_STRETCH); int dest_x, dest_y, dest_w, dest_h; if (clip) { dest_x = clip->x; dest_y = clip->y; dest_w = clip->width; dest_h = clip->height; } else { dest_x = x; dest_y = y; dest_w = width; dest_h = height; } if (CSETS_IS_TRANSPARENT_PR_TINT(colorset)) { XClearArea(dpy, win, dest_x, dest_y, dest_w, dest_h, False); PGraphicsTintRectangle( dpy, win, colorset->tint, colorset->tint_percent, win, True, gc, None, None, dest_x, dest_y, dest_w, dest_h); return; } if (CSETS_IS_TRANSPARENT_PR_PURE(colorset)) { XClearArea(dpy, win, dest_x, dest_y, dest_w, dest_h, False); /* don't do anything */ return; } if (CSETS_IS_TRANSPARENT_ROOT(colorset)) { /* FIXME: optimize this ! */ x = y = 0; width = width + dest_x; height = height + dest_y; } /* minimize gc creation by remembering the last requested depth */ if (last_gc != None && depth != last_depth) { XFreeGC(dpy, last_gc); last_gc = None; } if (last_gc == None) { last_gc = fvwmlib_XCreateGC(dpy, win, 0, &xgcv); } draw_gc = last_gc; last_depth = depth; if (FHaveShapeExtension && colorset->shape_mask != None) { clipmask = CreateBackgroundPixmap( dpy, 0, width, height, colorset, 1, None, True); if (clipmask) { /* create a GC for clipping */ xgcv.clip_x_origin = x; xgcv.clip_y_origin = y; xgcv.clip_mask = clipmask; clip_gc = fvwmlib_XCreateGC( dpy, win, GCClipXOrigin | GCClipYOrigin | GCClipMask, &xgcv); draw_gc = clip_gc; } } if (!colorset->pixmap) { /* use the bg pixel */ XSetForeground(dpy, draw_gc, colorset->bg); XFillRectangle( dpy, win, draw_gc, dest_x, dest_y, dest_w, dest_h); } else { pixmap = CreateBackgroundPixmap( dpy, win, width, height, colorset, depth, gc, False); if (keep_aspect) { /* nothing to do */ } if (stretch_x || stretch_y) { if (!stretch_x && colorset->width != width) { pixmap2 = CreateStretchXPixmap( dpy, pixmap, colorset->width, height, depth, width, gc); XFreePixmap(dpy, pixmap); pixmap = pixmap2; } if (!stretch_y && colorset->height != height) { pixmap2 = CreateStretchYPixmap( dpy, pixmap, width, colorset->height, depth, height, gc); XFreePixmap(dpy, pixmap); pixmap = pixmap2; } } else { pixmap2 = CreateTiledPixmap( dpy, pixmap, colorset->width, colorset->height, width, height, depth, gc); XFreePixmap(dpy, pixmap); pixmap = pixmap2; } if (pixmap) { /* Copy the pixmap into the rectangle. */ XCopyArea( dpy, pixmap, win, draw_gc, dest_x - x, dest_y - y, dest_w, dest_h, dest_x, dest_y); XFreePixmap(dpy, pixmap); } } if (FHaveShapeExtension) { if (clipmask != None) { XFreePixmap(dpy, clipmask); } if (clip_gc != None) { XFreeGC(dpy, clip_gc); } } return; }
void bt::BitmapLoader::unload(::Drawable &drawable) { if (drawable) XFreePixmap(_display.XDisplay(), drawable); drawable = 0; }
void xf_window_free(xfContext* xfc) { if (xfc->gc_mono) { XFreeGC(xfc->display, xfc->gc_mono); xfc->gc_mono = 0; } if (xfc->window) { xf_DestroyDesktopWindow(xfc, xfc->window); xfc->window = NULL; } if (xfc->hdc) { gdi_DeleteDC(xfc->hdc); xfc->hdc = NULL; } if (xfc->xv_context) { xf_tsmf_uninit(xfc, NULL); xfc->xv_context = NULL; } if (xfc->bitmap_buffer) { _aligned_free(xfc->bitmap_buffer); xfc->bitmap_buffer = NULL; xfc->bitmap_size = 0; } if (xfc->image) { xfc->image->data = NULL; XDestroyImage(xfc->image); xfc->image = NULL; } if (xfc->bitmap_mono) { XFreePixmap(xfc->display, xfc->bitmap_mono); xfc->bitmap_mono = 0; } if (xfc->primary) { XFreePixmap(xfc->display, xfc->primary); xfc->primary = 0; } if (xfc->gc) { XFreeGC(xfc->display, xfc->gc); xfc->gc = 0; } if (xfc->modifierMap) { XFreeModifiermap(xfc->modifierMap); xfc->modifierMap = NULL; } }
void set_up_bitmaps() { /* first-stage pixmaps -- each different colored part must be created from a mono bitmap, and then laid atop each other to make the final multi-color pixmap. */ Pixmap playerbit[PLAYERPHASES][PLAYERPARTS]; Pixmap burnbit[BURNDIRECTIONS][BURNPARTS]; Pixmap firebit[FIREPHASES][FIREPARTS]; Pixmap sweeperbit[SWEEPERPHASES][SWEEPERPARTS]; Pixmap guardbit[GUARDPARTS]; Pixmap guardlightbit[GUARDLIGHTS]; Pixmap guardflamebit[GUARDDIRECTIONS][GUARDFLAMEPARTS]; Pixmap explodebit[EXPLODEFRAMES]; Pixmap skelbit[EXPLODEFRAMES]; Pixmap doorbit[DOORFRAMES][DOORPARTS]; Pixmap fuelbit[FUELPARTS]; Pixmap keybit[KEYPARTS]; Pixmap extramanbit; int i, j, k, g[GUARDLIGHTS]; /* Each of the following sections essentially does this: create and erase the main pixmap create all the secondary pixmaps from bitmap data copy the secondary pixmaps onto the main pixmap with the proper color */ /* Player pixmaps */ for(i=0; i<PLAYERPHASES; i++) { playerpix[i] = XCreatePixmap(display, gamewindow, PLAYERWIDTH, PLAYERHEIGHT, depth); XFillRectangle(display, playerpix[i], ctable[CBLACK].smallgc, 0, 0, PLAYERWIDTH, PLAYERHEIGHT); for(j=0; j<PLAYERPARTS; j++) { playerbit[i][j] = XCreateBitmapFromData(display, gamewindow, player_bits[i][j], PLAYERWIDTH, PLAYERHEIGHT); XCopyPlane(display, playerbit[i][j], playerpix[i], ctable[playercolor[j]].smallgc, 0, 0, PLAYERWIDTH, PLAYERHEIGHT, 0, 0, 1); } } /* Pixmaps for the jetpack flame */ for(i=0; i<BURNDIRECTIONS; i++) { burnpix[i] = XCreatePixmap(display, gamewindow, BURNWIDTH, BURNHEIGHT, depth); XFillRectangle(display, burnpix[i], ctable[CBLACK].smallgc, 0, 0, BURNWIDTH, BURNHEIGHT); for(j=0; j<BURNPARTS; j++) { burnbit[i][j] = XCreateBitmapFromData(display, gamewindow, burn_bits[i][j], BURNWIDTH, BURNHEIGHT); XCopyPlane(display, burnbit[i][j], burnpix[i], ctable[burncolor[j]].smallgc, 0, 0, BURNWIDTH, BURNHEIGHT, 0, 0, 1); } } /* Wall sweeper pixmaps (very pretty) */ for(i=0; i<SWEEPERPHASES; i++) { sweeperpix[i] = XCreatePixmap(display, gamewindow, SWEEPERWIDTH, SWEEPERHEIGHT, depth); XFillRectangle(display, sweeperpix[i], ctable[CBLACK].smallgc, 0, 0, SWEEPERWIDTH, SWEEPERHEIGHT); for(j=0; j<SWEEPERPARTS; j++) { sweeperbit[i][j] = XCreateBitmapFromData(display, gamewindow, sweeper_bits[i][j], SWEEPERWIDTH, SWEEPERHEIGHT); XCopyPlane(display, sweeperbit[i][j], sweeperpix[i], ctable[sweepcolor[j]].smallgc, 0, 0, SWEEPERWIDTH, SWEEPERHEIGHT, 0, 0, 1); } } /* Fireball pixmaps */ for(i=0; i<FIREPHASES; i++) { firepix[i] = XCreatePixmap(display, gamewindow, FIREWIDTH, FIREHEIGHT, depth); XFillRectangle(display, firepix[i], ctable[CBLACK].smallgc, 0, 0, FIREWIDTH, FIREHEIGHT); for(j=0; j<FIREPARTS; j++) { firebit[i][j] = XCreateBitmapFromData(display, gamewindow, fire_bits[i][j], FIREWIDTH, FIREHEIGHT); XCopyPlane(display, firebit[i][j], firepix[i], ctable[firecolor[j]].smallgc, 0, 0, FIREWIDTH, FIREHEIGHT, 0, 0, 1); } } /* Guard pixmaps. These are a little odd because of the random blinking light sequences. There are three sets of lights on the guard, and each can be on or off. This makes 8 different frames, but to cut down on bitmap data, I only made the three light bitmaps rather than 8. */ for(i=0; i<GUARDPARTS; i++) { guardbit[i] = XCreateBitmapFromData(display, gamewindow, guard_bits[i], GUARDWIDTH, GUARDHEIGHT); for(j=0; j<GUARDDIRECTIONS; j++) { guardflamebit[j][i] = XCreateBitmapFromData(display, gamewindow, guard_flame_bits[j][i], GUARDWIDTH, GUARDHEIGHT); } } for(i=0; i<GUARDLIGHTS; i++) { guardlightbit[i] = XCreateBitmapFromData(display, gamewindow, guard_light_bits[i], GUARDWIDTH, GUARDHEIGHT); } for(i=0; i<GUARDDIRECTIONS; i++) { for(j=0; j<GUARDPHASES; j++) { guardpix[i][j] = XCreatePixmap(display, gamewindow, GUARDWIDTH, GUARDHEIGHT, depth); XFillRectangle(display, guardpix[i][j], ctable[CBLACK].smallgc, 0, 0, GUARDWIDTH, GUARDHEIGHT); for(k=0; k<GUARDPARTS; k++) { XCopyPlane(display, guardbit[k], guardpix[i][j], ctable[guardcolor[k]].smallgc, 0, 0, GUARDWIDTH, GUARDHEIGHT, 0, 0, 1); } for(k=0; k<GUARDFLAMEPARTS; k++) { XCopyPlane(display, guardflamebit[i][k], guardpix[i][j], ctable[guardflamecolor[k]].smallgc, 0, 0, GUARDWIDTH, GUARDHEIGHT, 0, 0, 1); } /* This initialization will need to be expanded if I add more lights. */ g[2] = j / 4; g[1] = (j % 4) / 2; g[0] = (j % 4) % 2; for(k=0; k<GUARDLIGHTS; k++) { if(g[k]) XCopyPlane(display, guardlightbit[k], guardpix[i][j], ctable[guardlightcolor].smallgc, 0, 0, GUARDWIDTH, GUARDHEIGHT, 0, 0, 1); } } } /* Player explosion pixmaps */ for(i=0; i<EXPLODEFRAMES; i++) { explodepix[i] = XCreatePixmap(display, gamewindow, EXPLODEWIDTH, EXPLODEHEIGHT, depth); XFillRectangle(display, explodepix[i], ctable[CBLACK].smallgc, 0, 0, EXPLODEWIDTH, EXPLODEHEIGHT); explodebit[i] = XCreateBitmapFromData(display, gamewindow, explode_bits[i], EXPLODEWIDTH, EXPLODEHEIGHT); skelbit[i] = XCreateBitmapFromData(display, gamewindow, skel_bits[i], SKELWIDTH, SKELHEIGHT); XCopyPlane(display, explodebit[i], explodepix[i], ctable[explodecolor].smallgc, 0, 0, EXPLODEWIDTH, EXPLODEHEIGHT, 0, 0, 1); XCopyPlane(display, skelbit[i], explodepix[i], ctable[skelcolor].smallgc, 0, 0, SKELWIDTH, SKELHEIGHT, (EXPLODEWIDTH - SKELWIDTH) / 2, (EXPLODEWIDTH - SKELWIDTH) / 2, 1); } /* Fuel pod pixmap */ fuelpix = XCreatePixmap(display, gamewindow, FUELWIDTH, FUELHEIGHT, depth); XFillRectangle(display, fuelpix, ctable[CBLACK].smallgc, 0, 0, FUELWIDTH, FUELHEIGHT); for(i=0; i<FUELPARTS; i++) { fuelbit[i] = XCreateBitmapFromData(display, gamewindow, fuel_bits[i], FUELWIDTH, FUELHEIGHT); XCopyPlane(display, fuelbit[i], fuelpix, ctable[fuelcolor[i]].smallgc, 0, 0, FUELWIDTH, FUELHEIGHT, 0, 0, 1); } /* Key pixmap */ keypix = XCreatePixmap(display, gamewindow, KEYWIDTH, KEYHEIGHT, depth); XFillRectangle(display, keypix, ctable[CBLACK].smallgc, 0, 0, KEYWIDTH, KEYHEIGHT); for(i=0; i<KEYPARTS; i++) { keybit[i] = XCreateBitmapFromData(display, gamewindow, key_bits[i], KEYWIDTH, KEYHEIGHT); XCopyPlane(display, keybit[i], keypix, ctable[keycolor[i]].smallgc, 0, 0, KEYWIDTH, KEYHEIGHT, 0, 0, 1); } /* Door pixmaps. The only difference in frames is the color, but I wanted it this way in case I want to animate the door in the future. */ for(i=0; i<DOORFRAMES; i++) { doorpix[i] = XCreatePixmap(display, gamewindow, DOORWIDTH, DOORHEIGHT, depth); XFillRectangle(display, doorpix[i], ctable[CBLACK].smallgc, 0, 0, DOORWIDTH, DOORHEIGHT); for(j=0; j<DOORPARTS; j++) { doorbit[i][j] = XCreateBitmapFromData(display, gamewindow, door_bits[i][j], DOORWIDTH, DOORHEIGHT); XCopyPlane(display, doorbit[i][j], doorpix[i], ctable[doorcolor[i][j]].smallgc, 0, 0, DOORWIDTH, DOORHEIGHT, 0, 0, 1); } } /* Extra player pixmap */ extramanpix = XCreatePixmap(display, gamewindow, EXTRAMANWIDTH, EXTRAMANHEIGHT, depth); XFillRectangle(display, extramanpix, ctable[CBLACK].smallgc, 0, 0, EXTRAMANWIDTH, EXTRAMANHEIGHT); extramanbit = XCreateBitmapFromData(display, gamewindow, extraman_bits, EXTRAMANWIDTH, EXTRAMANHEIGHT); XCopyPlane(display, extramanbit, extramanpix, ctable[extramancolor].smallgc, 0, 0, EXTRAMANWIDTH, EXTRAMANHEIGHT, 0, 0, 1); /* free all the temporary pixmaps */ for(i=0; i<PLAYERPHASES; i++) { for(j=0; j<PLAYERPARTS; j++) { XFreePixmap(display, playerbit[i][j]); } } for(i=0; i<BURNDIRECTIONS; i++) { for(j=0; j<BURNPARTS; j++) { XFreePixmap(display, burnbit[i][j]); } } for(i=0; i<FIREPHASES; i++) { for(j=0; j<FIREPARTS; j++) { XFreePixmap(display, firebit[i][j]); } } for(i=0; i<SWEEPERPHASES; i++) { for(j=0; j<SWEEPERPARTS; j++) { XFreePixmap(display, sweeperbit[i][j]); } } for(i=0; i<GUARDPARTS; i++) { XFreePixmap(display, guardbit[i]); } for(i=0; i<GUARDLIGHTS; i++) { XFreePixmap(display, guardlightbit[i]); } for(i=0; i<GUARDDIRECTIONS; i++) { for(j=0; j<GUARDFLAMEPARTS; j++) { XFreePixmap(display, guardflamebit[i][j]); } } for(i=0; i<EXPLODEFRAMES; i++) { XFreePixmap(display, explodebit[i]); XFreePixmap(display, skelbit[i]); } for(i=0; i<DOORFRAMES; i++) { for(j=0; j<DOORPARTS; j++) { XFreePixmap(display, doorbit[i][j]); } } for(i=0; i<FUELPARTS; i++) { XFreePixmap(display, fuelbit[i]); } for(i=0; i<KEYPARTS; i++) { XFreePixmap(display, keybit[i]); } XFreePixmap(display, extramanbit); }
/* * 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; }
bool P3DGLMemoryContextPixmap::Create (unsigned int Width, unsigned int Height, bool NeedAlpha) { bool Result; XVisualInfo *VisualInfo; Result = true; if (Connection == NULL) { OwnConnection = true; Connection = XOpenDisplay(NULL); if (Connection == NULL) { return(false); } } else { OwnConnection = false; } Result = true; if (NeedAlpha) { VisualInfo = glXChooseVisual(Connection, DefaultScreen(Connection), VisualAttrArrayAlpha); } else { VisualInfo = glXChooseVisual(Connection, DefaultScreen(Connection), VisualAttrArray); } if (VisualInfo != NULL) { TargetPixmap = XCreatePixmap(Connection, DefaultRootWindow(Connection), Width, Height, VisualInfo->depth); TargetGLXPixmap = glXCreateGLXPixmap(Connection,VisualInfo,TargetPixmap); /*FIXME: check for errors here */ OffScreenGLXContext = glXCreateContext(Connection,VisualInfo,NULL,False); if (OffScreenGLXContext != NULL) { Ok = true; Result = MakeCurrent(); if (Result) { Result = P3DGLExtInit(); } Ok = Result; } else { Result = false; } if (!Result) { glXDestroyGLXPixmap(Connection,TargetGLXPixmap); XFreePixmap(Connection,TargetPixmap); } XFree(VisualInfo); } else { Result = false; } if (!Result) { if (OwnConnection) { XCloseDisplay(Connection); } Connection = NULL; } Ok = Result; return(Result); }
/* **************************************************************** * Modifica o fundo da janela * **************************************************************** */ int set_background (Display *dpy, Window win, XImage *ximage, const char *name) { Pixmap pic; int ret = 0; /* * Cria o Pixmap correspondente à imagem. */ pic = XCreatePixmap ( dpy, win, ximage->width, ximage->height, DefaultDepth (dpy, screen) ); if (pic == 0) { msg ("\"%s\": o servidor X não pode criar o Mapa de Pixels", name); return (-1); } /* * Envia para o servidor o conteúdo do Pixmap (a imagem). */ if (XPutImage (dpy, pic, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height)) { msg ("\"%s\": o servidor X rejeitou a imagem", name); XFreePixmap (dpy, pic); return (-1); } /* * O Pixmap torna-se o fundo da janela. */ XSetWindowBackgroundPixmap (dpy, win, pic); if (Rflag) { Atom prop, type; uchar *data; ulong length, after; int format; XClearWindow (dpy, win); XFlush (dpy); prop = XInternAtom (dpy, "_XSETROOT_ID", False); (void)XGetWindowProperty ( dpy, win, prop, 0, 1, True, AnyPropertyType, &type, &format, &length, &after, &data ); #if (0) /*******************************************************/ /* NÃO SEI BEM PARA QUE SERVIA... */ if ( type == XA_PIXMAP && format == 32 && length == 1 && after == 0 ) XKillClient (dpy, *((Pixmap *)data)); #endif /*******************************************************/ XChangeProperty ( dpy, win, prop, XA_PIXMAP, 32, PropModeReplace, (uchar *)&pic, 1 ); XSetCloseDownMode (dpy, RetainPermanent); XFlush (dpy); ret = -1; } XFreePixmap (dpy, pic); return (ret); } /* end set_background */
void FreePixmap ( Display *display, Pixmap p ) { assert( p ); XFreePixmap( display, p ); }
/* 建立 Tray */ void gui_tray_init(void) { winlist_t *win = NULL; if (gui->tray_win) { //return; win = gui->tray_win; } else { #if 0 //manager_window = XGetSelectionOwner(gui->display, selection_atom); manager_window = ManagerWindow(gui->display, gui->screen); if (manager_window != None) { Atom visual_atom = XInternAtom(gui->display, "_NET_SYSTEM_TRAY_VISUAL", False); Atom type; int format; union { unsigned long *prop; unsigned char *prop_ch; } prop = { NULL }; unsigned long nitems; unsigned long bytes_after; int result; type = None; result = XGetWindowProperty (gui->display, manager_window, visual_atom, 0, sizeof(long), False, XA_VISUALID, &type, &format, &nitems, &bytes_after, &(prop.prop_ch)); Visual *default_xvisual; if (result == 0 && type == XA_VISUALID && nitems == 1 && format == 32) { VisualID visual_id = prop.prop[0]; visual = x11_screen_lookup_visual (visual_id); } } #endif #if 1 /* Atom actual_type; int actual_format; unsigned long nitems, bytes_remaining; unsigned char *data = 0; int result = XGetWindowProperty(gui->display, manager_window, visual_atom, 0, 1, False, XA_VISUALID, &actual_type, &actual_format, &nitems, &bytes_remaining, &data); VisualID vid = 0; if (result == Success && data && actual_type == XA_VISUALID && actual_format == 32 && nitems == 1 && bytes_remaining == 0) vid = *(VisualID*)data; if (data) XFree(data); if (vid == 0) return; */ uint mask = VisualScreenMask; XVisualInfo *vi, rvi; int count=0, i; //rvi.visualid = vid; rvi.screen = gui->screen; vi = XGetVisualInfo(gui->display, mask, &rvi, &count); for(i=0; i<count; i++) { if (vi[i].depth == 32 && (vi[i].red_mask == 0xff0000 && vi[i].green_mask == 0x00ff00 && vi[i].blue_mask == 0x0000ff)) { //printf("rgba_visual=%d\n", vi[i].visual->visualid); visual = &vi[i]; break; } } /*if (vi) { //visual = vi[0]; visual = &vi[0]; //return; //XFree((char*)vi); }*/ #endif if(visual && visual->visual) win = gui_new_win_tray((XVisualInfo*)visual); else win = gui_new_win(); } /* Tray 不需要邊框 */ XSetWindowBorderWidth(gui->display, win->window, 0); XSetWindowAttributes win_attr; win_attr.override_redirect = True; XChangeWindowAttributes(gui->display, win->window, CWOverrideRedirect, &win_attr); Pixmap tray, mask; XpmAttributes attributes; attributes.valuemask = 0; if (!ProcessTrayIcon(gui->display, win->window, oxim_tray, &icon, &icon_mask, &picon)) { //fprintf(stderr, "failed to get inactive icon image\n"); return; } #if 1 if(visual && visual->visual) { /* GCs for copy and drawing on mask */ XGCValues gv; gv.foreground = BlackPixel(gui->display, gui->screen); gv.background = BlackPixel(gui->display, gui->screen); //GC gc = XCreateGC(gui->display, win->window, GCBackground|GCForeground, &gv); GC gc = XCreateGC(gui->display, aw, GCBackground|GCForeground, &gv); XSetClipMask(gui->display, gc, icon_mask); } #endif XpmCreatePixmapFromData(gui->display, win->window, oxim_tray, &tray, &mask, &attributes); tray_w = attributes.width; tray_h = attributes.height; win->width = tray_w; win->height = tray_h; XpmFreeAttributes(&attributes); XFreePixmap(gui->display, tray); if (mask) { XFreePixmap(gui->display, mask); } win->pos_x = 0; win->pos_y = 0; win->win_draw_func = NULL; win->win_event_func = gui_focus_event; XSizeHints *size_hints = XAllocSizeHints(); size_hints->flags = PMinSize | PMaxSize; size_hints->min_width = win->width; size_hints->min_height = win->height; size_hints->max_width = win->width; size_hints->max_height = win->height; XSetWMNormalHints(gui->display, win->window, size_hints); XFree(size_hints); Atom xembed_info = XInternAtom(gui->display, "_XEMBED_INFO", False); unsigned int mapping[2]; mapping[0] = 0; /* ver 0 */ mapping[1] = 1; /* request mapping */ XChangeProperty(gui->display, win->window, xembed_info, xembed_info, 32, PropModeReplace, (unsigned char *)mapping, 2); gui->tray_win = win; }
Memimage* _xattach(char *label, char *winsize) { char *argv[2], *disp; int i, havemin, height, mask, n, width, x, xrootid, y; Rectangle r; XClassHint classhint; XDrawable pmid; XPixmapFormatValues *pfmt; XScreen *xscreen; XSetWindowAttributes attr; XSizeHints normalhint; XTextProperty name; XVisualInfo xvi; XWindow xrootwin; XWindowAttributes wattr; XWMHints hint; Atom atoms[2]; /* if(XInitThreads() == 0){ fprint(2, "XInitThreads failed\n"); abort(); } */ /* * Connect to X server. */ _x.display = XOpenDisplay(NULL); if(_x.display == nil){ disp = getenv("DISPLAY"); werrstr("XOpenDisplay %s: %r", disp ? disp : ":0"); free(disp); return nil; } _x.fd = ConnectionNumber(_x.display); XSetErrorHandler(xerror); XSetIOErrorHandler(xioerror); xrootid = DefaultScreen(_x.display); xrootwin = DefaultRootWindow(_x.display); /* * Figure out underlying screen format. */ if(XMatchVisualInfo(_x.display, xrootid, 24, TrueColor, &xvi) || XMatchVisualInfo(_x.display, xrootid, 24, DirectColor, &xvi)){ _x.vis = xvi.visual; _x.depth = 24; } else if(XMatchVisualInfo(_x.display, xrootid, 16, TrueColor, &xvi) || XMatchVisualInfo(_x.display, xrootid, 16, DirectColor, &xvi)){ _x.vis = xvi.visual; _x.depth = 16; } else if(XMatchVisualInfo(_x.display, xrootid, 15, TrueColor, &xvi) || XMatchVisualInfo(_x.display, xrootid, 15, DirectColor, &xvi)){ _x.vis = xvi.visual; _x.depth = 15; } else if(XMatchVisualInfo(_x.display, xrootid, 8, PseudoColor, &xvi) || XMatchVisualInfo(_x.display, xrootid, 8, StaticColor, &xvi)){ if(_x.depth > 8){ werrstr("can't deal with colormapped depth %d screens", _x.depth); goto err0; } _x.vis = xvi.visual; _x.depth = 8; } else{ _x.depth = DefaultDepth(_x.display, xrootid); if(_x.depth != 8){ werrstr("can't understand depth %d screen", _x.depth); goto err0; } _x.vis = DefaultVisual(_x.display, xrootid); } if(DefaultDepth(_x.display, xrootid) == _x.depth) _x.usetable = 1; /* * _x.depth is only the number of significant pixel bits, * not the total number of pixel bits. We need to walk the * display list to find how many actual bits are used * per pixel. */ _x.chan = 0; pfmt = XListPixmapFormats(_x.display, &n); for(i=0; i<n; i++){ if(pfmt[i].depth == _x.depth){ switch(pfmt[i].bits_per_pixel){ case 1: /* untested */ _x.chan = GREY1; break; case 2: /* untested */ _x.chan = GREY2; break; case 4: /* untested */ _x.chan = GREY4; break; case 8: _x.chan = CMAP8; break; case 15: _x.chan = RGB15; break; case 16: /* how to tell RGB15? */ _x.chan = RGB16; break; case 24: /* untested (impossible?) */ _x.chan = RGB24; break; case 32: _x.chan = XRGB32; break; } } } if(_x.chan == 0){ werrstr("could not determine screen pixel format"); goto err0; } /* * Set up color map if necessary. */ xscreen = DefaultScreenOfDisplay(_x.display); _x.cmap = DefaultColormapOfScreen(xscreen); if(_x.vis->class != StaticColor){ plan9cmap(); setupcmap(xrootwin); } /* * We get to choose the initial rectangle size. * This is arbitrary. In theory we should read the * command line and allow the traditional X options. */ mask = 0; x = 0; y = 0; if(winsize && winsize[0]){ if(parsewinsize(winsize, &r, &havemin) < 0) sysfatal("%r"); }else{ /* * Parse the various X resources. Thanks to Peter Canning. */ char *screen_resources, *display_resources, *geom, *geomrestype, *home, *file; XrmDatabase database; XrmValue geomres; database = XrmGetDatabase(_x.display); screen_resources = XScreenResourceString(xscreen); if(screen_resources != nil){ XrmCombineDatabase(XrmGetStringDatabase(screen_resources), &database, False); XFree(screen_resources); } display_resources = XResourceManagerString(_x.display); if(display_resources == nil){ home = getenv("HOME"); if(home!=nil && (file=smprint("%s/.Xdefaults", home)) != nil){ XrmCombineFileDatabase(file, &database, False); free(file); } free(home); }else XrmCombineDatabase(XrmGetStringDatabase(display_resources), &database, False); geom = smprint("%s.geometry", label); if(geom && XrmGetResource(database, geom, nil, &geomrestype, &geomres)) mask = XParseGeometry(geomres.addr, &x, &y, (uint*)&width, (uint*)&height); free(geom); if((mask & WidthValue) && (mask & HeightValue)){ r = Rect(0, 0, width, height); }else{ r = Rect(0, 0, WidthOfScreen(xscreen)*3/4, HeightOfScreen(xscreen)*3/4); if(Dx(r) > Dy(r)*3/2) r.max.x = r.min.x + Dy(r)*3/2; if(Dy(r) > Dx(r)*3/2) r.max.y = r.min.y + Dx(r)*3/2; } if(mask & XNegative){ x += WidthOfScreen(xscreen); } if(mask & YNegative){ y += HeightOfScreen(xscreen); } havemin = 0; } screenrect = Rect(0, 0, WidthOfScreen(xscreen), HeightOfScreen(xscreen)); windowrect = r; memset(&attr, 0, sizeof attr); attr.colormap = _x.cmap; attr.background_pixel = ~0; attr.border_pixel = 0; _x.drawable = XCreateWindow( _x.display, /* display */ xrootwin, /* parent */ x, /* x */ y, /* y */ Dx(r), /* width */ Dy(r), /* height */ 0, /* border width */ _x.depth, /* depth */ InputOutput, /* class */ _x.vis, /* visual */ /* valuemask */ CWBackPixel|CWBorderPixel|CWColormap, &attr /* attributes (the above aren't?!) */ ); /* * Label and other properties required by ICCCCM. */ memset(&name, 0, sizeof name); if(label == nil) label = "pjw-face-here"; name.value = (uchar*)label; name.encoding = XA_STRING; name.format = 8; name.nitems = strlen((char*)name.value); memset(&normalhint, 0, sizeof normalhint); normalhint.flags = PSize|PMaxSize; if(winsize && winsize[0]){ normalhint.flags &= ~PSize; normalhint.flags |= USSize; normalhint.width = Dx(r); normalhint.height = Dy(r); }else{ if((mask & WidthValue) && (mask & HeightValue)){ normalhint.flags &= ~PSize; normalhint.flags |= USSize; normalhint.width = width; normalhint.height = height; } if((mask & WidthValue) && (mask & HeightValue)){ normalhint.flags |= USPosition; normalhint.x = x; normalhint.y = y; } } normalhint.max_width = WidthOfScreen(xscreen); normalhint.max_height = HeightOfScreen(xscreen); memset(&hint, 0, sizeof hint); hint.flags = InputHint|StateHint; hint.input = 1; hint.initial_state = NormalState; memset(&classhint, 0, sizeof classhint); classhint.res_name = label; classhint.res_class = label; argv[0] = label; argv[1] = nil; XSetWMProperties( _x.display, /* display */ _x.drawable, /* window */ &name, /* XA_WM_NAME property */ &name, /* XA_WM_ICON_NAME property */ argv, /* XA_WM_COMMAND */ 1, /* argc */ &normalhint, /* XA_WM_NORMAL_HINTS */ &hint, /* XA_WM_HINTS */ &classhint /* XA_WM_CLASSHINTS */ ); XFlush(_x.display); if(havemin){ XWindowChanges ch; memset(&ch, 0, sizeof ch); ch.x = r.min.x; ch.y = r.min.y; XConfigureWindow(_x.display, _x.drawable, CWX|CWY, &ch); /* * Must pretend origin is 0,0 for X. */ r = Rect(0,0,Dx(r),Dy(r)); } /* * Look up clipboard atom. */ _x.clipboard = XInternAtom(_x.display, "CLIPBOARD", False); _x.utf8string = XInternAtom(_x.display, "UTF8_STRING", False); _x.targets = XInternAtom(_x.display, "TARGETS", False); _x.text = XInternAtom(_x.display, "TEXT", False); _x.compoundtext = XInternAtom(_x.display, "COMPOUND_TEXT", False); _x.takefocus = XInternAtom(_x.display, "WM_TAKE_FOCUS", False); _x.losefocus = XInternAtom(_x.display, "_9WM_LOSE_FOCUS", False); _x.wmprotos = XInternAtom(_x.display, "WM_PROTOCOLS", False); atoms[0] = _x.takefocus; atoms[1] = _x.losefocus; XChangeProperty(_x.display, _x.drawable, _x.wmprotos, XA_ATOM, 32, PropModeReplace, (uchar*)atoms, 2); /* * Put the window on the screen, check to see what size we actually got. */ XMapWindow(_x.display, _x.drawable); XSync(_x.display, False); if(!XGetWindowAttributes(_x.display, _x.drawable, &wattr)) fprint(2, "XGetWindowAttributes failed\n"); else if(wattr.width && wattr.height){ if(wattr.width != Dx(r) || wattr.height != Dy(r)){ r.max.x = wattr.width; r.max.y = wattr.height; } }else fprint(2, "XGetWindowAttributes: bad attrs\n"); /* * Allocate our local backing store. */ _x.screenr = r; _x.screenpm = XCreatePixmap(_x.display, _x.drawable, Dx(r), Dy(r), _x.depth); _x.nextscreenpm = _x.screenpm; _x.screenimage = _xallocmemimage(r, _x.chan, _x.screenpm); /* * Allocate some useful graphics contexts for the future. */ _x.gcfill = xgc(_x.screenpm, FillSolid, -1); _x.gccopy = xgc(_x.screenpm, -1, -1); _x.gcsimplesrc = xgc(_x.screenpm, FillStippled, -1); _x.gczero = xgc(_x.screenpm, -1, -1); _x.gcreplsrc = xgc(_x.screenpm, FillTiled, -1); pmid = XCreatePixmap(_x.display, _x.drawable, 1, 1, 1); _x.gcfill0 = xgc(pmid, FillSolid, 0); _x.gccopy0 = xgc(pmid, -1, -1); _x.gcsimplesrc0 = xgc(pmid, FillStippled, -1); _x.gczero0 = xgc(pmid, -1, -1); _x.gcreplsrc0 = xgc(pmid, FillTiled, -1); XFreePixmap(_x.display, pmid); return _x.screenimage; err0: /* * Should do a better job of cleaning up here. */ XCloseDisplay(_x.display); return nil; }
static Bool xlib_cursor_load( Handle self, Handle icon) { XImage *im; Pixmap p1 = None, p2 = None; Bool free_pixmap = true; GC gc; XGCValues gcv; char c; int id, w = guts.cursor_width, h = guts.cursor_height; id = get_cursor( self, &p1, &p2, nil, nil); if ( id < crDefault || id > crUser) return false; if ( id == crUser) { if ( !p1 || !p2) { warn( "User pointer inconsistency"); return false; } free_pixmap = false; } else { XFontStruct *fs; XCharStruct *cs; int idx = cursor_map[id]; if ( !load_pointer_font()) return false; fs = guts.pointer_font; if ( !fs-> per_char) cs = &fs-> min_bounds; else if ( idx < fs-> min_char_or_byte2 || idx > fs-> max_char_or_byte2) { int default_char = fs-> default_char; if ( default_char < fs-> min_char_or_byte2 || default_char > fs-> max_char_or_byte2) default_char = fs-> min_char_or_byte2; cs = fs-> per_char + default_char - fs-> min_char_or_byte2; } else cs = fs-> per_char + idx - fs-> min_char_or_byte2; p1 = XCreatePixmap( DISP, guts. root, w, h, 1); p2 = XCreatePixmap( DISP, guts. root, w, h, 1); gcv. background = 1; gcv. foreground = 0; gcv. font = guts.pointer_font-> fid; gc = XCreateGC( DISP, p1, GCBackground | GCForeground | GCFont, &gcv); XFillRectangle( DISP, p1, gc, 0, 0, w, h); gcv. background = 0; gcv. foreground = 1; XChangeGC( DISP, gc, GCBackground | GCForeground, &gcv); XFillRectangle( DISP, p2, gc, 0, 0, w, h); XDrawString( DISP, p1, gc, -cs-> lbearing, cs-> ascent, (c = (char)(idx+1), &c), 1); gcv. background = 1; gcv. foreground = 0; XChangeGC( DISP, gc, GCBackground | GCForeground, &gcv); XDrawString( DISP, p2, gc, -cs-> lbearing, cs-> ascent, (c = (char)(idx+1), &c), 1); XDrawString( DISP, p1, gc, -cs-> lbearing, cs-> ascent, (c = (char)idx, &c), 1); XFreeGC( DISP, gc); } CIcon(icon)-> create_empty( icon, w, h, imBW); im = XGetImage( DISP, p1, 0, 0, w, h, 1, XYPixmap); prima_copy_xybitmap( PIcon(icon)-> data, (Byte*)im-> data, PIcon(icon)-> w, PIcon(icon)-> h, PIcon(icon)-> lineSize, im-> bytes_per_line); XDestroyImage( im); im = XGetImage( DISP, p2, 0, 0, w, h, 1, XYPixmap); prima_copy_xybitmap( PIcon(icon)-> mask, (Byte*)im-> data, PIcon(icon)-> w, PIcon(icon)-> h, PIcon(icon)-> maskLine, im-> bytes_per_line); if ( id == crUser) { int i; Byte * mask = PIcon(icon)-> mask; for ( i = 0; i < PIcon(icon)-> maskSize; i++) mask[i] = ~mask[i]; } XDestroyImage( im); if ( free_pixmap) { XFreePixmap( DISP, p1); XFreePixmap( DISP, p2); } return true; }
/* sets a window background from a colorset * if width or height are zero the window size is queried */ void SetWindowBackgroundWithOffset( Display *dpy, Window win, int x_off, int y_off, unsigned int width, unsigned int height, colorset_t *colorset, unsigned int depth, GC gc, Bool clear_area) { Pixmap pixmap = None; Pixmap mask = None; union { XID junk; unsigned int ui_junk; int i_junk; } XID_int; if (0 == width || 0 == height) { if (!XGetGeometry( dpy, win, &XID_int.junk, &XID_int.i_junk, &XID_int.i_junk, (unsigned int *)&width, (unsigned int *)&height, &XID_int.ui_junk, &XID_int.ui_junk)) { return; } } if (FHaveShapeExtension && colorset->shape_mask) { mask = CreateBackgroundPixmap( dpy, None, width, height, colorset, 1, None, True); if (mask != None) { FShapeCombineMask( dpy, win, FShapeBounding, 0, 0, mask, FShapeSet); XFreePixmap(dpy, mask); } } if (!colorset->pixmap) { /* use the bg pixel */ XSetWindowBackground(dpy, win, colorset->bg); if (clear_area) { XClearArea(dpy, win, 0, 0, width, height, True); } } else { pixmap = CreateOffsetBackgroundPixmap( dpy, win, x_off, y_off, width, height, colorset, depth, gc, False); if (pixmap) { XSetWindowBackgroundPixmap(dpy, win, pixmap); if (clear_area) { XClearArea(dpy, win, 0, 0, width, height, True); } if (pixmap != ParentRelative) { XFreePixmap(dpy, pixmap); } } } return; }
void Fake_glXUseXFont(Font font, int first, int count, int listbase) { Display *dpy; Window win; Pixmap pixmap; GC gc; XGCValues values; unsigned long valuemask; XFontStruct *fs; GLint swapbytes, lsbfirst, rowlength; GLint skiprows, skippixels, alignment; unsigned int max_width, max_height, max_bm_width, max_bm_height; GLubyte *bm; int i; dpy = glXGetCurrentDisplay(); if (!dpy) return; /* I guess glXMakeCurrent wasn't called */ win = RootWindow(dpy, DefaultScreen(dpy)); fs = XQueryFont(dpy, font); if (!fs) { _mesa_error(NULL, GL_INVALID_VALUE, "Couldn't get font structure information"); return; } /* Allocate a bitmap that can fit all characters. */ max_width = fs->max_bounds.rbearing - fs->min_bounds.lbearing; max_height = fs->max_bounds.ascent + fs->max_bounds.descent; max_bm_width = (max_width + 7) / 8; max_bm_height = max_height; bm = (GLubyte *) MALLOC((max_bm_width * max_bm_height) * sizeof(GLubyte)); if (!bm) { XFreeFontInfo(NULL, fs, 1); _mesa_error(NULL, GL_OUT_OF_MEMORY, "Couldn't allocate bitmap in glXUseXFont()"); return; } #if 0 /* get the page info */ pages = fs->max_char_or_byte2 - fs->min_char_or_byte2 + 1; firstchar = (fs->min_byte1 << 8) + fs->min_char_or_byte2; lastchar = (fs->max_byte1 << 8) + fs->max_char_or_byte2; rows = fs->max_byte1 - fs->min_byte1 + 1; unsigned int first_char, last_char, pages, rows; #endif /* Save the current packing mode for bitmaps. */ glGetIntegerv(GL_UNPACK_SWAP_BYTES, &swapbytes); glGetIntegerv(GL_UNPACK_LSB_FIRST, &lsbfirst); glGetIntegerv(GL_UNPACK_ROW_LENGTH, &rowlength); glGetIntegerv(GL_UNPACK_SKIP_ROWS, &skiprows); glGetIntegerv(GL_UNPACK_SKIP_PIXELS, &skippixels); glGetIntegerv(GL_UNPACK_ALIGNMENT, &alignment); /* Enforce a standard packing mode which is compatible with fill_bitmap() from above. This is actually the default mode, except for the (non)alignment. */ glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE); glPixelStorei(GL_UNPACK_LSB_FIRST, GL_FALSE); glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); glPixelStorei(GL_UNPACK_SKIP_ROWS, 0); glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); pixmap = XCreatePixmap(dpy, win, 10, 10, 1); values.foreground = BlackPixel(dpy, DefaultScreen(dpy)); values.background = WhitePixel(dpy, DefaultScreen(dpy)); values.font = fs->fid; valuemask = GCForeground | GCBackground | GCFont; gc = XCreateGC(dpy, pixmap, valuemask, &values); XFreePixmap(dpy, pixmap); #ifdef DEBUG if (debug_xfonts) dump_font_struct(fs); #endif for (i = 0; i < count; i++) { unsigned int width, height, bm_width, bm_height; GLfloat x0, y0, dx, dy; XCharStruct *ch; int x, y; unsigned int c = first + i; int list = listbase + i; int valid; /* check on index validity and get the bounds */ ch = isvalid(fs, c); if (!ch) { ch = &fs->max_bounds; valid = 0; } else { valid = 1; } #ifdef DEBUG if (debug_xfonts) { char s[7]; sprintf(s, isprint(c) ? "%c> " : "\\%03o> ", c); dump_char_struct(ch, s); } #endif /* glBitmap()' parameters: straight from the glXUseXFont(3) manpage. */ width = ch->rbearing - ch->lbearing; height = ch->ascent + ch->descent; x0 = -ch->lbearing; y0 = ch->descent - 0; /* XXX used to subtract 1 here */ /* but that caused a conformace failure */ dx = ch->width; dy = 0; /* X11's starting point. */ x = -ch->lbearing; y = ch->ascent; /* Round the width to a multiple of eight. We will use this also for the pixmap for capturing the X11 font. This is slightly inefficient, but it makes the OpenGL part real easy. */ bm_width = (width + 7) / 8; bm_height = height; glNewList(list, GL_COMPILE); if (valid && (bm_width > 0) && (bm_height > 0)) { MEMSET(bm, '\0', bm_width * bm_height); fill_bitmap(dpy, win, gc, bm_width, bm_height, x, y, c, bm); glBitmap(width, height, x0, y0, dx, dy, bm); #ifdef DEBUG if (debug_xfonts) { printf("width/height = %u/%u\n", width, height); printf("bm_width/bm_height = %u/%u\n", bm_width, bm_height); dump_bitmap(bm_width, bm_height, bm); } #endif } else { glBitmap(0, 0, 0.0, 0.0, dx, dy, NULL); } glEndList(); } FREE(bm); XFreeFontInfo(NULL, fs, 1); XFreeGC(dpy, gc); /* Restore saved packing modes. */ glPixelStorei(GL_UNPACK_SWAP_BYTES, swapbytes); glPixelStorei(GL_UNPACK_LSB_FIRST, lsbfirst); glPixelStorei(GL_UNPACK_ROW_LENGTH, rowlength); glPixelStorei(GL_UNPACK_SKIP_ROWS, skiprows); glPixelStorei(GL_UNPACK_SKIP_PIXELS, skippixels); glPixelStorei(GL_UNPACK_ALIGNMENT, alignment); }
X11Graphics::~X11Graphics() { XFreeGC( XDISPLAY, m_gc ); XDestroyRegion( m_mask ); XFreePixmap( XDISPLAY, m_pixmap ); }