From d8072be54dbf665834107100eb887f2a09872222 Mon Sep 17 00:00:00 2001 From: Arthur Arlt Date: Wed, 6 Jul 2011 11:58:23 +0200 Subject: [PATCH] Move OverlayWindow from Workspace to its own class All the functionality of Overlay Window is moved to its own class OverlayWindow. It is created and owned by class Scene, since almost all function calls are called from this class. REVIEW: 101866 --- CMakeLists.txt | 3 +- composite.cpp | 97 ++-------------------------- events.cpp | 11 ++-- overlaywindow.cpp | 146 +++++++++++++++++++++++++++++++++++++++++++ overlaywindow.h | 53 ++++++++++++++++ scene.cpp | 8 +++ scene.h | 3 + scene_opengl.cpp | 1 + scene_opengl_egl.cpp | 16 ++--- scene_opengl_glx.cpp | 16 ++--- scene_xrender.cpp | 17 ++--- workspace.cpp | 6 +- workspace.h | 19 ------ 13 files changed, 251 insertions(+), 145 deletions(-) create mode 100644 overlaywindow.cpp create mode 100644 overlaywindow.h diff --git a/CMakeLists.txt b/CMakeLists.txt index a37fbd8c51..18a69b2e0e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -118,7 +118,8 @@ set(kwin_KDEINIT_SRCS group.cpp bridge.cpp manage.cpp - notifications.cpp + notifications.cpp + overlaywindow.cpp activation.cpp useractions.cpp geometry.cpp diff --git a/composite.cpp b/composite.cpp index 8c87984874..513faaf5c9 100644 --- a/composite.cpp +++ b/composite.cpp @@ -47,6 +47,7 @@ along with this program. If not, see . #include "unmanaged.h" #include "deleted.h" #include "effects.h" +#include "overlaywindow.h" #include "scene.h" #include "scene_basic.h" #include "scene_xrender.h" @@ -379,7 +380,7 @@ void Workspace::performCompositing() { #ifdef KWIN_HAVE_COMPOSITING if (((repaints_region.isEmpty() && !windowRepaintsPending()) // no damage - || !overlay_visible)) { // nothing is visible anyway + || !scene->overlayWindow()->isVisible())) { // nothing is visible anyway vBlankPadding += 3; scene->idle(); // Note: It would seem here we should undo suspended unredirect, but when scenes need @@ -492,94 +493,6 @@ void Workspace::stopMousePolling() mousePollingTimer.stop(); } -bool Workspace::createOverlay() -{ - assert(overlay == None); - if (!Extensions::compositeOverlayAvailable()) - return false; - if (!Extensions::shapeInputAvailable()) // needed in setupOverlay() - return false; -#ifdef HAVE_XCOMPOSITE_OVERLAY - overlay = XCompositeGetOverlayWindow(display(), rootWindow()); - if (overlay == None) - return false; - XResizeWindow(display(), overlay, displayWidth(), displayHeight()); - return true; -#else - return false; -#endif -} - -void Workspace::setupOverlay(Window w) -{ - assert(overlay != None); - assert(Extensions::shapeInputAvailable()); - XSetWindowBackgroundPixmap(display(), overlay, None); - overlay_shape = QRegion(); - setOverlayShape(QRect(0, 0, displayWidth(), displayHeight())); - if (w != None) { - XSetWindowBackgroundPixmap(display(), w, None); - XShapeCombineRectangles(display(), w, ShapeInput, 0, 0, NULL, 0, ShapeSet, Unsorted); - } - XSelectInput(display(), overlay, VisibilityChangeMask); -} - -void Workspace::showOverlay() -{ - assert(overlay != None); - if (overlay_shown) - return; - XMapSubwindows(display(), overlay); - XMapWindow(display(), overlay); - overlay_shown = true; -} - -void Workspace::hideOverlay() -{ - assert(overlay != None); - XUnmapWindow(display(), overlay); - overlay_shown = false; - setOverlayShape(QRect(0, 0, displayWidth(), displayHeight())); -} - -void Workspace::setOverlayShape(const QRegion& reg) -{ - // Avoid setting the same shape again, it causes flicker (apparently it is not a no-op - // and triggers something). - if (reg == overlay_shape) - return; - QVector< QRect > rects = reg.rects(); - XRectangle* xrects = new XRectangle[ rects.count()]; - for (int i = 0; - i < rects.count(); - ++i) { - xrects[ i ].x = rects[ i ].x(); - xrects[ i ].y = rects[ i ].y(); - xrects[ i ].width = rects[ i ].width(); - xrects[ i ].height = rects[ i ].height(); - } - XShapeCombineRectangles(display(), overlay, ShapeBounding, 0, 0, - xrects, rects.count(), ShapeSet, Unsorted); - delete[] xrects; - XShapeCombineRectangles(display(), overlay, ShapeInput, 0, 0, NULL, 0, ShapeSet, Unsorted); - overlay_shape = reg; -} - -void Workspace::destroyOverlay() -{ - if (overlay == None) - return; - // reset the overlay shape - XRectangle rec = { 0, 0, displayWidth(), displayHeight() }; - XShapeCombineRectangles(display(), overlay, ShapeBounding, 0, 0, &rec, 1, ShapeSet, Unsorted); - XShapeCombineRectangles(display(), overlay, ShapeInput, 0, 0, &rec, 1, ShapeSet, Unsorted); -#ifdef HAVE_XCOMPOSITE_OVERLAY - XCompositeReleaseOverlayWindow(display(), overlay); -#endif - overlay = None; - overlay_shown = false; -} - bool Workspace::compositingActive() { return !m_finishingCompositing && compositing(); @@ -588,7 +501,7 @@ bool Workspace::compositingActive() // force is needed when the list of windows changes (e.g. a window goes away) void Workspace::checkUnredirect(bool force) { - if (!compositing() || overlay == None || !options->unredirectFullscreen) + if (!compositing() || scene->overlayWindow()->window() == None || !options->unredirectFullscreen) return; if (force) forceUnredirectCheck = true; @@ -598,7 +511,7 @@ void Workspace::checkUnredirect(bool force) void Workspace::delayedCheckUnredirect() { - if (!compositing() || overlay == None || !options->unredirectFullscreen) + if (!compositing() || scene->overlayWindow()->window() == None || !options->unredirectFullscreen) return; ToplevelList list; bool changed = forceUnredirectCheck; @@ -621,7 +534,7 @@ void Workspace::delayedCheckUnredirect() if (c->unredirected()) reg -= c->geometry(); } - setOverlayShape(reg); + scene->overlayWindow()->setShape(reg); } //**************************************** diff --git a/events.cpp b/events.cpp index 887047cad7..f523bf75e1 100644 --- a/events.cpp +++ b/events.cpp @@ -34,6 +34,7 @@ along with this program. If not, see . #include "tabbox.h" #endif #include "group.h" +#include "overlaywindow.h" #include "rules.h" #include "unmanaged.h" #include "effects.h" @@ -445,15 +446,15 @@ bool Workspace::workspaceEvent(XEvent * e) case Expose: if (compositing() && (e->xexpose.window == rootWindow() // root window needs repainting - || (overlay != None && e->xexpose.window == overlay))) { // overlay needs repainting + || (scene->overlayWindow()->window() != None && e->xexpose.window == scene->overlayWindow()->window()))) { // overlay needs repainting addRepaint(e->xexpose.x, e->xexpose.y, e->xexpose.width, e->xexpose.height); } break; case VisibilityNotify: - if (compositing() && overlay != None && e->xvisibility.window == overlay) { - bool was_visible = overlay_visible; - overlay_visible = (e->xvisibility.state != VisibilityFullyObscured); - if (!was_visible && overlay_visible) { + if (compositing() && scene->overlayWindow()->window() != None && e->xvisibility.window == scene->overlayWindow()->window()) { + bool was_visible = scene->overlayWindow()->isVisible(); + scene->overlayWindow()->setVisibility((e->xvisibility.state != VisibilityFullyObscured)); + if (!was_visible && scene->overlayWindow()->isVisible()) { // hack for #154825 addRepaintFull(); QTimer::singleShot(2000, this, SLOT(addRepaintFull())); diff --git a/overlaywindow.cpp b/overlaywindow.cpp new file mode 100644 index 0000000000..89fa65c74e --- /dev/null +++ b/overlaywindow.cpp @@ -0,0 +1,146 @@ +/******************************************************************** + KWin - the KDE window manager + This file is part of the KDE project. + +Copyright (C) 2011 Arthur Arlt + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program. If not, see . +*********************************************************************/ + +#include "overlaywindow.h" + +#include "kwinglobals.h" + +#include "assert.h" + +#include + +#include + +namespace KWin { +OverlayWindow::OverlayWindow() + : m_window(None) + , m_visible(true) + , m_shown(false) +{ +} + +OverlayWindow::~OverlayWindow() +{ +} + +bool OverlayWindow::create() +{ + assert(m_window == None); + if (!Extensions::compositeOverlayAvailable()) + return false; + if (!Extensions::shapeInputAvailable()) // needed in setupOverlay() + return false; +#ifdef HAVE_XCOMPOSITE_OVERLAY + m_overlay = XCompositeGetOverlayWindow(display(), rootWindow()); + if (m_overlay == None) + return false; + XResizeWindow(display(), m_overlay, displayWidth(), displayHeight()); + return true; +#else + return false; +#endif +} + +void OverlayWindow::setup(Window window) +{ + assert(m_window != None); + assert(Extensions::shapeInputAvailable()); + XSetWindowBackgroundPixmap(display(), m_window, None); + m_shape = QRegion(); + setShape(QRect(0, 0, displayWidth(), displayHeight())); + if (window != None) { + XSetWindowBackgroundPixmap(display(), window, None); + XShapeCombineRectangles(display(), window, ShapeInput, 0, 0, NULL, 0, ShapeSet, Unsorted); + } + XSelectInput(display(), m_window, VisibilityChangeMask); +} + +void OverlayWindow::show() +{ + assert(m_window != None); + if (m_shown) + return; + XMapSubwindows(display(), m_window); + XMapWindow(display(), m_window); + m_shown = true; +} + +void OverlayWindow::hide() +{ + assert(m_window != None); + XUnmapWindow(display(), m_window); + m_shown = false; + setShape(QRect(0, 0, displayWidth(), displayHeight())); +} + +void OverlayWindow::setShape(const QRegion& reg) +{ + // Avoid setting the same shape again, it causes flicker (apparently it is not a no-op + // and triggers something). + if (reg == m_shape) + return; + QVector< QRect > rects = reg.rects(); + XRectangle* xrects = new XRectangle[ rects.count()]; + for (int i = 0; + i < rects.count(); + ++i) { + xrects[ i ].x = rects[ i ].x(); + xrects[ i ].y = rects[ i ].y(); + xrects[ i ].width = rects[ i ].width(); + xrects[ i ].height = rects[ i ].height(); + } + XShapeCombineRectangles(display(), m_window, ShapeBounding, 0, 0, + xrects, rects.count(), ShapeSet, Unsorted); + delete[] xrects; + XShapeCombineRectangles(display(), m_window, ShapeInput, 0, 0, NULL, 0, ShapeSet, Unsorted); + m_shape = reg; +} + +bool OverlayWindow::isVisible() +{ + return m_visible; +} + +void OverlayWindow::setVisibility(bool visible) +{ + m_visible = visible; +} + +void OverlayWindow::destroy() +{ + if (m_window == None) + return; + // reset the overlay shape + XRectangle rec = { 0, 0, displayWidth(), displayHeight() }; + XShapeCombineRectangles(display(), m_window, ShapeBounding, 0, 0, &rec, 1, ShapeSet, Unsorted); + XShapeCombineRectangles(display(), m_window, ShapeInput, 0, 0, &rec, 1, ShapeSet, Unsorted); +#ifdef HAVE_XCOMPOSITE_OVERLAY + XCompositeReleaseOverlayWindow(display(), m_overlay); +#endif + m_window = None; + m_shown = false; +} + +Window OverlayWindow::window() +{ + return m_window; +} + +} // namespace KWin diff --git a/overlaywindow.h b/overlaywindow.h new file mode 100644 index 0000000000..02d3bc7e9b --- /dev/null +++ b/overlaywindow.h @@ -0,0 +1,53 @@ +/******************************************************************** + KWin - the KDE window manager + This file is part of the KDE project. + +Copyright (C) 2011 Arthur Arlt + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program. If not, see . +*********************************************************************/ + +#ifndef KWIN_OVERLAYWINDOW_H +#define KWIN_OVERLAYWINDOW_H + +#include + +#include + +namespace KWin { +class OverlayWindow { +public: + OverlayWindow(); + ~OverlayWindow(); + /// Creates XComposite overlay window, call initOverlay() afterwards + bool create(); + /// Init overlay and the destination window in it + void setup(Window window); + void show(); + void hide(); // hides and resets overlay window + void setShape(const QRegion& reg); + /// Destroys XComposite overlay window + void destroy(); + Window window(); + bool isVisible(); + void setVisibility(bool visible); +private: + bool m_visible; + bool m_shown; // For showOverlay() + QRegion m_shape; + Window m_window; +}; +} // namespace + +#endif //KWIN_OVERLAYWINDOW_H diff --git a/scene.cpp b/scene.cpp index 826ed1b724..6512302d10 100644 --- a/scene.cpp +++ b/scene.cpp @@ -77,6 +77,7 @@ along with this program. If not, see . #include "deleted.h" #include "effects.h" #include "lanczosfilter.h" +#include "overlaywindow.h" #include "shadow.h" #include @@ -95,12 +96,14 @@ Scene::Scene(Workspace* ws) , wspace(ws) , has_waitSync(false) , lanczos_filter(new LanczosFilter()) + , m_overlayWindow(new OverlayWindow()) { } Scene::~Scene() { delete lanczos_filter; + delete m_overlayWindow; } // returns mask and possibly modified region @@ -321,6 +324,11 @@ void Scene::finalDrawWindow(EffectWindowImpl* w, int mask, QRegion region, Windo w->sceneWindow()->performPaint(mask, region, data); } +OverlayWindow* Scene::overlayWindow() +{ + return m_overlayWindow; +} + //**************************************** // Scene::Window //**************************************** diff --git a/scene.h b/scene.h index 9dea5a86ce..7ebb2e5675 100644 --- a/scene.h +++ b/scene.h @@ -35,6 +35,7 @@ class Deleted; class EffectFrameImpl; class EffectWindowImpl; class LanczosFilter; +class OverlayWindow; class Shadow; // The base class for compositing backends. @@ -95,6 +96,7 @@ public: bool waitSyncAvailable() { return has_waitSync; } + OverlayWindow* overlayWindow(); public Q_SLOTS: // opacity of a window changed virtual void windowOpacityChanged(KWin::Toplevel* c) = 0; @@ -152,6 +154,7 @@ protected: Workspace* wspace; bool has_waitSync; LanczosFilter* lanczos_filter; + OverlayWindow* m_overlayWindow; }; // The base class for windows representations in composite backends diff --git a/scene_opengl.cpp b/scene_opengl.cpp index ad681ca3a2..0980229bb9 100644 --- a/scene_opengl.cpp +++ b/scene_opengl.cpp @@ -77,6 +77,7 @@ Sources and other compositing managers: #include "client.h" #include "deleted.h" #include "effects.h" +#include "overlaywindow.h" #include diff --git a/scene_opengl_egl.cpp b/scene_opengl_egl.cpp index 9d2c61c528..8b1b51225c 100644 --- a/scene_opengl_egl.cpp +++ b/scene_opengl_egl.cpp @@ -62,7 +62,7 @@ SceneOpenGL::~SceneOpenGL() { if (!init_ok) { // TODO this probably needs to clean up whatever has been created until the failure - wspace->destroyOverlay(); + m_overlayWindow->destroy(); return; } foreach (Window * w, windows) @@ -76,8 +76,8 @@ SceneOpenGL::~SceneOpenGL() eglReleaseThread(); SceneOpenGL::EffectFrame::cleanup(); checkGLError("Cleanup"); - if (wspace->overlayWindow()) { - wspace->destroyOverlay(); + if (m_overlayWindow->window()) { + m_overlayWindow->destroy(); } } @@ -96,13 +96,13 @@ bool SceneOpenGL::initRenderingContext() return false; eglBindAPI(EGL_OPENGL_ES_API); initBufferConfigs(); - if (!wspace->createOverlay()) { + if (!m_overlayWindow->create()) { kError(1212) << "Could not get overlay window"; return false; } else { - wspace->setupOverlay(None); + m_overlayWindow->setup(None); } - surface = eglCreateWindowSurface(dpy, config, wspace->overlayWindow(), 0); + surface = eglCreateWindowSurface(dpy, config, m_overlayWindow->window(), 0); const EGLint context_attribs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, @@ -177,8 +177,8 @@ void SceneOpenGL::paint(QRegion damage, ToplevelList toplevels) int mask = 0; paintScreen(&mask, &damage); // call generic implementation ungrabXServer(); // ungrab before flushBuffer(), it may wait for vsync - if (wspace->overlayWindow()) // show the window only after the first pass, since - wspace->showOverlay(); // that pass may take long + if (m_overlayWindow->window()) // show the window only after the first pass, since + m_overlayWindow->show(); // that pass may take long lastRenderTime = t.elapsed(); flushBuffer(mask, damage); // do cleanup diff --git a/scene_opengl_glx.cpp b/scene_opengl_glx.cpp index 8eb3282752..f9358267e2 100644 --- a/scene_opengl_glx.cpp +++ b/scene_opengl_glx.cpp @@ -128,7 +128,7 @@ SceneOpenGL::~SceneOpenGL() { if (!init_ok) { // TODO this probably needs to clean up whatever has been created until the failure - wspace->destroyOverlay(); + m_overlayWindow->destroy(); return; } foreach (Window * w, windows) @@ -137,11 +137,11 @@ SceneOpenGL::~SceneOpenGL() cleanupGL(); glXMakeCurrent(display(), None, NULL); glXDestroyContext(display(), ctxbuffer); - if (wspace->overlayWindow()) { + if (m_overlayWindow->window()) { if (hasGLXVersion(1, 3)) glXDestroyWindow(display(), glxbuffer); XDestroyWindow(display(), buffer); - wspace->destroyOverlay(); + m_overlayWindow->destroy(); } else { glXDestroyPixmap(display(), glxbuffer); XFreeGC(display(), gcroot); @@ -196,19 +196,19 @@ bool SceneOpenGL::initBuffer() { if (!initBufferConfigs()) return false; - if (fbcbuffer_db != NULL && wspace->createOverlay()) { + if (fbcbuffer_db != NULL && m_overlayWindow->create()) { // we have overlay, try to create double-buffered window in it fbcbuffer = fbcbuffer_db; XVisualInfo* visual = glXGetVisualFromFBConfig(display(), fbcbuffer); XSetWindowAttributes attrs; attrs.colormap = XCreateColormap(display(), rootWindow(), visual->visual, AllocNone); - buffer = XCreateWindow(display(), wspace->overlayWindow(), 0, 0, displayWidth(), displayHeight(), + buffer = XCreateWindow(display(), m_overlayWindow->window(), 0, 0, displayWidth(), displayHeight(), 0, visual->depth, InputOutput, visual->visual, CWColormap, &attrs); if (hasGLXVersion(1, 3)) glxbuffer = glXCreateWindow(display(), fbcbuffer, buffer, NULL); else glxbuffer = buffer; - wspace->setupOverlay(buffer); + m_overlayWindow->setup(buffer); db = true; XFree(visual); } else if (fbcbuffer_nondb != NULL) { @@ -458,8 +458,8 @@ void SceneOpenGL::paint(QRegion damage, ToplevelList toplevels) #endif glPopMatrix(); ungrabXServer(); // ungrab before flushBuffer(), it may wait for vsync - if (wspace->overlayWindow()) // show the window only after the first pass, since - wspace->showOverlay(); // that pass may take long + if (m_overlayWindow->window()) // show the window only after the first pass, since + m_overlayWindow->show(); // that pass may take long lastRenderTime = t.elapsed(); flushBuffer(mask, damage); // do cleanup diff --git a/scene_xrender.cpp b/scene_xrender.cpp index 5fdd2c94d3..eaa50cd9a6 100644 --- a/scene_xrender.cpp +++ b/scene_xrender.cpp @@ -46,6 +46,7 @@ along with this program. If not, see . #include "client.h" #include "deleted.h" #include "effects.h" +#include "overlaywindow.h" #include "kwinxrenderutils.h" #include @@ -99,16 +100,16 @@ SceneXrender::SceneXrender(Workspace* ws) return; } KXErrorHandler xerr; - if (wspace->createOverlay()) { - wspace->setupOverlay(None); + if (m_overlayWindow->create()) { + m_overlayWindow->setup(None); XWindowAttributes attrs; - XGetWindowAttributes(display(), wspace->overlayWindow(), &attrs); + XGetWindowAttributes(display(), m_overlayWindow->window(), &attrs); format = XRenderFindVisualFormat(display(), attrs.visual); if (format == NULL) { kError(1212) << "Failed to find XRender format for overlay window"; return; } - front = XRenderCreatePicture(display(), wspace->overlayWindow(), format, 0, NULL); + front = XRenderCreatePicture(display(), m_overlayWindow->window(), format, 0, NULL); } else { // create XRender picture for the root window format = XRenderFindVisualFormat(display(), DefaultVisual(display(), DefaultScreen(display()))); @@ -132,13 +133,13 @@ SceneXrender::~SceneXrender() { if (!init_ok) { // TODO this probably needs to clean up whatever has been created until the failure - wspace->destroyOverlay(); + m_overlayWindow->destroy(); return; } XRenderFreePicture(display(), front); XRenderFreePicture(display(), buffer); buffer = None; - wspace->destroyOverlay(); + m_overlayWindow->destroy(); foreach (Window * w, windows) delete w; } @@ -167,8 +168,8 @@ void SceneXrender::paint(QRegion damage, ToplevelList toplevels) } int mask = 0; paintScreen(&mask, &damage); - if (wspace->overlayWindow()) // show the window only after the first pass, since - wspace->showOverlay(); // that pass may take long + if (m_overlayWindow->window()) // show the window only after the first pass, since + m_overlayWindow->show(); // that pass may take long lastRenderTime = t.elapsed(); flushBuffer(mask, damage); // do cleanup diff --git a/workspace.cpp b/workspace.cpp index e880ddf23b..0639b6a141 100644 --- a/workspace.cpp +++ b/workspace.cpp @@ -59,6 +59,7 @@ along with this program. If not, see . #include "unmanaged.h" #include "deleted.h" #include "effects.h" +#include "overlaywindow.h" #include "tilinglayout.h" #include "scripting/scripting.h" @@ -149,9 +150,6 @@ Workspace::Workspace(bool restore) , compositingSuspended(false) , compositingBlocked(false) , xrrRefreshRate(0) - , overlay(None) - , overlay_visible(true) - , overlay_shown(false) , transSlider(NULL) , transButton(NULL) , forceUnredirectCheck(true) @@ -532,7 +530,7 @@ Client* Workspace::createClient(Window w, bool is_mapped) Unmanaged* Workspace::createUnmanaged(Window w) { - if (w == overlay) + if (w == scene->overlayWindow()->window()) return NULL; Unmanaged* c = new Unmanaged(this); if (!c->track(w)) { diff --git a/workspace.h b/workspace.h index f90b1feacb..66b9830650 100644 --- a/workspace.h +++ b/workspace.h @@ -535,16 +535,6 @@ public: void addRepaint(const QRect& r); void addRepaint(const QRegion& r); void addRepaint(int x, int y, int w, int h); - /// Creates XComposite overlay window, call initOverlay() afterwards - bool createOverlay(); - /// Init overlay and the destination window in it - void setupOverlay(Window window); - void showOverlay(); - void hideOverlay(); // hides and resets overlay window - void setOverlayShape(const QRegion& reg); - /// Destroys XComposite overlay window - void destroyOverlay(); - Window overlayWindow(); void checkUnredirect(bool force = false); void checkCompositeTimer(); @@ -940,10 +930,6 @@ private: uint vBlankInterval, vBlankPadding, fpsInterval, estimatedRenderTime; int xrrRefreshRate; // used only for compositing QRegion repaints_region; - Window overlay; // XComposite overlay window - bool overlay_visible; - bool overlay_shown; // For showOverlay() - QRegion overlay_shape; QSlider* transSlider; QPushButton* transButton; QTimer unredirectTimer; @@ -1124,11 +1110,6 @@ inline bool Workspace::globalShortcutsDisabled() const return global_shortcuts_disabled || global_shortcuts_disabled_for_client; } -inline Window Workspace::overlayWindow() -{ - return overlay; -} - inline bool Workspace::rulesUpdatesDisabled() const { return rules_updates_disabled;