← Back to branch summary

~ubuntu-branches/ubuntu/maverick/bluedevil/maverick-proposed

« back to all changes in this revision

Viewing changes to src/kcmodule/bluedeviladapters.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Mark Purcell
  • Date: 2010-08-07 09:04:19 UTC
  • Revision ID: james.westby@ubuntu.com-20100807090419-68k54ucso2htcf5z
Tags: upstream-1.0~rc2
Import upstream version 1.0~rc2

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/kcmodule/bluedeviladapters.cpp
 
1
/*
 
2
 * Copyright (C) 2010 Rafael Fernández López <ereslibre@kde.org>
 
3
 * Copyright (C) 2010 UFO Coders <info@ufocoders.com>
 
4
 *
 
5
 * This program is free software; you can redistribute it and/or
 
6
 * modify it under the terms of the GNU General Public
 
7
 * License as published by the Free Software Foundation; either
 
8
 * version 2 of the License, or (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 GNU
 
13
 * General Public License for more details.
 
14
 *
 
15
 * You should have received a copy of the GNU Library General Public License
 
16
 * along with this library; see the file COPYING.LIB.  If not, write to
 
17
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 
18
 * Boston, MA 02110-1301, USA.
 
19
 */
 
20
 
 
21
#include "bluedeviladapters.h"
 
22
#include "systemcheck.h"
 
23
 
 
24
#include <QtCore/QTimer>
 
25
 
 
26
#include <QtGui/QScrollArea>
 
27
#include <QtGui/QBoxLayout>
 
28
#include <QtGui/QRadioButton>
 
29
#include <QtGui/QCheckBox>
 
30
#include <QtGui/QSlider>
 
31
#include <QtGui/QLabel>
 
32
#include <QtGui/QFormLayout>
 
33
#include <QtGui/QButtonGroup>
 
34
 
 
35
#include <bluedevil/bluedevil.h>
 
36
 
 
37
#include <kicon.h>
 
38
#include <klineedit.h>
 
39
#include <kaboutdata.h>
 
40
#include <kpluginfactory.h>
 
41
 
 
42
K_PLUGIN_FACTORY(BlueDevilFactory, registerPlugin<KCMBlueDevilAdapters>();)
 
43
K_EXPORT_PLUGIN(BlueDevilFactory("bluedeviladapters"))
 
44
 
 
45
////////////////////////////////////////////////////////////////////////////////////////////////////
 
46
 
 
47
AdapterSettings::AdapterSettings(Adapter *adapter, KCModule *parent)
 
48
    : QGroupBox(parent)
 
49
    , m_adapter(adapter)
 
50
    , m_name(new KLineEdit(this))
 
51
    , m_hidden(new QRadioButton(i18n("Hidden"), this))
 
52
    , m_alwaysVisible(new QRadioButton(i18n("Always visible"), this))
 
53
    , m_temporaryVisible(new QRadioButton(i18n("Temporary visible"), this))
 
54
    , m_discoverTime(new QSlider(Qt::Horizontal, this))
 
55
    , m_discoverTimeLabel(new QLabel(this))
 
56
    , m_discoverTimeWidget(new QWidget(this))
 
57
    , m_powered(new QCheckBox(this))
 
