You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
704 lines
17 KiB
704 lines
17 KiB
/*
|
|
* Copyright (c) 2002,2003 Hamish Rodda <rodda@kde.org>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#include "randr.h"
|
|
|
|
#include <qtimer.h>
|
|
|
|
#include <kdebug.h>
|
|
#include <klocale.h>
|
|
#include <kglobal.h>
|
|
#include <kapplication.h>
|
|
#include <kiconloader.h>
|
|
#include <dcopclient.h>
|
|
#include <kipc.h>
|
|
#include <kactivelabel.h>
|
|
|
|
#include "ktimerdialog.h"
|
|
|
|
#include <X11/Xlib.h>
|
|
#define INT8 _X11INT8
|
|
#define INT32 _X11INT32
|
|
#include <X11/Xproto.h>
|
|
#undef INT8
|
|
#undef INT32
|
|
#include <X11/extensions/Xrandr.h>
|
|
|
|
class RandRScreenPrivate
|
|
{
|
|
public:
|
|
RandRScreenPrivate() : config(0L) {};
|
|
~RandRScreenPrivate()
|
|
{
|
|
if (config)
|
|
XRRFreeScreenConfigInfo(config);
|
|
}
|
|
|
|
XRRScreenConfiguration* config;
|
|
};
|
|
|
|
RandRScreen::RandRScreen(int screenIndex)
|
|
: d(new RandRScreenPrivate())
|
|
, m_screen(screenIndex)
|
|
, m_shownDialog(NULL)
|
|
{
|
|
loadSettings();
|
|
setOriginal();
|
|
}
|
|
|
|
RandRScreen::~RandRScreen()
|
|
{
|
|
delete d;
|
|
}
|
|
|
|
void RandRScreen::loadSettings()
|
|
{
|
|
if (d->config)
|
|
XRRFreeScreenConfigInfo(d->config);
|
|
|
|
d->config = XRRGetScreenInfo(qt_xdisplay(), RootWindow(qt_xdisplay(), m_screen));
|
|
Q_ASSERT(d->config);
|
|
|
|
Rotation rotation;
|
|
m_currentSize = m_proposedSize = XRRConfigCurrentConfiguration(d->config, &rotation);
|
|
m_currentRotation = m_proposedRotation = rotation;
|
|
|
|
m_pixelSizes.clear();
|
|
m_mmSizes.clear();
|
|
int numSizes;
|
|
XRRScreenSize* sizes = XRRSizes(qt_xdisplay(), m_screen, &numSizes);
|
|
for (int i = 0; i < numSizes; i++) {
|
|
m_pixelSizes.append(QSize(sizes[i].width, sizes[i].height));
|
|
m_mmSizes.append(QSize(sizes[i].mwidth, sizes[i].mheight));
|
|
}
|
|
|
|
m_rotations = XRRRotations(qt_xdisplay(), m_screen, &rotation);
|
|
|
|
m_currentRefreshRate = m_proposedRefreshRate = refreshRateHzToIndex(m_currentSize, XRRConfigCurrentRate(d->config));
|
|
}
|
|
|
|
void RandRScreen::setOriginal()
|
|
{
|
|
m_originalSize = m_currentSize;
|
|
m_originalRotation = m_currentRotation;
|
|
m_originalRefreshRate = m_currentRefreshRate;
|
|
}
|
|
|
|
bool RandRScreen::applyProposed()
|
|
{
|
|
//kdDebug() << k_funcinfo << " size " << (SizeID)proposedSize() << ", rotation " << proposedRotation() << ", refresh " << refreshRateIndexToHz(proposedSize(), proposedRefreshRate()) << endl;
|
|
|
|
Status status;
|
|
|
|
if (proposedRefreshRate() < 0)
|
|
status = XRRSetScreenConfig(qt_xdisplay(), d->config, DefaultRootWindow(qt_xdisplay()), (SizeID)proposedSize(), (Rotation)proposedRotation(), CurrentTime);
|
|
else {
|
|
if( refreshRateIndexToHz(proposedSize(), proposedRefreshRate()) <= 0 ) {
|
|
m_proposedRefreshRate = 0;
|
|
}
|
|
status = XRRSetScreenConfigAndRate(qt_xdisplay(), d->config, DefaultRootWindow(qt_xdisplay()), (SizeID)proposedSize(), (Rotation)proposedRotation(), refreshRateIndexToHz(proposedSize(), proposedRefreshRate()), CurrentTime);
|
|
}
|
|
|
|
//kdDebug() << "New size: " << WidthOfScreen(ScreenOfDisplay(QPaintDevice::x11AppDisplay(), screen)) << ", " << HeightOfScreen(ScreenOfDisplay(QPaintDevice::x11AppDisplay(), screen)) << endl;
|
|
|
|
if (status == RRSetConfigSuccess) {
|
|
m_currentSize = m_proposedSize;
|
|
m_currentRotation = m_proposedRotation;
|
|
m_currentRefreshRate = m_proposedRefreshRate;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool RandRScreen::applyProposedAndConfirm()
|
|
{
|
|
if (proposedChanged()) {
|
|
setOriginal();
|
|
|
|
if (applyProposed()) {
|
|
if (!confirm()) {
|
|
proposeOriginal();
|
|
applyProposed();
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool RandRScreen::confirm()
|
|
{
|
|
// uncomment the line below and edit out the KTimerDialog stuff to get
|
|
// a version which works on today's kdelibs (no accept dialog is presented)
|
|
|
|
// FIXME remember to put the dialog on the right screen
|
|
|
|
KTimerDialog acceptDialog ( 15000, KTimerDialog::CountDown,
|
|
KApplication::kApplication()->mainWidget(),
|
|
"mainKTimerDialog",
|
|
true,
|
|
i18n("Confirm Display Setting Change"),
|
|
KTimerDialog::Ok|KTimerDialog::Cancel,
|
|
KTimerDialog::Cancel);
|
|
|
|
acceptDialog.setButtonOK(KGuiItem(i18n("&Accept Configuration"), "button_ok"));
|
|
acceptDialog.setButtonCancel(KGuiItem(i18n("&Return to Previous Configuration"), "button_cancel"));
|
|
|
|
KActiveLabel *label = new KActiveLabel(i18n("Your screen orientation, size and refresh rate "
|
|
"have been changed to the requested settings. Please indicate whether you wish to "
|
|
"keep this configuration. In 15 seconds the display will revert to your previous "
|
|
"settings."), &acceptDialog, "userSpecifiedLabel");
|
|
|
|
acceptDialog.setMainWidget(label);
|
|
|
|
KDialog::centerOnScreen(&acceptDialog, m_screen);
|
|
|
|
m_shownDialog = &acceptDialog;
|
|
connect( m_shownDialog, SIGNAL( destroyed()), this, SLOT( shownDialogDestroyed()));
|
|
connect( kapp->desktop(), SIGNAL( resized(int)), this, SLOT( desktopResized()));
|
|
|
|
return acceptDialog.exec();
|
|
}
|
|
|
|
void RandRScreen::shownDialogDestroyed()
|
|
{
|
|
m_shownDialog = NULL;
|
|
disconnect( kapp->desktop(), SIGNAL( resized(int)), this, SLOT( desktopResized()));
|
|
}
|
|
|
|
void RandRScreen::desktopResized()
|
|
{
|
|
if( m_shownDialog != NULL )
|
|
KDialog::centerOnScreen(m_shownDialog, m_screen);
|
|
}
|
|
|
|
QString RandRScreen::changedMessage() const
|
|
{
|
|
if (currentRefreshRate() == -1)
|
|
return i18n("New configuration:\nResolution: %1 x %2\nOrientation: %3")
|
|
.arg(currentPixelWidth())
|
|
.arg(currentPixelHeight())
|
|
.arg(currentRotationDescription());
|
|
else
|
|
return i18n("New configuration:\nResolution: %1 x %2\nOrientation: %3\nRefresh rate: %4")
|
|
.arg(currentPixelWidth())
|
|
.arg(currentPixelHeight())
|
|
.arg(currentRotationDescription())
|
|
.arg(currentRefreshRateDescription());
|
|
}
|
|
|
|
bool RandRScreen::changedFromOriginal() const
|
|
{
|
|
return m_currentSize != m_originalSize || m_currentRotation != m_originalRotation || m_currentRefreshRate != m_originalRefreshRate;
|
|
}
|
|
|
|
void RandRScreen::proposeOriginal()
|
|
{
|
|
m_proposedSize = m_originalSize;
|
|
m_proposedRotation = m_originalRotation;
|
|
m_proposedRefreshRate = m_originalRefreshRate;
|
|
}
|
|
|
|
bool RandRScreen::proposedChanged() const
|
|
{
|
|
return m_currentSize != m_proposedSize || m_currentRotation != m_proposedRotation || m_currentRefreshRate != m_proposedRefreshRate;
|
|
}
|
|
|
|
QString RandRScreen::rotationName(int rotation, bool pastTense, bool capitalised)
|
|
{
|
|
if (!pastTense)
|
|
switch (rotation) {
|
|
case RR_Rotate_0:
|
|
return i18n("Normal");
|
|
case RR_Rotate_90:
|
|
return i18n("Left (90 degrees)");
|
|
case RR_Rotate_180:
|
|
return i18n("Upside-down (180 degrees)");
|
|
case RR_Rotate_270:
|
|
return i18n("Right (270 degrees)");
|
|
case RR_Reflect_X:
|
|
return i18n("Mirror horizontally");
|
|
case RR_Reflect_Y:
|
|
return i18n("Mirror vertically");
|
|
default:
|
|
return i18n("Unknown orientation");
|
|
}
|
|
|
|
switch (rotation) {
|
|
case RR_Rotate_0:
|
|
return i18n("Normal");
|
|
case RR_Rotate_90:
|
|
return i18n("Rotated 90 degrees counterclockwise");
|
|
case RR_Rotate_180:
|
|
return i18n("Rotated 180 degrees counterclockwise");
|
|
case RR_Rotate_270:
|
|
return i18n("Rotated 270 degrees counterclockwise");
|
|
default:
|
|
if (rotation & RR_Reflect_X)
|
|
if (rotation & RR_Reflect_Y)
|
|
if (capitalised)
|
|
return i18n("Mirrored horizontally and vertically");
|
|
else
|
|
return i18n("mirrored horizontally and vertically");
|
|
else
|
|
if (capitalised)
|
|
return i18n("Mirrored horizontally");
|
|
else
|
|
return i18n("mirrored horizontally");
|
|
else if (rotation & RR_Reflect_Y)
|
|
if (capitalised)
|
|
return i18n("Mirrored vertically");
|
|
else
|
|
return i18n("mirrored vertically");
|
|
else
|
|
if (capitalised)
|
|
return i18n("Unknown orientation");
|
|
else
|
|
return i18n("unknown orientation");
|
|
}
|
|
}
|
|
|
|
QPixmap RandRScreen::rotationIcon(int rotation) const
|
|
{
|
|
// Adjust icons for current screen orientation
|
|
if (!(m_currentRotation & RR_Rotate_0) && rotation & (RR_Rotate_0 | RR_Rotate_90 | RR_Rotate_180 | RR_Rotate_270)) {
|
|
int currentAngle = m_currentRotation & (RR_Rotate_90 | RR_Rotate_180 | RR_Rotate_270);
|
|
switch (currentAngle) {
|
|
case RR_Rotate_90:
|
|
rotation <<= 3;
|
|
break;
|
|
case RR_Rotate_180:
|
|
rotation <<= 2;
|
|
break;
|
|
case RR_Rotate_270:
|
|
rotation <<= 1;
|
|
break;
|
|
}
|
|
|
|
// Fix overflow
|
|
if (rotation > RR_Rotate_270) {
|
|
rotation >>= 4;
|
|
}
|
|
}
|
|
|
|
switch (rotation) {
|
|
case RR_Rotate_0:
|
|
return SmallIcon("up");
|
|
case RR_Rotate_90:
|
|
return SmallIcon("back");
|
|
case RR_Rotate_180:
|
|
return SmallIcon("down");
|
|
case RR_Rotate_270:
|
|
return SmallIcon("forward");
|
|
case RR_Reflect_X:
|
|
case RR_Reflect_Y:
|
|
default:
|
|
return SmallIcon("stop");
|
|
}
|
|
}
|
|
|
|
QString RandRScreen::currentRotationDescription() const
|
|
{
|
|
QString ret = rotationName(m_currentRotation & RotateMask);
|
|
|
|
if (m_currentRotation != m_currentRotation & RotateMask)
|
|
if (m_currentRotation & RR_Rotate_0)
|
|
ret = rotationName(m_currentRotation & (RR_Reflect_X + RR_Reflect_X), true, true);
|
|
else
|
|
ret += ", " + rotationName(m_currentRotation & (RR_Reflect_X + RR_Reflect_X), true, false);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int RandRScreen::rotationIndexToDegree(int rotation) const
|
|
{
|
|
switch (rotation & RotateMask) {
|
|
case RR_Rotate_90:
|
|
return 90;
|
|
|
|
case RR_Rotate_180:
|
|
return 180;
|
|
|
|
case RR_Rotate_270:
|
|
return 270;
|
|
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
int RandRScreen::rotationDegreeToIndex(int degree) const
|
|
{
|
|
switch (degree) {
|
|
case 90:
|
|
return RR_Rotate_90;
|
|
|
|
case 180:
|
|
return RR_Rotate_180;
|
|
|
|
case 270:
|
|
return RR_Rotate_270;
|
|
|
|
default:
|
|
return RR_Rotate_0;
|
|
}
|
|
}
|
|
|
|
int RandRScreen::currentPixelWidth() const
|
|
{
|
|
return m_pixelSizes[m_currentSize].width();
|
|
}
|
|
|
|
int RandRScreen::currentPixelHeight() const
|
|
{
|
|
return m_pixelSizes[m_currentSize].height();
|
|
}
|
|
|
|
int RandRScreen::currentMMWidth() const
|
|
{
|
|
return m_pixelSizes[m_currentSize].width();
|
|
}
|
|
|
|
int RandRScreen::currentMMHeight() const
|
|
{
|
|
return m_pixelSizes[m_currentSize].height();
|
|
}
|
|
|
|
QStringList RandRScreen::refreshRates(int size) const
|
|
{
|
|
int nrates;
|
|
short* rates = XRRRates(qt_xdisplay(), m_screen, (SizeID)size, &nrates);
|
|
|
|
QStringList ret;
|
|
for (int i = 0; i < nrates; i++)
|
|
ret << refreshRateDirectDescription(rates[i]);
|
|
|
|
return ret;
|
|
}
|
|
|
|
QString RandRScreen::refreshRateDirectDescription(int rate) const
|
|
{
|
|
return i18n("Refresh rate in Hertz (Hz)", "%1 Hz").arg(rate);
|
|
}
|
|
|
|
QString RandRScreen::refreshRateIndirectDescription(int size, int index) const
|
|
{
|
|
return i18n("Refresh rate in Hertz (Hz)", "%1 Hz").arg(refreshRateIndexToHz(size, index));
|
|
}
|
|
|
|
QString RandRScreen::refreshRateDescription(int size, int index) const
|
|
{
|
|
return refreshRates(size)[index];
|
|
}
|
|
|
|
bool RandRScreen::proposeRefreshRate(int index)
|
|
{
|
|
if (index >= 0 && (int)refreshRates(proposedSize()).count() > index) {
|
|
m_proposedRefreshRate = index;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
int RandRScreen::currentRefreshRate() const
|
|
{
|
|
return m_currentRefreshRate;
|
|
}
|
|
|
|
QString RandRScreen::currentRefreshRateDescription() const
|
|
{
|
|
return refreshRateIndirectDescription(m_currentSize, m_currentRefreshRate);
|
|
}
|
|
|
|
int RandRScreen::proposedRefreshRate() const
|
|
{
|
|
return m_proposedRefreshRate;
|
|
}
|
|
|
|
int RandRScreen::refreshRateHzToIndex(int size, int hz) const
|
|
{
|
|
int nrates;
|
|
short* rates = XRRRates(qt_xdisplay(), m_screen, (SizeID)size, &nrates);
|
|
|
|
for (int i = 0; i < nrates; i++)
|
|
if (hz == rates[i])
|
|
return i;
|
|
|
|
if (nrates != 0)
|
|
// Wrong input Hz!
|
|
Q_ASSERT(false);
|
|
|
|
return -1;
|
|
}
|
|
|
|
int RandRScreen::refreshRateIndexToHz(int size, int index) const
|
|
{
|
|
int nrates;
|
|
short* rates = XRRRates(qt_xdisplay(), m_screen, (SizeID)size, &nrates);
|
|
|
|
if (nrates == 0 || index < 0)
|
|
return 0;
|
|
|
|
// Wrong input Hz!
|
|
if(index >= nrates)
|
|
return 0;
|
|
|
|
return rates[index];
|
|
}
|
|
|
|
int RandRScreen::numSizes() const
|
|
{
|
|
return m_pixelSizes.count();
|
|
}
|
|
|
|
const QSize& RandRScreen::pixelSize(int index) const
|
|
{
|
|
return m_pixelSizes[index];
|
|
}
|
|
|
|
const QSize& RandRScreen::mmSize(int index) const
|
|
{
|
|
return m_mmSizes[index];
|
|
}
|
|
|
|
int RandRScreen::sizeIndex(QSize pixelSize) const
|
|
{
|
|
for (uint i = 0; i < m_pixelSizes.count(); i++)
|
|
if (m_pixelSizes[i] == pixelSize)
|
|
return i;
|
|
|
|
return -1;
|
|
}
|
|
|
|
int RandRScreen::rotations() const
|
|
{
|
|
return m_rotations;
|
|
}
|
|
|
|
int RandRScreen::currentRotation() const
|
|
{
|
|
return m_currentRotation;
|
|
}
|
|
|
|
int RandRScreen::currentSize() const
|
|
{
|
|
return m_currentSize;
|
|
}
|
|
|
|
int RandRScreen::proposedRotation() const
|
|
{
|
|
return m_proposedRotation;
|
|
}
|
|
|
|
void RandRScreen::proposeRotation(int newRotation)
|
|
{
|
|
m_proposedRotation = newRotation & OrientationMask;
|
|
}
|
|
|
|
int RandRScreen::proposedSize() const
|
|
{
|
|
return m_proposedSize;
|
|
}
|
|
|
|
bool RandRScreen::proposeSize(int newSize)
|
|
{
|
|
if ((int)m_pixelSizes.count() > newSize) {
|
|
m_proposedSize = newSize;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void RandRScreen::load(KConfig& config)
|
|
{
|
|
config.setGroup(QString("Screen%1").arg(m_screen));
|
|
|
|
if (proposeSize(sizeIndex(QSize(config.readNumEntry("width", currentPixelWidth()), config.readNumEntry("height", currentPixelHeight())))))
|
|
proposeRefreshRate(refreshRateHzToIndex(proposedSize(), config.readNumEntry("refresh", currentRefreshRate())));
|
|
|
|
proposeRotation(rotationDegreeToIndex(config.readNumEntry("rotation", 0)) + (config.readBoolEntry("reflectX") ? ReflectX : 0) + (config.readBoolEntry("reflectY") ? ReflectY : 0));
|
|
}
|
|
|
|
void RandRScreen::save(KConfig& config) const
|
|
{
|
|
config.setGroup(QString("Screen%1").arg(m_screen));
|
|
config.writeEntry("width", currentPixelWidth());
|
|
config.writeEntry("height", currentPixelHeight());
|
|
config.writeEntry("refresh", refreshRateIndexToHz(currentSize(), currentRefreshRate()));
|
|
config.writeEntry("rotation", rotationIndexToDegree(currentRotation()));
|
|
config.writeEntry("reflectX", (bool)(currentRotation() & ReflectMask) == ReflectX);
|
|
config.writeEntry("reflectY", (bool)(currentRotation() & ReflectMask) == ReflectY);
|
|
}
|
|
|
|
RandRDisplay::RandRDisplay()
|
|
: m_valid(true)
|
|
{
|
|
// Check extension
|
|
Status s = XRRQueryExtension(qt_xdisplay(), &m_eventBase, &m_errorBase);
|
|
if (!s) {
|
|
m_errorCode = QString("%1, base %1").arg(s).arg(m_errorBase);
|
|
m_valid = false;
|
|
return;
|
|
}
|
|
|
|
int major_version, minor_version;
|
|
XRRQueryVersion(qt_xdisplay(), &major_version, &minor_version);
|
|
|
|
m_version = QString("X Resize and Rotate extension version %1.%1").arg(major_version).arg(minor_version);
|
|
|
|
m_numScreens = ScreenCount(qt_xdisplay());
|
|
|
|
// This assumption is WRONG with Xinerama
|
|
// Q_ASSERT(QApplication::desktop()->numScreens() == ScreenCount(qt_xdisplay()));
|
|
|
|
m_screens.setAutoDelete(true);
|
|
for (int i = 0; i < m_numScreens; i++) {
|
|
m_screens.append(new RandRScreen(i));
|
|
}
|
|
|
|
setCurrentScreen(QApplication::desktop()->primaryScreen());
|
|
}
|
|
|
|
bool RandRDisplay::isValid() const
|
|
{
|
|
return m_valid;
|
|
}
|
|
|
|
const QString& RandRDisplay::errorCode() const
|
|
{
|
|
return m_errorCode;
|
|
}
|
|
|
|
int RandRDisplay::eventBase() const
|
|
{
|
|
return m_eventBase;
|
|
}
|
|
|
|
int RandRDisplay::screenChangeNotifyEvent() const
|
|
{
|
|
return m_eventBase + RRScreenChangeNotify;
|
|
}
|
|
|
|
int RandRDisplay::errorBase() const
|
|
{
|
|
return m_errorBase;
|
|
}
|
|
|
|
const QString& RandRDisplay::version() const
|
|
{
|
|
return m_version;
|
|
}
|
|
|
|
void RandRDisplay::setCurrentScreen(int index)
|
|
{
|
|
m_currentScreenIndex = index;
|
|
m_currentScreen = m_screens.at(m_currentScreenIndex);
|
|
Q_ASSERT(m_currentScreen);
|
|
}
|
|
|
|
int RandRDisplay::screenIndexOfWidget(QWidget* widget)
|
|
{
|
|
int ret = QApplication::desktop()->screenNumber(widget);
|
|
return ret != -1 ? ret : QApplication::desktop()->primaryScreen();
|
|
}
|
|
|
|
int RandRDisplay::currentScreenIndex() const
|
|
{
|
|
return m_currentScreenIndex;
|
|
}
|
|
|
|
void RandRDisplay::refresh()
|
|
{
|
|
for (RandRScreen* s = m_screens.first(); s; s = m_screens.next())
|
|
s->loadSettings();
|
|
}
|
|
|
|
int RandRDisplay::numScreens() const
|
|
{
|
|
return m_numScreens;
|
|
}
|
|
|
|
RandRScreen* RandRDisplay::screen(int index)
|
|
{
|
|
return m_screens.at(index);
|
|
}
|
|
|
|
RandRScreen* RandRDisplay::currentScreen()
|
|
{
|
|
return m_currentScreen;
|
|
}
|
|
|
|
bool RandRDisplay::loadDisplay(KConfig& config, bool loadScreens)
|
|
{
|
|
if (loadScreens)
|
|
for (RandRScreen* s = m_screens.first(); s; s = m_screens.next())
|
|
s->load(config);
|
|
|
|
return applyOnStartup(config);
|
|
}
|
|
|
|
bool RandRDisplay::applyOnStartup(KConfig& config)
|
|
{
|
|
config.setGroup("Display");
|
|
return config.readBoolEntry("ApplyOnStartup", false);
|
|
}
|
|
|
|
bool RandRDisplay::syncTrayApp(KConfig& config)
|
|
{
|
|
config.setGroup("Display");
|
|
return config.readBoolEntry("SyncTrayApp", false);
|
|
}
|
|
|
|
void RandRDisplay::saveDisplay(KConfig& config, bool applyOnStartup, bool syncTrayApp)
|
|
{
|
|
Q_ASSERT(!config.isReadOnly());
|
|
|
|
config.setGroup("Display");
|
|
config.writeEntry("ApplyOnStartup", applyOnStartup);
|
|
config.writeEntry("SyncTrayApp", syncTrayApp);
|
|
|
|
for (RandRScreen* s = m_screens.first(); s; s = m_screens.next())
|
|
s->save(config);
|
|
}
|
|
|
|
void RandRDisplay::applyProposed(bool confirm)
|
|
{
|
|
for (int screenIndex = 0; screenIndex < numScreens(); screenIndex++) {
|
|
if (screen(screenIndex)->proposedChanged()) {
|
|
if (confirm)
|
|
screen(screenIndex)->applyProposedAndConfirm();
|
|
else
|
|
screen(screenIndex)->applyProposed();
|
|
}
|
|
}
|
|
}
|
|
|
|
int RandRScreen::pixelCount( int index ) const
|
|
{
|
|
QSize sz = pixelSize(index);
|
|
return sz.width() * sz.height();
|
|
}
|
|
|
|
#include "randr.moc"
|