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();
}