58
{
 
59
    QButtonGroup *const buttonGroup = new QButtonGroup(this);
 
60
    buttonGroup->addButton(m_hidden);
 
61
    buttonGroup->addButton(m_alwaysVisible);
 
62
    buttonGroup->addButton(m_temporaryVisible);
 
63
 
 
64
    m_name->setText(adapter->name());
 
65
    m_nameOrig = adapter->name();
 
66
    m_hiddenOrig = false;
 
67
    m_alwaysVisibleOrig = false;
 
68
    m_temporaryVisibleOrig = false;
 
69
    if (!adapter->isDiscoverable()) {
 
70
        m_hidden->setChecked(true);
 
71
        m_hiddenOrig = true;
 
72
    } else {
 
73
        if (!adapter->discoverableTimeout()) {
 
74
            m_alwaysVisible->setChecked(true);
 
75
            m_alwaysVisibleOrig = true;
 
76
        } else {
 
77
            m_temporaryVisible->setChecked(true);
 
78
            m_temporaryVisibleOrig = true;
 
79
        }
 
80
    }
 
81
    m_discoverTime->setRange(1, 30);
 
82
    m_discoverTime->setValue(adapter->discoverableTimeout() / 60);
 
83
    m_discoverTime->setTickPosition(QSlider::TicksBelow);
 
84
    m_discoverTime->setTickInterval(1);
 
85
    m_discoverTimeOrig = qMax((quint32) 1, adapter->discoverableTimeout() / 60);
 
86
 
 
87
    QHBoxLayout *layout = new QHBoxLayout;
 
88
    layout->addWidget(m_discoverTime);
 
89
    layout->addWidget(m_discoverTimeLabel);
 
90
    m_discoverTimeWidget->setLayout(layout);
 
91
    m_discoverTimeWidget->setEnabled(m_temporaryVisibleOrig);
 
92
 
 
93
    m_discoverTimeLabel->setText(i18np("1 minute", "%1 minutes", m_discoverTime->value()));
 
94
 
 
95
    m_powered->setChecked(adapter->isPowered());
 
96
    m_poweredOrig = adapter->isPowered();
 
97
 
 
98
    m_layout = new QFormLayout;
 
99
    m_layout->addRow(i18n("Name"), m_name);
 
100
    m_layout->addRow(i18n("Powered"), m_powered);
 
101
    m_layout->addRow(i18n("Visibility"), m_hidden);
 
102
    m_layout->addWidget(m_alwaysVisible);
 
103
    m_layout->addWidget(m_temporaryVisible);
 
104
    m_layout->addRow(i18n("Discover Time"), m_discoverTimeWidget);
 
105
    setLayout(m_layout);
 
106
 
 
107
    m_layout->labelForField(m_discoverTimeWidget)->setEnabled(m_temporaryVisibleOrig);
 
108
 
 
109
    connect(m_adapter, SIGNAL(propertyChanged(QString,QVariant)), this, SLOT(readChanges()));
 
110
    connect(m_name, SIGNAL(textEdited(QString)), this, SLOT(slotSettingsChanged()));
 
111
    connect(m_hidden, SIGNAL(toggled(bool)), this, SLOT(visibilityChanged()));
 
112
    connect(m_hidden, SIGNAL(toggled(bool)), this, SLOT(slotSettingsChanged()));
 
113
    connect(m_alwaysVisible, SIGNAL(toggled(bool)), this, SLOT(visibilityChanged()));
 
114
    connect(m_alwaysVisible, SIGNAL(toggled(bool)), this, SLOT(slotSettingsChanged()));
 
115
    connect(m_temporaryVisible, SIGNAL(toggled(bool)), this, SLOT(visibilityChanged()));
 
116
    connect(m_temporaryVisible, SIGNAL(toggled(bool)), this, SLOT(slotSettingsChanged()));
 
117
    connect(m_discoverTime, SIGNAL(valueChanged(int)), this, SLOT(slotSettingsChanged()));
 
118
    connect(m_powered, SIGNAL(stateChanged(int)), this, SLOT(slotSettingsChanged()));
 
119
 
 
120
    if (BlueDevil::Manager::self()->defaultAdapter() == adapter) {
 
121
        setTitle(i18n("Default adapter: %1 (%2)").arg(adapter->name()).arg(adapter->address()));
 
122
    } else {
 
123
        setTitle(i18n("Adapter: %1 (%2)").arg(adapter->name()).arg(adapter->address()));
 
124
    }
 
125
}
 
126
 
 
127
AdapterSettings::~AdapterSettings()
 
128
{
 
129
}
 
130
 
 
131
bool AdapterSettings::isModified() const
 
