workspace/kcontrol/randr/randrscreen.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 "randrscreen.h"
  20 #include "randrcrtc.h"
  21 #include "randroutput.h"
  22 #include "randrmode.h"
  23
  24 #include <KConfig>
  25 #include <KConfigGroup>
  26 #include <QAction>
  27
  28 RandRScreen::RandRScreen(int screenIndex)
  29 : m_resources(0L)
  30 {
  31         m_index = screenIndex;
  32         m_rect = QRect(0, 0, XDisplayWidth(QX11Info::display(), m_index),
  33                                  XDisplayHeight(QX11Info::display(), m_index));
  34
  35         m_connectedCount = 0;
  36         m_activeCount = 0;
  37
  38         loadSettings();
  39         load();
  40
  41         // select for randr input events
  42         int mask = RRScreenChangeNotifyMask |
  43                    RRCrtcChangeNotifyMask   |
  44                    RROutputChangeNotifyMask |
  45                    RROutputPropertyNotifyMask;
  46
  47         XRRSelectInput(QX11Info::display(), rootWindow(), 0);
  48         XRRSelectInput(QX11Info::display(), rootWindow(), mask);
  49 }
  50
  51 RandRScreen::~RandRScreen()
  52 {
  53         if (m_resources)
  54                 XRRFreeScreenResources(m_resources);
  55
  56         //qDeleteAll(m_crtcs);
  57         //qDeleteAll(m_outputs);
  58         //qDeleteAll(m_modes);
  59 }
  60
  61 int RandRScreen::index() const
  62 {
  63         return m_index;
  64 }
  65
  66 XRRScreenResources* RandRScreen::resources() const
  67 {
  68         return m_resources;
  69 }
  70
  71 Window RandRScreen::rootWindow() const
  72 {
  73         return RootWindow(QX11Info::display(), m_index);
  74 }
  75
  76 void RandRScreen::loadSettings(bool notify)
  77 {
  78         bool changed = false;
  79         int minW, minH, maxW, maxH;
  80
  81         Status status = XRRGetScreenSizeRange(QX11Info::display(), rootWindow(),
  82                                          &minW, &minH, &maxW, &maxH);
  83         //FIXME: we should check the status here
  84         Q_UNUSED(status);
  85         QSize minSize = QSize(minW, minH);
  86         QSize maxSize = QSize(maxW, maxH);
  87
  88         if (minSize != m_minSize || maxSize != m_maxSize)
  89         {
  90                 m_minSize = minSize;
  91                 m_maxSize = maxSize;
  92                 changed = true;
  93         }
  94
  95         if (m_resources)
  96                 XRRFreeScreenResources(m_resources);
  97
  98         m_resources = XRRGetScreenResources(QX11Info::display(), rootWindow());
  99         Q_ASSERT(m_resources);
 100
 101         RandR::timestamp = m_resources->timestamp;
 102
 103         // get all modes
 104         for (int i = 0; i < m_resources->nmode; ++i)
 105         {
 106                 if (!m_modes.contains(m_resources->modes[i].id))
 107                 {
 108                         m_modes[m_resources->modes[i].id] = RandRMode(&m_resources->modes[i]);
 109                         changed = true;
 110                 }
 111         }
 112
 113         //get all crtcs
 114         kDebug() << "Creating CRTC object for XID 0 (\"None\")";
 115         RandRCrtc *c_none = new RandRCrtc(this, None);
 116         m_crtcs[None] = c_none;
 117
 118         for (int i = 0; i < m_resources->ncrtc; ++i)
 119         {
 120                 if (m_crtcs.contains(m_resources->crtcs[i]))
 121                         m_crtcs[m_resources->crtcs[i]]->loadSettings(notify);
 122                 else
 123                 {
 124                         kDebug() << "Creating CRTC object for XID" << m_resources->crtcs[i];
 125                         RandRCrtc *c = new RandRCrtc(this, m_resources->crtcs[i]);
 126                         connect(c, SIGNAL(crtcChanged(RRCrtc, int)), this, SIGNAL(configChanged()));
 127                         connect(c, SIGNAL(crtcChanged(RRCrtc, int)), this, SLOT(save()));
 128                         c->loadSettings(notify);
 129                         m_crtcs[m_resources->crtcs[i]] = c;
 130                         changed = true;
 131                 }
 132         }
 133
 134         //get all outputs
 135         for (int i = 0; i < m_resources->noutput; ++i)
 136         {
 137                 if (m_outputs.contains(m_resources->outputs[i]))
 138                         ;//m_outputs[m_resources->outputs[i]]->loadSettings(notify);
 139                 else
 140                 {
 141                         kDebug() << "Creating output object for XID" << m_resources->outputs[i];
 142                         RandROutput *o = new RandROutput(this, m_resources->outputs[i]);
 143                         connect(o, SIGNAL(outputChanged(RROutput, int)), this,
 144                                       SLOT(slotOutputChanged(RROutput, int)));
 145                         m_outputs[m_resources->outputs[i]] = o;
 146                         if (o->isConnected())
 147                                 m_connectedCount++;
 148                         if (o->isActive())
 149                                 m_activeCount++;
 150
 151                         changed = true;
 152                 }
 153         }
 154
 155         if (notify && changed)
 156                 emit configChanged();
 157
 158 }
 159
 160 void RandRScreen::handleEvent(XRRScreenChangeNotifyEvent* event)
 161 {
 162         m_rect.setWidth(event->width);
 163         m_rect.setHeight(event->height);
 164
 165         emit configChanged();
 166 }
 167
 168 void RandRScreen::handleRandREvent(XRRNotifyEvent* event)
 169 {
 170         RandRCrtc *c;
 171         RandROutput *o;
 172         XRRCrtcChangeNotifyEvent *crtcEvent;
 173         XRROutputChangeNotifyEvent *outputEvent;
 174         XRROutputPropertyNotifyEvent *propertyEvent;
 175
 176         // forward events to crtcs and outputs
 177         switch (event->subtype) {
 178                 case RRNotify_CrtcChange:
 179                         crtcEvent = (XRRCrtcChangeNotifyEvent*)event;
 180                         c = crtc(crtcEvent->crtc);
 181                         Q_ASSERT(c);
 182                         c->handleEvent(crtcEvent);
 183                         return;
 184
 185                 case RRNotify_OutputChange:
 186                         outputEvent = (XRROutputChangeNotifyEvent*)event;
 187                         o = output(outputEvent->output);
 188                         Q_ASSERT(o);
 189                         o->handleEvent(outputEvent);
 190                         return;
 191
 192                 case RRNotify_OutputProperty:
 193                         propertyEvent = (XRROutputPropertyNotifyEvent*)event;
 194                         o = output(propertyEvent->output);
 195                         Q_ASSERT(o);
 196                         o->handlePropertyEvent(propertyEvent);
 197                         return;
 198         }
 199 }
 200
 201 QSize RandRScreen::minSize() const
 202 {
 203         return m_minSize;
 204 }
 205
 206 QSize RandRScreen::maxSize() const
 207 {
 208         return m_maxSize;
 209 }
 210
 211 CrtcMap RandRScreen::crtcs() const
 212 {
 213         return m_crtcs;
 214 }
 215
 216 RandRCrtc* RandRScreen::crtc(RRCrtc id) const
 217 {
 218         if (m_crtcs.contains(id))
 219                 return m_crtcs[id];
 220
 221         return 0;
 222 }
 223
 224 OutputMap RandRScreen::outputs() const
 225 {
 226         return m_outputs;
 227 }
 228
 229 RandROutput* RandRScreen::output(RROutput id) const
 230 {
 231         if (m_outputs.contains(id))
 232                 return m_outputs[id];
 233
 234         return 0;
 235 }
 236
 237 ModeMap RandRScreen::modes() const
 238 {
 239         return m_modes;
 240 }
 241
 242 RandRMode RandRScreen::mode(RRMode id) const
 243 {
 244         if (m_modes.contains(id))
 245                 return m_modes[id];
 246
 247         return RandRMode(0);
 248 }
 249
 250 bool RandRScreen::adjustSize(const QRect &minimumSize)
 251 {
 252         //try to find a size in which all outputs fit
 253
 254         //start with a given minimum rect
 255         QRect rect = QRect(0, 0, 0, 0).united(minimumSize);
 256
 257         foreach(RandROutput *output, m_outputs)
 258         {
 259                 // outputs that are not active should not be taken into account
 260                 // when calculating the screen size
 261                 if (!output->isActive())
 262                         continue;
 263                 rect = rect.united(output->rect());
 264         }
 265
 266
 267         // check bounds
 268         if (rect.width() < m_minSize.width())
 269                 rect.setWidth(m_minSize.width());
 270         if (rect.height() < m_minSize.height())
 271                 rect.setHeight(m_minSize.height());
 272
 273         if (rect.width() > m_maxSize.width())
 274                 return false;
 275         if (rect.height() > m_maxSize.height())
 276                 return false;
 277
 278         return setSize(rect.size());
 279 }
 280
 281 bool RandRScreen::setSize(const QSize &s)
 282 {
 283         if (s == m_rect.size())
 284                 return true;
 285
 286         if (s.width() < m_minSize.width() ||
 287             s.height() < m_minSize.height() ||
 288             s.width() > m_maxSize.width() ||
 289             s.height() > m_maxSize.height())
 290                 return false;
 291
 292         int widthMM, heightMM;
 293         float dpi;
 294
 295         /* values taken from xrandr */
 296         dpi = (25.4 * DisplayHeight(QX11Info::display(), m_index)) / DisplayHeightMM(QX11Info::display(), m_index);
 297         widthMM =  (int) ((25.4 * s.width()) / dpi);
 298         heightMM = (int) ((25.4 * s.height()) / dpi);
 299
 300         XRRSetScreenSize(QX11Info::display(), rootWindow(), s.width(), s.height(), widthMM, heightMM);
 301         m_rect.setSize(s);
 302
 303         return true;
 304 }
 305
 306 int RandRScreen::connectedCount() const
 307 {
 308         return m_connectedCount;
 309 }
 310
 311 int RandRScreen::activeCount() const
 312 {
 313         return m_activeCount;
 314 }
 315
 316 bool RandRScreen::outputsUnified() const
 317 {
 318         return m_outputsUnified;
 319 }
 320
 321 void RandRScreen::setOutputsUnified(bool unified)
 322 {
 323         m_outputsUnified = unified;
 324
 325         // should this be called here?
 326         slotUnifyOutputs(unified);
 327 }
 328
 329 int RandRScreen::unifiedRotations() const
 330 {
 331
 332         bool first = true;
 333         int rotations = RandR::Rotate0;
 334
 335         foreach(RandRCrtc *crtc, m_crtcs)
 336         {
 337                 if (!crtc->connectedOutputs().count())
 338                         continue;
 339
 340                 if (first)
 341                 {
 342                         rotations = crtc->rotations();
 343                         first = false;
 344                 }
 345                 else
 346                         rotations &= crtc->rotations();
 347         }
 348
 349         return rotations;
 350 }
 351
 352 SizeList RandRScreen::unifiedSizes() const
 353 {
 354         SizeList sizeList;
 355         bool first = true;
 356
 357         foreach(RandROutput *output, m_outputs)
 358         {
 359                 if (!output->isConnected())
 360                         continue;
 361
 362                 if (first)
 363                 {
 364                         // we start using the list from the first output
 365                         sizeList = output->sizes();
 366                         first = false;
 367                 }
 368                 else
 369                 {
 370                         SizeList outputSizes = output->sizes();
 371                         for (int i = sizeList.count() - 1; i >=0; --i)
 372                         {
 373                                 // check if the current output has the i-th size of the sizeList
 374                                 // if not, remove from the list
 375                                 if (outputSizes.indexOf(sizeList[i]) == -1)
 376                                         sizeList.removeAt(i);
 377                         }
 378                 }
 379         }
 380
 381         return sizeList;
 382 }
 383
 384 QRect RandRScreen::rect() const
 385 {
 386         return m_rect;
 387 }
 388
 389 void RandRScreen::load(KConfig &config)
 390 {
 391         KConfigGroup group = config.group("Screen_" + QString::number(m_index));
 392         m_outputsUnified = group.readEntry("OutputsUnified", false);
 393         m_unifiedRect = (group.readEntry("UnifiedRect", "0,0,0,0") == "0,0,0,0")
 394                 ? QRect() // "0,0,0,0" (serialization for QRect()) does not convert to a QRect
 395                 : group.readEntry("UnifiedRect", QRect());
 396         m_unifiedRotation = group.readEntry("UnifiedRotation", (int) RandR::Rotate0);
 397
 398         slotUnifyOutputs(m_outputsUnified);
 399
 400         foreach(RandROutput *output, m_outputs)
 401         {
 402                 if (output->isConnected())
 403                         output->load(config);
 404         }
 405 }
 406
 407 void RandRScreen::save(KConfig &config)
 408 {
 409         KConfigGroup group = config.group("Screen_" + QString::number(m_index));
 410         group.writeEntry("OutputsUnified", m_outputsUnified);
 411         group.writeEntry("UnifiedRect", m_unifiedRect);
 412         group.writeEntry("UnifiedRotation", m_unifiedRotation);
 413
 414         foreach(RandROutput *output, m_outputs)
 415         {
 416                 if (output->isConnected())
 417                         output->save(config);
 418         }
 419 }
 420
 421 void RandRScreen::save()
 422 {
 423         KConfig cfg("krandrrc");
 424         save(cfg);
 425 }
 426
 427 void RandRScreen::load()
 428 {
 429         KConfig cfg("krandrrc");
 430         load(cfg);
 431 }
 432
 433 bool RandRScreen::applyProposed(bool confirm)
 434 {
 435         kDebug() << "Applying proposed changes for screen" << m_index << "...";
 436
 437         bool succeed = true;
 438         QRect r;
 439
 440         foreach(RandROutput *output, m_outputs) {
 441                 /*
 442                 r = output->rect();
 443                 RandROutput::Relation outputRelation;
 444                 RandROutput *related = output->relation(&outputRelation);
 445
 446                 if(!related) {
 447                         r.setTopLeft(QPoint(0, 0));
 448                 }
 449                 QRect relativeRect = related->rect();
 450
 451                 switch(outputRelation) {
 452                 case RandROutput::LeftOf:
 453                         r.setTopLeft(QPoint(relativeRect.x() - r.x(),
 454                                             relativeRect.y()));
 455                 case RandROutput::RightOf:
 456                         r.setTopLeft(QPoint(relativeRect.x() + r.x(),
 457                                             relativeRect.y()));
 458                 case RandROutput::Over:
 459                         r.setTopLeft(QPoint(relativeRect.x(),
 460                                             relativeRect.y() - r.y()));
 461                 case RandROutput::Under:
 462                         r.setTopLeft(QPoint(relativeRect.x(),
 463                                             relativeRect.y() + r.y()));
 464
 465                 case RandROutput::SameAs:
 466                         r.setTopLeft(related->rect().topLeft());
 467                         break;
 468                 }
 469                 output->proposeRect(r);
 470                 */
 471                 if(!output->applyProposed()) {
 472                         succeed = false;
 473                         break;
 474                 }
 475         }
 476         /*
 477         foreach(RandROutput *output, m_outputs)
 478         {
 479                 r = output->rect();
 480                 if (!output->applyProposed())
 481                 {
 482                         succeed = false;
 483                         break;
 484                 }
 485         }*/
 486
 487         kDebug() << "Changes have been applied to all outputs.";
 488
 489         // if we could apply the config clean, ask for confirmation
 490         if (succeed && confirm)
 491                 succeed = RandR::confirm(r);
 492
 493         // if we succeeded applying and the user confirmed the changes,
 494         // just return from here
 495         if (succeed)
 496                 return true;
 497
 498         kDebug() << "Changes canceled, reverting to original setup.";
 499
 500         //Revert changes if not succeed
 501         foreach(RandROutput *o, m_outputs)
 502         {
 503                 if (o->isConnected())
 504                 {
 505                         o->proposeOriginal();
 506                         o->applyProposed();
 507                 }
 508         }
 509         return false;
 510 }
 511
 512 void RandRScreen::unifyOutputs()
 513 {
 514         KConfig cfg("krandrrc");
 515         SizeList sizes = unifiedSizes();
 516
 517         //FIXME: better handle this
 518         if (!sizes.count())
 519                 return;
 520
 521         // if there is only one output connected, there is no way to unify it
 522         if (m_connectedCount <= 1)
 523                 return;
 524
 525         if (sizes.indexOf(m_unifiedRect.size()) == -1)
 526                 m_unifiedRect.setSize(sizes.first());
 527
 528         kDebug() << "Unifying outputs using rect " << m_unifiedRect;
 529         // iterate over all outputs and make sure all connected outputs get activated
 530         // and use the right size
 531         foreach(RandROutput *o, m_outputs)
 532         {
 533                 // if the output is not connected we don't need to do anything
 534                 if (!o->isConnected())
 535                        continue;
 536
 537                 // if the output is connected and already has the same rect and rotation
 538                 // as the unified ones, continue
 539                 if (o->isActive() && o->rect() == m_unifiedRect
 540                                   && o->rotation() == m_unifiedRotation)
 541                         continue;
 542
 543                 // this is to get the refresh rate to use
 544                 //o->load(cfg);
 545                 o->proposeRect(m_unifiedRect);
 546                 o->proposeRotation(m_unifiedRotation);
 547                 o->applyProposed(RandR::ChangeRect | RandR::ChangeRotation, false);
 548         }
 549
 550         // FIXME: if by any reason we were not able to unify the outputs, we should
 551         // do something
 552         save();
 553         emit configChanged();
 554 }
 555
 556 void RandRScreen::slotResizeUnified(QAction *action)
 557 {
 558         m_unifiedRect.setSize(action->data().toSize());
 559         unifyOutputs();
 560 }
 561
 562 void RandRScreen::slotUnifyOutputs(bool unified)
 563 {
 564         m_outputsUnified = unified;
 565         KConfig cfg("krandrrc");
 566
 567         if (!unified || m_connectedCount <= 1)
 568         {
 569                 foreach(RandROutput *output, m_outputs)
 570                         if (output->isConnected())
 571                         {
 572                                 output->load(cfg);
 573                                 output->applyProposed();
 574                         }
 575         }
 576         else
 577         {
 578                 SizeList sizes = unifiedSizes();
 579
 580                 if (!sizes.count())
 581                 {
 582                         // FIXME: this should be better handle
 583                         return;
 584                 }
 585
 586                 QSize s = m_unifiedRect.size();
 587
 588                 // if the last size we used is not available, use the first one
 589                 // from the list
 590                 if (sizes.indexOf(s) == -1)
 591                         s = sizes[0];
 592
 593                 m_unifiedRect.setTopLeft(QPoint(0,0));
 594                 m_unifiedRect.setSize(s);
 595                 unifyOutputs();
 596         }
 597 }
 598
 599 void RandRScreen::slotRotateUnified(QAction *action)
 600 {
 601         m_unifiedRotation = action->data().toInt();
 602
 603         unifyOutputs();
 604 }
 605
 606 void RandRScreen::slotOutputChanged(RROutput id, int changes)
 607 {
 608         Q_UNUSED(id);
 609         Q_UNUSED(changes);
 610
 611         int connected = 0, active = 0;
 612         foreach(RandROutput *output, m_outputs)
 613         {
 614                 if (output->isConnected())
 615                         connected++;
 616                 if (output->isActive())
 617                         active++;
 618         }
 619
 620         m_connectedCount = connected;
 621         m_activeCount = active;
 622
 623         // if there is less than 2 outputs connected, there is no need to unify
 624         if (connected <= 1)
 625                 return;
 626
 627         // wait some time before checking the output configuration as some randr
 628         // clients do operations in more than one step
 629         if(m_outputsUnified)
 630                 unifyOutputs();
 631 }
 632
 633 #include "randrscreen.moc"
 634
 635