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