workspace/kcontrol/randr/krandrtray.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 #include "krandrtray.h"
  21 #include "krandrpassivepopup.h"
  22 #include "krandrtray.moc"
  23 #include "legacyrandrscreen.h"
  24 #ifdef HAS_RANDR_1_2
  25 #include "randrscreen.h"
  26 #include "randroutput.h"
  27 #include "randrmode.h"
  28 #endif
  29
  30 #include <config-randr.h>
  31
  32 #include <KActionCollection>
  33 #include <KApplication>
  34 #include <KCMultiDialog>
  35 #include <KComponentData>
  36 #include <KHelpMenu>
  37 #include <KIcon>
  38 #include <KIconLoader>
  39 #include <KLocale>
  40 #include <KMenu>
  41 #include <KAction>
  42 #include <QMouseEvent>
  43 #include <QVariant>
  44
  45 KRandRSystemTray::KRandRSystemTray(RandRDisplay *dpy, QWidget* parent)
  46         : KSystemTrayIcon("preferences-desktop-display-randr", parent),
  47           m_help(new KHelpMenu(parent, KGlobal::mainComponent().aboutData(), false, actionCollection())),
  48           m_popupUp(false),
  49           m_display(dpy)
  50 {
  51         setIcon(KSystemTrayIcon::loadIcon("preferences-desktop-display-randr"));
  52         connect(this, SIGNAL(quitSelected()), kapp, SLOT(quit()));
  53         this->setToolTip( i18n("Screen resize & rotate"));
  54
  55         m_menu = new KMenu(parentWidget());
  56         setContextMenu(m_menu);
  57
  58         connect(this, SIGNAL(activated(QSystemTrayIcon::ActivationReason)), SLOT(slotActivated(QSystemTrayIcon::ActivationReason)));
  59
  60         connect(m_menu, SIGNAL(aboutToShow()), this, SLOT(slotPrepareMenu()));
  61         m_display->refresh();
  62 }
  63
  64 void KRandRSystemTray::slotActivated(QSystemTrayIcon::ActivationReason reason)
  65 {
  66         if(reason == QSystemTrayIcon::DoubleClick) {
  67                 slotPrefs();
  68         }
  69 }
  70
  71 void KRandRSystemTray::slotPrepareMenu()
  72 {
  73         QAction *action;
  74
  75         m_menu->clear();
  76
  77         if (!m_display->isValid())
  78         {
  79                 action = m_menu->addAction(i18n("Required X Extension Not Available"));
  80                 action->setEnabled(false);
  81
  82         }
  83         else
  84         {
  85                 m_screenPopups.clear();
  86                 for (int s = 0; s < m_display->numScreens(); s++)
  87                 {
  88                         m_display->setCurrentScreen(s);
  89                         if (s == m_display->screenIndexOfWidget(parentWidget()))
  90                         {
  91                                 /*lastIndex = menu->insertItem(i18n("Screen %1").arg(s+1));
  92                                 menu->setItemEnabled(lastIndex, false);*/
  93                         }
  94                         else
  95                         {
  96                                 KMenu* subMenu = new KMenu(i18n("Screen %1", s+1), m_menu );
  97                                 subMenu->setObjectName( QString("screen%1").arg(s+1) );
  98                                 m_screenPopups.append(subMenu);
  99                                 populateMenu(subMenu);
 100                                 action = m_menu->addMenu(subMenu);
 101                                 connect(subMenu, SIGNAL(activated(int)), SLOT(slotScreenActivated()));
 102                         }
 103                 }
 104
 105                 m_display->setCurrentScreen(m_display->screenIndexOfWidget(m_menu));
 106                 if (m_display->needsRefresh()) {
 107                         kDebug() << "Configuration dirty, reloading settings...";
 108                         m_display->refresh();
 109                 }
 110
 111                 populateMenu(m_menu);
 112         }
 113
 114         m_menu->addSeparator();
 115
 116         KAction *actPrefs = actionCollection()->addAction( QString() );
 117      actPrefs->setIcon( KIcon( "configure" ) );
 118      actPrefs->setText( i18n( "Configure Display..." ) );
 119
 120         connect( actPrefs, SIGNAL( triggered( bool ) ), SLOT( slotPrefs() ) );
 121         m_menu->addAction( actPrefs );
 122
 123         m_menu->addMenu(/*SmallIcon("help-contents"),KStandardGuiItem::help().text(),*/ m_help->menu());
 124         QAction *quitAction = actionCollection()->action(KStandardAction::name(KStandardAction::Quit));
 125         m_menu->addAction( quitAction );
 126 }
 127
 128 void KRandRSystemTray::slotScreenActivated()
 129 {
 130         m_display->setCurrentScreen(m_screenPopups.indexOf(static_cast<KMenu*>(sender())));
 131 }
 132
 133 void KRandRSystemTray::configChanged()
 134 {
 135         m_display->refresh();
 136
 137         static bool first = true;
 138
 139         if (!first)
 140         {
 141                 QString message;
 142 #ifdef HAS_RANDR_1_2
 143                 if (RandR::has_1_2)
 144                         // TODO: display config changed message
 145                         message = "Screen config changed";
 146                 else
 147 #endif
 148                         message = m_display->currentLegacyScreen()->changedMessage();
 149
 150                 KRandrPassivePopup::message(
 151                 i18n("Screen configuration has changed"),
 152                 message, SmallIcon("view-fullscreen"),
 153                 parentWidget());
 154         }
 155
 156         first = false;
 157 }
 158
 159 void KRandRSystemTray::populateMenu(KMenu* menu)
 160 {
 161 #ifdef HAS_RANDR_1_2
 162         if (RandR::has_1_2)
 163         {
 164                 QAction *action;
 165                 QActionGroup *actionGroup;
 166
 167                 OutputMap outputs = m_display->currentScreen()->outputs();
 168                 if (outputs.count() <= 0)
 169                         return;
 170
 171                 RandRScreen *screen = m_display->currentScreen();
 172                 Q_ASSERT(screen);
 173
 174                 // if the outputs are unified, do not show output-specific size
 175                 // changing options in the tray.
 176                 if (screen->outputsUnified() && screen->connectedCount() > 1)
 177                 {
 178                         SizeList sizes = screen->unifiedSizes();
 179
 180                         if (sizes.count())
 181                         {
 182                                 // populate unified sizes
 183                                 QSize currentSize;
 184                                 currentSize = screen->rect().size();
 185
 186                                 menu->addTitle(SmallIcon("view-fullscreen"), i18n("Screen Size"));
 187                                 actionGroup = populateSizes(menu, sizes, currentSize);
 188                                 connect(actionGroup, SIGNAL(triggered(QAction*)), screen, SLOT(slotResizeUnified(QAction*)));
 189
 190                                 // if the outputs are unified, we can rotate the screen on all outputs
 191                                 int rotations = screen->unifiedRotations();
 192                                 if (rotations != RandR::Rotate0)
 193                                 {
 194                                         menu->addTitle(SmallIcon("view-refresh"), i18n("Orientation"));
 195                                         int rotation = RandR::Rotate0;
 196                                         foreach(RandROutput *output, screen->outputs())
 197                                                 if (output->isActive())
 198                                                 {
 199                                                         rotation = output->rotation();
 200                                                         break;
 201                                                 }
 202
 203                                         actionGroup = populateRotations(menu, rotations, rotation);
 204                                         connect(actionGroup, SIGNAL(triggered(QAction*)), screen, SLOT(slotRotateUnified(QAction*)));
 205                                 }
 206                         }
 207                 }
 208                 else
 209                 {
 210                         if (screen->connectedCount() != 1)
 211                                 menu->addTitle(SmallIcon("view-fullscreen"), i18n("Outputs"));
 212
 213                         foreach(RandROutput *output, outputs)
 214                         {
 215                                 if (output->isConnected())
 216                                 {
 217                                         KMenu *outputMenu;
 218                                         if (screen->connectedCount() == 1)
 219                                                 outputMenu = menu;
 220                                         else
 221                                                 outputMenu = new KMenu(output->name());
 222                                         outputMenu->setIcon(SmallIcon(output->icon()));
 223                                         outputMenu->addTitle(SmallIcon("view-fullscreen"), i18n("%1 - Screen Size", output->name()));
 224
 225                                         QSize currentSize = output->rect().size();
 226
 227                                         // if the output is rotated 90 or 270, the returned rect is inverted
 228                                         // so we need to invert the size before comparing
 229                                         if (output->rotation() & (RandR::Rotate90 | RandR::Rotate270))
 230                                                 currentSize = QSize(currentSize.height(), currentSize.width());
 231
 232                                         actionGroup = populateSizes(outputMenu, output->sizes(), currentSize);
 233                                         connect(actionGroup, SIGNAL(triggered(QAction*)), output, SLOT(slotChangeSize(QAction*)));
 234
 235                                         // if there is only one output active, do not show the disable option
 236                                         // this prevents the user from doing wrong things ;)
 237                                         kDebug() << "Active outputs: " << screen->activeCount();
 238                                         if (screen->activeCount() != 1)
 239                                         {
 240                                                 action = outputMenu->addAction(i18n("Disable"));
 241                                                 if (output->crtc() == None)
 242                                                 {
 243                                                         QFont font = action->font();
 244                                                         font.setBold(true);
 245                                                         action->setFont(font);
 246                                                 }
 247                                                 connect(action, SIGNAL(triggered(bool)), output, SLOT(slotDisable()));
 248                                         }
 249
 250                                         // Display the rotations
 251                                         int rotations = output->rotations();
 252                                         // Don't display the rotation options if there is no point (ie. none are supported)
 253                                         // XFree86 4.3 does not include rotation support.
 254                                         if (rotations != RandR::Rotate0)
 255                                         {
 256                                                 outputMenu->addTitle(SmallIcon("view-refresh"), i18n("Orientation"));
 257                                                 actionGroup = populateRotations(outputMenu, rotations, output->rotation());
 258                                                 connect(actionGroup, SIGNAL(triggered(QAction*)),
 259                                                         output, SLOT(slotChangeRotation(QAction*)));
 260                                         }
 261
 262                                         // refresh rate
 263                                         RateList rates = output->refreshRates();
 264                                         if (rates.count())
 265                                         {
 266                                                 outputMenu->addTitle(SmallIcon("chronometer"), i18n("Refresh Rate"));
 267                                                 actionGroup = populateRates(outputMenu, rates, output->refreshRate());
 268                                                 connect(actionGroup, SIGNAL(triggered(QAction*)),
 269                                                         output, SLOT(slotChangeRefreshRate(QAction*)));
 270                                         }
 271
 272                                         if (screen->connectedCount() != 1)
 273                                                 menu->addMenu(outputMenu);
 274                                 }
 275                         }
 276                 }
 277                 // if there is more than one output connected, give the option to unify the outputs
 278                 if (screen->connectedCount() != 1)
 279                 {
 280                         menu->addSeparator();
 281                         action = menu->addAction( i18n("Unify Outputs"), screen, SLOT(slotUnifyOutputs(bool)) );
 282                         action->setCheckable(true);
 283                         action->setChecked(screen->outputsUnified());
 284                 }
 285         }
 286         else
 287 #endif
 288                 populateLegacyMenu(menu);
 289 }
 290
 291 void KRandRSystemTray::populateLegacyMenu(KMenu* menu)
 292 {
 293         menu->addTitle(SmallIcon("view-fullscreen"), i18n("Screen Size"));
 294
 295         LegacyRandRScreen *screen = m_display->currentLegacyScreen();
 296         Q_ASSERT(screen);
 297
 298         // add sizes
 299         QActionGroup *screenSizeGroup = populateSizes(menu, RandR::sortSizes(screen->pixelSizes()), screen->currentPixelSize());
 300         connect(screenSizeGroup, SIGNAL(triggered(QAction*)), SLOT(slotResolutionChanged(QAction*)));
 301
 302         // Don't display the rotation options if there is no point (ie. none are supported)
 303         // XFree86 4.3 does not include rotation support.
 304         if (screen->rotations() != RandR::Rotate0)
 305         {
 306                 menu->addTitle(SmallIcon("view-refresh"), i18n("Orientation"));
 307
 308                 QActionGroup *rotationGroup = populateRotations(menu, screen->rotations(), screen->rotation());
 309                 connect(rotationGroup, SIGNAL(triggered(QAction*)), SLOT(slotOrientationChanged(QAction*)));
 310         }
 311
 312         RateList rr = screen->refreshRates(screen->proposedSize());
 313         if (rr.count())
 314         {
 315                 menu->addTitle(SmallIcon("clock"), i18n("Refresh Rate"));
 316
 317                 QActionGroup *rateGroup = populateRates(menu, rr, screen->refreshRate());
 318                 connect(rateGroup, SIGNAL(triggered(QAction*)), SLOT(slotRefreshRateChanged(QAction*)));
 319         }
 320 }
 321
 322 QActionGroup *KRandRSystemTray::populateRotations(KMenu *menu, int rotations, int rotation)
 323 {
 324         QAction *action;
 325         QActionGroup *rotateGroup = new QActionGroup(menu);
 326
 327
 328         for (int i = 0; i < 6; i++)
 329         {
 330                 if ((1 << i) & rotations)
 331                 {
 332                         action = menu->addAction(QIcon(RandR::rotationIcon(1 << i, rotation)),
 333                                                            RandR::rotationName(1 << i));
 334
 335                         action->setData(1 << i);
 336                         if (rotation & (1 << i))
 337                         {
 338                                 QFont font = action->font();
 339                                 font.setBold(true);
 340                                 action->setFont(font);
 341                         }
 342                         rotateGroup->addAction(action);
 343                 }
 344         }
 345         return rotateGroup;
 346 }
 347
 348 QActionGroup *KRandRSystemTray::populateSizes(KMenu *menu, const SizeList &sizes, const QSize &size)
 349 {
 350         QAction *action;
 351         QActionGroup *sizeGroup = new QActionGroup(menu);
 352         for (int i = 0; i < sizes.count(); ++i)
 353         {
 354                 QSize s = sizes[i];
 355                 action = menu->addAction(QString("%1 x %2").arg(s.width()).arg(s.height()));
 356                 action->setData(s);
 357                 if (s == size)
 358                 {
 359                         QFont font = action->font();
 360                         font.setBold(true);
 361                         action->setFont(font);
 362                 }
 363                 sizeGroup->addAction(action);
 364         }
 365         return sizeGroup;
 366 }
 367
 368 QActionGroup *KRandRSystemTray::populateRates(KMenu *menu, const RateList &rates, float rate)
 369 {
 370         QAction *action;
 371         QActionGroup *rateGroup = new QActionGroup(menu);
 372
 373         foreach(float r, rates)
 374         {
 375                 action = menu->addAction(ki18n("%1 Hz").subs(r, 0, 'f', 1).toString());
 376                 action->setData(r);
 377                 if (r == rate)
 378                 {
 379                         QFont f = action->font();
 380                         f.setBold(true);
 381                         action->setFont(f);
 382                 }
 383                 rateGroup->addAction(action);
 384         }
 385         return rateGroup;
 386 }
 387
 388 void KRandRSystemTray::slotResolutionChanged(QAction *action)
 389 {
 390         LegacyRandRScreen *screen = m_display->currentLegacyScreen();
 391         Q_ASSERT(screen);
 392
 393         QSize s = action->data().toSize();
 394         int index = 0;
 395         const SizeList pixelSizes = screen->pixelSizes();
 396         for (int i = 0; i < pixelSizes.count(); ++i)
 397                 if (pixelSizes[i] == s)
 398                 {
 399                         index = i;
 400                         break;
 401                 }
 402
 403         if (screen->size() == index)
 404                 return;
 405
 406         screen->proposeSize(index);
 407
 408         screen->proposeRefreshRate(-1);
 409
 410         if (screen->applyProposedAndConfirm())
 411         {
 412                 KConfig config("krandrrc");
 413                 if (m_display->syncTrayApp(config))
 414                         screen->save(config);
 415         }
 416 }
 417
 418 void KRandRSystemTray::slotOrientationChanged(QAction *action)
 419 {
 420         LegacyRandRScreen *screen = m_display->currentLegacyScreen();
 421         Q_ASSERT(screen);
 422
 423         int propose = screen->rotation();
 424         int rotate = action->data().toInt();
 425
 426         if (rotate & RandR::RotateMask)
 427                 propose &= RandR::ReflectMask;
 428
 429         propose ^= rotate;
 430
 431         if (screen->rotation() == propose)
 432                 return;
 433
 434         screen->proposeRotation(propose);
 435
 436         if (screen->applyProposedAndConfirm())
 437         {
 438                 KConfig config("krandrrc");
 439                 if (m_display->syncTrayApp(config))
 440                         screen->save(config);
 441         }
 442 }
 443
 444 void KRandRSystemTray::slotRefreshRateChanged(QAction *action)
 445 {
 446         LegacyRandRScreen *screen = m_display->currentLegacyScreen();
 447         Q_ASSERT(screen);
 448
 449         int index = action->data().toInt();
 450
 451         if (screen->refreshRate() == index)
 452                 return;
 453
 454         screen->proposeRefreshRate(index);
 455
 456         if (screen->applyProposedAndConfirm())
 457         {
 458                 KConfig config("krandrrc");
 459                 if (m_display->syncTrayApp(config))
 460                         screen->save(config);
 461         }
 462 }
 463
 464 void KRandRSystemTray::slotPrefs()
 465 {
 466         KCMultiDialog *kcm = new KCMultiDialog( parentWidget() );
 467         kcm->setFaceType( KCMultiDialog::Plain );
 468         kcm->setPlainCaption( i18n( "Configure Display" ) );
 469         kcm->addModule( "display" );
 470         kcm->exec();
 471         delete kcm;
 472 }