132
{
 
133
    return m_name->text() != m_nameOrig || m_hidden->isChecked() != m_hiddenOrig ||
 
134
           m_alwaysVisible->isChecked() != m_alwaysVisibleOrig ||
 
135
           m_temporaryVisible->isChecked() != m_temporaryVisibleOrig ||
 
136
           m_discoverTime->value() != m_discoverTimeOrig || m_powered->isChecked() != m_poweredOrig;
 
137
}
 
138
 
 
139
void AdapterSettings::applyChanges()
 
140
{
 
141
    if (m_name->text() != m_nameOrig) {
 
142
        m_adapter->setName(m_name->text());
 
143
    }
 
144
 
 
145
    if (m_hidden->isChecked()) {
 
146
        m_adapter->setDiscoverable(false);
 
147
    } else if (m_alwaysVisible->isChecked()) {
 
148
        m_adapter->setDiscoverable(true);
 
149
        m_adapter->setDiscoverableTimeout(0);
 
150
    } else {
 
151
        m_adapter->setDiscoverable(true);
 
152
        m_adapter->setDiscoverableTimeout(m_discoverTime->value() * 60);
 
153
    }
 
154
 
 
155
    if (m_powered->isChecked() != m_poweredOrig) {
 
156
        m_adapter->setPowered(m_powered->isChecked());
 
157
    }
 
158
}
 
159
 
 
160
QString AdapterSettings::name() const
 
161
{
 
162
    return m_name->text();
 
163
}
 
164
 
 
165
AdapterSettings::DiscoverOptions AdapterSettings::discoverOptions() const
 
166
{
 
167
    if (m_hidden->isChecked()) {
 
168
        return Hidden;
 
169
    }
 
170
    if (m_alwaysVisible->isChecked()) {
 
171
        return AlwaysVisible;
 
172
    }
 
173
    return TemporaryVisible;
 
174
}
 
175
 
 
176
quint32 AdapterSettings::discoverTime() const
 
177
{
 
178
    return m_discoverTime->value() * 60;
 
179
}
 
180
 
 
181
bool AdapterSettings::powered() const
 
182
{
 
183
    return m_powered->isChecked();
 
184
}
 
185
 
 
186
void AdapterSettings::readChanges()
 
187
{
 
188
    blockSignals(true);
 
189
 
 
190
    m_nameOrig = m_adapter->name();
 
191
    m_hiddenOrig = !m_adapter->isDiscoverable();
 
192
    m_alwaysVisibleOrig = m_adapter->isDiscoverable() && !m_adapter->discoverableTimeout();
 
193
    m_temporaryVisibleOrig = m_adapter->isDiscoverable() && m_adapter->discoverableTimeout();
 
194
    m_discoverTimeOrig = qMax((quint32) 1, m_adapter->discoverableTimeout() / 60);
 
195
    m_poweredOrig = m_adapter->isPowered();
 
196
 
 
197
    m_name->setText(m_nameOrig);
 
198
    m_hidden->setChecked(m_hiddenOrig);
 
199
    m_alwaysVisible->setChecked(m_alwaysVisibleOrig);
 
200
    m_temporaryVisible->setChecked(m_temporaryVisibleOrig);
 
201
    m_discoverTime->setValue(m_discoverTimeOrig);
 
202
    m_powered->setChecked(m_poweredOrig);
 
203
 
 
204
    m_discoverTimeLabel->setText(i18np("1 minute", "%1 minutes", m_discoverTime->value()));
 
205
    if (BlueDevil::Manager::self()->defaultAdapter() == m_adapter) {
 
206
        setTitle(i18n("Default adapter: %1 (%2)").arg(m_adapter->name()).arg(m_adapter->address()));
 
207
    } else {
 
208
        setTitle(i18n("Adapter: %1 (%2)").arg(m_adapter->name()).arg(m_adapter->address()));
 
209
    }
 
210
 
 
211
    blockSignals(false);
 
212
 
 
213
    emit settingsChanged(false);
 
214
}
 
215
 
 
216
void AdapterSettings::visibilityChanged()
 
