workspace/kcontrol/randr/legacyrandrscreen.cpp

   1 /*
   2  * Copyright (c) 2007      Gustavo Pichorim Boiko <gustavo.boiko@kdemail.net>
   3  * Copyright (c) 2002,2003 Hamish Rodda <rodda@kde.org>
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18  */
  19
  20
  21
  22 #include <QTimer>
  23 //Added by qt3to4:
  24 #include <QPixmap>
  25 #include "ktimerdialog.h"
  26
  27 #include <kdebug.h>
  28 #include <klocale.h>
  29 #include <kglobal.h>
  30 #include <kapplication.h>
  31 #include <kiconloader.h>
  32 #include <QtGui/QLabel>
  33 #include <QDesktopWidget>
  34
  35 #include <QX11Info>
  36 #include "legacyrandrscreen.h"
  37
  38 LegacyRandRScreen::LegacyRandRScreen(int screenIndex)
  39         : m_config(0L)
  40         , m_screen(screenIndex)
  41         , m_shownDialog(NULL)
  42 {
  43         loadSettings();
  44         setOriginal();
  45 }
  46
  47 LegacyRandRScreen::~LegacyRandRScreen()
  48 {
  49         if (m_config)
  50                 XRRFreeScreenConfigInfo(m_config);
  51 }
  52
  53 void LegacyRandRScreen::loadSettings()
  54 {
  55         if (m_config)
  56                 XRRFreeScreenConfigInfo(m_config);
  57
  58         m_config = XRRGetScreenInfo(QX11Info::display(), rootWindow());
  59         Q_ASSERT(m_config);
  60
  61         Rotation rotation;
  62         m_currentSize = m_proposedSize = XRRConfigCurrentConfiguration(m_config, &rotation);
  63         m_currentRotation = m_proposedRotation = rotation;
  64
  65         m_pixelSizes.clear();
  66         m_mmSizes.clear();
  67         int numSizes;
  68         XRRScreenSize* sizes = XRRSizes(QX11Info::display(), m_screen, &numSizes);
  69         for (int i = 0; i < numSizes; i++) {
  70                 m_pixelSizes.append(QSize(sizes[i].width, sizes[i].height));
  71                 m_mmSizes.append(QSize(sizes[i].mwidth, sizes[i].mheight));
  72         }
  73
  74         m_rotations = XRRRotations(QX11Info::display(), m_screen, &rotation);
  75
  76         m_currentRefreshRate = m_proposedRefreshRate = refreshRateHzToIndex(m_currentSize, XRRConfigCurrentRate(m_config));
  77 }
  78
  79 void LegacyRandRScreen::setOriginal()
  80 {
  81         m_originalSize = m_currentSize;
  82         m_originalRotation = m_currentRotation;
  83         m_originalRefreshRate = m_currentRefreshRate;
  84 }
  85
  86 bool LegacyRandRScreen::applyProposed()
  87 {
  88         //kDebug() << " size " << (SizeID)proposedSize() << ", rotation " << proposedRotation() << ", refresh " << refreshRateIndexToHz(proposedSize(), proposedRefreshRate());
  89
  90         Status status;
  91
  92         if (proposedRefreshRate() < 0)
  93                 status = XRRSetScreenConfig(QX11Info::display(), m_config, rootWindow(), (SizeID)proposedSize(), (Rotation)proposedRotation(), CurrentTime);
  94         else {
  95                 if( refreshRateIndexToHz(proposedSize(), proposedRefreshRate()) <= 0 ) {
  96                         m_proposedRefreshRate = 0;
  97                 }
  98                 status = XRRSetScreenConfigAndRate(QX11Info::display(), m_config, rootWindow(), (SizeID)proposedSize(), (Rotation)proposedRotation(), refreshRateIndexToHz(proposedSize(), proposedRefreshRate()), CurrentTime);
  99         }
 100
 101         //kDebug() << "New size: " << WidthOfScreen(ScreenOfDisplay(QPaintDevice::x11AppDisplay(), screen)) << ", " << HeightOfScreen(ScreenOfDisplay(QPaintDevice::x11AppDisplay(), screen));
 102
 103         if (status == RRSetConfigSuccess) {
 104                 m_currentSize = m_proposedSize;
 105                 m_currentRotation = m_proposedRotation;
 106                 m_currentRefreshRate = m_proposedRefreshRate;
 107                 return true;
 108         }
 109
 110         return false;
 111 }
 112
 113 bool LegacyRandRScreen::applyProposedAndConfirm()
 114 {
 115         if (proposedChanged()) {
 116                 setOriginal();
 117
 118                 if (applyProposed()) {
 119                         if (!RandR::confirm()) {
 120                                 proposeOriginal();
 121                                 applyProposed();
 122                                 return false;
 123                         }
 124                 } else {
 125                         return false;
 126                 }
 127         }
 128
 129         return true;
 130 }
 131
 132 Window LegacyRandRScreen::rootWindow() const
 133 {
 134         return RootWindow(QX11Info::display(), m_screen);
 135 }
 136
 137 QString LegacyRandRScreen::changedMessage() const
 138 {
 139         if (refreshRate() == -1)
 140                 return i18n("New configuration:\nResolution: %1 x %2\nOrientation: %3",
 141                          currentPixelSize().width(),
 142                          currentPixelSize().height(),
 143                          currentRotationDescription());
 144         else
 145                 return i18n("New configuration:\nResolution: %1 x %2\nOrientation: %3\nRefresh rate: %4",
 146                          currentPixelSize().width(),
 147                          currentPixelSize().height(),
 148                          currentRotationDescription(),
 149                          currentRefreshRateDescription());
 150 }
 151
 152 bool LegacyRandRScreen::changedFromOriginal() const
 153 {
 154         return m_currentSize != m_originalSize || m_currentRotation != m_originalRotation || m_currentRefreshRate != m_originalRefreshRate;
 155 }
 156
 157 void LegacyRandRScreen::proposeOriginal()
 158 {
 159         m_proposedSize = m_originalSize;
 160         m_proposedRotation = m_originalRotation;
 161         m_proposedRefreshRate = m_originalRefreshRate;
 162 }
 163
 164 bool LegacyRandRScreen::proposedChanged() const
 165 {
 166         return m_currentSize != m_proposedSize || m_currentRotation != m_proposedRotation || m_currentRefreshRate != m_proposedRefreshRate;
 167 }
 168
 169 QString LegacyRandRScreen::currentRotationDescription() const
 170 {
 171         QString ret = RandR::rotationName(m_currentRotation & RandR::RotateMask);
 172
 173         if (m_currentRotation != (m_currentRotation & RandR::RotateMask))
 174                 if (m_currentRotation & RR_Rotate_0)
 175                         ret = RandR::rotationName(m_currentRotation & (RR_Reflect_X + RR_Reflect_X), true, true);
 176                 else
 177                         ret += ", " + RandR::rotationName(m_currentRotation & (RR_Reflect_X + RR_Reflect_X), true, false);
 178
 179         return ret;
 180 }
 181
 182 int LegacyRandRScreen::rotationIndexToDegree(int rotation) const
 183 {
 184         switch (rotation & RandR::RotateMask) {
 185                 case RR_Rotate_90:
 186                         return 90;
 187
 188                 case RR_Rotate_180:
 189                         return 180;
 190
 191                 case RR_Rotate_270:
 192                         return 270;
 193
 194                 default:
 195                         return 0;
 196         }
 197 }
 198
 199 int LegacyRandRScreen::rotationDegreeToIndex(int degree) const
 200 {
 201         switch (degree) {
 202                 case 90:
 203                         return RR_Rotate_90;
 204
 205                 case 180:
 206                         return RR_Rotate_180;
 207
 208                 case 270:
 209                         return RR_Rotate_270;
 210
 211                 default:
 212                         return RR_Rotate_0;
 213         }
 214 }
 215
 216 const QSize& LegacyRandRScreen::currentPixelSize() const
 217 {
 218         return m_pixelSizes[m_currentSize];
 219 }
 220
 221 RateList LegacyRandRScreen::refreshRates(int size) const
 222 {
 223         int nrates;
 224         short* rrates = XRRRates(QX11Info::display(), m_screen, (SizeID)size, &nrates);
 225
 226         RateList rateList;
 227         for (int i = 0; i < nrates; i++)
 228                 rateList.append(rrates[i]);
 229
 230         return rateList;
 231 }
 232
 233 QString LegacyRandRScreen::refreshRateDirectDescription(int rate) const
 234 {
 235         return i18nc("Refresh rate in Hertz (Hz)", "%1 Hz", rate);
 236 }
 237
 238 QString LegacyRandRScreen::refreshRateIndirectDescription(int size, int index) const
 239 {
 240         return i18nc("Refresh rate in Hertz (Hz)", "%1 Hz", refreshRateIndexToHz(size, index));
 241 }
 242
 243 QString LegacyRandRScreen::refreshRateDescription(int size, int index) const
 244 {
 245         return ki18n("%1 Hz").subs(refreshRates(size)[index], 0, 'f', 1).toString();
 246 }
 247
 248 bool LegacyRandRScreen::proposeRefreshRate(int index)
 249 {
 250         if (index >= 0 && (int)refreshRates(proposedSize()).count() > index) {
 251                 m_proposedRefreshRate = index;
 252                 return true;
 253         }
 254
 255         return false;
 256 }
 257
 258 int LegacyRandRScreen::refreshRate() const
 259 {
 260         return m_currentRefreshRate;
 261 }
 262
 263 QString LegacyRandRScreen::currentRefreshRateDescription() const
 264 {
 265         return refreshRateIndirectDescription(m_currentSize, m_currentRefreshRate);
 266 }
 267
 268 int LegacyRandRScreen::proposedRefreshRate() const
 269 {
 270         return m_proposedRefreshRate;
 271 }
 272
 273 int LegacyRandRScreen::refreshRateHzToIndex(int size, int hz) const
 274 {
 275         int nrates;
 276         short* rates = XRRRates(QX11Info::display(), m_screen, (SizeID)size, &nrates);
 277
 278         for (int i = 0; i < nrates; i++)
 279                 if (hz == rates[i])
 280                         return i;
 281
 282         if (nrates != 0)
 283                 // Wrong input Hz!
 284                 Q_ASSERT(false);
 285
 286         return -1;
 287 }
 288
 289 int LegacyRandRScreen::refreshRateIndexToHz(int size, int index) const
 290 {
 291         int nrates;
 292         short* rates = XRRRates(QX11Info::display(), m_screen, (SizeID)size, &nrates);
 293
 294         if (nrates == 0 || index < 0)
 295                 return 0;
 296
 297         // Wrong input Hz!
 298         if(index >= nrates)
 299                 return 0;
 300
 301         return rates[index];
 302 }
 303
 304 int LegacyRandRScreen::numSizes() const
 305 {
 306         return m_pixelSizes.count();
 307 }
 308
 309 const QSize& LegacyRandRScreen::pixelSize(int index) const
 310 {
 311         return m_pixelSizes[index];
 312 }
 313
 314 const QSize& LegacyRandRScreen::mmSize(int index) const
 315 {
 316         return m_mmSizes[index];
 317 }
 318
 319 int LegacyRandRScreen::sizeIndex(const QSize &pixelSize) const
 320 {
 321         for (int i = 0; i < m_pixelSizes.count(); i++)
 322                 if (m_pixelSizes[i] == pixelSize)
 323                         return i;
 324
 325         return -1;
 326 }
 327
 328 int LegacyRandRScreen::rotations() const
 329 {
 330         return m_rotations;
 331 }
 332
 333 int LegacyRandRScreen::rotation() const
 334 {
 335         return m_currentRotation;
 336 }
 337
 338 int LegacyRandRScreen::size() const
 339 {
 340         return m_currentSize;
 341 }
 342
 343 int LegacyRandRScreen::proposedRotation() const
 344 {
 345         return m_proposedRotation;
 346 }
 347
 348 void LegacyRandRScreen::proposeRotation(int newRotation)
 349 {
 350         m_proposedRotation = newRotation & RandR::OrientationMask;
 351 }
 352
 353 int LegacyRandRScreen::proposedSize() const
 354 {
 355         return m_proposedSize;
 356 }
 357
 358 bool LegacyRandRScreen::proposeSize(int newSize)
 359 {
 360         if ((int)m_pixelSizes.count() > newSize) {
 361                 m_proposedSize = newSize;
 362                 return true;
 363         }
 364
 365         return false;
 366 }
 367
 368 void LegacyRandRScreen::load(KConfig& config)
 369 {
 370         KConfigGroup group = config.group(QString("Screen%1").arg(m_screen));
 371
 372         if (proposeSize(sizeIndex(group.readEntry("size", currentPixelSize()))))
 373                 proposeRefreshRate(refreshRateHzToIndex(proposedSize(), group.readEntry("refresh", refreshRate())));
 374
 375         proposeRotation(rotationDegreeToIndex(  group.readEntry("rotation", 0)) +
 376                                                 (group.readEntry("reflectX", false) ? RandR::ReflectX : 0) +
 377                                                 (group.readEntry("reflectY",false) ? RandR::ReflectY : 0));
 378 }
 379
 380 void LegacyRandRScreen::save(KConfig& config) const
 381 {
 382         KConfigGroup group = config.group(QString("Screen%1").arg(m_screen));
 383         group.writeEntry("size", currentPixelSize());
 384         group.writeEntry("refresh", refreshRateIndexToHz(size(), refreshRate()));
 385         group.writeEntry("rotation", rotationIndexToDegree(rotation()));
 386         group.writeEntry("reflectX", (bool)(rotation() & RandR::ReflectMask) == RandR::ReflectX);
 387         group.writeEntry("reflectY", (bool)(rotation() & RandR::ReflectMask) == RandR::ReflectY);
 388 }
 389
 390 int LegacyRandRScreen::pixelCount( int index ) const
 391 {
 392         QSize sz = pixelSize(index);
 393         return sz.width() * sz.height();
 394 }
 395
 396 SizeList LegacyRandRScreen::pixelSizes() const
 397 {
 398         return m_pixelSizes;
 399 }
 400
 401 #include "legacyrandrscreen.moc"