← Back to branch summary

~ubuntu-branches/ubuntu/utopic/kde-workspace/utopic-proposed

« back to all changes in this revision

Viewing changes to libs/kephal/client/dbusconfigurations.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Michał Zając
  • Date: 2011-07-09 08:31:15 UTC
  • Revision ID: james.westby@ubuntu.com-20110709083115-ohyxn6z93mily9fc
Tags: upstream-4.6.90
Import upstream version 4.6.90

Show diffs side-by-side

added added

removed removed

Lines of Context:
libs/kephal/client/dbusconfigurations.cpp
 
1
/*
 
2
 *   Copyright 2008 Aike J Sommer <dev@aikesommer.name>
 
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
 
6
 *   published by the Free Software Foundation; either version 2,
 
7
 *   or (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 Library General Public
 
15
 *   License along with this program; if not, write to the
 
16
 *   Free Software Foundation, Inc.,
 
17
 *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 
18
 */
 
19
 
 
20
 
 
21
#include "dbusconfigurations.h"
 
22
 
 
23
#include "outputs.h"
 
24
 
 
25
 
 
26
namespace Kephal {
 
27
 
 
28
    DBusConfiguration::DBusConfiguration(DBusConfigurations * parent, QString name)
 
29
        : Configuration(parent),
 
30
        m_name(name),
 
31
        m_parent(parent)
 
32
    {
 
33
    }
 
34
 
 
35
    QString DBusConfiguration::name() {
 
36
        return m_name;
 
37
    }
 
38
 
 
39
    bool DBusConfiguration::isModifiable() {
 
40
        return m_parent->interface()->isModifiable(m_name);
 
41
    }
 
42
 
 
43
    bool DBusConfiguration::isActivated() {
 
44
        return m_parent->interface()->isActivated(m_name);
 
45
    }
 
46
 
 
47
    QMap<int, QPoint> DBusConfiguration::layout() {
 
48
        return QMap<int, QPoint>();
 
49
    }
 
50
 
 
51
    void DBusConfiguration::activate() {
 
52
        m_parent->interface()->activate(m_name);
 
53
    }
 
54
 
 
55
    int DBusConfiguration::primaryScreen() {
 
56
        return m_parent->interface()->primaryScreen(m_name);
 
57
    }
 
58
 
 
59
 
 
60
 
 
61
    DBusConfigurations::DBusConfigurations(QObject * parent)
 
62
            : Configurations(parent)
 
63
    {
 
64
        m_interface = new org::kde::Kephal::Configurations(
 
65
            "org.kde.Kephal",
 
66
            "/modules/kephal/Configurations",
 
67
            QDBusConnection::sessionBus(),
 
68
            this);
 
69
 
 
70
        if (! m_interface->isValid()) {
 
71
            m_valid = false;
 
72
            return;
 
73
        }
 
74
 
 
75
        m_valid = true;
 
76
 
 
77
        const QStringList names = m_interface->configurations();
 
78
        foreach (const QString& name, names) {
 
79
            m_configs.insert(name, new DBusConfiguration(this, name));
 
80
        }
 
81
 
 
82
        connect(m_interface, SIGNAL(configurationActivated(QString)), this, SLOT(configurationActivatedSlot(QString)));
 
83
        connect(m_interface, SIGNAL(confirmed()), this, SIGNAL(confirmed()));
 
84
        connect(m_interface, SIGNAL(reverted()), this, SIGNAL(reverted()));
 
85
        connect(m_interface, SIGNAL(confirmTimeout(int)), this, SIGNAL(confirmTimeout(int)));
 
86
    }
 
87
 
 
88
 
 
89
    QMap<QString, Configuration *> DBusConfigurations::configurations() {
 
90
        QMap<QString, Configuration *> result;
 
91
        for (QMap<QString, DBusConfiguration *>::const_iterator i = m_configs.constBegin(); i != m_configs.constEnd(); ++i) {
 
92
            result.insert(i.key(), i.value());
 
93
        }
 
94
        return result;
 
95
    }
 
96
 
 
97
    Configuration * DBusConfigurations::activeConfiguration() {
 
98
        QString name = m_interface->activeConfiguration();
 
99
        if ((! name.isEmpty()) && m_configs.contains(name)) {
 
100
            return m_configs[name];
 
101
        }
 
102
        return 0;
 
103
    }
 
104
 
 
105
    QList<Configuration *> DBusConfigurations::alternateConfigurations() {
 
106
        const QStringList names = m_interface->alternateConfigurations();
 
107
        QList<Configuration *> result;
 
108
        foreach (const QString& name, names) {
 
109
            if (m_configs.contains(name)) {
 
110
                result << m_configs[name];
 
111
            }
 
112
        }
 
113
        return result;
 
114
    }
 
115
 
 
116
    QList<QPoint> DBusConfigurations::possiblePositions(const Output * output) {
 
117
        QList<QPoint> result;
 
118
        int num = m_interface->numAvailablePositions(output->id());
 
119
        for (int i = 0; i < num; ++i) {
 
120
            result << m_interface->availablePosition(output->id(), i);
 
121
        }
 
122
        return result;
 
123
    }
 
124
 
 
125
    bool DBusConfigurations::move(Output * output, const QPoint & position) {
 
126
        return m_interface->move(output->id(), position);
 
127
    }
 
128
 
 
129
    bool DBusConfigurations::resize(Output * output, const QSize & size) {
 
130
        return m_interface->resize(output->id(), size);
 
131
    }
 
132
 
 
133
    bool DBusConfigurations::rotate(Output * output, Rotation rotation) {
 
134
        return m_interface->rotate(output->id(), rotation);
 
135
    }
 
136
 
 
137
    bool DBusConfigurations::reflectX(Output * output, bool reflect) {
 
138
        return m_interface->reflectX(output->id(), reflect);
 
139
    }
 
140
 
 
141
    bool DBusConfigurations::reflectY(Output * output, bool reflect) {
 
142
        return m_interface->reflectY(output->id(), reflect);
 
143
    }
 
144
 
 
145
    bool DBusConfigurations::changeRate(Output * output, float rate) {
 
146
        return m_interface->changeRate(output->id(), rate);
 
147
    }
 
148
 
 
149
    bool DBusConfigurations::isValid() {
 
150
        return m_valid;
 
151
    }
 
152
 
 
153
    org::kde::Kephal::Configurations * DBusConfigurations::interface() {
 
154
        return m_interface;
 
155
    }
 
156
 
 
157
    int DBusConfigurations::screen(Output * output) {
 
158
        return m_interface->screen(output->id());
 
159
    }
 
160
 
 
161
    void DBusConfigurations::applyOutputSettings() {
 
162
    }
 
163
 
 
164
    void DBusConfigurations::setPolling(bool polling) {
 
165
        m_interface->setPolling(polling);
 
166
    }
 
167
 
 
168
    bool DBusConfigurations::polling() {
 
169
        return m_interface->polling();
 
170
    }
 
171
 
 
172
    void DBusConfigurations::configurationActivatedSlot(QString name) {
 
173
        if ((! name.isEmpty()) && m_configs.contains(name)) {
 
174
            emit configurationActivated(m_configs[name]);
 
175
        }
 
176
    }
 
177
 
 
178
    void DBusConfigurations::confirm() {
 
179
        m_interface->confirm();
 
180
    }
 
181
 
 
182
    void DBusConfigurations::revert() {
 
183
        m_interface->revert();
 
184
    }
 
185
 
 
186
}