217
{
 
218
    QRadioButton *const sdr = static_cast<QRadioButton*>(sender());
 
219
    if (!sdr->isChecked()) {
 
220
        return;
 
221
    }
 
222
    const bool enabled = sender() == m_temporaryVisible;
 
223
    m_discoverTimeWidget->setEnabled(enabled);
 
224
    m_layout->labelForField(m_discoverTimeWidget)->setEnabled(enabled);
 
225
}
 
226
 
 
227
void AdapterSettings::slotSettingsChanged()
 
228
{
 
229
    m_discoverTimeLabel->setText(i18np("1 minute", "%1 minutes", m_discoverTime->value()));
 
230
    emit settingsChanged(isModified());
 
231
}
 
232
 
 
233
////////////////////////////////////////////////////////////////////////////////////////////////////
 
234
 
 
235
KCMBlueDevilAdapters::KCMBlueDevilAdapters(QWidget *parent, const QVariantList&)
 
236
    : KCModule(BlueDevilFactory::componentData(), parent)
 
237
    , m_noAdaptersMessage(0)
 
238
    , m_systemCheck(new SystemCheck(this))
 
239
{
 
240
    KAboutData* ab = new KAboutData(
 
241
        "kcmbluedeviladapters", 0, ki18n("BlueDevil Adapters"), "1.0",
 
242
        ki18n("BlueDevil Adapters Control Panel Module"),
 
243
        KAboutData::License_GPL, ki18n("(c) 2010 Rafael Fernández López"));
 
244
 
 
245
    ab->addAuthor(ki18n("Rafael Fernández López"), ki18n("Developer and Maintainer"), "ereslibre@kde.org");
 
246
    setAboutData(ab);
 
247
 
 
248
    connect(m_systemCheck, SIGNAL(updateInformationStateRequest()),
 
249
            this, SLOT(updateInformationState()));
 
250
 
 
251
    QVBoxLayout *layout = new QVBoxLayout;
 
252
    m_systemCheck->createWarnings(layout);
 
253
    QScrollArea *mainArea = new QScrollArea(this);
 
254
    QWidget *widget = new QWidget(mainArea);
 
255
    m_layout = new QVBoxLayout;
 
256
    widget->setLayout(m_layout);
 
257
    mainArea->setWidget(widget);
 
258
    mainArea->setWidgetResizable(true);
 
259
    layout->addWidget(mainArea);
 
260
    setLayout(layout);
 
261
 
 
262
    connect(BlueDevil::Manager::self(), SIGNAL(adapterAdded(Adapter*)),
 
263
            this, SLOT(updateAdapters()));
 
264
    connect(BlueDevil::Manager::self(), SIGNAL(adapterRemoved(Adapter*)),
 
265
            this, SLOT(updateAdapters()));
 
266
    connect(BlueDevil::Manager::self(), SIGNAL(defaultAdapterChanged(Adapter*)),
 
267
            this, SLOT(defaultAdapterChanged(Adapter*)));
 
268
 
 
269
    BlueDevil::Adapter *const defaultAdapter = BlueDevil::Manager::self()->defaultAdapter();
 
270
    if (defaultAdapter) {
 
271
        connect(defaultAdapter, SIGNAL(discoverableChanged(bool)),
 
272
                this, SLOT(adapterDiscoverableChanged()));
 
273
    }
 
274
 
 
275
    fillAdaptersInformation();
 
276
    updateInformationState();
 
277
}
 
278
 
 
279
KCMBlueDevilAdapters::~KCMBlueDevilAdapters()
 
280
{
 
281
}
 
282
 
 
283
void KCMBlueDevilAdapters::defaults()
 
284
{
 
285
}
 
286
 
 
287
void KCMBlueDevilAdapters::save()
 
288
{
 
289
    Q_FOREACH (AdapterSettings *const adapterSettings, m_adapterSettingsMap) {
 
290
        adapterSettings->applyChanges();
 
291
    }
 
292
    QTimer::singleShot(300, this, SLOT(updateInformationState()));
 
293
}
 
