void X11Grabber::setupResources() { if(_XShmAvailable && !_useXGetImage) { _xImage = XShmCreateImage(_x11Display, _windowAttr.visual, _windowAttr.depth, ZPixmap, NULL, &_shminfo, _croppedWidth, _croppedHeight); _shminfo.shmid = shmget(IPC_PRIVATE, _xImage->bytes_per_line * _xImage->height, IPC_CREAT|0777); _xImage->data = (char*)shmat(_shminfo.shmid,0,0); _shminfo.shmaddr = _xImage->data; _shminfo.readOnly = False; XShmAttach(_x11Display, &_shminfo); } if (_XRenderAvailable && !_useXGetImage) { if(_XShmPixmapAvailable) { _pixmap = XShmCreatePixmap(_x11Display, _window, _xImage->data, &_shminfo, _croppedWidth, _croppedHeight, _windowAttr.depth); } else { _pixmap = XCreatePixmap(_x11Display, _window, _croppedWidth, _croppedHeight, _windowAttr.depth); } _srcFormat = XRenderFindVisualFormat(_x11Display, _windowAttr.visual); _dstFormat = XRenderFindVisualFormat(_x11Display, _windowAttr.visual); _srcPicture = XRenderCreatePicture(_x11Display, _window, _srcFormat, CPRepeat, &_pictAttr); _dstPicture = XRenderCreatePicture(_x11Display, _pixmap, _dstFormat, CPRepeat, &_pictAttr); XRenderSetPictureFilter(_x11Display, _srcPicture, FilterBilinear, NULL, 0); } }
Workspace::Workspace() : mDamage( None ), mWaitForClients( false ), mInitialRepaint( true ) { Extensions::initialize(); XGrabServer( dpy ); // Redirect all toplevel window contents to offscreen storage XCompositeRedirectSubwindows( dpy, rootId(), CompositeRedirectManual ); initClientList(); // Request notification about toplevel window state changes XSelectInput( dpy, rootId(), SubstructureNotifyMask | ExposureMask | StructureNotifyMask | PropertyChangeMask ); XUngrabServer( dpy ); // Get the picture format for the root window mFormat = XRenderFindVisualFormat( dpy, visual() ); // Create an unclipped picture for drawing on the root window XRenderPictureAttributes pa; pa.subwindow_mode = IncludeInferiors; mFrontbuffer = XRenderCreatePicture( dpy, rootId(), format(), CPSubwindowMode, &pa ); createBackbuffer(); XSync( dpy, false ); }
/* static */ XRenderPictFormat* gfxXlibSurface::FindRenderFormat(Display *dpy, gfxImageFormat format) { switch (format) { case ImageFormatARGB32: return XRenderFindStandardFormat (dpy, PictStandardARGB32); case ImageFormatRGB24: return XRenderFindStandardFormat (dpy, PictStandardRGB24); case ImageFormatRGB16_565: { // PictStandardRGB16_565 is not standard Xrender format // we should try to find related visual // and find xrender format by visual Visual *visual = FindVisual(DefaultScreenOfDisplay(dpy), format); if (!visual) return NULL; return XRenderFindVisualFormat(dpy, visual); } case ImageFormatA8: return XRenderFindStandardFormat (dpy, PictStandardA8); case ImageFormatA1: return XRenderFindStandardFormat (dpy, PictStandardA1); default: break; } return (XRenderPictFormat*)NULL; }
void window_set_mapped(Window id, bool mapped) { window_t *window = window_get(id); if (window == NULL) return; window->mapped = mapped; if (mapped == TRUE) { XRenderPictFormat *format; XRenderPictureAttributes pa; format = XRenderFindVisualFormat(conn, visual); pa.subwindow_mode = IncludeInferiors; if (window->picture != None) XRenderFreePicture(conn, window->picture); if (window->pixmap != None) XFreePixmap(conn, window->pixmap); window->pixmap = XCompositeNameWindowPixmap(conn, id); window->picture = XRenderCreatePicture(conn, window->pixmap, format, CPSubwindowMode, &pa); XDamageCreate(conn, window->pixmap, XDamageReportNonEmpty); window_list_remove(id); window_list_append(id); } }
void PreviewWidget::paintEvent(QPaintEvent *) { QPixmap buffer(size()); QPainter p(&buffer); p.fillRect(rect(), colorGroup().brush(QColorGroup::Background)); Picture dest; if(!qt_has_xft || !qt_use_xrender) { XRenderPictFormat *fmt = XRenderFindVisualFormat(x11Display(), (Visual *)buffer.x11Visual()); dest = XRenderCreatePicture(x11Display(), buffer.handle(), fmt, 0, NULL); } else dest = buffer.x11RenderHandle(); int rwidth = width() / numCursors; for(int i = 0; i < numCursors; i++) { if(cursors[i]->picture()) { XRenderComposite(x11Display(), PictOpOver, cursors[i]->picture(), 0, dest, 0, 0, 0, 0, rwidth * i + (rwidth - cursors[i]->width()) / 2, (height() - cursors[i]->height()) / 2, cursors[i]->width(), cursors[i]->height()); } } bitBlt(this, 0, 0, &buffer); if(!qt_has_xft || !qt_use_xrender) XRenderFreePicture(x11Display(), dest); }
void CarioQImageMainWindow::on_draw_widget_button_clicked() { int height = ui->label->height(); int width = ui->label->width(); const QX11Info& info = ui->label->x11Info(); Drawable drawable = ui->label->handle(); Display* display = info.display(); Screen* screen = XScreenOfDisplay(display, info.screen()); Visual* visual = reinterpret_cast<Visual*>(info.visual()); XRenderPictFormat *format = XRenderFindVisualFormat(display, visual); //cairo_surface_t * pCairoSurface = cairo_xlib_surface_create_with_xrender_format( // display, drawable, screen, format, width, height); cairo_surface_t * pCairoSurface = cairo_xlib_surface_create( display, drawable, visual, width, height); cairo_t* pCairoContext = cairo_create(pCairoSurface); cairo_surface_destroy(pCairoSurface); if(pCairoContext) { cairo_set_source_rgb (pCairoContext, 0.627, 0, 0); cairo_set_font_size (pCairoContext, 24.0); cairo_move_to (pCairoContext, 10.0, 34.0); cairo_show_text (pCairoContext, "Using X11 Surface"); cairo_destroy(pCairoContext); } // ui->label->update(); }
static Picture gdk_x11_drawable_get_picture (GdkDrawable *drawable) { GdkDrawableImplX11 *impl = GDK_DRAWABLE_IMPL_X11 (drawable); if (!impl->picture) { Display *xdisplay = GDK_SCREEN_XDISPLAY (impl->screen); XRenderPictFormat *format; GdkVisual *visual = gdk_drawable_get_visual (GDK_DRAWABLE_IMPL_X11 (drawable)->wrapper); if (!visual) return None; format = XRenderFindVisualFormat (xdisplay, GDK_VISUAL_XVISUAL (visual)); if (format) { XRenderPictureAttributes attributes; attributes.graphics_exposures = False; impl->picture = XRenderCreatePicture (xdisplay, impl->xid, format, CPGraphicsExposure, &attributes); } } return impl->picture; }
void xfwmPixmapCreate (ScreenInfo * screen_info, xfwmPixmap * pm, gint width, gint height) { TRACE ("entering xfwmPixmapCreate, width=%i, height=%i", width, height); g_return_if_fail (screen_info != NULL); if ((width < 1) || (height < 1)) { xfwmPixmapInit (screen_info, pm); } else { pm->screen_info = screen_info; pm->pixmap = XCreatePixmap (myScreenGetXDisplay (screen_info), screen_info->xroot, width, height, screen_info->depth); pm->mask = XCreatePixmap (myScreenGetXDisplay (screen_info), pm->pixmap, width, height, 1); pm->width = width; pm->height = height; #ifdef HAVE_RENDER pm->pict_format = XRenderFindVisualFormat (myScreenGetXDisplay (screen_info), screen_info->visual); pm->pict = None; #endif } }
void clear_pixmap(Pixmap p, int x, int y, int w, int h) { Picture pict = XRenderCreatePicture(server.dsp, p, XRenderFindVisualFormat(server.dsp, server.visual), 0, 0); XRenderColor col = { .red=0, .green=0, .blue=0, .alpha=0 }; XRenderFillRectangle(server.dsp, PictOpSrc, pict, &col, x, y, w, h); XRenderFreePicture(server.dsp, pict); }
// This code can only run after thumbnailer's drawing_area has been realized, // and after the main loop has run so that wnck_window is initialized. static void initialize_thumbnailer_pictures (SSThumbnailer *thumbnailer) { Display *display; GdkScreen *screen; XRenderPictFormat *format; XRenderPictureAttributes pa; display = gdk_x11_get_default_xdisplay (); screen = gtk_widget_get_screen (thumbnailer->drawing_area); format = XRenderFindVisualFormat (display, DefaultVisual ( display, gdk_screen_get_number (screen))); thumbnailer->thumbnail_pixmap = gdk_pixmap_new ( thumbnailer->drawing_area->window, THUMBNAIL_SIZE, THUMBNAIL_SIZE, -1); thumbnailer->thumbnail_picture = XRenderCreatePicture (display, GDK_DRAWABLE_XID (thumbnailer->thumbnail_pixmap), format, 0, NULL); pa.subwindow_mode = IncludeInferiors; thumbnailer->window_picture = XRenderCreatePicture (display, wnck_window_get_xid (thumbnailer->wnck_window), format, CPSubwindowMode, &pa); XRenderSetPictureFilter (display, thumbnailer->window_picture, "good", NULL, 0); }
/* Java->C glue code: * Java package: jogamp.nativewindow.x11.X11Lib * Java method: boolean XRenderFindVisualFormat(long dpy, long visual, XRenderPictFormat dest) */ JNIEXPORT jboolean JNICALL Java_jogamp_nativewindow_x11_X11Lib_XRenderFindVisualFormat1(JNIEnv *env, jclass _unused, jlong dpy, jlong visual, jobject xRenderPictFormat) { XRenderPictFormat * dest = (XRenderPictFormat *) (*env)->GetDirectBufferAddress(env, xRenderPictFormat); XRenderPictFormat * src = XRenderFindVisualFormat((Display *) (intptr_t) dpy, (Visual *) (intptr_t) visual); if (NULL == src) return JNI_FALSE; memcpy(dest, src, sizeof(XRenderPictFormat)); return JNI_TRUE; }
static cairo_surface_t * _cairo_boilerplate_xlib_perf_create_surface (Display *dpy, cairo_content_t content, int width, int height, xlib_target_closure_t *xtc) { XSetWindowAttributes attr; XRenderPictFormat *xrender_format; Visual *visual; switch (content) { case CAIRO_CONTENT_COLOR_ALPHA: xrender_format = XRenderFindStandardFormat (dpy, PictStandardARGB32); if (xrender_format == NULL) { CAIRO_BOILERPLATE_DEBUG (("X server does not have the Render extension.\n")); return NULL; } xtc->drawable = XCreatePixmap (dpy, DefaultRootWindow (dpy), width, height, xrender_format->depth); xtc->drawable_is_pixmap = TRUE; break; case CAIRO_CONTENT_COLOR: if (! _cairo_boilerplate_xlib_check_screen_size (dpy, DefaultScreen (dpy), width, height)) { CAIRO_BOILERPLATE_DEBUG (("Surface is larger than the Screen.\n")); return NULL; } visual = DefaultVisual (dpy, DefaultScreen (dpy)); xrender_format = XRenderFindVisualFormat (dpy, visual); if (xrender_format == NULL) { CAIRO_BOILERPLATE_DEBUG (("X server does not have the Render extension.\n")); return NULL; } attr.override_redirect = True; xtc->drawable = XCreateWindow (dpy, DefaultRootWindow (dpy), 0, 0, width, height, 0, xrender_format->depth, InputOutput, visual, CWOverrideRedirect, &attr); XMapWindow (dpy, xtc->drawable); xtc->drawable_is_pixmap = FALSE; break; case CAIRO_CONTENT_ALPHA: default: CAIRO_BOILERPLATE_DEBUG (("Invalid content for xlib test: %d\n", content)); return NULL; } return cairo_xlib_surface_create_with_xrender_format (dpy, xtc->drawable, DefaultScreenOfDisplay (dpy), xrender_format, width, height); }
void FdoSelectionManager::initSelection() { XSetSelectionOwner(d->display, d->selectionAtom, winId(), CurrentTime); WId selectionOwner = XGetSelectionOwner(d->display, d->selectionAtom); if (selectionOwner != winId()) { // FIXME: Hmmm... Reading the docs on XSetSelectionOwner, // this should not be possible. kDebug() << "Tried to set selection owner to" << winId() << "but it is set to" << selectionOwner; return; } // Prefer the ARGB32 visual if available int nvi; VisualID visual = XVisualIDFromVisual((Visual*)QX11Info::appVisual()); XVisualInfo templ; templ.visualid = visual; XVisualInfo *xvi = XGetVisualInfo(d->display, VisualIDMask, &templ, &nvi); if (xvi && xvi[0].depth > 16) { templ.screen = xvi[0].screen; templ.depth = 32; templ.c_class = TrueColor; XFree(xvi); xvi = XGetVisualInfo(d->display, VisualScreenMask | VisualDepthMask | VisualClassMask, &templ, &nvi); for (int i = 0; i < nvi; i++) { XRenderPictFormat *format = XRenderFindVisualFormat(d->display, xvi[i].visual); if (format && format->type == PictTypeDirect && format->direct.alphaMask) { visual = xvi[i].visualid; break; } } XFree(xvi); } XChangeProperty(d->display, winId(), d->visualAtom, XA_VISUALID, 32, PropModeReplace, (const unsigned char*)&visual, 1); if (!s_painter) { s_painter = new X11EmbedPainter; } s_manager = this; WId root = QX11Info::appRootWindow(); XClientMessageEvent xev; xev.type = ClientMessage; xev.window = root; xev.message_type = XInternAtom(d->display, "MANAGER", false); xev.format = 32; xev.data.l[0] = CurrentTime; xev.data.l[1] = d->selectionAtom; xev.data.l[2] = winId(); xev.data.l[3] = 0; xev.data.l[4] = 0; XSendEvent(d->display, root, false, StructureNotifyMask, (XEvent*)&xev); }
int InitCompositeWin(XParms xp, Parms p, int reps) { XRenderPictFormat *format; (void) InitScroll (xp, p, reps); InitCopyLocations (xp, p, reps); format = XRenderFindVisualFormat (xp->d, xp->vinfo.visual); winPict = XRenderCreatePicture (xp->d, xp->w, format, 0, NULL); return reps; }
static void x11_connect (void) { char *c; int nitems; if (x11_connected) return; XInitThreads (); GUI_display = XOpenDisplay (0); if (!GUI_display) errx (EXIT_FAILURE, "Failed to open GUI_display"); XSynchronize (GUI_display, True); GUI_screenidx = DefaultScreen (GUI_display); GUI_screen = DefaultScreenOfDisplay (GUI_display); GUI_visual = DefaultVisual (GUI_display, GUI_screenidx); GUI_visual_info = XGetVisualInfo (GUI_display, VisualNoMask, &GUI_visual_template, &nitems); xa_wm_delete_window = XInternAtom (GUI_display, "WM_DELETE_WINDOW", False); xa_clipboard = XInternAtom (GUI_display, "CLIPBOARD", False); xa_utf8_string = XInternAtom (GUI_display, "UTF8_STRING", False); xa_prop_paste = XInternAtom (GUI_display, "BRA_PASTE", False); xim = 0; if ((c = XSetLocaleModifiers ("")) && *c) xim = XOpenIM (GUI_display, 0, 0, 0); if (!xim && (c = XSetLocaleModifiers ("@im=none")) && *c) xim = XOpenIM (GUI_display, 0, 0, 0); if (!xim) errx (EXIT_FAILURE, "Failed to open X Input Method"); xrenderpictformat = XRenderFindVisualFormat (GUI_display, GUI_visual); if (!xrenderpictformat) errx (EXIT_FAILURE, "XRenderFindVisualFormat failed"); argb32pictformat = XRenderFindStandardFormat (GUI_display, PictStandardARGB32); a8pictformat = XRenderFindStandardFormat (GUI_display, PictStandardA8); if (!a8pictformat) errx (EXIT_FAILURE, "XrenderFindStandardFormat failed for PictStandardA8"); XSynchronize (GUI_display, False); x11_connected = 1; }
ClientWin * clientwin_create(MainWin *mw, Window client) { ClientWin *cw = (ClientWin *)malloc(sizeof(ClientWin)); XSetWindowAttributes sattr; XWindowAttributes attr; XRenderPictureAttributes pa; cw->mainwin = mw; cw->pixmap = None; cw->focused = 0; cw->origin = cw->destination = None; cw->damage = None; cw->damaged = False; /* cw->repair = None; */ sattr.border_pixel = sattr.background_pixel = 0; sattr.colormap = mw->colormap; sattr.event_mask = ButtonPressMask | ButtonReleaseMask | KeyReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask | ExposureMask | FocusChangeMask; sattr.override_redirect = mw->lazy_trans; cw->client.window = client; cw->mini.format = mw->format; cw->mini.window = XCreateWindow(mw->dpy, mw->lazy_trans ? mw->root : mw->window, 0, 0, 1, 1, 0, mw->depth, InputOutput, mw->visual, CWColormap | CWBackPixel | CWBorderPixel | CWEventMask | CWOverrideRedirect, &sattr); if(cw->mini.window == None) { free(cw); return 0; } XGetWindowAttributes(mw->dpy, client, &attr); cw->client.format = XRenderFindVisualFormat(mw->dpy, attr.visual); pa.subwindow_mode = IncludeInferiors; cw->origin = XRenderCreatePicture (cw->mainwin->dpy, cw->client.window, cw->client.format, CPSubwindowMode, &pa); XRenderSetPictureFilter(cw->mainwin->dpy, cw->origin, FilterBest, 0, 0); XSelectInput(cw->mainwin->dpy, cw->client.window, SubstructureNotifyMask | StructureNotifyMask); return cw; }
void server_init_visual() { // inspired by freedesktops fdclock ;) XVisualInfo *xvi; XVisualInfo templ = { .screen=server.screen, .depth=32, .class=TrueColor }; int nvi; xvi = XGetVisualInfo(server.dsp, VisualScreenMask|VisualDepthMask|VisualClassMask, &templ, &nvi); Visual *visual = 0; if (xvi) { int i; XRenderPictFormat *format; for (i = 0; i < nvi; i++) { format = XRenderFindVisualFormat(server.dsp, xvi[i].visual); if (format->type == PictTypeDirect && format->direct.alphaMask) { visual = xvi[i].visual; break; } } } XFree (xvi); // check composite manager server.composite_manager = XGetSelectionOwner(server.dsp, server.atom._NET_WM_CM_S0); if (server.colormap) XFreeColormap(server.dsp, server.colormap); if (server.colormap32) XFreeColormap(server.dsp, server.colormap32); if (visual) { server.visual32 = visual; server.colormap32 = XCreateColormap(server.dsp, server.root_win, visual, AllocNone); } if (!server.disable_transparency && visual && server.composite_manager != None && snapshot_path == 0) { XSetWindowAttributes attrs; attrs.event_mask = StructureNotifyMask; XChangeWindowAttributes (server.dsp, server.composite_manager, CWEventMask, &attrs); server.real_transparency = 1; server.depth = 32; printf("real transparency on... depth: %d\n", server.depth); server.colormap = XCreateColormap(server.dsp, server.root_win, visual, AllocNone); server.visual = visual; } else { // no composite manager or snapshot mode => fake transparency server.real_transparency = 0; server.depth = DefaultDepth(server.dsp, server.screen); printf("real transparency off.... depth: %d\n", server.depth); server.colormap = DefaultColormap(server.dsp, server.screen); server.visual = DefaultVisual(server.dsp, server.screen); } }
void DrawTrayWindow(int f_state, int x, int y, int w, int h) { if ( !bUseTrayIcon ) return; if (!tray_mapped) { tray_mapped = True; if (!tray_find_dock(dpy, tray.window)) return; } if (!tray_get_visual(dpy, &tray)) { XClearArea (dpy, tray.window, x, y, w, h, False); XSetClipOrigin(dpy, tray.gc, x, y); XPutImage(dpy, tray.window, tray.gc, tray.icon[f_state], x, y, x, y, w, h); } else { Picture trayw, mask, icon; XWindowAttributes attrs; XGetWindowAttributes( dpy, tray.window , &attrs ); XRenderPictFormat* format = XRenderFindVisualFormat( dpy, attrs.visual ); XRenderPictFormat *pformat = XRenderFindStandardFormat( dpy, PictStandardA1 ); XRenderPictFormat *pformat2 = XRenderFindStandardFormat( dpy, PictStandardRGB24 ); XRenderPictureAttributes pattrs; trayw = XRenderCreatePicture(dpy, tray.window, format, 0, NULL); mask = XRenderCreatePicture(dpy, tray.icon_mask[f_state], pformat, 0, NULL); pattrs.alpha_map = mask; icon = XRenderCreatePicture(dpy, tray.picon[f_state], pformat2, CPAlphaMap, &pattrs); XRenderComposite(dpy, PictOpOver, icon, None, trayw, x,y , x,y,x,y,w,h); XRenderFreePicture(dpy,trayw); XRenderFreePicture(dpy,mask); XRenderFreePicture(dpy,icon); } }
int InitCompositePix(XParms xp, Parms p, int reps) { XRenderPictFormat *format = NULL; int depth; (void) InitCompositeWin (xp, p, reps); /* Create pixmap to write stuff into, and initialize it */ switch (xp->planemask) { case PictStandardNative: depth = xp->vinfo.depth; format = XRenderFindVisualFormat (xp->d, xp->vinfo.visual); break; case PictStandardRGB24: depth = 24; break; case PictStandardARGB32: depth = 32; break; case PictStandardA8: depth = 8; break; case PictStandardA4: depth = 4; break; case PictStandardA1: depth = 1; break; default: depth = 0; break; } if (!format) format = XRenderFindStandardFormat (xp->d, xp->planemask); pix = XCreatePixmap(xp->d, xp->w, WIDTH, HEIGHT, depth); pixPict = XRenderCreatePicture (xp->d, pix, format, 0, NULL); XRenderComposite (xp->d, PictOpClear, winPict, None, pixPict, 0, 0, 0, 0, 0, 0, WIDTH, HEIGHT); #if 1 XRenderComposite (xp->d, PictOpOver, winPict, None, pixPict, 0, 0, 0, 0, 0, 0, WIDTH, HEIGHT); #endif return reps; }
int backing_init(backing_t *backing, Display *dpy, Window root, int width, int height, int depth) { XRenderPictFormat templ; int screen = DefaultScreen(dpy); unsigned long gcm; XGCValues gcv; backing->dpy = dpy; backing->root = root; backing->active = 0; gcm = 0; gcm |= GCSubwindowMode; gcv.subwindow_mode = IncludeInferiors; backing->gc = XCreateGC(backing->dpy, backing->root, gcm, &gcv); backing->root_pixmap = 0; backing->brush_pixmap = 0; backing->total_width = width; backing->total_height = height; backing->depth = depth; backing->root_pict = 0; backing->brush_pict = 0; backing->root_format = XRenderFindVisualFormat(dpy,DefaultVisual(dpy, screen)); templ.type = PictTypeDirect; templ.depth = 32; templ.direct.alpha = 24; templ.direct.alphaMask = 0xff; templ.direct.red = 16; templ.direct.redMask = 0xff; templ.direct.green = 8; templ.direct.greenMask = 0xff; templ.direct.blue = 0; templ.direct.blueMask = 0xff; backing->brush_format = XRenderFindFormat (dpy, PictFormatType| PictFormatDepth| PictFormatAlpha| PictFormatAlphaMask| PictFormatRed| PictFormatRedMask| PictFormatGreen| PictFormatGreenMask| PictFormatBlue| PictFormatBlueMask, &templ, 0); return 0; }
void xfwmPixmapInit (ScreenInfo * screen_info, xfwmPixmap * pm) { pm->screen_info = screen_info; pm->pixmap = None; pm->mask = None; pm->width = 0; pm->height = 0; #ifdef HAVE_RENDER pm->pict_format = XRenderFindVisualFormat (myScreenGetXDisplay (screen_info), screen_info->visual); pm->pict = None; #endif }
void XftDrawChange (XftDraw *draw, Drawable drawable) { draw->drawable = drawable; if (draw->render_able) { XRenderPictFormat *format; XRenderFreePicture (draw->dpy, draw->render.pict); format = XRenderFindVisualFormat (draw->dpy, draw->visual); draw->render.pict = XRenderCreatePicture (draw->dpy, draw->drawable, format, 0, 0); } }
void checkComposite() { if( qgetenv( "KDE_SKIP_ARGB_VISUALS" ) == "1" ) return; // thanks to zack rusin and frederik for pointing me in the right direction // for the following bits of X11 code dpy = XOpenDisplay(0); // open default display if (!dpy) { kError() << "Cannot connect to the X server"; return; } int screen = DefaultScreen(dpy); int eventBase, errorBase; if (XRenderQueryExtension(dpy, &eventBase, &errorBase)) { int nvi; XVisualInfo templ; templ.screen = screen; templ.depth = 32; templ.c_class = TrueColor; XVisualInfo *xvi = XGetVisualInfo(dpy, VisualScreenMask | VisualDepthMask | VisualClassMask, &templ, &nvi); for (int i = 0; i < nvi; ++i) { XRenderPictFormat *format = XRenderFindVisualFormat(dpy, xvi[i].visual); if (format->type == PictTypeDirect && format->direct.alphaMask) { visual = xvi[i].visual; colormap = XCreateColormap(dpy, RootWindow(dpy, screen), visual, AllocNone); XFree(xvi); return; } } XFree(xvi); } XCloseDisplay( dpy ); dpy = NULL; }
int InitCompositeWin(XParms xp, Parms p, int64_t reps) { XRenderPictFormat *format; (void) InitScroll (xp, p, reps); InitCopyLocations(p->special, 1, 1, reps, &segsa, &segsb); if (p->fillStyle) { int mul = 0x10000; int div = p->fillStyle; InitCopyLocations (p->special, mul, div, reps, &segsa2, &segsb2); } format = XRenderFindVisualFormat (xp->d, xp->vinfo.visual); winPict = XRenderCreatePicture (xp->d, xp->w, format, 0, NULL); return reps; }
void arrowsinit() { dsp = XOpenDisplay(NULL); int scr = DefaultScreen(dsp); scrwidth = DisplayWidth(dsp, scr); scrheight = DisplayHeight(dsp, scr); rootwin = DefaultRootWindow(dsp); pixmap = XCreatePixmap(dsp, rootwin, scrwidth, scrheight, DefaultDepth(dsp, scr)); XRenderPictFormat *xrformat = XRenderFindVisualFormat(dsp, DefaultVisual(dsp, scr)); cairo_surface_t *surface = cairo_xlib_surface_create_with_xrender_format(dsp, pixmap, ScreenOfDisplay(dsp, scr), xrformat, scrwidth, scrheight); cr = cairo_create(surface); XSetWindowBackgroundPixmap(dsp, rootwin, pixmap); }
void init_render(struct xinfo *X, struct panel *P) { bbwidth = P->width; bbheight = P->theme->height; bb = imlib_create_image(bbwidth, bbheight); bbcolor = imlib_create_image(bbwidth, bbheight); imlib_context_set_image(bb); imlib_image_set_has_alpha(1); bbdpy = X->display; bbvis = X->visual; bbwin = P->win; bbcm = X->colmap; bbx = P->x; bby = P->y; rootpmap = &X->rootpmap; theme = P->theme; imlib_context_set_display(bbdpy); imlib_context_set_visual(bbvis); imlib_context_set_colormap(bbcm); #ifdef WITH_COMPOSITE if (P->theme->use_composite) { XRenderPictFormat *fmt = XRenderFindStandardFormat(bbdpy, PictStandardARGB32); bbalpha = imlib_create_image(bbwidth, bbheight); pixcolor = XCreatePixmap(bbdpy, bbwin, bbwidth, bbheight, 32); pixalpha = XCreatePixmap(bbdpy, bbwin, bbwidth, bbheight, 32); piccolor = XRenderCreatePicture(bbdpy, pixcolor, fmt, 0, 0); picalpha = XRenderCreatePicture(bbdpy, pixalpha, fmt, 0, 0); XRenderPictureAttributes pwin; pwin.subwindow_mode = IncludeInferiors; rootpic = XRenderCreatePicture(bbdpy, bbwin, XRenderFindVisualFormat(bbdpy, bbvis), CPSubwindowMode, &pwin); } else #endif if (*rootpmap) { update_bg(); } else { set_bg(); } imlib_context_set_blend(0); imlib_context_set_operation(IMLIB_OP_COPY); }
GLXFBConfig qglx_findConfig(Display *display, int screen , const QSurfaceFormat &format, int drawableBit) { bool reduced = true; GLXFBConfig chosenConfig = 0; QSurfaceFormat reducedFormat = format; while (!chosenConfig && reduced) { QVector<int> spec = qglx_buildSpec(reducedFormat, drawableBit); int confcount = 0; GLXFBConfig *configs; configs = glXChooseFBConfig(display, screen,spec.constData(),&confcount); if (confcount) { for (int i = 0; i < confcount; i++) { chosenConfig = configs[i]; // Make sure we try to get an ARGB visual if the format asked for an alpha: if (reducedFormat.hasAlpha()) { int alphaSize; glXGetFBConfigAttrib(display,configs[i],GLX_ALPHA_SIZE,&alphaSize); if (alphaSize > 0) { XVisualInfo *visual = glXGetVisualFromFBConfig(display, chosenConfig); bool hasAlpha = false; #if !defined(QT_NO_XRENDER) XRenderPictFormat *pictFormat = XRenderFindVisualFormat(display, visual->visual); hasAlpha = pictFormat->direct.alphaMask > 0; #else hasAlpha = visual->depth == 32; #endif XFree(visual); if (hasAlpha) break; } } else { break; // Just choose the first in the list if there's no alpha requested } } XFree(configs); } if (!chosenConfig) reducedFormat = qglx_reduceSurfaceFormat(reducedFormat,&reduced); } return chosenConfig; }
static void DrawTrayExtend(winlist_t *win) { Pixmap tray, dummy; XpmAttributes attr; attr.valuemask = 0; XpmCreatePixmapFromData(gui->display, win->window, oxim_tray, &tray, &dummy, &attr); int tray_w = attr.width; int tray_h = attr.height; int w = win->width; int h = win->height; int x=0, y=0; int offset_y = h/2 - tray_h/2; Picture trayw, mask, icon; XWindowAttributes attrs; XGetWindowAttributes( gui->display, win->window , &attrs ); XRenderPictFormat* format = XRenderFindVisualFormat( gui->display, attrs.visual ); XRenderPictFormat *pformat = XRenderFindStandardFormat( gui->display, PictStandardA1 ); XRenderPictFormat *pformat2 = XRenderFindStandardFormat( gui->display, PictStandardRGB24 ); XRenderPictureAttributes pattrs; trayw = XRenderCreatePicture(gui->display, win->window, format, 0, NULL); mask = XRenderCreatePicture(gui->display, icon_mask, pformat, 0, NULL); pattrs.alpha_map = mask; icon = XRenderCreatePicture(gui->display, picon, pformat2, CPAlphaMap, &pattrs); XRenderComposite(gui->display, PictOpOver, icon, None, trayw, x,y-offset_y , x,y,x,y,w,h); XRenderFreePicture(gui->display,trayw); XRenderFreePicture(gui->display,mask); XRenderFreePicture(gui->display,icon); XFreePixmap(gui->display,tray); if(dummy) XFreePixmap(gui->display,dummy); }
static int fbconfig_supports_alpha(Display *dpy, GLXFBConfig cfg) { XRenderPictFormat *pict_format; XVisualInfo *visual_info; int well_does_it = 1; visual_info = glXGetVisualFromFBConfig(dpy, cfg); pict_format = XRenderFindVisualFormat(dpy, visual_info->visual); if (!pict_format || !pict_format->direct.alphaMask) well_does_it = 0; free(visual_info); return well_does_it; }
/* * Builds a pixmap of the same size as the terminal window that contains * the tiled portion of the root pixmap that is supposed to be covered by * our window. */ void rxvt_term::render_root_image () { /* root dimensions may change from call to call - but Display structure should * be always up-to-date, so let's use it : */ int screen = display->screen; int root_width = DisplayWidth (dpy, screen); int root_height = DisplayHeight (dpy, screen); int parent_width = szHint.width; int parent_height = szHint.height; int sx, sy; sx = parent_x; sy = parent_y; /* check if we are outside of the visible part of the virtual screen : */ if (sx + parent_width <= 0 || sy + parent_height <= 0 || sx >= root_width || sy >= root_height) return; while (sx < 0) sx += root_img->w; while (sy < 0) sy += root_img->h; rxvt_img *img = root_img->sub_rect (sx, sy, parent_width, parent_height); if (root_effects.need_blur ()) img->blur (root_effects.h_blurRadius, root_effects.v_blurRadius)->replace (img); if (root_effects.need_tint ()) { rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC); if (root_effects.tint_set) root_effects.tint.get (c); rxvt_img::nv factor = root_effects.shade / 100. - 1.; img->shade (factor, c)->replace (img); } XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); img->convert_format (format, pix_colors [Color_bg])->replace (img); delete bg_img; bg_img = img; }