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);
}
// 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);
}
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);
}
}
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 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);
}
}
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);
}
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);
}
static void
configure_window (struct gui_instance *gi)
{
if (gi->back_buffer)
XRenderFreePicture (GUI_display, gi->back_buffer);
if (gi->fontdraw)
XftDrawDestroy (gi->fontdraw);
if (gi->pmap)
XFreePixmap (GUI_display, gi->pmap);
if (gi->gc)
XFreeGC (GUI_display, gi->gc);
gi->gc = XCreateGC (GUI_display, gi->window, 0, 0);
gi->pmap = XCreatePixmap (GUI_display, gi->window, gi->width, gi->height, GUI_visual_info->depth);
gi->fontdraw = XftDrawCreate (GUI_display, gi->pmap, GUI_visual, DefaultColormap (GUI_display, GUI_screenidx));
gi->back_buffer
= XRenderCreatePicture (GUI_display, gi->pmap, xrenderpictformat, 0, 0);
if (!gi->back_buffer)
errx (EXIT_FAILURE, "Failed to create back buffer for X window (XRenderCreatePicture)");
}
JNIEXPORT void JNICALL
Java_sun_java2d_xr_XRSurfaceData_initXRPicture(JNIEnv *env, jobject xsd,
jlong pXSData,
jint pictFormat)
{
#ifndef HEADLESS
X11SDOps *xsdo;
XRenderPictFormat *fmt;
J2dTraceLn(J2D_TRACE_INFO, "in XRSurfaceData_initXRender");
xsdo = (X11SDOps *) jlong_to_ptr(pXSData);
if (xsdo == NULL) {
return;
}
if (xsdo->xrPic == None) {
XRenderPictureAttributes pict_attr;
pict_attr.repeat = RepeatNone;
fmt = XRenderFindStandardFormat(awt_display, pictFormat);
xsdo->xrPic =
XRenderCreatePicture(awt_display, xsdo->drawable, fmt,
CPRepeat, &pict_attr);
}
(*env)->SetIntField (env, xsd, pictID, xsdo->xrPic);
(*env)->SetIntField (env, xsd, xidID, xsdo->drawable);
#endif /* !HEADLESS */
}
Picture PreviewCursor::createPicture(const XcursorImage *image) const
{
Display *dpy = QPaintDevice::x11AppDisplay();
XImage ximage;
ximage.width = image->width;
ximage.height = image->height;
ximage.xoffset = 0;
ximage.format = ZPixmap;
ximage.data = reinterpret_cast< char * >(image->pixels);
ximage.byte_order = ImageByteOrder(dpy);
ximage.bitmap_unit = 32;
ximage.bitmap_bit_order = ximage.byte_order;
ximage.bitmap_pad = 32;
ximage.depth = 32;
ximage.bits_per_pixel = 32;
ximage.bytes_per_line = image->width * 4;
ximage.red_mask = 0x00ff0000;
ximage.green_mask = 0x0000ff00;
ximage.blue_mask = 0x000000ff;
ximage.obdata = 0;
XInitImage(&ximage);
Pixmap pix = XCreatePixmap(dpy, DefaultRootWindow(dpy), ximage.width, ximage.height, 32);
GC gc = XCreateGC(dpy, pix, 0, NULL);
XPutImage(dpy, pix, gc, &ximage, 0, 0, 0, 0, ximage.width, ximage.height);
XFreeGC(dpy, gc);
XRenderPictFormat *fmt = XRenderFindStandardFormat(dpy, PictStandardARGB32);
Picture pict = XRenderCreatePicture(dpy, pix, fmt, 0, NULL);
XFreePixmap(dpy, pix);
return pict;
}
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
clientwin_move(ClientWin *cw, float f, int x, int y)
{
/* int border = MAX(1, (double)DISTANCE(cw->mainwin) * f * 0.25); */
int border = 0;
XSetWindowBorderWidth(cw->mainwin->dpy, cw->mini.window, border);
cw->factor = f;
cw->mini.x = x + (int)cw->x * f;
cw->mini.y = y + (int)cw->y * f;
if(cw->mainwin->lazy_trans)
{
cw->mini.x += cw->mainwin->x;
cw->mini.y += cw->mainwin->y;
}
cw->mini.width = MAX(1, (int)cw->client.width * f);
cw->mini.height = MAX(1, (int)cw->client.height * f);
XMoveResizeWindow(cw->mainwin->dpy, cw->mini.window, cw->mini.x - border, cw->mini.y - border, cw->mini.width, cw->mini.height);
if(cw->pixmap)
XFreePixmap(cw->mainwin->dpy, cw->pixmap);
if(cw->destination)
XRenderFreePicture(cw->mainwin->dpy, cw->destination);
cw->pixmap = XCreatePixmap(cw->mainwin->dpy, cw->mini.window, cw->mini.width, cw->mini.height, cw->mainwin->depth);
XSetWindowBackgroundPixmap(cw->mainwin->dpy, cw->mini.window, cw->pixmap);
cw->destination = XRenderCreatePicture(cw->mainwin->dpy, cw->pixmap, cw->mini.format, 0, 0);
}
static Picture createPicture(Pixmap pix, int depth)
{
if (pix == None)
return None;
if (renderformats[ depth ] == NULL) {
switch(depth) {
case 1:
renderformats[ 1 ] = XRenderFindStandardFormat(display(), PictStandardA1);
break;
case 8:
renderformats[ 8 ] = XRenderFindStandardFormat(display(), PictStandardA8);
break;
case 24:
renderformats[ 24 ] = XRenderFindStandardFormat(display(), PictStandardRGB24);
break;
case 32:
renderformats[ 32 ] = XRenderFindStandardFormat(display(), PictStandardARGB32);
break;
default: {
XRenderPictFormat req;
long mask = PictFormatType | PictFormatDepth;
req.type = PictTypeDirect;
req.depth = depth;
renderformats[ depth ] = XRenderFindFormat(display(), mask, &req, 0);
break;
}
}
if (renderformats[ depth ] == NULL) {
kWarning(1212) << "Could not find XRender format for depth" << depth;
return None;
}
}
return XRenderCreatePicture(display(), pix, renderformats[ depth ], 0, NULL);
}
static Picture source_shm(struct test_display *t, struct test_target *target)
{
XShmSegmentInfo *shm = t->target == REF ? &shmref : &shmout;
Pixmap pixmap;
Picture picture;
int size;
if (shm->shmid == -1)
return 0;
pixmap = XShmCreatePixmap(t->dpy, t->root,
shm->shmaddr, shm,
target->width, target->height, 32);
picture = XRenderCreatePicture(t->dpy, pixmap,
XRenderFindStandardFormat(t->dpy, 0),
0, NULL);
XFreePixmap(t->dpy, pixmap);
size = target->width * target->height * 4;
memset(shm->shmaddr, 0x80, size/2);
memset(shm->shmaddr+size/2, 0xff, size/2);
return picture;
}
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 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);
}
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 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 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);
}
static XPicture sGetSolidFill(Color c)
{
int q = GetHashValue(c) % (int)XRSolidFillCount;
XRSolidFill& f = sFill[q];
if(f.color == c && f.picture)
return f.picture;
if(f.picture)
XRenderFreePicture(Xdisplay, f.picture);
if(f.pixmap)
XFreePixmap(Xdisplay, f.pixmap);
f.pixmap = XCreatePixmap(Xdisplay, Xroot, 1, 1, 32);
XRenderPictureAttributes attr;
attr.repeat = XTrue;
f.picture = XRenderCreatePicture(Xdisplay, f.pixmap,
XRenderFindStandardFormat(Xdisplay, PictStandardARGB32),
CPRepeat, &attr);
f.color = c;
XRenderColor xc;
xc.red = s255d16(c.GetR());
xc.green = s255d16(c.GetG());
xc.blue = s255d16(c.GetB());
xc.alpha = 65535;
XRenderFillRectangle(Xdisplay, PictOpSrc, f.picture, &xc, 0, 0, 1, 1);
return f.picture;
}
static Picture source_pixmap(struct test_display *t, struct test_target *target, int format)
{
XRenderColor render_color[2] = {
{ 0x8000, 0x8000, 0x8000, 0x8000 },
{ 0xffff, 0xffff, 0xffff, 0xffff },
};
Pixmap pixmap;
Picture picture;
pixmap = XCreatePixmap(t->dpy, t->root,
target->width, target->height,
PIXMAN_FORMAT_DEPTH(formats[format].pixman_format));
picture = XRenderCreatePicture(t->dpy, pixmap,
XRenderFindStandardFormat(t->dpy, format),
0, NULL);
XFreePixmap(t->dpy, pixmap);
XRenderFillRectangle(t->dpy, PictOpSrc, picture, &render_color[0],
0, 0, target->width, target->height/2);
XRenderFillRectangle(t->dpy, PictOpSrc, picture, &render_color[1],
0, target->height/2, target->width, target->height/2);
return picture;
}
static void
_eiw_render_loop(Window win, EImage * im, EiwData * d)
{
int w, h;
XRenderPictFormat *pictfmt;
Pixmap pmap;
Picture pict;
EImageGetSize(im, &w, &h);
pictfmt = XRenderFindStandardFormat(disp, PictStandardARGB32);
pmap = XCreatePixmap(disp, WinGetXwin(VROOT), w, h, 32);
imlib_context_set_image(im);
imlib_context_set_drawable(pmap);
imlib_render_image_on_drawable(0, 0);
pict = XRenderCreatePicture(disp, pmap, pictfmt, 0, 0);
XFreePixmap(disp, pmap);
if (d->curs != None)
XFreeCursor(disp, d->curs);
d->curs = XRenderCreateCursor(disp, pict, w / 2, h / 2);
XRenderFreePicture(disp, pict);
XDefineCursor(disp, win, d->curs);
}
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);
}
// Create the compositing buffer. The root window is not double-buffered,
// so it is done manually using this buffer,
void SceneXrender::createBuffer()
{
if (buffer != None)
XRenderFreePicture(display(), buffer);
Pixmap pixmap = XCreatePixmap(display(), rootWindow(), displayWidth(), displayHeight(), DefaultDepth(display(), DefaultScreen(display())));
buffer = XRenderCreatePicture(display(), pixmap, format, 0, 0);
XFreePixmap(display(), pixmap); // The picture owns the pixmap now
}
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);
}
XftDraw *XftDrawCreateAlpha( Display *display,
Pixmap pixmap,
int depth )
{
// taken from Xft 1 sources, see copyright above
XftDraw *draw;
draw = (XftDraw *) malloc (sizeof (XftDraw));
if (!draw)
return 0;
draw->dpy = display;
draw->drawable = pixmap;
draw->visual = 0;
draw->colormap = 0;
draw->core_set = False;
draw->clip = 0;
// Qt addition - go ahead and create the render picture now
draw->render_set = True;
draw->render_able = False;
if ( qt_use_xrender ) {
draw->render_able = True;
XRenderPictFormat *format = 0;
XRenderPictFormat req;
unsigned long mask = PictFormatType | PictFormatDepth | PictFormatAlphaMask;
req.type = PictTypeDirect;
req.depth = depth;
req.direct.alphaMask = 0xff;
format = XRenderFindFormat(draw->dpy, mask, &req, 0);
if (format) {
draw->render.pict =
XRenderCreatePicture(draw->dpy, draw->drawable, format, 0, 0);
}
// to keep Xft from trying to free zero pixmaps/pictures, we need to create
// 2 more pictures (that are identical to draw->render.pict) :/
draw->render.src[0].pict =
XRenderCreatePicture( draw->dpy, draw->drawable, format, 0, 0 );
draw->render.src[1].pict =
XRenderCreatePicture( draw->dpy, draw->drawable, format, 0, 0 );
}
return draw;
}
PP_Resource
ppb_graphics2d_create(PP_Instance instance, const struct PP_Size *size, PP_Bool is_always_opaque)
{
struct pp_instance_s *pp_i = tables_get_pp_instance(instance);
if (!pp_i) {
trace_error("%s, bad instance\n", __func__);
return 0;
}
PP_Resource graphics_2d = pp_resource_allocate(PP_RESOURCE_GRAPHICS2D, pp_i);
struct pp_graphics2d_s *g2d = pp_resource_acquire(graphics_2d, PP_RESOURCE_GRAPHICS2D);
if (!g2d) {
trace_error("%s, can't create graphics2d resource\n", __func__);
return 0;
}
g2d->is_always_opaque = is_always_opaque;
g2d->scale = config.device_scale;
g2d->width = size->width;
g2d->height = size->height;
g2d->stride = 4 * size->width;
g2d->scaled_width = g2d->width * g2d->scale + 0.5;
g2d->scaled_height = g2d->height * g2d->scale + 0.5;
g2d->scaled_stride = 4 * g2d->scaled_width;
g2d->data = calloc(g2d->stride * g2d->height, 1);
g2d->second_buffer = calloc(g2d->scaled_stride * g2d->scaled_height, 1);
if (!g2d->data || !g2d->second_buffer) {
trace_warning("%s, can't allocate memory\n", __func__);
free_and_nullify(g2d->data);
free_and_nullify(g2d->second_buffer);
pp_resource_release(graphics_2d);
ppb_core_release_resource(graphics_2d);
return 0;
}
g2d->cairo_surf = cairo_image_surface_create_for_data((unsigned char *)g2d->data,
CAIRO_FORMAT_ARGB32, g2d->width, g2d->height, g2d->stride);
g2d->task_list = NULL;
if (pp_i->is_transparent) {
// we need XRender picture (which in turn requires X Pixmap) to alpha blend
// our images with existing pixmap provided by the browser. This is only needed
// is instance is transparent, therefore depth is always 32-bit.
pthread_mutex_lock(&display.lock);
g2d->pixmap = XCreatePixmap(display.x, DefaultRootWindow(display.x), g2d->scaled_width,
g2d->scaled_height, 32);
XFlush(display.x);
g2d->xr_pict = XRenderCreatePicture(display.x, g2d->pixmap, display.pictfmt_argb32, 0, 0);
g2d->gc = XCreateGC(display.x, g2d->pixmap, 0, 0);
XFlush(display.x);
pthread_mutex_unlock(&display.lock);
}
pp_resource_release(graphics_2d);
return graphics_2d;
}
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;
}
/* Apply the cursor to the Chromium OS X11 server.
* Adapted from the XcursorImageLoadCursor implementation in libXcursor,
* copyright 2002 Keith Packard.
*/
static void apply_cursor(Display* d, Window w, XFixesCursorImage *image) {
static Cursor cur_cursor = 0;
XImage ximage;
Pixmap pixmap;
Picture picture;
GC gc;
XRenderPictFormat *format;
Cursor cursor;
/* Unset the current cursor if no image is passed. */
if (!image) {
if (cur_cursor) {
XUndefineCursor(d, w);
XFreeCursor(d, cur_cursor);
cur_cursor = 0;
}
return;
}
ximage.width = image->width;
ximage.height = image->height;
ximage.xoffset = 0;
ximage.format = ZPixmap;
ximage.data = (char *) image->pixels;
ximage.byte_order = LSBFirst;
ximage.bitmap_unit = 32;
ximage.bitmap_bit_order = ximage.byte_order;
ximage.bitmap_pad = 32;
ximage.depth = 32;
ximage.bits_per_pixel = 32;
ximage.bytes_per_line = image->width * 4;
ximage.red_mask = 0xff0000;
ximage.green_mask = 0x00ff00;
ximage.blue_mask = 0x0000ff;
ximage.obdata = 0;
if (!XInitImage(&ximage)) {
puts("failed to init image");
return;
}
pixmap = XCreatePixmap(d, w, image->width, image->height, 32);
gc = XCreateGC(d, pixmap, 0, 0);
XPutImage(d, pixmap, gc, &ximage, 0, 0, 0, 0, image->width, image->height);
XFreeGC(d, gc);
format = XRenderFindStandardFormat(d, PictStandardARGB32);
picture = XRenderCreatePicture(d, pixmap, format, 0, 0);
XFreePixmap(d, pixmap);
cursor = XRenderCreateCursor(d, picture, image->xhot, image->yhot);
XRenderFreePicture(d, picture);
XDefineCursor(d, w, cursor);
XFlush(d);
if (cur_cursor)
XFreeCursor(d, cur_cursor);
cur_cursor = cursor;
}
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;
}
