workspace/kcontrol/randr/randrcrtc.cpp

   1 /*
   2  * Copyright (c) 2007      Gustavo Pichorim Boiko <gustavo.boiko@kdemail.net>
   3  *
   4  *  This program is free software; you can redistribute it and/or modify
   5  *  it under the terms of the GNU General Public License as published by
   6  *  the Free Software Foundation; either version 2 of the License, or
   7  *  (at your option) any later version.
   8  *
   9  *  This program is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *  GNU General Public License for more details.
  13  *
  14  *  You should have received a copy of the GNU General Public License
  15  *  along with this program; if not, write to the Free Software
  16  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  17  */
  18
  19 #include "randrcrtc.h"
  20 #include "randrscreen.h"
  21 #include "randroutput.h"
  22 #include "randrmode.h"
  23
  24 RandRCrtc::RandRCrtc(RandRScreen *parent, RRCrtc id)
  25         : QObject(parent),
  26           m_currentRect(0, 0, 0, 0),
  27           m_originalRect(m_currentRect),
  28           m_proposedRect(m_originalRect)
  29 {
  30         m_screen = parent;
  31         Q_ASSERT(m_screen);
  32
  33         m_currentRotation = m_originalRotation = m_proposedRotation = RandR::Rotate0;
  34         m_currentRate = m_originalRate = m_proposedRate = 0;
  35         m_currentMode = 0;
  36         m_rotations = RandR::Rotate0;
  37
  38         m_id = id;
  39 }
  40
  41 RandRCrtc::~RandRCrtc()
  42 {
  43         // do nothing for now
  44 }
  45
  46 RRCrtc RandRCrtc::id() const
  47 {
  48         return m_id;
  49 }
  50
  51 int RandRCrtc::rotations() const
  52 {
  53         return m_rotations;
  54 }
  55
  56 int RandRCrtc::rotation() const
  57 {
  58         return m_currentRotation;
  59 }
  60
  61 bool RandRCrtc::isValid(void) const
  62 {
  63         return m_id != None;
  64 }
  65
  66 void RandRCrtc::loadSettings(bool notify)
  67 {
  68         if(m_id == None)
  69                 return;
  70
  71         kDebug() << "Querying information about CRTC" << m_id;
  72
  73         int changes = 0;
  74         XRRCrtcInfo *info = XRRGetCrtcInfo(QX11Info::display(), m_screen->resources(), m_id);
  75         Q_ASSERT(info);
  76
  77         if (RandR::timestamp != info->timestamp)
  78                 RandR::timestamp = info->timestamp;
  79
  80         QRect rect = QRect(info->x, info->y, info->width, info->height);
  81         if (rect != m_currentRect)
  82         {
  83                 m_currentRect = rect;
  84                 changes |= RandR::ChangeRect;
  85         }
  86
  87         // get all connected outputs
  88         // and create a list of modes that are available in all connected outputs
  89         OutputList outputs;
  90
  91         for (int i = 0; i < info->noutput; ++i) {
  92                 outputs.append(info->outputs[i]);
  93         }
  94
  95         // check if the list changed from the original one
  96         if (outputs != m_connectedOutputs)
  97         {
  98                 changes |= RandR::ChangeOutputs;
  99                 m_connectedOutputs = outputs;
 100         }
 101
 102         // get all outputs this crtc can be connected to
 103         outputs.clear();
 104         for (int i = 0; i < info->npossible; ++i)
 105                 outputs.append(info->possible[i]);
 106
 107         if (outputs != m_possibleOutputs)
 108         {
 109                 changes |= RandR::ChangeOutputs;
 110                 m_possibleOutputs = outputs;
 111         }
 112
 113         // get all rotations
 114         m_rotations = info->rotations;
 115         if (m_currentRotation != info->rotation)
 116         {
 117                 m_currentRotation = info->rotation;
 118                 changes |= RandR::ChangeRotation;
 119         }
 120
 121         // check if the current mode has changed
 122         if (m_currentMode != info->mode)
 123         {
 124                 m_currentMode = info->mode;
 125                 changes |= RandR::ChangeMode;
 126         }
 127
 128         RandRMode m = m_screen->mode(m_currentMode);
 129         if (m_currentRate != m.refreshRate())
 130         {
 131                 m_currentRate = m.refreshRate();
 132                 changes |= RandR::ChangeRate;
 133         }
 134
 135         // just to make sure it gets initialized
 136         m_proposedRect = m_currentRect;
 137         m_proposedRotation = m_currentRotation;
 138         m_proposedRate = m_currentRate;
 139
 140         // free the info
 141         XRRFreeCrtcInfo(info);
 142
 143         if (changes && notify)
 144                 emit crtcChanged(m_id, changes);
 145 }
 146
 147 void RandRCrtc::handleEvent(XRRCrtcChangeNotifyEvent *event)
 148 {
 149         kDebug() << "[CRTC] Event...";
 150         int changed = 0;
 151
 152         if (event->mode != m_currentMode)
 153         {
 154                 kDebug() << "   Changed mode";
 155                 changed |= RandR::ChangeMode;
 156                 m_currentMode = event->mode;
 157         }
 158
 159         if (event->rotation != m_currentRotation)
 160         {
 161                 kDebug() << "   Changed rotation: " << event->rotation;
 162                 changed |= RandR::ChangeRotation;
 163                 m_currentRotation = event->rotation;
 164         }
 165         if (event->x != m_currentRect.x() || event->y != m_currentRect.y())
 166         {
 167                 kDebug() << "   Changed position: " << event->x << "," << event->y;
 168                 changed |= RandR::ChangeRect;
 169                 m_currentRect.moveTopLeft(QPoint(event->x, event->y));
 170         }
 171
 172         RandRMode mode = m_screen->mode(m_currentMode);
 173         if (mode.size() != m_currentRect.size())
 174         {
 175                 kDebug() << "   Changed size: " << mode.size();
 176                 changed |= RandR::ChangeRect;
 177                 m_currentRect.setSize(mode.size());
 178                 //Do NOT use event->width and event->height here, as it is being returned wrongly
 179         }
 180
 181         if (changed)
 182                 emit crtcChanged(m_id, changed);
 183 }
 184
 185 RandRMode RandRCrtc::mode() const
 186 {
 187         return m_screen->mode(m_currentMode);
 188 }
 189
 190 QRect RandRCrtc::rect() const
 191 {
 192         return m_currentRect;
 193 }
 194
 195 float RandRCrtc::refreshRate() const
 196 {
 197         return m_currentRate;
 198 }
 199
 200 bool RandRCrtc::applyProposed()
 201 {
 202         kDebug() << "Applying proposed changes for CRTC" << m_id << "...";
 203         kDebug() << "       Current Screen rect:" << m_screen->rect();
 204         kDebug() << "       Current CRTC rect:" << m_currentRect;
 205         kDebug() << "       Current rotation:" << m_currentRotation;
 206         kDebug() << "       Proposed CRTC rect:" << m_proposedRect;
 207         kDebug() << "       Proposed rotation:" << m_proposedRotation;
 208         kDebug() << "       Proposed refresh rate:" << m_proposedRate;
 209         kDebug() << "       Enabled outputs:";
 210         if (m_connectedOutputs.isEmpty())
 211                 kDebug() << "          - none";
 212         for (int i = 0; i < m_connectedOutputs.count(); ++i)
 213                 kDebug() << "          -" << m_screen->output(m_connectedOutputs.at(i))->name();
 214
 215         RandRMode mode;
 216         if (m_proposedRect.size() == m_currentRect.size() && m_proposedRate == m_currentRate)
 217         {
 218                 mode = m_screen->mode(m_currentMode);
 219         }
 220         else
 221         {
 222                 // find a mode that has the desired size and is supported
 223                 // by all connected outputs
 224                 ModeList modeList = modes();
 225                 ModeList matchModes;
 226
 227                 foreach(RRMode m, modeList)
 228                 {
 229                         RandRMode mode = m_screen->mode(m);
 230                         if (mode.size() == m_proposedRect.size())
 231                                 matchModes.append(m);
 232                 }
 233
 234                 // if no matching modes were found, disable output
 235                 // else set the mode to the first mode in the list. If no refresh rate was given
 236                 // or no mode was found matching the given refresh rate, the first mode of the
 237                 // list will be used
 238                 if (!matchModes.count())
 239                         mode = RandRMode();
 240                 else
 241                         mode = m_screen->mode(matchModes.first());
 242
 243                 foreach(RRMode m, matchModes)
 244                 {
 245                         RandRMode testMode = m_screen->mode(m);
 246                         if (testMode.refreshRate() == m_proposedRate)
 247                         {
 248                                 mode = testMode;
 249                                 break;
 250                         }
 251                 }
 252         }
 253
 254         // if no output was connected, set the mode to None
 255         if (!m_connectedOutputs.count())
 256                 mode = RandRMode();
 257         else if (!mode.isValid())
 258                 return false;
 259
 260         if (mode.isValid())
 261         {
 262                 if (m_currentRotation == m_proposedRotation ||
 263                     (m_currentRotation == RandR::Rotate0 && m_proposedRotation == RandR::Rotate180) ||
 264                     (m_currentRotation == RandR::Rotate180 && m_proposedRotation == RandR::Rotate0) ||
 265                     (m_currentRotation == RandR::Rotate90 && m_proposedRotation == RandR::Rotate270) ||
 266                     (m_currentRotation == RandR::Rotate270 && m_proposedRotation == RandR::Rotate90))
 267                 {
 268                         QRect r = QRect(0,0,0,0).united(m_proposedRect);
 269                         if (r.width() > m_screen->maxSize().width() || r.height() > m_screen->maxSize().height())
 270                                 return false;
 271
 272                         // if the desired mode is bigger than the current screen size, first change the
 273                         // screen size, and then the crtc size
 274                         if (!m_screen->rect().contains(r))
 275                         {
 276                                 // try to adjust the screen size
 277                                 if (!m_screen->adjustSize(r))
 278                                         return false;
 279                         }
 280
 281                 }
 282                 else
 283                 {
 284
 285                         QRect r(m_proposedRect.topLeft(), QSize(m_proposedRect.height(), m_proposedRect.width()));
 286                         if (!m_screen->rect().contains(r))
 287                         {
 288                                 // check if the rotated rect is smaller than the max screen size
 289                                 r = m_screen->rect().united(r);
 290                                 if (r.width() > m_screen->maxSize().width() || r.height() > m_screen->maxSize().height())
 291                                         return false;
 292
 293                                 // adjust the screen size
 294                                 r = r.united(m_currentRect);
 295                                 if (!m_screen->adjustSize(r))
 296                                         return false;
 297                         }
 298                 }
 299         }
 300
 301         RROutput *outputs = new RROutput[m_connectedOutputs.count()];
 302         for (int i = 0; i < m_connectedOutputs.count(); ++i)
 303                 outputs[i] = m_connectedOutputs.at(i);
 304
 305         Status s = XRRSetCrtcConfig(QX11Info::display(), m_screen->resources(), m_id,
 306                                     RandR::timestamp, m_proposedRect.x(), m_proposedRect.y(), mode.id(),
 307                                     m_proposedRotation, outputs, m_connectedOutputs.count());
 308
 309         delete[] outputs;
 310
 311         bool ret;
 312         if (s == RRSetConfigSuccess)
 313         {
 314                 kDebug() << "Changes for CRTC" << m_id << "successfully applied.";
 315                 m_currentMode = mode.id();
 316                 m_currentRotation = m_proposedRotation;
 317                 m_currentRect = m_proposedRect;
 318                 m_currentRate = mode.refreshRate();
 319                 emit crtcChanged(m_id, RandR::ChangeMode);
 320                 ret = true;
 321         }
 322         else
 323         {
 324                 kDebug() << "Failed to apply changes for CRTC" << m_id;
 325                 ret = false;
 326                 // Invalidate the XRRScreenResources cache
 327                 if(s == RRSetConfigInvalidConfigTime)
 328                         m_screen->loadSettings(true);
 329         }
 330
 331         m_screen->adjustSize();
 332         return ret;
 333 }
 334
 335 bool RandRCrtc::proposeSize(const QSize &s)
 336 {
 337         m_proposedRect.setSize(s);
 338         m_proposedRate = 0;
 339         return true;
 340 }
 341
 342 bool RandRCrtc::proposePosition(const QPoint &p)
 343 {
 344         m_proposedRect.moveTopLeft(p);
 345         return true;
 346 }
 347
 348 bool RandRCrtc::proposeRotation(int rotation)
 349 {
 350         // check if this crtc supports the asked rotation
 351         if (!rotation & m_rotations)
 352                 return false;
 353
 354         m_proposedRotation = rotation;
 355         return true;
 356
 357 }
 358
 359 bool RandRCrtc::proposeRefreshRate(float rate)
 360 {
 361         m_proposedRate = rate;
 362         return true;
 363 }
 364
 365 void RandRCrtc::proposeOriginal()
 366 {
 367         m_proposedRotation = m_originalRotation;
 368         m_proposedRect = m_originalRect;
 369         m_proposedRate = m_originalRate;
 370 }
 371
 372 void RandRCrtc::setOriginal()
 373 {
 374         m_originalRotation = m_currentRotation;
 375         m_originalRect = m_currentRect;
 376         m_originalRate = m_currentRate;
 377 }
 378
 379 bool RandRCrtc::proposedChanged()
 380 {
 381         return (m_proposedRotation != m_currentRotation ||
 382                 m_proposedRect != m_currentRect ||
 383                 m_proposedRate != m_currentRate);
 384 }
 385
 386 bool RandRCrtc::addOutput(RROutput output, const QSize &s)
 387 {
 388         QSize size = s;
 389         // if no mode was given, use the current one
 390         if (!size.isValid())
 391                 size = m_currentRect.size();
 392
 393         // check if this output is not already on this crtc
 394         // if not, add it
 395         if (m_connectedOutputs.indexOf(output) == -1)
 396         {
 397                 // the given output is not possible
 398                 if (m_possibleOutputs.indexOf(output) == -1)
 399                         return false;
 400
 401                 m_connectedOutputs.append(output);
 402         }
 403         m_proposedRect = QRect(m_proposedRect.topLeft(), s);
 404         return true;
 405 }
 406
 407 bool RandRCrtc::removeOutput(RROutput output)
 408 {
 409         int index = m_connectedOutputs.indexOf(output);
 410         if (index == -1)
 411                 return false;
 412
 413         m_connectedOutputs.removeAt(index);
 414         return true;
 415 }
 416
 417 OutputList RandRCrtc::connectedOutputs() const
 418 {
 419         return m_connectedOutputs;
 420 }
 421
 422 ModeList RandRCrtc::modes() const
 423 {
 424         ModeList modeList;
 425
 426         bool first = true;
 427
 428         foreach(RROutput o, m_connectedOutputs)
 429         {
 430                 RandROutput *output = m_screen->output(o);
 431                 if (first)
 432                 {
 433                         modeList = output->modes();
 434                         first = false;
 435                 }
 436                 else
 437                 {
 438                         foreach(RRMode m, modeList)
 439                         {
 440                                 if (output->modes().indexOf(m) == -1)
 441                                         modeList.removeAll(m);
 442                         }
 443                 }
 444         }
 445
 446         return modeList;
 447 }
 448
 449 #include "randrcrtc.moc"
 450
 451