294
 
 
295
void KCMBlueDevilAdapters::updateAdapters()
 
296
{
 
297
    fillAdaptersInformation();
 
298
    QTimer::singleShot(300, this, SLOT(updateInformationState()));
 
299
}
 
300
 
 
301
void KCMBlueDevilAdapters::defaultAdapterChanged(Adapter *adapter)
 
302
{
 
303
    if (adapter) {
 
304
        connect(adapter, SIGNAL(discoverableChanged(bool)),
 
305
                this, SLOT(adapterDiscoverableChanged()));
 
306
    }
 
307
    QTimer::singleShot(300, this, SLOT(updateInformationState()));
 
308
}
 
309
 
 
310
void KCMBlueDevilAdapters::adapterDiscoverableChanged()
 
311
{
 
312
    QTimer::singleShot(300, this, SLOT(updateInformationState()));
 
313
}
 
314
 
 
315
void KCMBlueDevilAdapters::generateNoAdaptersMessage()
 
316
{
 
317
    QGridLayout *layout = new QGridLayout;
 
318
    m_noAdaptersMessage = new QWidget(this);
 
319
    QLabel *label = new QLabel(m_noAdaptersMessage);
 
320
    label->setPixmap(KIcon("dialog-information").pixmap(128, 128));
 
321
    layout->addWidget(label, 0, 1, Qt::AlignHCenter);
 
322
    layout->addWidget(new QLabel("No adapters found. Please connect one.", m_noAdaptersMessage),
 
323
                                 1, 1, Qt::AlignHCenter);
 
324
    layout->setRowStretch(2, 1);
 
325
    layout->setColumnStretch(0, 1);
 
326
    layout->setColumnStretch(2, 1);
 
327
    m_noAdaptersMessage->setLayout(layout);
 
328
    m_noAdaptersMessage->setVisible(false);
 
329
}
 
330
 
 
331
void KCMBlueDevilAdapters::updateInformationState()
 
332
{
 
333
    m_systemCheck->updateInformationState();
 
334
}
 
335
 
 
336
void KCMBlueDevilAdapters::adapterConfigurationChanged(bool modified)
 
337
{
 
338
    if (modified) {
 
339
        emit changed(true);
 
340
        return;
 
341
    }
 
342
    Q_FOREACH (AdapterSettings *const adapterSettings, m_adapterSettingsMap) {
 
343
        if (adapterSettings->isModified()) {
 
344
            return;
 
345
        }
 
346
    }
 
347
    emit changed(false);
 
348
}
 
349
 
 
350
void KCMBlueDevilAdapters::fillAdaptersInformation()
 
351
{
 
352
    qDeleteAll(m_adapterSettingsMap);
 
353
    m_adapterSettingsMap.clear();
 
354
 
 
355
    for (int i = 0; i < m_layout->count(); ++i) {
 
356
        m_layout->takeAt(0);
 
357
    }
 
358
 
 
359
    if (BlueDevil::Manager::self()->adapters().isEmpty()) {
 
360
        generateNoAdaptersMessage();
 
361
        m_layout->addWidget(m_noAdaptersMessage);
 
362
        m_noAdaptersMessage->setVisible(true);
 
363
        return;
 
364
    }
 
365
 
 
366
    if (m_noAdaptersMessage) {
 
367
        m_noAdaptersMessage->setVisible(false);
 
368
    }
 
369
 
 
370
    Q_FOREACH (Adapter *const adapter, BlueDevil::Manager::self()->adapters()) {
 
371
        AdapterSettings *const adapterSettings = new AdapterSettings(adapter, this);
 
372
        connect(adapterSettings, SIGNAL(settingsChanged(bool)),
 
373
                this, SLOT(adapterConfigurationChanged(bool)));
 
374
        m_adapterSettingsMap.insert(adapter, adapterSettings);
 
375
        m_layout->addWidget(adapterSettings);
 
376
    }
 
377
 
 
378
    m_layout->addStretch();
 
379
}