void Thumbnail::drawPreview() { if (! _previewValid) { if (! _minimized) { XRenderComposite(_dpy, PictOpSrc, _clientPict, None, _image->picture(), _clientDecoXScaled-_clientDecoX, _clientDecoYScaled - _clientDecoY, 0, 0, _clientOffsetX, _clientOffsetY, _clientScaledWidth, _clientScaledHeight); _previewOnceDrawn = true; } else { if (! _previewOnceDrawn) { XRenderComposite(_dpy, PictOpSrc, Resources::instance()->brokenPattern()->picture(), None, _image->picture(), 0, 0, 0, 0, _clientOffsetX, _clientOffsetY, _clientScaledWidth, _clientScaledHeight ); } } _previewValid = true; } }
static void CompositeArea(XParms xp, Parms p, int64_t reps, Picture src, Picture dst) { int i, size; XSegment *sa, *sb; XSegment *sa2, *sb2; size = p->special; sa = segsa; sb = segsb; sa2 = segsa2 ? segsa2 : segsa; sb2 = segsb2 ? segsb2 : segsb; for (i = 0; i < reps; i++) { XRenderComposite (xp->d, xp->func, src, None, dst, sa2->x1, sa2->y1, 0, 0, sa->x2, sa->y2, size, size); XRenderComposite (xp->d, xp->func, src, None, dst, sa2->x2, sa2->y2, 0, 0, sa->x1, sa->y1, size, size); XRenderComposite (xp->d, xp->func, src, None, dst, sb2->x2, sb2->y2, 0, 0, sb->x1, sb->y1, size, size); XRenderComposite (xp->d, xp->func, src, None, dst, sb2->x1, sb2->y1, 0, 0, sb->x2, sb->y2, size, size); CheckAbort (); sa++; sb++; sa2++; sb2++; } }
static void clientwin_repaint(ClientWin *cw, XRectangle *rect) { XRenderColor *tint = cw->focused ? &cw->mainwin->highlightTint : &cw->mainwin->normalTint; int s_x = (double)rect->x * cw->factor, s_y = (double)rect->y * cw->factor, s_w = (double)rect->width * cw->factor, s_h = (double)rect->height * cw->factor; if(cw->mainwin->lazy_trans) { XRenderComposite(cw->mainwin->dpy, PictOpSrc, cw->origin, cw->focused ? cw->mainwin->highlightPicture : cw->mainwin->normalPicture, cw->destination, s_x, s_y, 0, 0, s_x, s_y, s_w, s_h); } else { XRenderComposite(cw->mainwin->dpy, PictOpSrc, cw->mainwin->background, None, cw->destination, cw->mini.x + s_x, cw->mini.y + s_y, 0, 0, s_x, s_y, s_w, s_h); XRenderComposite(cw->mainwin->dpy, PictOpOver, cw->origin, cw->focused ? cw->mainwin->highlightPicture : cw->mainwin->normalPicture, cw->destination, s_x, s_y, 0, 0, s_x, s_y, s_w, s_h); } if(tint->alpha) XRenderFillRectangle(cw->mainwin->dpy, PictOpOver, cw->destination, tint, s_x, s_y, s_w, s_h); XClearArea(cw->mainwin->dpy, cw->mini.window, s_x, s_y, s_w, s_h, False); }
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; }
static double _bench_source(struct test_display *t, enum target target_type, int op, int src, int loops) { XRenderColor render_color = { 0x8000, 0x8000, 0x8000, 0x8000 }; struct test_target target; Picture picture; struct timespec tv; double elapsed; test_target_create_render(t, target_type, &target); XRenderFillRectangle(t->dpy, PictOpClear, target.picture, &render_color, 0, 0, target.width, target.height); picture = source[src].create(t, &target); if (picture) { test_timer_start(t, &tv); while (loops--) XRenderComposite(t->dpy, op, picture, 0, target.picture, 0, 0, 0, 0, 0, 0, target.width, target.height); elapsed = test_timer_stop(t, &tv); XRenderFreePicture(t->dpy, picture); } else elapsed = -1; test_target_destroy_render(t, &target); return elapsed; }
static void fill_rect(struct test_display *t, Picture p, int x, int y, int w, int h, uint8_t red, uint8_t green, uint8_t blue) { Drawable tmp; XRenderColor c; Picture src; XRenderPictFormat *format; format = XRenderFindStandardFormat(t->dpy, PictStandardRGB24); tmp = XCreatePixmap(t->dpy, DefaultRootWindow(t->dpy), w, h, format->depth); src = XRenderCreatePicture(t->dpy, tmp, format, 0, NULL); c.red = (int)red << 8 | red; c.green = (int)green << 8 | green; c.blue = (int)blue << 8 | blue; c.alpha = 0xffff; XRenderFillRectangle(t->dpy, PictOpSrc, src, &c, 0, 0, w, h); XRenderComposite(t->dpy, PictOpOver, src, 0, p, 0, 0, 0, 0, x, y, w, h); XRenderFreePicture(t->dpy, src); XFreePixmap(t->dpy, tmp); }
static void _render_copy(struct test_target *tt, int x, int y, int w, int h, uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha) { XRenderColor color; Picture src; Pixmap tmp; tmp = XCreatePixmap(tt->dpy->dpy, DefaultRootWindow(tt->dpy->dpy), 10+w, 20+h, tt->format->depth); src = XRenderCreatePicture(tt->dpy->dpy, tmp, tt->format, 0, NULL); /* magenta border */ color.red = 0xffff; color.green = 0; color.blue = 0xffff; color.alpha = 0xffff; XRenderFillRectangle(tt->dpy->dpy, PictOpSrc, src, &color, 0, 0, w+10, h+20); color.red = red * alpha; color.green = green * alpha; color.blue = blue * alpha; color.alpha = alpha << 8 | alpha; XRenderFillRectangle(tt->dpy->dpy, PictOpSrc, src, &color, 5, 10, w, h); XRenderComposite(tt->dpy->dpy, PictOpSrc, src, 0, tt->picture, 5, 10, 0, 0, x, y, w, h); XRenderFreePicture(tt->dpy->dpy, src); XFreePixmap(tt->dpy->dpy, tmp); }
static void fill_rect(struct test_display *dpy, Picture p, uint8_t op, int x, int y, int w, int h, uint8_t s_red, uint8_t s_green, uint8_t s_blue, uint8_t s_alpha, uint8_t m_red, uint8_t m_green, uint8_t m_blue, uint8_t m_alpha) { XRenderColor render_color; Picture source, mask; render_color.red = s_red * s_alpha; render_color.green = s_green * s_alpha; render_color.blue = s_blue * s_alpha; render_color.alpha = s_alpha << 8 | s_alpha; source = XRenderCreateSolidFill(dpy->dpy, &render_color); render_color.red = m_red * m_alpha; render_color.green = m_green * m_alpha; render_color.blue = m_blue * m_alpha; render_color.alpha = m_alpha << 8 | m_alpha; mask = XRenderCreateSolidFill(dpy->dpy, &render_color); XRenderComposite(dpy->dpy, op, source, mask, p, 0, 0, 0, 0, x, y, w,h); XRenderFreePicture(dpy->dpy, mask); XRenderFreePicture(dpy->dpy, source); }
void xf_draw_screen_scaled(xfInfo* xfi) { XTransform transform; Picture windowPicture; Picture primaryPicture; XRenderPictureAttributes pa; XRenderPictFormat* picFormat; picFormat = XRenderFindStandardFormat(xfi->display, PictStandardRGB24); pa.subwindow_mode = IncludeInferiors; primaryPicture = XRenderCreatePicture(xfi->display, xfi->primary, picFormat, CPSubwindowMode, &pa); windowPicture = XRenderCreatePicture(xfi->display, xfi->window->handle, picFormat, CPSubwindowMode, &pa); transform.matrix[0][0] = XDoubleToFixed(1); transform.matrix[0][1] = XDoubleToFixed(0); transform.matrix[0][2] = XDoubleToFixed(0); transform.matrix[1][0] = XDoubleToFixed(0); transform.matrix[1][1] = XDoubleToFixed(1); transform.matrix[1][2] = XDoubleToFixed(0); transform.matrix[2][0] = XDoubleToFixed(0); transform.matrix[2][1] = XDoubleToFixed(0); transform.matrix[2][2] = XDoubleToFixed(xfi->scale); XRenderSetPictureTransform(xfi->display, primaryPicture, &transform); XRenderComposite(xfi->display, PictOpSrc, primaryPicture, 0, windowPicture, 0, 0, 0, 0, 0, 0, xfi->currentWidth, xfi->currentHeight); }
void Canvas::copyCanvas(const Canvas* canvas, const Rect& src, const Point& origin, bool copyAlpha) { Point offset = absolutePosition(); if ( (rgba() == false && canvas->rgba() == false) || (rgba() == true && canvas->rgba() == true && copyAlpha) ) { XCopyArea( display()->xdisplay(), canvas->xdrawable(), xdrawable(), xgc(), src.origin.x, src.origin.y, src.size.w, src.size.h, origin.x + offset.x, origin.y + offset.y ); } else { XRenderComposite( display()->xdisplay(), PictOpOver, canvas->xpicture(), None, xpicture(), src.origin.x, src.origin.y, 0, 0, origin.x + offset.x, origin.y + offset.y, src.size.w, src.size.h ); } }
void Canvas::copyRotatedCanvas(const Canvas* canvas, const Rect& src, const Point& origin) { XTransform xform = {{ { XDoubleToFixed(0), XDoubleToFixed(-1), XDoubleToFixed(0) }, { XDoubleToFixed(1), XDoubleToFixed(0), XDoubleToFixed(0) }, { XDoubleToFixed(0), XDoubleToFixed(0), XDoubleToFixed(1) }, }}; XRenderSetPictureTransform(display()->xdisplay(), canvas->xpicture(), &xform); Point offset = absolutePosition(); XRenderComposite( display()->xdisplay(), PictOpOver, canvas->xpicture(), None, xpicture(), // src.origin.x, src.origin.y, // 0, 0, // origin.x + offset.x, origin.y + offset.y, // src.size.w, src.size.h src.origin.x, -src.size.w, 0, 0, origin.x + offset.x, origin.y + offset.y, src.size.w, src.size.h ); XTransform identity = {{ { XDoubleToFixed(1), XDoubleToFixed(0), XDoubleToFixed(0) }, { XDoubleToFixed(0), XDoubleToFixed(1), XDoubleToFixed(0) }, { XDoubleToFixed(0), XDoubleToFixed(0), XDoubleToFixed(1) }, }}; XRenderSetPictureTransform(display()->xdisplay(), canvas->xpicture(), &identity); }
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 SetSurface(SystemDraw& w, int x, int y, int cx, int cy, const RGBA *pixels) { GuiLock __; Pixmap pixmap = XCreatePixmap(Xdisplay, Xroot, cx, cy, 24); XPicture picture = XRenderCreatePicture( Xdisplay, pixmap, XRenderFindStandardFormat(Xdisplay, PictStandardRGB24), 0, 0 ); XImage ximg; sInitXImage(ximg, Size(cx, cy)); ximg.bitmap_pad = 32; ximg.bytes_per_line = 4 * cx; ximg.bits_per_pixel = 32; ximg.blue_mask = 0x00ff0000; ximg.green_mask = 0x0000ff00; ximg.red_mask = 0x000000ff; ximg.bitmap_unit = 32; ximg.depth = 24; ximg.data = (char *)pixels; XInitImage(&ximg); GC gc = XCreateGC(Xdisplay, pixmap, 0, 0); XPutImage(Xdisplay, pixmap, gc, &ximg, 0, 0, 0, 0, cx, cy); XFreeGC(Xdisplay, gc); XFreePixmap(Xdisplay, pixmap); XRenderComposite(Xdisplay, PictOpOver, picture, 0, XftDrawPicture(w.GetXftDraw()), 0, 0, 0, 0, x, y, cx, cy); XRenderFreePicture(Xdisplay, picture); }
void xf_draw_screen_scaled(xfContext* xfc, int x, int y, int w, int h, BOOL scale) { #ifdef WITH_XRENDER XTransform transform; Picture windowPicture; Picture primaryPicture; XRenderPictureAttributes pa; XRenderPictFormat* picFormat; XRectangle xr; picFormat = XRenderFindStandardFormat(xfc->display, PictStandardRGB24); pa.subwindow_mode = IncludeInferiors; primaryPicture = XRenderCreatePicture(xfc->display, xfc->primary, picFormat, CPSubwindowMode, &pa); windowPicture = XRenderCreatePicture(xfc->display, xfc->window->handle, picFormat, CPSubwindowMode, &pa); transform.matrix[0][0] = XDoubleToFixed(1); transform.matrix[0][1] = XDoubleToFixed(0); transform.matrix[0][2] = XDoubleToFixed(0); transform.matrix[1][0] = XDoubleToFixed(0); transform.matrix[1][1] = XDoubleToFixed(1); transform.matrix[1][2] = XDoubleToFixed(0); transform.matrix[2][0] = XDoubleToFixed(0); transform.matrix[2][1] = XDoubleToFixed(0); transform.matrix[2][2] = XDoubleToFixed(xfc->settings->ScalingFactor); if( (w != 0) && (h != 0) ) { if(scale == TRUE) { xr.x = x * xfc->settings->ScalingFactor; xr.y = y * xfc->settings->ScalingFactor; xr.width = (w+1) * xfc->settings->ScalingFactor; xr.height = (h+1) * xfc->settings->ScalingFactor; } else { xr.x = x; xr.y = y; xr.width = w; xr.height = h; } XRenderSetPictureClipRectangles(xfc->display, primaryPicture, 0, 0, &xr, 1); } XRenderSetPictureTransform(xfc->display, primaryPicture, &transform); XRenderComposite(xfc->display, PictOpSrc, primaryPicture, 0, windowPicture, 0, 0, 0, 0, xfc->offset_x, xfc->offset_y, xfc->currentWidth, xfc->currentHeight); XRenderFreePicture(xfc->display, primaryPicture); XRenderFreePicture(xfc->display, windowPicture); #endif }
void window_draw(Window id, Picture surface) { window_t *window = window_get(id); if (window == NULL) return; XRenderComposite(conn, PictOpSrc, window->picture, None, surface, 0, 0, 0, 0, window->x, window->y, window->width, window->height); }
void render_present() { update_bg(); #ifdef WITH_COMPOSITE if (theme->use_composite) { /* * Because XRender can't do directly SRCc * SRCa + DSTc * (1 - SRCa) blending, * I must apply SRCa to my SRCc manually. To do this I'm using PictOpSrc with * alpha channel in mask. So, I need to copy RGB data to one buffer (color) and * Alpha to another buffer (mask), then use them in XRenderComposite. * * But I think in can be done on theme loading stage. Just apply SRCa to SRCc * immediately. Optimization? */ /* copy color part to bbcolor */ imlib_context_set_image(bbcolor); imlib_image_set_has_alpha(1); imlib_context_set_color(0,0,0,255); imlib_image_fill_rectangle(0,0,bbwidth,bbheight); imlib_blend_image_onto_image(bb,0,0,0,bbwidth,bbheight,0,0,bbwidth,bbheight); imlib_context_set_drawable(pixcolor); imlib_render_image_on_drawable(0,0); /* copy alpha part to bbalpha */ imlib_context_set_image(bbalpha); imlib_image_copy_alpha_to_image(bb,0,0); imlib_image_set_has_alpha(1); imlib_context_set_drawable(pixalpha); imlib_render_image_on_drawable(0,0); XRenderComposite(bbdpy, PictOpSrc, piccolor, picalpha, rootpic, 0, 0, 0, 0, 0, 0, bbwidth, bbheight); } else #endif if (*rootpmap) { imlib_context_set_image(bbcolor); imlib_blend_image_onto_image(bg,0,0,0,bbwidth,bbheight,0,0,bbwidth,bbheight); imlib_context_set_blend(1); imlib_blend_image_onto_image(bb,0,0,0,bbwidth,bbheight,0,0,bbwidth,bbheight); imlib_context_set_blend(0); imlib_context_set_drawable(bbwin); imlib_render_image_on_drawable(0,0); } else { imlib_context_set_drawable(bbwin); imlib_context_set_image(bb); imlib_render_image_on_drawable(0,0); } }
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); } }
void xrender_surf_blend(Display *disp, Xrender_Surf *src, Xrender_Surf *dst, int x, int y, int w, int h, int smooth) { XFilters *flt; XTransform xf; xf.matrix[0][0] = (65536 * src->w) / w; xf.matrix[0][1] = 0; xf.matrix[0][2] = 0; xf.matrix[1][0] = 0; xf.matrix[1][1] = (65536 * src->h) / h; xf.matrix[1][2] = 0; xf.matrix[2][0] = 0; xf.matrix[2][1] = 0; xf.matrix[2][2] = 65536; if (smooth) XRenderSetPictureFilter(disp, src->pic, "bilinear", NULL, 0); else XRenderSetPictureFilter(disp, src->pic, "nearest", NULL, 0); XRenderSetPictureTransform(disp, src->pic, &xf); XRenderComposite(disp, PictOpOver, src->pic, None, dst->pic, 0, 0, 0, 0, x, y, w, h); }
static gboolean xfwmWindowCopyComposite (xfwmWindow * win, xfwmPixmap * pix) { if (myDisplayHaveRender (win->screen_info->display_info)) { Picture pict; Pixmap temp; if (!pix->pict) { TRACE ("xfwmWindowCopyComposite: Pixmap picture does not exist"); return FALSE; } if (!win->pict_format) { TRACE ("xfwmWindowCopyComposite: Window picture format is unknown"); return FALSE; } temp = XCreatePixmap (myScreenGetXDisplay (win->screen_info), win->window, pix->width, pix->height, win->depth); if (!temp) { return FALSE; } pict = XRenderCreatePicture (myScreenGetXDisplay (win->screen_info), temp, win->pict_format, 0, NULL); if (!pict) { XFreePixmap (myScreenGetXDisplay (win->screen_info), temp); return FALSE; } XRenderComposite (myScreenGetXDisplay (win->screen_info), PictOpSrc, pix->pict, None, pict, 0, 0, 0, 0, 0, 0, pix->width, pix->height); XRenderFreePicture (myScreenGetXDisplay (win->screen_info), pict); XSetWindowBackgroundPixmap (myScreenGetXDisplay (win->screen_info), win->window, temp); XFreePixmap (myScreenGetXDisplay (win->screen_info), temp); return TRUE; } return FALSE; }
static void CompositeArea(XParms xp, Parms p, int reps, Picture src, Picture dst) { int i, size; XSegment *sa, *sb; size = p->special; for (sa = segsa, sb = segsb, i = 0; i != reps; i++, sa++, sb++) { XRenderComposite (xp->d, xp->func, src, None, dst, sa->x1, sa->y1, 0, 0, sa->x2, sa->y2, size, size); XRenderComposite (xp->d, xp->func, src, None, dst, sa->x2, sa->y2, 0, 0, sa->x1, sa->y1, size, size); XRenderComposite (xp->d, xp->func, src, None, dst, sb->x2, sb->y2, 0, 0, sb->x1, sb->y1, size, size); XRenderComposite (xp->d, xp->func, src, None, dst, sb->x1, sb->y1, 0, 0, sb->x2, sb->y2, size, size); CheckAbort (); } }
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); }
void QX11WindowSurface::beginPaint(const QRegion &rgn) { #ifndef QT_NO_XRENDER if (d_ptr->translucentBackground) { if (d_ptr->device.depth() != 32) static_cast<QX11PixmapData *>(d_ptr->device.data_ptr())->convertToARGB32(); ::Picture src = X11->getSolidFill(d_ptr->device.x11Info().screen(), Qt::transparent); ::Picture dst = d_ptr->device.x11PictureHandle(); const QVector<QRect> rects = rgn.rects(); const int w = d_ptr->device.width(); const int h = d_ptr->device.height(); for (QVector<QRect>::const_iterator it = rects.begin(); it != rects.end(); ++it) XRenderComposite(X11->display, PictOpSrc, src, 0, dst, 0, 0, w, h, it->x(), it->y(), it->width(), it->height()); } #endif }
Image<ColorRgb> & X11Grabber::grab() { updateScreenDimensions(); if (_XRenderAvailable && !_useXGetImage) { XRenderComposite( _x11Display, // *dpy, PictOpSrc, // op, _srcPicture, // src None, // mask _dstPicture, // dst _cropLeft, // src_x _cropTop, // src_y 0, // mask_x 0, // mask_y 0, // dst_x 0, // dst_y _croppedWidth, // width _croppedHeight); // height XSync(_x11Display, False); if (_XShmAvailable) { XShmGetImage(_x11Display, _pixmap, _xImage, 0, 0, AllPlanes); } else { _xImage = XGetImage(_x11Display, _pixmap, 0, 0, _croppedWidth, _croppedHeight, AllPlanes, ZPixmap); } } else { if (_XShmAvailable && !_useXGetImage) { XShmGetImage(_x11Display, _window, _xImage, _cropLeft, _cropTop, AllPlanes); } else { _xImage = XGetImage(_x11Display, _window, _cropLeft, _cropTop, _croppedWidth, _croppedHeight, AllPlanes, ZPixmap); } } if (_xImage == nullptr) { std::cerr << "X11GRABBER ERROR: Grab failed" << std::endl; return _image; } _imageResampler.processImage(reinterpret_cast<const uint8_t *>(_xImage->data), _xImage->width, _xImage->height, _xImage->bytes_per_line, PIXELFORMAT_BGR32, _image); return _image; }
/** Composite a picture on the appropriate screen by combining the * specified rectangle of the transformed src and mask operands with * the specified rectangle of the dst using op as the compositing * operator. For a complete description see the protocol document of * the RENDER library. */ void dmxComposite(CARD8 op, PicturePtr pSrc, PicturePtr pMask, PicturePtr pDst, INT16 xSrc, INT16 ySrc, INT16 xMask, INT16 yMask, INT16 xDst, INT16 yDst, CARD16 width, CARD16 height) { ScreenPtr pScreen = pDst->pDrawable->pScreen; DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum]; PictureScreenPtr ps = GetPictureScreen(pScreen); dmxPictPrivPtr pSrcPriv = DMX_GET_PICT_PRIV(pSrc); dmxPictPrivPtr pMaskPriv = NULL; dmxPictPrivPtr pDstPriv = DMX_GET_PICT_PRIV(pDst); if (pMask) pMaskPriv = DMX_GET_PICT_PRIV(pMask); DMX_UNWRAP(Composite, dmxScreen, ps); #if 0 if (ps->Composite) ps->Composite(op, pSrc, pMask, pDst, xSrc, ySrc, xMask, yMask, xDst, yDst, width, height); #endif /* Composite on back-end server */ if (pSrcPriv->pict && pDstPriv->pict && ((pMaskPriv && pMaskPriv->pict) || !pMaskPriv)) { XRenderComposite(dmxScreen->beDisplay, op, pSrcPriv->pict, pMaskPriv ? pMaskPriv->pict : None, pDstPriv->pict, xSrc, ySrc, xMask, yMask, xDst, yDst, width, height); dmxSync(dmxScreen, FALSE); } DMX_WRAP(Composite, dmxComposite, dmxScreen, ps); }
void X11EmbedContainer::paintEvent(QPaintEvent *event) { Q_UNUSED(event); if (!d->updatesEnabled) { return; } if (!d->picture) { FdoSelectionManager::painter()->updateContainer(this); return; } // Taking a detour via a QPixmap is unfortunately the only way we can get // the window contents into Qt's backing store. QPixmap pixmap(size()); pixmap = toX11Pixmap(pixmap); pixmap.fill(Qt::transparent); XRenderComposite(x11Info().display(), PictOpSrc, d->picture, None, pixmap.x11PictureHandle(), 0, 0, 0, 0, 0, 0, width(), height()); QPainter p(this); p.drawPixmap(0, 0, pixmap); }
void xRenderRoundBox(Picture pict, const QRect &rect, int , const QColor &c) { XRenderPicture fill = xRenderFill(c); int op = c.alpha() == 255 ? PictOpSrc : PictOpOver; // TODO: implement second paramenter "roundness" // so rather use ?? XRenderCompositeTriFan (dpy, op, src, dst, maskFormat, xSrc, ySrc, //XPointFixed *points, npoint); // this will require "points on a circle" calculation, however... int s = qMin(CS, qMin(rect.height() / 2, rect.width() / 2)); int x, y, b, r; rect.getCoords(&x, &y, &r, &b); r -= (s - 1); b -= (s - 1); XRenderComposite(display(), PictOpOver, fill, *circle(0), pict, 0, 0, 0, 0, x, y, CS, CS); XRenderComposite(display(), PictOpOver, fill, *circle(1), pict, 0, 0, CS - s, 0, r, y, s, s); XRenderComposite(display(), PictOpOver, fill, *circle(2), pict, 0, 0, CS - s, CS - s, r, b, s, s); XRenderComposite(display(), PictOpOver, fill, *circle(3), pict, 0, 0, 0, CS - s, x, b, s, s); XRenderComposite(display(), op, fill, 0, pict, 0, 0, 0, 0, x + s, y, rect.width() - 2 * s, s); XRenderComposite(display(), op, fill, 0, pict, 0, 0, 0, 0, x, y + s, rect.width(), rect.height() - 2 * s); XRenderComposite(display(), op, fill, 0, pict, 0, 0, 0, 0, x + s, b, rect.width() - 2 * s, s); }
void Canvas::copyScaleCanvas(const Canvas* canvas, const Rect& src, const Rect& dst) { if (src.size == dst.size) { copyCanvas(canvas, src, dst.origin); return; } if (dst.size.w <= 0 || dst.size.h <= 0) return; XTransform xform = {{ { XDoubleToFixed((double)src.size.w / dst.size.w), XDoubleToFixed(0), XDoubleToFixed(src.origin.x) }, { XDoubleToFixed(0), XDoubleToFixed((double)src.size.h / dst.size.h), XDoubleToFixed(src.origin.y) }, { XDoubleToFixed(0), XDoubleToFixed(0), XDoubleToFixed(1) }, }}; XRenderSetPictureTransform(display()->xdisplay(), canvas->xpicture(), &xform); Point offset = absolutePosition(); XRenderComposite( display()->xdisplay(), PictOpOver, canvas->xpicture(), None, xpicture(), 0, 0, 0, 0, dst.origin.x + offset.x, dst.origin.y + offset.y, dst.size.w, dst.size.h ); XTransform identity = {{ { XDoubleToFixed(1), XDoubleToFixed(0), XDoubleToFixed(0) }, { XDoubleToFixed(0), XDoubleToFixed(1), XDoubleToFixed(0) }, { XDoubleToFixed(0), XDoubleToFixed(0), XDoubleToFixed(1) }, }}; XRenderSetPictureTransform(display()->xdisplay(), canvas->xpicture(), &identity); }
void SceneXrender::selfCheckSetup() { KXErrorHandler err; QImage img( selfCheckWidth(), selfCheckHeight(), QImage::Format_RGB32 ); img.setPixel( 0, 0, QColor( Qt::red ).rgb()); img.setPixel( 1, 0, QColor( Qt::green ).rgb()); img.setPixel( 2, 0, QColor( Qt::blue ).rgb()); img.setPixel( 0, 1, QColor( Qt::white ).rgb()); img.setPixel( 1, 1, QColor( Qt::black ).rgb()); img.setPixel( 2, 1, QColor( Qt::white ).rgb()); QPixmap pix = QPixmap::fromImage( img ); foreach( const QPoint& p, selfCheckPoints()) { XSetWindowAttributes wa; wa.override_redirect = True; ::Window window = XCreateWindow( display(), rootWindow(), 0, 0, selfCheckWidth(), selfCheckHeight(), 0, QX11Info::appDepth(), CopyFromParent, CopyFromParent, CWOverrideRedirect, &wa ); XSetWindowBackgroundPixmap( display(), window, pix.handle()); XClearWindow( display(), window ); XMapWindow( display(), window ); // move the window one down to where the result will be rendered too, just in case // the render would fail completely and eventual check would try to read this window's contents XMoveWindow( display(), window, p.x() + 1, p.y()); XCompositeRedirectWindow( display(), window, CompositeRedirectAutomatic ); Pixmap wpix = XCompositeNameWindowPixmap( display(), window ); XWindowAttributes attrs; XGetWindowAttributes( display(), window, &attrs ); XRenderPictFormat* format = XRenderFindVisualFormat( display(), attrs.visual ); Picture pic = XRenderCreatePicture( display(), wpix, format, 0, 0 ); QRect rect( p.x(), p.y(), selfCheckWidth(), selfCheckHeight()); XRenderComposite( display(), PictOpSrc, pic, None, buffer, 0, 0, 0, 0, rect.x(), rect.y(), rect.width(), rect.height()); XRenderFreePicture( display(), pic ); XFreePixmap( display(), wpix ); XDestroyWindow( display(), window ); }
void Thumbnail::redraw() { int borderWidth = Settings::instance()->borderWidth(); int headerHeight = Resources::instance()->headerMiddle()->height(); int headerLeftWidth = Resources::instance()->headerLeft()->width(); int headerRightWidth = Resources::instance()->headerRight()->width(); int w = _clientScaledWidth; int h = _clientScaledHeight; bool selected = (!Settings::instance()->disableSelection()) && this == _teleWindow->activeThumbnail(); const XRenderColor *borderColor = selected ? Resources::instance()->borderActiveColor() : Resources::instance()->borderColor(); Picture left = selected ? Resources::instance()->headerLeftSelected()->picture() : Resources::instance()->headerLeft()->picture(); Picture right = selected ? Resources::instance()->headerRightSelected()->picture() : Resources::instance()->headerRight()->picture(); Picture middle = selected ? Resources::instance()->headerMiddleSelected()->picture() : Resources::instance()->headerMiddle()->picture(); XRenderComposite(_dpy, PictOpSrc, left, None, _image->picture(), 0, 0, 0, 0, _clientOffsetX - borderWidth, _clientOffsetY - headerHeight, headerLeftWidth, headerHeight ); XRenderComposite(_dpy, PictOpSrc, right, None, _image->picture(), 0, 0, 0, 0, _clientOffsetX + w + borderWidth - headerRightWidth, _clientOffsetY - headerHeight, headerRightWidth, headerHeight ); XRenderComposite(_dpy, PictOpSrc, middle, None, _image->picture(), 0, 0, 0, 0, _clientOffsetX - borderWidth + headerLeftWidth, _clientOffsetY - headerHeight, w + 2 * borderWidth - headerLeftWidth - headerRightWidth, headerHeight ); // Left border XRenderFillRectangle(_dpy, PictOpSrc, _image->picture(), borderColor, _clientOffsetX - borderWidth, _clientOffsetY, borderWidth, h ); // Right border XRenderFillRectangle(_dpy, PictOpSrc, _image->picture(), borderColor, _clientOffsetX + w, _clientOffsetY, borderWidth, h ); // Bottom border XRenderFillRectangle(_dpy, PictOpSrc, _image->picture(), borderColor, _clientOffsetX - borderWidth, _clientOffsetY + h, w + 2*borderWidth, borderWidth ); // Drawing title text XftColor fontColor; fontColor.pixel = 0; fontColor.color.red = 0xffff; fontColor.color.green = 0xffff; fontColor.color.blue = 0xffff; fontColor.color.alpha = 0xffff; XRectangle rect = { _clientOffsetX - borderWidth + Settings::instance()->textLeftMargin(), _clientOffsetY - headerHeight, _clientScaledWidth + 2*borderWidth - Settings::instance()->textLeftMargin() - Settings::instance()->textRightMargin(), headerHeight }; Region clip = XCreateRegion(); XUnionRectWithRegion(&rect, clip, clip); XftDrawSetClip(_xftDraw, clip); XftDrawStringUtf8(_xftDraw, &fontColor, _teleWindow->xftFont(), _clientOffsetX - borderWidth + Settings::instance()->textLeftMargin(), _clientOffsetY + Settings::instance()->textYOffset(), (const FcChar8*)_title, strlen(_title) ); XDestroyRegion(clip); drawPreview(); }
void Thumbnail::onResize() { Image* oldImage = _image; if (_image) { XftDrawDestroy(_xftDraw); XFreeGC(_dpy, _gc); } _image = new Image(_dpy, _width, _height); _gc = XCreateGC(_dpy, _image->pixmap(), 0, 0); XSetGraphicsExposures(_dpy, _gc, false); _xftDraw = XftDrawCreate(_dpy, _image->pixmap(), XTools::rgbaVisual()->visual, DefaultColormap(_dpy, DefaultScreen(_dpy))); XWindowAttributes attrs; XGetWindowAttributes(_dpy, _clientWindow, &attrs); _clientWidth = attrs.width; _clientHeight= attrs.height; #ifdef MAEMO4 _clientDecoX = attrs.x; _clientDecoY = attrs.y; #endif int borderWidth = Settings::instance()->borderWidth(); int headerHeight = Resources::instance()->headerMiddle()->height(); int oldClientScaledWidth = _clientScaledWidth; int oldClientScaledHeight= _clientScaledHeight; _clientScaledWidth = _width - 2 * borderWidth; _clientScaledHeight = _height - headerHeight - borderWidth; double scale = _clientScaledWidth; scale /= _clientWidth; _clientDecoXScaled = (int)round(scale * _clientDecoX); _clientDecoYScaled = (int)round(scale * _clientDecoY); _clientOffsetX = borderWidth; _clientOffsetY = headerHeight; XTransform xform = {{ { XDoubleToFixed(1.0/scale), XDoubleToFixed(0), XDoubleToFixed(0) }, { XDoubleToFixed(0), XDoubleToFixed(1.0/scale), XDoubleToFixed(0) }, { XDoubleToFixed(0), XDoubleToFixed(0), XDoubleToFixed(1) }, } }; XRenderSetPictureTransform(_dpy, _clientPict, &xform); if (_minimized && oldImage != 0) { // Workaround for corner case: if this function is called when // client is minimized, we need to rescale cached pixmap, because // can't grab new picture from window // Yes, this function MAY be called when client is minimised - for // example when thumbnail needs to be resized because number of // windows changed Image* temp = new Image(_dpy, _clientScaledWidth, _clientScaledHeight, 32); XTransform xform = {{ { XDoubleToFixed(((double)oldClientScaledWidth)/_clientScaledWidth), XDoubleToFixed(0), XDoubleToFixed(0) }, { XDoubleToFixed(0), XDoubleToFixed(((double)oldClientScaledHeight)/_clientScaledHeight), XDoubleToFixed(0) }, { XDoubleToFixed(0), XDoubleToFixed(0), XDoubleToFixed(1) } } }; XRenderSetPictureTransform(_dpy, oldImage->picture(), &xform); XRenderComposite(_dpy, PictOpSrc, oldImage->picture(), 0, temp->picture(), _clientOffsetX*_clientScaledWidth/oldClientScaledWidth, _clientOffsetY*_clientScaledHeight/oldClientScaledHeight, 0, 0, 0, 0, _clientScaledWidth, _clientScaledHeight ); XCopyArea(_dpy, temp->pixmap(), _image->pixmap(), _gc, 0, 0, _clientScaledWidth, _clientScaledHeight, _clientOffsetX, _clientOffsetY ); delete temp; } _previewValid = false; delete oldImage; redraw(); }