workspace/kcontrol/randr/randrdisplay.cpp

   1 /*
   2  * Copyright (c) 2008      Harry Bock <hbock@providence.edu>
   3  * Copyright (c) 2007      Gustavo Pichorim Boiko <gustavo.boiko@kdemail.net>
   4  * Copyright (c) 2002,2003 Hamish Rodda <rodda@kde.org>
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19  */
  20
  21 #include <KLocale>
  22 #include <KConfigGroup>
  23 #include <KDebug>
  24 #include <QApplication>
  25 #include <QDesktopWidget>
  26 #include <QX11Info>
  27
  28 #include "randrdisplay.h"
  29 #ifdef HAS_RANDR_1_2
  30 #include "randrscreen.h"
  31 #endif
  32 #include "legacyrandrscreen.h"
  33 #include <config-randr.h>
  34
  35 RandRDisplay::RandRDisplay()
  36         : m_valid(true)
  37 {
  38         m_dpy = QX11Info::display();
  39
  40         // Check extension
  41         if(XRRQueryExtension(m_dpy, &m_eventBase, &m_errorBase) == False) {
  42                 m_valid = false;
  43                 return;
  44         }
  45
  46         int major_version, minor_version;
  47         XRRQueryVersion(m_dpy, &major_version, &minor_version);
  48
  49         m_version = i18n("X Resize and Rotate extension version %1.%2",
  50                          major_version,minor_version);
  51
  52         // check if we have the new version of the XRandR extension
  53         RandR::has_1_2 = (major_version > 1 || (major_version == 1 && minor_version >= 2));
  54
  55         if(RandR::has_1_2)
  56                 kDebug() << "Using XRANDR extension 1.2 or greater.";
  57         else kDebug() << "Using legacy XRANDR extension (1.1 or earlier).";
  58
  59         kDebug() << "XRANDR error base: " << m_errorBase;
  60         m_numScreens = ScreenCount(m_dpy);
  61         m_currentScreenIndex = 0;
  62
  63         // set the timestamp to 0
  64         RandR::timestamp = 0;
  65
  66         // This assumption is WRONG with Xinerama
  67         // Q_ASSERT(QApplication::desktop()->numScreens() == ScreenCount(QX11Info::display()));
  68
  69         for (int i = 0; i < m_numScreens; i++) {
  70 #ifdef HAS_RANDR_1_2
  71                 if (RandR::has_1_2)
  72                         m_screens.append(new RandRScreen(i));
  73                 else
  74 #endif
  75                         m_legacyScreens.append(new LegacyRandRScreen(i));
  76         }
  77
  78 #if 0
  79 //#ifdef HAS_RANDR_1_2
  80         // check if we have more than one output, if no, revert to the legacy behavior
  81         if (RandR::has_1_2)
  82         {
  83                 int count = 0;
  84                 foreach(RandRScreen *screen, m_screens)
  85                         count += screen->outputs().count();
  86
  87                 if (count < 2)
  88                 {
  89                         RandR::has_1_2 = false;
  90                         for (int i = 0; i < m_numScreens; ++i)
  91                         {
  92                                 delete m_screens[i];
  93                                 m_legacyScreens.append(new LegacyRandRScreen(i));
  94                         }
  95                         m_screens.clear();
  96                 }
  97         }
  98 #endif
  99         setCurrentScreen(DefaultScreen(QX11Info::display()));
 100 }
 101
 102 RandRDisplay::~RandRDisplay()
 103 {
 104                 qDeleteAll(m_legacyScreens);
 105 #ifdef HAS_RANDR_1_2
 106                 qDeleteAll(m_screens);
 107 #endif
 108 }
 109
 110 bool RandRDisplay::isValid() const
 111 {
 112         return m_valid;
 113 }
 114
 115 const QString& RandRDisplay::errorCode() const
 116 {
 117         return m_errorCode;
 118 }
 119
 120 int RandRDisplay::eventBase() const
 121 {
 122         return m_eventBase;
 123 }
 124
 125 int RandRDisplay::errorBase() const
 126 {
 127         return m_errorBase;
 128 }
 129
 130 const QString& RandRDisplay::version() const
 131 {
 132         return m_version;
 133 }
 134
 135 void RandRDisplay::setCurrentScreen(int index)
 136 {
 137         Q_ASSERT(index < ScreenCount(m_dpy));
 138         m_currentScreenIndex = index;
 139 }
 140
 141 int RandRDisplay::screenIndexOfWidget(QWidget* widget)
 142 {
 143         //int ret = QApplication::desktop()->screenNumber(widget);
 144         //return ret != -1 ? ret : QApplication::desktop()->primaryScreen();
 145
 146         // get info from Qt's X11 info directly; QDesktopWidget seems to use
 147         // Xinerama by default, which doesn't work properly with randr.
 148         // It will return more screens than exist for the display, causing
 149         // a crash in the screen/currentScreen methods.
 150         if(widget)
 151                 return widget->x11Info().screen();
 152
 153         return -1;
 154 }
 155
 156 int RandRDisplay::currentScreenIndex() const
 157 {
 158         return m_currentScreenIndex;
 159 }
 160
 161 bool RandRDisplay::needsRefresh() const
 162 {
 163         Time time, config_timestamp;
 164         time = XRRTimes(m_dpy, m_currentScreenIndex, &config_timestamp);
 165
 166         kDebug() << "Cache:" << RandR::timestamp << "Server:" << time << "Config:" << config_timestamp;
 167         return (RandR::timestamp < time);
 168 }
 169
 170 void RandRDisplay::refresh()
 171 {
 172 #ifdef HAS_RANDR_1_2
 173         if (RandR::has_1_2) {
 174                 for (int i = 0; i < m_screens.count(); ++i) {
 175                         RandRScreen* s = m_screens.at(i);
 176                         s->loadSettings();
 177                 }
 178         }
 179         else
 180 #endif
 181         {
 182                 for (int i = 0; i < m_legacyScreens.size(); ++i) {
 183                         LegacyRandRScreen* s = m_legacyScreens.at(i);
 184                         s->loadSettings();
 185                 }
 186         }
 187 }
 188
 189 bool RandRDisplay::canHandle(const XEvent *e) const
 190 {
 191         if (e->type == m_eventBase + RRScreenChangeNotify)
 192                 return true;
 193 #ifdef HAS_RANDR_1_2
 194         else if (e->type == m_eventBase + RRNotify)
 195                 return true;
 196 #endif
 197         return false;
 198 }
 199
 200
 201 void RandRDisplay::handleEvent(XEvent *e)
 202 {
 203         if (e->type == m_eventBase + RRScreenChangeNotify) {
 204 #ifdef HAS_RANDR_1_2
 205                 if (RandR::has_1_2) {
 206                         XRRScreenChangeNotifyEvent *event = (XRRScreenChangeNotifyEvent*)(e);
 207                         for (int i=0; i < m_screens.count(); ++i) {
 208                                 RandRScreen *screen = m_screens.at(i);
 209                                 if (screen->rootWindow() == event->root)
 210                                         screen->handleEvent(event);
 211                         }
 212
 213                 }
 214                 else
 215 #endif
 216                 {
 217                         // handle the event
 218                 }
 219         }
 220 #ifdef HAS_RANDR_1_2
 221         else if (e->type == m_eventBase + RRNotify) {
 222                 //forward the event to the right screen
 223                 XRRNotifyEvent *event = (XRRNotifyEvent*)e;
 224                 for (int i=0; i < m_screens.count(); ++i) {
 225                         RandRScreen *screen = m_screens.at(i);
 226                         if ( screen->rootWindow() == event->window ) {
 227                                 screen->handleRandREvent(event);
 228                         }
 229                 }
 230         }
 231 #endif
 232 }
 233
 234 int RandRDisplay::numScreens() const
 235 {
 236         Q_ASSERT(ScreenCount(QX11Info::display()) == m_numScreens);
 237         return m_numScreens;
 238 }
 239
 240 LegacyRandRScreen* RandRDisplay::legacyScreen(int index)
 241 {
 242         return m_legacyScreens.at(index);
 243 }
 244
 245 LegacyRandRScreen* RandRDisplay::currentLegacyScreen()
 246 {
 247         return m_legacyScreens.at(m_currentScreenIndex);
 248 }
 249
 250 #ifdef HAS_RANDR_1_2
 251 RandRScreen* RandRDisplay::screen(int index)
 252 {
 253         return m_screens.at(index);
 254 }
 255
 256 RandRScreen* RandRDisplay::currentScreen()
 257 {
 258         return m_screens.at(m_currentScreenIndex);
 259 }
 260 #endif
 261
 262 bool RandRDisplay::loadDisplay(KConfig& config, bool loadScreens)
 263 {
 264         if (loadScreens)
 265         {
 266 #ifdef HAS_RANDR_1_2
 267                 if (RandR::has_1_2)
 268                 {
 269                         foreach(RandRScreen *s, m_screens)
 270                                 s->load(config);
 271
 272                 }
 273                 else
 274 #endif
 275                 {
 276                         foreach(LegacyRandRScreen* s, m_legacyScreens)
 277                                 s->load(config);
 278                 }
 279         }
 280         return applyOnStartup(config);
 281 }
 282
 283 bool RandRDisplay::applyOnStartup(KConfig& config)
 284 {
 285         return config.group("Display").readEntry("ApplyOnStartup", false);
 286 }
 287
 288 bool RandRDisplay::syncTrayApp(KConfig& config)
 289 {
 290         return config.group("Display").readEntry("SyncTrayApp", false);
 291 }
 292
 293 void RandRDisplay::saveDisplay(KConfig& config, bool applyOnStartup, bool syncTrayApp)
 294 {
 295         KConfigGroup group = config.group("Display");
 296         group.writeEntry("ApplyOnStartup", applyOnStartup);
 297         group.writeEntry("SyncTrayApp", syncTrayApp);
 298
 299 #ifdef HAS_RANDR_1_2
 300         if (RandR::has_1_2)
 301         {
 302                 foreach(RandRScreen *s, m_screens)
 303                         s->save(config);
 304         }
 305         else
 306 #endif
 307         {
 308                 foreach(LegacyRandRScreen *s, m_legacyScreens)
 309                         s->save(config);
 310         }
 311 }
 312
 313 void RandRDisplay::applyProposed(bool confirm)
 314 {
 315
 316 #ifdef HAS_RANDR_1_2
 317         if (RandR::has_1_2)
 318                 foreach(RandRScreen *s, m_screens)
 319                         s->applyProposed(confirm);
 320         else
 321 #endif
 322         {
 323                 foreach(LegacyRandRScreen *s, m_legacyScreens)
 324                 {
 325                         if (s->proposedChanged()) {
 326                                 if (confirm)
 327                                                 s->applyProposedAndConfirm();
 328                                 else
 329                                                 s->applyProposed();
 330                         }
 331                 }
 332         }
 333 }
 334