static bool supportsXDamageAndXComposite(GdkWindow* window)
{
static bool initialized = false;
static bool hasExtensions = false;
if (initialized)
return hasExtensions;
initialized = true;
Display* display = GDK_DISPLAY_XDISPLAY(gdk_window_get_display(window));
int errorBase;
if (!XDamageQueryExtension(display, &XDamageNotifier::s_damageEventBase, &errorBase))
return false;
int eventBase;
if (!XCompositeQueryExtension(display, &eventBase, &errorBase))
return false;
// We need to support XComposite version 0.2.
int major, minor;
XCompositeQueryVersion(display, &major, &minor);
if (major < 0 || (!major && minor < 2))
return false;
hasExtensions = true;
return true;
}
gboolean xdk_display_has_damage_extension(XdkDisplay * self)
{
g_return_val_if_fail(self, FALSE);
int event_base, error_base;
return XDamageQueryExtension(self->priv->peer, & event_base, & error_base);
}
void EffectHunter::collectFPS()
{
long fpsSum = 0;
bool firstDamageFlag = true;
XDamageCreate(mXWindowDisplay, mWinId, XDamageReportRawRectangles);
int damageEvt, damageErr;
if (!XDamageQueryExtension (mXWindowDisplay, &damageEvt, &damageErr)){
std::cerr << "not support damage\n";
exit(-1);
}
XEvent e;
if (mMode == SAMPLE_FPS) {
struct itimerval itVal;
itVal.it_interval.tv_sec = 1;
itVal.it_interval.tv_usec = 0;
itVal.it_value.tv_sec = 1;
itVal.it_value.tv_usec = 0;
setitimer(ITIMER_REAL, &itVal, NULL);
XSync(mXWindowDisplay, true);
while (!mTermFlag) {
XNextEvent(mXWindowDisplay, &e);
if (e.type == (damageEvt + XDamageNotify)) {
//printEvent(&e);
mFPS++;
}
}
itVal.it_interval.tv_sec = 0;
itVal.it_interval.tv_usec = 0;
itVal.it_value.tv_sec = 0;
itVal.it_value.tv_usec = 0;
setitimer(ITIMER_REAL, &itVal, NULL);;
std::cout << " [Info]: Sampling finished." << std::endl;
for(int i=0; i<mSampleCount; i++) {
fpsSum += mFPSs[i];
}
std::cout << " [Info]: Average FPS - " << (double)fpsSum/mSampleCount << std::endl;
} else if (mMode == SAMPLE_TIMESTAMP) {
XSync(mXWindowDisplay, true);
while (!mTermFlag) {
XNextEvent(mXWindowDisplay, &e);
if (e.type == (damageEvt + XDamageNotify)) {
//printEvent(&e);
gettimeofday(mLastXDamageEventTimeStamp, NULL);
if (firstDamageFlag) {
mFirstXDamageEventTimeStamp->tv_sec = mLastXDamageEventTimeStamp->tv_sec;
mFirstXDamageEventTimeStamp->tv_usec = mLastXDamageEventTimeStamp->tv_usec;
firstDamageFlag = false;
}
}
}
}
}
X11Support::X11Support()
{
m_instance = this;
oldX11ErrorHandler = XSetErrorHandler(x11errorHandler);
int damageErrorBase;
XDamageQueryExtension(QX11Info::display(), &m_damageEventBase, &damageErrorBase);
}
void CompMgr::run()
{
dpy = XOpenDisplay(0);
::createAtomList();
XSetErrorHandler (error);
if (!XRenderQueryExtension (dpy, &render_event, &render_error))
{
fprintf (stderr, "No render extension\n");
return;
}
if (!XDamageQueryExtension (dpy, &damage_event, &damage_error))
{
fprintf (stderr, "No damage extension\n");
return;
}
if (!XFixesQueryExtension (dpy, &xfixes_event, &xfixes_error))
{
fprintf (stderr, "No XFixes extension\n");
return;
}
if (!register_cm(dpy))
return;
Workspace* workspace = Workspace::instance();
qDebug("Composite Manager started.");
while (!m_stop)
{
XEvent event;
XNextEvent( dpy, &event );
workspace->x11Event( &event );
}
qDebug("Composite Manager stopped.");
delete workspace;
XCloseDisplay (dpy);
}
gboolean
_cogl_xlib_renderer_connect (CoglRenderer *renderer, GError **error)
{
CoglXlibRenderer *xlib_renderer =
_cogl_xlib_renderer_get_data (renderer);
CoglX11Renderer *x11_renderer =
(CoglX11Renderer *) xlib_renderer;
int damage_error;
if (!assert_xlib_display (renderer, error))
return FALSE;
if (getenv ("COGL_X11_SYNC"))
XSynchronize (xlib_renderer->xdpy, TRUE);
/* Check whether damage events are supported on this display */
if (!XDamageQueryExtension (xlib_renderer->xdpy,
&x11_renderer->damage_base,
&damage_error))
x11_renderer->damage_base = -1;
xlib_renderer->trap_state = NULL;
xlib_renderer->poll_fd.fd = ConnectionNumber (xlib_renderer->xdpy);
xlib_renderer->poll_fd.events = COGL_POLL_FD_EVENT_IN;
register_xlib_renderer (renderer);
return TRUE;
}
gboolean
_cogl_xlib_renderer_connect (CoglRenderer *renderer, CoglError **error)
{
CoglXlibRenderer *xlib_renderer =
_cogl_xlib_renderer_get_data (renderer);
CoglX11Renderer *x11_renderer =
(CoglX11Renderer *) xlib_renderer;
int damage_error;
int randr_error;
if (!assert_xlib_display (renderer, error))
return FALSE;
if (getenv ("COGL_X11_SYNC"))
XSynchronize (xlib_renderer->xdpy, TRUE);
/* Check whether damage events are supported on this display */
if (!XDamageQueryExtension (xlib_renderer->xdpy,
&x11_renderer->damage_base,
&damage_error))
x11_renderer->damage_base = -1;
/* Check whether randr is supported on this display */
if (!XRRQueryExtension (xlib_renderer->xdpy,
&x11_renderer->randr_base,
&randr_error))
x11_renderer->randr_base = -1;
xlib_renderer->trap_state = NULL;
if (renderer->xlib_enable_event_retrieval)
{
_cogl_poll_renderer_add_fd (renderer,
ConnectionNumber (xlib_renderer->xdpy),
COGL_POLL_FD_EVENT_IN,
prepare_xlib_events_timeout,
dispatch_xlib_events,
renderer);
}
XRRSelectInput(xlib_renderer->xdpy,
DefaultRootWindow (xlib_renderer->xdpy),
RRScreenChangeNotifyMask
| RRCrtcChangeNotifyMask
| RROutputPropertyNotifyMask);
update_outputs (renderer, FALSE);
register_xlib_renderer (renderer);
cogl_xlib_renderer_add_filter (renderer,
randr_filter,
renderer);
return TRUE;
}
void
_cogl_xlib_query_damage_extension (void)
{
int damage_error;
Display *display;
_COGL_GET_CONTEXT (ctxt, NO_RETVAL);
/* Check whether damage events are supported on this display */
display = cogl_xlib_renderer_get_display (ctxt->display->renderer);
if (!XDamageQueryExtension (display, &ctxt->damage_base, &damage_error))
ctxt->damage_base = -1;
}
void xf_xdamage_init(xfInfo* xfi)
{
int damage_event;
int damage_error;
int major, minor;
XGCValues values;
if (XDamageQueryExtension(xfi->display, &damage_event, &damage_error) == 0)
{
fprintf(stderr, "XDamageQueryExtension failed\n");
return;
}
XDamageQueryVersion(xfi->display, &major, &minor);
if (XDamageQueryVersion(xfi->display, &major, &minor) == 0)
{
fprintf(stderr, "XDamageQueryVersion failed\n");
return;
}
else if (major < 1)
{
fprintf(stderr, "XDamageQueryVersion failed: major:%d minor:%d\n", major, minor);
return;
}
xfi->xdamage_notify_event = damage_event + XDamageNotify;
xfi->xdamage = XDamageCreate(xfi->display, xfi->root_window, XDamageReportDeltaRectangles);
if (xfi->xdamage == None)
{
fprintf(stderr, "XDamageCreate failed\n");
return;
}
#ifdef WITH_XFIXES
xfi->xdamage_region = XFixesCreateRegion(xfi->display, NULL, 0);
if (xfi->xdamage_region == None)
{
fprintf(stderr, "XFixesCreateRegion failed\n");
XDamageDestroy(xfi->display, xfi->xdamage);
xfi->xdamage = None;
return;
}
#endif
values.subwindow_mode = IncludeInferiors;
xfi->xdamage_gc = XCreateGC(xfi->display, xfi->root_window, GCSubwindowMode, &values);
XSetFunction(xfi->display, xfi->xdamage_gc, GXcopy);
}
/* Connects to the X11 display, initializes extensions, register for events */
static int init_display(char* name) {
dpy = XOpenDisplay(name);
if (!dpy) {
error("Cannot open display.");
return -1;
}
/* We need XTest, XDamage and XFixes */
int event, error, major, minor;
if (!XTestQueryExtension(dpy, &event, &error, &major, &minor)) {
error("XTest not available!");
return -1;
}
if (!XDamageQueryExtension(dpy, &damageEvent, &error)) {
error("XDamage not available!");
return -1;
}
if (!XFixesQueryExtension(dpy, &fixesEvent, &error)) {
error("XFixes not available!");
return -1;
}
/* Get notified when new windows are created. */
Window root = DefaultRootWindow(dpy);
XSelectInput(dpy, root, SubstructureNotifyMask);
/* Register damage events for existing windows */
Window rootp, parent;
Window *children;
unsigned int i, nchildren;
XQueryTree(dpy, root, &rootp, &parent, &children, &nchildren);
/* FIXME: We never reset the handler, is that a good thing? */
XSetErrorHandler(xerror_handler);
register_damage(dpy, root);
for (i = 0; i < nchildren; i++) {
register_damage(dpy, children[i]);
}
XFree(children);
/* Register for cursor events */
XFixesSelectCursorInput(dpy, root, XFixesDisplayCursorNotifyMask);
return 0;
}
bool
_cg_xlib_renderer_connect(cg_renderer_t *renderer, cg_error_t **error)
{
cg_xlib_renderer_t *xlib_renderer = _cg_xlib_renderer_get_data(renderer);
cg_x11_renderer_t *x11_renderer = (cg_x11_renderer_t *)xlib_renderer;
int damage_error;
int randr_error;
if (!assert_xlib_display(renderer, error))
return false;
if (getenv("CG_X11_SYNC"))
XSynchronize(xlib_renderer->xdpy, true);
/* Check whether damage events are supported on this display */
if (!XDamageQueryExtension(
xlib_renderer->xdpy, &x11_renderer->damage_base, &damage_error))
x11_renderer->damage_base = -1;
/* Check whether randr is supported on this display */
if (!XRRQueryExtension(
xlib_renderer->xdpy, &x11_renderer->randr_base, &randr_error))
x11_renderer->randr_base = -1;
xlib_renderer->trap_state = NULL;
if (renderer->xlib_enable_event_retrieval) {
_cg_loop_add_fd(renderer,
ConnectionNumber(xlib_renderer->xdpy),
CG_POLL_FD_EVENT_IN,
prepare_xlib_events_timeout,
dispatch_xlib_events,
renderer);
}
XRRSelectInput(xlib_renderer->xdpy,
DefaultRootWindow(xlib_renderer->xdpy),
RRScreenChangeNotifyMask | RRCrtcChangeNotifyMask |
RROutputPropertyNotifyMask);
update_outputs(renderer, false);
register_xlib_renderer(renderer);
cg_xlib_renderer_add_filter(renderer, randr_filter, renderer);
return true;
}
static gboolean
ccm_display_init_damage (CCMDisplay * self)
{
g_return_val_if_fail (self != NULL, FALSE);
if (XDamageQueryExtension (self->priv->xdisplay,
&self->priv->damage.event_base,
&self->priv->damage.error_base))
{
self->priv->damage.available = TRUE;
ccm_debug ("DAMAGE EVENT BASE: %i", self->priv->damage.event_base);
ccm_debug ("DAMAGE ERROR BASE: %i", self->priv->damage.error_base);
return TRUE;
}
return FALSE;
}
void rmdQueryExtensions(Display *dpy,
ProgArgs *args,
int *damage_event,
int *damage_error,
int *shm_opcode) {
int xf_event_basep,
xf_error_basep,
shm_event_base,
shm_error_base,
shape_event_base,
shape_error_base;
if((!(args->full_shots))&&(!XDamageQueryExtension( dpy, damage_event, damage_error))) {
fprintf(stderr,"XDamage extension not found!!!\n"
"Try again using the --full-shots option, though\n"
"enabling XDamage is highly recommended,\n"
"for performance reasons.\n");
exit(4);
}
if((!args->noshared)&&(!XQueryExtension(dpy,
"MIT-SHM",
shm_opcode,
&shm_event_base,
&shm_error_base))) {
args->noshared=1;
fprintf(stderr,"Shared Memory extension not present!\n"
"Try again using the --no-shared option\n");
exit(5);
}
if((args->xfixes_cursor)&&
(XFixesQueryExtension(dpy,&xf_event_basep,&xf_error_basep)==False)) {
args->xfixes_cursor=0;
fprintf(stderr,"Xfixes extension not present!\n"
"Please run with the -dummy-cursor or"
" --no-cursor option.\n");
exit(6);
}
if((!args->noframe)&&
(!XShapeQueryExtension(dpy,&shape_event_base,&shape_error_base))) {
fprintf(stderr,"XShape Not Found!!!\n"
"Frame won't be available.\n");
args->noframe=1;
}
}
void check_features(void) {
int event_base, error_base, glxver;
int major = 0, minor = 3;
if(!XCompositeQueryExtension(dpy, &event_base, &error_base))
die(1, "Composite extension not available\n");
if(!XCompositeQueryVersion(dpy, &major, &minor))
die(1, "Composite extension version >=0.3 is required\n");
if(!XShapeQueryExtension(dpy, &event_base, &error_base))
die(1, "Shape extension not available\n");
if(!XDamageQueryExtension(dpy, &event_base, &error_base))
die(1, "Damage extension not available\n");
if(!glXQueryExtension(dpy, &event_base, &error_base))
die(1, "GLX extension not available\n");
glXQueryVersion(dpy, &major, &minor);
glxver = MAKE_GL_VERSION(major, minor, 0);
if(glxver < 0x010300) // GLX 1.3 required
die(1, "GLX version >=1.3 is required\n");
info("All features supported\n");
}
static gboolean
byzanz_recorder_prepare (ByzanzRecorder *recorder)
{
GdkDisplay *display;
Display *dpy;
display = gdk_display_get_default ();
dpy = gdk_x11_display_get_xdisplay (display);
if (!XDamageQueryExtension (dpy, &recorder->damage_event_base, &recorder->damage_error_base) ||
!XFixesQueryExtension (dpy, &recorder->fixes_event_base, &recorder->fixes_error_base))
return FALSE;
gdk_x11_register_standard_event_type (display,
recorder->damage_event_base + XDamageNotify, 1);
gdk_x11_register_standard_event_type (display,
recorder->fixes_event_base + XFixesCursorNotify, 1);
return TRUE;
}
FdoSelectionManagerPrivate(FdoSelectionManager *q)
: q(q),
notificationsEngine(0),
haveComposite(false)
{
display = QX11Info::display();
selectionAtom = XInternAtom(display, "_NET_SYSTEM_TRAY_S" + QByteArray::number(QX11Info::appScreen()), false);
opcodeAtom = XInternAtom(display, "_NET_SYSTEM_TRAY_OPCODE", false);
messageAtom = XInternAtom(display, "_NET_SYSTEM_TRAY_MESSAGE_DATA", false);
visualAtom = XInternAtom(display, "_NET_SYSTEM_TRAY_VISUAL", false);
#if defined(HAVE_XFIXES) && defined(HAVE_XDAMAGE) && defined(HAVE_XCOMPOSITE)
int eventBase, errorBase;
bool haveXfixes = XFixesQueryExtension(display, &eventBase, &errorBase);
bool haveXdamage = XDamageQueryExtension(display, &damageEventBase, &errorBase);
bool haveXComposite = XCompositeQueryExtension(display, &eventBase, &errorBase);
if (haveXfixes && haveXdamage && haveXComposite) {
haveComposite = true;
oldEventFilter = QCoreApplication::instance()->setEventFilter(x11EventFilter);
}
#endif
}
static gboolean
check_extensions (ClutterX11TexturePixmap *texture)
{
int damage_error;
ClutterX11TexturePixmapPrivate *priv;
Display *dpy;
priv = texture->priv;
if (_damage_event_base)
return TRUE;
dpy = clutter_x11_get_default_display();
if (!XDamageQueryExtension (dpy,
&_damage_event_base, &damage_error))
{
g_warning ("No Damage extension");
return FALSE;
}
return TRUE;
}
static int x11_shadow_xdamage_init(x11ShadowSubsystem* subsystem)
{
#ifdef WITH_XDAMAGE
int major, minor;
int damage_event;
int damage_error;
if (!subsystem->use_xfixes)
return -1;
if (!XDamageQueryExtension(subsystem->display, &damage_event, &damage_error))
return -1;
if (!XDamageQueryVersion(subsystem->display, &major, &minor))
return -1;
if (major < 1)
return -1;
subsystem->xdamage_notify_event = damage_event + XDamageNotify;
subsystem->xdamage = XDamageCreate(subsystem->display, subsystem->root_window, XDamageReportDeltaRectangles);
if (!subsystem->xdamage)
return -1;
#ifdef WITH_XFIXES
subsystem->xdamage_region = XFixesCreateRegion(subsystem->display, NULL, 0);
if (!subsystem->xdamage_region)
return -1;
#endif
return 1;
#else
return -1;
#endif
}
nsresult nsPluginNativeWindowGtk2::CreateXCompositedWindow() {
NS_ASSERTION(!mSocketWidget,"Already created a socket widget!");
mParentWindow = gtk_window_new(GTK_WINDOW_POPUP);
mSocketWidget = gtk_socket_new();
GdkWindow *parent_win = mParentWindow->window;
//attach the socket to the container widget
gtk_widget_set_parent_window(mSocketWidget, parent_win);
// Make sure to handle the plug_removed signal. If we don't the
// socket will automatically be destroyed when the plug is
// removed, which means we're destroying it more than once.
// SYNTAX ERROR.
g_signal_connect(mSocketWidget, "plug_removed",
G_CALLBACK(plug_removed_cb), NULL);
g_signal_connect(mSocketWidget, "destroy",
G_CALLBACK(gtk_widget_destroyed), &mSocketWidget);
/*gpointer user_data = NULL;
gdk_window_get_user_data(parent_win, &user_data);
*/
GtkContainer *container = GTK_CONTAINER(mParentWindow);
gtk_container_add(container, mSocketWidget);
gtk_widget_realize(mSocketWidget);
// Resize before we show
SetAllocation();
gtk_widget_set_size_request (mSocketWidget, width, height);
/* move offscreen */
gtk_window_move (GTK_WINDOW(mParentWindow), width+1000, height+1000);
gtk_widget_show(mSocketWidget);
gtk_widget_show_all(mParentWindow);
/* store away a reference to the socketwidget */
mPlugWindow = (mSocketWidget);
gdk_flush();
window = (nsPluginPort *)gtk_socket_get_id(GTK_SOCKET(mSocketWidget));
/* This is useful if we still have the plugin window inline
* i.e. firefox vs. fennec */
// gdk_window_set_composited(mSocketWidget->window, TRUE);
if (!mDamage) {
/* we install a general handler instead of one specific to a particular window
* because we don't have a GdkWindow for the plugin window */
gdk_window_add_filter (parent_win, plugin_composite_filter_func, this);
int junk;
if (!XDamageQueryExtension (GDK_DISPLAY (), &xdamage_event_base, &junk))
printf ("This requires the XDamage extension");
mDamage = XDamageCreate(GDK_DISPLAY(), (Drawable)window, XDamageReportNonEmpty);
XCompositeRedirectWindow (GDK_DISPLAY(),
(Drawable)window,
CompositeRedirectManual);
/* this is a hack to avoid having flash causing a crash when it is unloaded.
* libplayback sets up dbus_connection_filters. When flash is unloaded it takes
* libplayback with it, however the connection filters are not removed
* which causes a crash when dbus tries to execute them. dlopening libplayback
* ensures that those functions stay around even after flash is gone. */
static void *libplayback_handle;
if (!libplayback_handle) {
libplayback_handle = dlopen("libplayback-1.so.0", RTLD_NOW);
}
}
// Fill out the ws_info structure.
// (The windowless case is done in nsObjectFrame.cpp.)
GdkWindow *gdkWindow = gdk_window_lookup((XID)window);
mWsInfo.display = GDK_WINDOW_XDISPLAY(gdkWindow);
mWsInfo.colormap = GDK_COLORMAP_XCOLORMAP(gdk_drawable_get_colormap(gdkWindow));
GdkVisual* gdkVisual = gdk_drawable_get_visual(gdkWindow);
mWsInfo.visual = GDK_VISUAL_XVISUAL(gdkVisual);
mWsInfo.depth = gdkVisual->depth;
return NS_OK;
}
MDeclarativeStatusBar::MDeclarativeStatusBar(QDeclarativeItem *parent) :
QDeclarativeItem(parent),
updatesEnabled(true),
mousePressed(false),
feedbackDelay(false),
swipeGesture(false),
sharedPixmapHandle(0),
pixmapDamage(0),
mOrientation(MDeclarativeScreen::Portrait),
#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
updateSharedTexture(false),
#endif
feedbackPlayer(new FeedbackPlayer(this))
{
setFlag(QGraphicsItem::ItemHasNoContents, false);
setAcceptedMouseButtons(Qt::LeftButton);
// higher than TitleBar
setZValue(1010);
setImplicitHeight(STATUSBAR_HEIGHT);
if (!filterRegistered) {
#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
::oldEventFilter = QCoreApplication::instance()->setEventFilter(x11EventFilter);
#else
qApp->installNativeEventFilter(this);
#endif
#ifdef HAVE_XDAMAGE
MDeclarativeScreen* screen = MDeclarativeScreen::instance();
XDamageQueryExtension(screen->display(), &xDamageEventBase, &xDamageErrorBase);
#endif
filterRegistered = true;
}
#ifdef HAVE_DBUS
if (QDBusConnection::sessionBus().interface()->isServiceRegistered(PIXMAP_PROVIDER_DBUS_SERVICE))
isPixmapProviderOnline = true;
else
#endif
isPixmapProviderOnline = false;
#ifdef HAVE_DBUS
dbusWatcher = new QDBusServiceWatcher( PIXMAP_PROVIDER_DBUS_SERVICE , QDBusConnection::sessionBus(),
QDBusServiceWatcher::WatchForRegistration|QDBusServiceWatcher::WatchForUnregistration,
this );
connect(dbusWatcher, SIGNAL(serviceRegistered(QString)),
this, SLOT(handlePixmapProviderOnline()));
connect(dbusWatcher, SIGNAL(serviceUnregistered(QString)),
this, SLOT(handlePixmapProviderOffline()));
#endif
querySharedPixmapFromProvider();
// XDamage event should come only when application is in foreground
#if defined USE_ABSTRACTION
QmlWindowState * windowState = QmlWindowState::instance();
#else
MWindowState * windowState = MWindowState::instance();
#endif
connect(windowState, SIGNAL(activeChanged()), this, SLOT(updateXdamageEventSubscription()));
connect(this, SIGNAL(visibleChanged()), this, SLOT(updateXdamageEventSubscription()));
if (!feedbackPlayer->init("qt-components")) {
delete feedbackPlayer;
feedbackPlayer = 0;
}
}
Bool
addDisplay (char *name,
char **plugin,
int nPlugin)
{
CompDisplay *d;
Display *dpy;
int i;
d = &compDisplay;
if (displayPrivateLen)
{
d->privates = malloc (displayPrivateLen * sizeof (CompPrivate));
if (!d->privates)
return FALSE;
}
else
d->privates = 0;
d->screenPrivateIndices = 0;
d->screenPrivateLen = 0;
for (i = 0; i < CompModNum; i++)
d->modMask[i] = CompNoMask;
d->plugin.list.type = CompOptionTypeString;
d->plugin.list.nValue = 0;
d->plugin.list.value = 0;
compDisplayInitOptions (d, plugin, nPlugin);
d->textureFilter = GL_LINEAR;
d->display = dpy = XOpenDisplay (name);
if (!d->display)
{
fprintf (stderr, "%s: Couldn't open display %s\n",
programName, XDisplayName (name));
return FALSE;
}
#ifdef DEBUG
XSynchronize (dpy, TRUE);
#endif
XSetErrorHandler (errorHandler);
updateModifierMappings (d);
d->setDisplayOption = setDisplayOption;
d->setDisplayOptionForPlugin = setDisplayOptionForPlugin;
d->initPluginForDisplay = initPluginForDisplay;
d->finiPluginForDisplay = finiPluginForDisplay;
d->handleEvent = handleEvent;
d->winTypeAtom = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE", 0);
d->winDesktopAtom = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_DESKTOP", 0);
d->winDockAtom = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_DOCK", 0);
d->winToolbarAtom = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_TOOLBAR", 0);
d->winMenuAtom = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_MENU", 0);
d->winUtilAtom = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_UTILITY", 0);
d->winSplashAtom = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_SPLASH", 0);
d->winDialogAtom = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_DIALOG", 0);
d->winNormalAtom = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_NORMAL", 0);
d->winOpacityAtom = XInternAtom (dpy, "_NET_WM_WINDOW_OPACITY", 0);
d->winActiveAtom = XInternAtom (dpy, "_NET_ACTIVE_WINDOW", 0);
d->wmStateAtom = XInternAtom (dpy, "WM_STATE", 0);
d->wmDeleteWindowAtom = XInternAtom (dpy, "WM_DELETE_WINDOW", 0);
d->xBackgroundAtom[0] = XInternAtom (dpy, "_XSETROOT_ID", 0);
d->xBackgroundAtom[1] = XInternAtom (dpy, "_XROOTPMAP_ID", 0);
if (testMode)
{
d->compositeOpcode = MAXSHORT;
d->compositeEvent = MAXSHORT;
d->compositeError = MAXSHORT;
d->damageEvent = MAXSHORT;
d->damageError = MAXSHORT;
}
else
{
int compositeMajor, compositeMinor;
if (!XQueryExtension (dpy,
COMPOSITE_NAME,
&d->compositeOpcode,
&d->compositeEvent,
&d->compositeError))
{
fprintf (stderr, "%s: No composite extension\n", programName);
return FALSE;
}
XCompositeQueryVersion (dpy, &compositeMajor, &compositeMinor);
if (compositeMajor == 0 && compositeMinor < 2)
{
fprintf (stderr, "%s: Old composite extension\n", programName);
return FALSE;
}
if (!XDamageQueryExtension (dpy, &d->damageEvent, &d->damageError))
{
fprintf (stderr, "%s: No damage extension\n", programName);
return FALSE;
}
}
d->shapeExtension = XShapeQueryExtension (dpy,
&d->shapeEvent,
&d->shapeError);
compDisplays = d;
if (testMode)
{
addScreen (d, 0);
}
else
{
XGrabServer (dpy);
for (i = 0; i < ScreenCount (dpy); i++)
{
redirectFailed = 0;
XCompositeRedirectSubwindows (dpy, XRootWindow (dpy, i),
CompositeRedirectManual);
XSync (dpy, FALSE);
if (redirectFailed)
{
fprintf (stderr, "%s: Another composite manager is already "
"running on screen: %d\n", programName, i);
}
else
{
if (!addScreen (d, i))
{
fprintf (stderr, "%s: Failed to manage screen: %d\n",
programName, i);
}
}
}
XUngrabServer (dpy);
}
if (!d->screens)
{
fprintf (stderr, "%s: No managable screens found on display %s\n",
programName, XDisplayName (name));
return FALSE;
}
return TRUE;
}
/* The main function */
int main(int argc, char const *argv[])
{
Display *dpy;
GString *line;
unsigned xeventmask;
int error_base, shape_event, damage_event;
struct
{
Bool children, creation, mapping, configure, shape;
Bool properties, clientmsg;
Bool visibility, exposure, damages;
Bool pointer, keyboard;
} track;
dpy = XOpenDisplay(NULL);
XSetErrorHandler(xerror_handler);
XA_utf8_string = XInternAtom(dpy, "UTF8_STRING", False);
XA_wm_state = XInternAtom(dpy, "WM_STATE", False);
if (argv[1] && !strcmp(argv[1], "-t"))
{
Opt_timestamp = 1;
optind++;
}
/* Choose which events we're interested in. */
memset(&track, 0, sizeof(track));
track.children = True;
track.creation = True;
track.mapping = True;
track.configure = True;
track.shape = True;
track.properties = True;
track.clientmsg = True;
track.visibility = True;
track.keyboard = True;
for (; argv[optind]; optind++)
{
char const *opt;
Bool add, del, *which;
opt = argv[optind];
add = opt[0] == '+';
del = opt[0] == '-';
if (add || del)
opt++;
if (!strcmp(opt, "children"))
which = &track.children;
else if (!strcmp(opt, "create"))
which = &track.creation;
else if (!strcmp(opt, "map"))
which = &track.mapping;
else if (!strcmp(opt, "config"))
which = &track.configure;
else if (!strcmp(opt, "shape"))
which = &track.shape;
else if (!strcmp(opt, "prop"))
which = &track.properties;
else if (!strcmp(opt, "ipc"))
which = &track.clientmsg;
else if (!strcmp(opt, "visibility"))
which = &track.visibility;
else if (!strcmp(opt, "expose"))
which = &track.exposure;
else if (!strcmp(opt, "damage"))
which = &track.damages;
else if (!strcmp(opt, "ptr"))
which = &track.pointer;
else if (!strcmp(opt, "kbd"))
which = &track.keyboard;
else
break;
if (!add && !del)
memset(&track, 0, sizeof(track));
*which = !del;
} /* for */
xeventmask = 0;
if (track.creation || track.mapping || track.configure
|| track.clientmsg)
xeventmask |= track.children
? SubstructureNotifyMask
: StructureNotifyMask;
if (track.shape)
XShapeQueryExtension(dpy, &shape_event, &error_base);
if (track.properties)
xeventmask |= PropertyChangeMask;
if (track.visibility)
xeventmask |= VisibilityChangeMask;
if (track.exposure)
xeventmask |= ExposureMask;
if (track.damages)
XDamageQueryExtension(dpy, &damage_event, &error_base);
if (track.pointer);
xeventmask |= EnterWindowMask|LeaveWindowMask;
if (track.keyboard)
xeventmask |= KeyPressMask|KeyReleaseMask;
/* XSelectInput() the windows we're interested in
* or the root window. */
if (argv[optind])
do
{
Window win;
char const *errp;
win = strtoul(argv[optind], (char **)&errp, 0);
if (errp == argv[optind] || *errp)
{
fprintf(stderr, "%s: what is `%s'?\n",
argv[0], argv[optind]);
exit(1);
}
XSelectInput(dpy, win, xeventmask);
if (track.shape)
XShapeSelectInput(dpy, win, ShapeNotifyMask);
if (track.damages)
XDamageCreate(dpy, win,
XDamageReportRawRectangles);
} while (argv[++optind]);
else
XSelectInput(dpy, DefaultRootWindow(dpy), xeventmask);
/* The main loop */
line = g_string_new("");
for (;;)
{
XEvent ev;
/* Wait for, get and process the next event. */
XNextEvent(dpy, &ev);
if (ev.type == CreateNotify)
{
XCreateWindowEvent const *create = &ev.xcreatewindow;
if (!track.creation)
continue;
fmtxid(line, create->parent);
g_string_append_printf(line,
"Create(0x%lx)", create->window);
output(line, ev.xany.send_event);
} else if (ev.type == DestroyNotify)
{
XDestroyWindowEvent const *destroy = &ev.xdestroywindow;
if (!track.creation)
continue;
fmtxid(line, destroy->event);
g_string_append_printf(line,
"Destroy(0x%lx)", destroy->window);
output(line, ev.xany.send_event);
} else if (ev.type == MapNotify)
{
XMapEvent const *map = &ev.xmap;
if (!track.mapping)
continue;
fmtxid(line, map->event);
g_string_append_printf(line, "Map(0x%lx%s)",
map->window, map->override_redirect
? ", override_redirected" : "");
output(line, ev.xany.send_event);
} else if (ev.type == UnmapNotify)
{
XUnmapEvent const *unmap = &ev.xunmap;
if (!track.mapping)
continue;
fmtxid(line, unmap->event);
g_string_append_printf(line, "Unmap(0x%lx%s)",
unmap->window, unmap->from_configure
? ", from_configure" : "");
output(line, ev.xany.send_event);
} else if (ev.type == ReparentNotify)
{
XReparentEvent const *reparent = &ev.xreparent;
if (!track.configure)
continue;
fmtxid(line, reparent->event);
g_string_append_printf(line,
"Reparent(0x%lx => 0x%lx)",
reparent->window, reparent->parent);
output(line, ev.xany.send_event);
} else if (ev.type == ConfigureNotify)
{
XConfigureEvent const *cfg = &ev.xconfigure;
if (!track.configure)
continue;
fmtxid(line, cfg->event);
g_string_append_printf(line,
"Configure(0x%lx => %dx%d%+d%+d, "
"above=0x%lx%s)", cfg->window,
cfg->width, cfg->height, cfg->x, cfg->y,
cfg->above, cfg->override_redirect
? ", override_redirected" : "");
output(line, ev.xany.send_event);
} else if (track.shape && ev.type == shape_event + ShapeNotify)
{
static char const *shapes[] =
{ "Bounding", "Clip", "Input" };
XShapeEvent sev;
memcpy(&sev, &ev, sizeof(sev));
fmtxid(line, sev.window);
g_string_append_printf(line,
"Shape(%s => %dx%d%+d%+d)",
shapes[sev.kind],
sev.width, sev.height, sev.x, sev.y);
output(line, ev.xany.send_event);
} else if (ev.type == PropertyNotify)
{
assert(track.properties);
property_event(dpy, &ev.xproperty, line);
} else if (ev.type == ClientMessage)
{
if (!track.clientmsg)
continue;
client_message(dpy, &ev.xclient, line);
} else if (ev.type == VisibilityNotify)
{
static char const *visibilities[] =
{
"unobscured",
"partially obscured",
"fully obscured",
};
XVisibilityEvent const *vis = &ev.xvisibility;
assert(track.visibility);
fmtxid(line, vis->window);
g_string_append_printf(line, "Visibility=%s",
visibilities[vis->state]);
output(line, ev.xany.send_event);
} else if (ev.type == Expose)
{
XExposeEvent const *ex = &ev.xexpose;
assert(track.exposure);
fmtxid(line, ex->window);
g_string_append_printf(line,
"Expose(%dx%d%+d%+d)",
ex->width, ex->height,
ex->x, ex->y);
output(line, ev.xany.send_event);
} else if (track.damages && ev.type == damage_event)
{
XDamageNotifyEvent dev;
memcpy(&dev, &ev, sizeof(dev));
fmtxid(line, dev.drawable);
g_string_append_printf(line,
"Damage(%dx%d%+d%+d)",
dev.area.width, dev.area.height,
dev.area.x, dev.area.y);
output(line, ev.xany.send_event);
XDamageSubtract(dpy, dev.damage, None, None);
} else if (ev.type == EnterNotify || ev.type == LeaveNotify)
{
XCrossingEvent const *cross = &ev.xcrossing;
if (!track.pointer)
continue;
fmtxid(line, cross->window);
g_string_append_printf(line,
"%s(%dx%d",
cross->type == EnterNotify
? "Enter" : "Leave",
cross->x, cross->y);
if (cross->mode == NotifyGrab)
g_string_append(line, ", grab");
else if (cross->mode == NotifyUngrab)
g_string_append(line, ", ungrab");
g_string_append_c(line, ')');
output(line, ev.xany.send_event);
} else if (ev.type == KeyPress || ev.type == KeyRelease)
{
static struct { int mask; char const *name; } states[] =
{
{ ShiftMask, "Shift" },
{ LockMask, "Lock" },
{ ControlMask, "Ctrl" },
{ Mod1Mask, "Mod1" },
{ Mod2Mask, "Mod2" },
{ Mod3Mask, "Mod3" },
{ Mod4Mask, "Mod4" },
{ Mod5Mask, "Mod5" },
};
unsigned i;
int has_modifiers;
XKeyEvent const *key;
assert(track.keyboard);
key = &ev.xkey;
fmtxid(line, key->window);
/* Prepend with the list of modifiers. */
has_modifiers = 0;
for (i = 0; i < G_N_ELEMENTS(states); i++)
if (key->state & states[i].mask)
{
if (!has_modifiers)
{
g_string_append_c(line, ' ');
has_modifiers = 1;
} else
g_string_append_c(line, '-');
g_string_append(line, states[i].name);
}
if (has_modifiers)
g_string_append_c(line, '-');
g_string_append_printf(line, "%s %s",
XKeysymToString(XKeycodeToKeysym(dpy,
key->keycode, 0)),
ev.type == KeyPress
? "pressed" : "released");
output(line, ev.xany.send_event);
} /* if */
} /* for ever */
return 0;
} /* main */
bool BackendInitialize(const char * display_name)
{
Display * dpy = XOpenDisplay(display_name);
if (!dpy)
{
fprintf (stderr, "%s: unable to open display '%s'\n",
g_program_name, XDisplayName (display_name));
usage();
return false;
}
Window root = DefaultRootWindow(dpy);
int damage_error, damage;
if (!XDamageQueryExtension (dpy, &damage, &damage_error))
{
fprintf (stderr, "%s: Backend does not have damage extension\n", g_program_name);
return false;
}
#ifndef USE_PANELS
XDamageCreate (dpy, root, XDamageReportRawRectangles);
#endif
XWindowAttributes attrib;
XGetWindowAttributes(dpy, root, &attrib);
if (attrib.width ==0 || attrib.height == 0)
{
fprintf(stderr, "%s: Bad root with %d x %d\n",
g_program_name, attrib.width, attrib.height);
return false;
}
#ifndef USE_PANELS
GLuint texture;
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, attrib.width, attrib.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
#endif
int buffer_size = attrib.width * attrib.height * 4;
unsigned char * buffer = (unsigned char *)malloc(buffer_size);
if (!buffer)
{
fprintf(stderr, "%s: Failed to allocate buffer %d x %d\n",
g_program_name, attrib.width, attrib.height);
return false;
}
uint32_t mask = ~dpy->resource_mask;
uint32_t shift = 0;
while (!(mask & 1))
{
shift++;
mask >>= 1;
}
g_backend._dpy = dpy;
g_backend._root = root;
g_backend._damage = damage;
g_backend._width = attrib.width;
g_backend._height = attrib.height;
#ifndef USE_PANELS
g_backend._texture = texture;
#endif
g_backend._mouse_x = attrib.width/2;
g_backend._mouse_y = attrib.height/2;
g_backend._buffer_size = buffer_size;
g_backend._buffer = buffer;
g_backend._mask = ~dpy->resource_mask;
g_backend._shift = shift;
#ifndef USE_PANELS
BackendUpdateTexture(root, texture, 0, 0, attrib.width, attrib.height);
#endif
return true;
}
void Extensions::init()
{
int event_base, error_base;
data_nextensions = 0;
shape_version = 0;
if( XShapeQueryExtension( display(), &shape_event_base, &error_base ))
{
int major, minor;
if( XShapeQueryVersion( display(), &major, &minor ))
{
shape_version = major * 0x10 + minor;
addData( "SHAPE" );
}
}
#ifdef HAVE_XRANDR
has_randr = XRRQueryExtension( display(), &randr_event_base, &error_base );
if( has_randr )
{
int major, minor;
XRRQueryVersion( display(), &major, &minor );
has_randr = ( major > 1 || ( major == 1 && minor >= 1 ) );
addData( "RANDR" );
}
#else
has_randr = false;
#endif
#ifdef HAVE_XDAMAGE
has_damage = XDamageQueryExtension( display(), &damage_event_base, &error_base );
if( has_damage )
addData( "DAMAGE" );
#else
has_damage = false;
#endif
composite_version = 0;
#ifdef HAVE_XCOMPOSITE
if( XCompositeQueryExtension( display(), &event_base, &error_base ))
{
int major = 0, minor = 0;
XCompositeQueryVersion( display(), &major, &minor );
composite_version = major * 0x10 + minor;
addData( "Composite" );
}
#endif
fixes_version = 0;
#ifdef HAVE_XFIXES
if( XFixesQueryExtension( display(), &event_base, &error_base ))
{
int major = 0, minor = 0;
XFixesQueryVersion( display(), &major, &minor );
fixes_version = major * 0x10 + minor;
addData( "XFIXES" );
}
#endif
render_version = 0;
#ifdef HAVE_XRENDER
if( XRenderQueryExtension( display(), &event_base, &error_base ))
{
int major = 0, minor = 0;
XRenderQueryVersion( display(), &major, &minor );
render_version = major * 0x10 + minor;
addData( "RENDER" );
}
#endif
has_glx = false;
#ifdef HAVE_OPENGL
has_glx = glXQueryExtension( display(), &event_base, &error_base );
if( has_glx )
addData( "GLX" );
#endif
#ifdef HAVE_XSYNC
if( XSyncQueryExtension( display(), &sync_event_base, &error_base ))
{
int major = 0, minor = 0;
if( XSyncInitialize( display(), &major, &minor ))
{
has_sync = true;
addData( "SYNC" );
}
}
#endif
kDebug( 1212 ) << "Extensions: shape: 0x" << QString::number( shape_version, 16 )
<< " composite: 0x" << QString::number( composite_version, 16 )
<< " render: 0x" << QString::number( render_version, 16 )
<< " fixes: 0x" << QString::number( fixes_version, 16 ) << endl;
}
