ground/gcs/src/libs/utils/savedaction.cpp

   1 /**
   2  ******************************************************************************
   3  *
   4  * @file       savedaction.cpp
   5  * @author     The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
   6  *             Parts by Nokia Corporation (qt-info@nokia.com) Copyright (C) 2009.
   7  * @brief
   8  * @see        The GNU Public License (GPL) Version 3
   9  * @defgroup
  10  * @{
  11  *
  12  *****************************************************************************/
  13 /*
  14  * This program is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License as published by
  16  * the Free Software Foundation; either version 3 of the License, or
  17  * (at your option) any later version.
  18  *
  19  * This program is distributed in the hope that it will be useful, but
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  21  * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
  22  * for more details.
  23  *
  24  * You should have received a copy of the GNU General Public License along
  25  * with this program; if not, write to the Free Software Foundation, Inc.,
  26  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  27  */
  28
  29 #include <utils/savedaction.h>
  30
  31 #include <utils/qtcassert.h>
  32 #include <utils/pathchooser.h>
  33
  34 #include <QtCore/QDebug>
  35 #include <QtCore/QSettings>
  36
  37 #include <QAbstractButton>
  38 #include <QAction>
  39 #include <QActionGroup>
  40 #include <QCheckBox>
  41 #include <QLineEdit>
  42 #include <QRadioButton>
  43 #include <QSpinBox>
  44
  45
  46 using namespace Utils;
  47
  48
  49 //////////////////////////////////////////////////////////////////////////
  50 //
  51 // SavedAction
  52 //
  53 //////////////////////////////////////////////////////////////////////////
  54
  55 /*!
  56     \class Utils::SavedAction
  57
  58     \brief The SavedAction class is a helper class for actions with persistent
  59     state.
  60
  61     \ingroup utils
  62
  63  */
  64
  65 SavedAction::SavedAction(QObject *parent)
  66     : QAction(parent)
  67 {
  68     m_widget = 0;
  69     connect(this, SIGNAL(triggered(bool)), this, SLOT(actionTriggered(bool)));
  70 }
  71
  72
  73 /*!
  74     Returns the current value of the object.
  75
  76     \sa setValue()
  77  */
  78 QVariant SavedAction::value() const
  79 {
  80     return m_value;
  81 }
  82
  83
  84 /*!
  85     Sets the current value of the object. If the value changed and
  86     \a doemit is true, the \c valueChanged() signal will be emitted.
  87
  88     \sa value()
  89  */
  90 void SavedAction::setValue(const QVariant &value, bool doemit)
  91 {
  92     if (value == m_value) {
  93         return;
  94     }
  95     m_value = value;
  96     if (this->isCheckable()) {
  97         this->setChecked(m_value.toBool());
  98     }
  99     if (doemit) {
 100         emit valueChanged(m_value);
 101     }
 102 }
 103
 104
 105 /*!
 106     Returns the default value to be used when the item does not exist yet
 107     in the settings.
 108
 109     \sa setDefaultValue()
 110  */
 111 QVariant SavedAction::defaultValue() const
 112 {
 113     return m_defaultValue;
 114 }
 115
 116
 117 /*!
 118     Sets the default value to be used when the item does not exist yet
 119     in the settings.
 120
 121     \sa defaultValue()
 122  */
 123 void SavedAction::setDefaultValue(const QVariant &value)
 124 {
 125     m_defaultValue = value;
 126 }
 127
 128
 129 /*!
 130     Returns the key to be used when accessing the settings.
 131
 132     \sa settingsKey()
 133  */
 134 QString SavedAction::settingsKey() const
 135 {
 136     return m_settingsKey;
 137 }
 138
 139
 140 /*!
 141     Sets the key to be used when accessing the settings.
 142
 143     \sa settingsKey()
 144  */
 145 void SavedAction::setSettingsKey(const QString &key)
 146 {
 147     m_settingsKey = key;
 148 }
 149
 150
 151 /*!
 152     Sets the key and group to be used when accessing the settings.
 153
 154     \sa settingsKey()
 155  */
 156 void SavedAction::setSettingsKey(const QString &group, const QString &key)
 157 {
 158     m_settingsKey   = key;
 159     m_settingsGroup = group;
 160 }
 161
 162
 163 /*!
 164     Sets the key to be used when accessing the settings.
 165
 166     \sa settingsKey()
 167  */
 168 QString SavedAction::settingsGroup() const
 169 {
 170     return m_settingsGroup;
 171 }
 172
 173 /*!
 174     Sets the group to be used when accessing the settings.
 175
 176     \sa settingsGroup()
 177  */
 178 void SavedAction::setSettingsGroup(const QString &group)
 179 {
 180     m_settingsGroup = group;
 181 }
 182
 183 QString SavedAction::textPattern() const
 184 {
 185     return m_textPattern;
 186 }
 187
 188 void SavedAction::setTextPattern(const QString &value)
 189 {
 190     m_textPattern = value;
 191 }
 192
 193 QString SavedAction::toString() const
 194 {
 195     return QLatin1String("value: ") + m_value.toString()
 196            + QLatin1String("  defaultvalue: ") + m_defaultValue.toString()
 197            + QLatin1String("  settingskey: ") + m_settingsGroup
 198            + '/' + m_settingsKey;
 199 }
 200
 201 /*!
 202     \fn QAction *SavedAction::updatedAction(const QString &text)
 203
 204     Adjust the \c text() of the underlying action.
 205
 206     This can be used to update the item shortly before e.g. a menu is shown.
 207
 208     If the item's \c textPattern() is empty the \a text will be used
 209     verbatim.
 210
 211     Otherwise, the behaviour depends on \a text: if it is non-empty,
 212     \c QString(textPattern()).arg(text), otherwise, \c textPattern()
 213     with the "%1" placeholder removed will be used.
 214
 215     \sa textPattern(), setTextPattern()
 216  */
 217 QAction *SavedAction::updatedAction(const QString &text0)
 218 {
 219     QString text = text0;
 220     bool enabled = true;
 221
 222     if (!m_textPattern.isEmpty()) {
 223         if (text.isEmpty()) {
 224             text    = m_textPattern;
 225             text.remove("\"%1\"");
 226             text.remove("%1");
 227             enabled = false;
 228         } else {
 229             text = m_textPattern.arg(text0);
 230         }
 231     }
 232     this->setEnabled(enabled);
 233     this->setData(text0);
 234     this->setText(text);
 235     return this;
 236 }
 237
 238 /*
 239     Uses \c settingsGroup() and \c settingsKey() to restore the
 240     item from \a settings,
 241
 242     \sa settingsKey(), settingsGroup(), writeSettings()
 243  */
 244 void SavedAction::readSettings(QSettings *settings)
 245 {
 246     if (m_settingsGroup.isEmpty() || m_settingsKey.isEmpty()) {
 247         return;
 248     }
 249     settings->beginGroup(m_settingsGroup);
 250     QVariant var = settings->value(m_settingsKey, m_defaultValue);
 251     // work around old ini files containing @Invalid() entries
 252     if (isCheckable() && !var.isValid()) {
 253         var = false;
 254     }
 255     setValue(var);
 256     // qDebug() << "READING: " << var.isValid() << m_settingsKey << " -> " << m_value
 257     // << " (default: " << m_defaultValue << ")" << var;
 258     settings->endGroup();
 259 }
 260
 261 /*
 262     Uses \c settingsGroup() and \c settingsKey() to write the
 263     item to \a settings,
 264
 265     \sa settingsKey(), settingsGroup(), readSettings()
 266  */
 267 void SavedAction::writeSettings(QSettings *settings)
 268 {
 269     if (m_settingsGroup.isEmpty() || m_settingsKey.isEmpty()) {
 270         return;
 271     }
 272     settings->beginGroup(m_settingsGroup);
 273     settings->setValue(m_settingsKey, m_value);
 274     // qDebug() << "WRITING: " << m_settingsKey << " -> " << toString();
 275     settings->endGroup();
 276 }
 277
 278 /*
 279     A \c SavedAction can be connected to a widget, typically a
 280     checkbox, radiobutton, or a lineedit in some configuration dialog.
 281
 282     The widget will retrieve its contents from the SavedAction's
 283     value, and - depending on the \a ApplyMode - either write
 284     changes back immediately, or when \s SavedAction::apply()
 285     is called explicitly.
 286
 287     \sa apply(), disconnectWidget()
 288  */
 289 void SavedAction::connectWidget(QWidget *widget, ApplyMode applyMode)
 290 {
 291     QTC_ASSERT(!m_widget,
 292                qDebug() << "ALREADY CONNECTED: " << widget << m_widget << toString(); return );
 293     m_widget    = widget;
 294     m_applyMode = applyMode;
 295
 296     if (QAbstractButton * button = qobject_cast<QAbstractButton *>(widget)) {
 297         if (button->isCheckable()) {
 298             button->setChecked(m_value.toBool());
 299             connect(button, SIGNAL(clicked(bool)),
 300                     this, SLOT(checkableButtonClicked(bool)));
 301         } else {
 302             connect(button, SIGNAL(clicked()),
 303                     this, SLOT(uncheckableButtonClicked()));
 304         }
 305     } else if (QSpinBox * spinBox = qobject_cast<QSpinBox *>(widget)) {
 306         spinBox->setValue(m_value.toInt());
 307
 308         // qDebug() << "SETTING VALUE" << spinBox->value();
 309         connect(spinBox, SIGNAL(valueChanged(int)),
 310                 this, SLOT(spinBoxValueChanged(int)));
 311         connect(spinBox, SIGNAL(valueChanged(QString)),
 312                 this, SLOT(spinBoxValueChanged(QString)));
 313     } else if (QDoubleSpinBox * doubleSpinBox = qobject_cast<QDoubleSpinBox *>(widget)) {
 314         doubleSpinBox->setValue(m_value.toDouble());
 315         // qDebug() << "SETTING VALUE" << doubleSpinBox->value();
 316         connect(doubleSpinBox, SIGNAL(valueChanged(double)),
 317                 this, SLOT(doubleSpinBoxValueChanged(double)));
 318         connect(doubleSpinBox, SIGNAL(valueChanged(QString)),
 319                 this, SLOT(doubleSpinBoxValueChanged(QString)));
 320     } else if (QLineEdit * lineEdit = qobject_cast<QLineEdit *>(widget)) {
 321         lineEdit->setText(m_value.toString());
 322         // qDebug() << "SETTING TEXT" << lineEdit->text();
 323         connect(lineEdit, SIGNAL(editingFinished()),
 324                 this, SLOT(lineEditEditingFinished()));
 325     } else if (PathChooser * pathChooser = qobject_cast<PathChooser *>(widget)) {
 326         pathChooser->setPath(m_value.toString());
 327         connect(pathChooser, SIGNAL(editingFinished()),
 328                 this, SLOT(pathChooserEditingFinished()));
 329         connect(pathChooser, SIGNAL(browsingFinished()),
 330                 this, SLOT(pathChooserEditingFinished()));
 331     } else {
 332         qDebug() << "Cannot connect widget " << widget << toString();
 333     }
 334 }
 335
 336 /*
 337     Disconnects the \c SavedAction from a widget.
 338
 339     \sa apply(), connectWidget()
 340  */
 341 void SavedAction::disconnectWidget()
 342 {
 343     m_widget = 0;
 344 }
 345
 346 void SavedAction::apply(QSettings *s)
 347 {
 348     if (QAbstractButton * button = qobject_cast<QAbstractButton *>(m_widget)) {
 349         setValue(button->isChecked());
 350     } else if (QLineEdit * lineEdit = qobject_cast<QLineEdit *>(m_widget)) {
 351         setValue(lineEdit->text());
 352     } else if (QSpinBox * spinBox = qobject_cast<QSpinBox *>(m_widget)) {
 353         setValue(spinBox->value());
 354     } else if (QDoubleSpinBox * doubleSpinBox = qobject_cast<QDoubleSpinBox *>(m_widget)) {
 355         setValue(doubleSpinBox->value());
 356     } else if (PathChooser * pathChooser = qobject_cast<PathChooser *>(m_widget)) {
 357         setValue(pathChooser->path());
 358     }
 359     if (s) {
 360         writeSettings(s);
 361     }
 362 }
 363
 364 void SavedAction::uncheckableButtonClicked()
 365 {
 366     QAbstractButton *button = qobject_cast<QAbstractButton *>(sender());
 367
 368     QTC_ASSERT(button, return );
 369     // qDebug() << "UNCHECKABLE BUTTON: " << sender();
 370     QAction::trigger();
 371 }
 372
 373 void SavedAction::checkableButtonClicked(bool)
 374 {
 375     QAbstractButton *button = qobject_cast<QAbstractButton *>(sender());
 376
 377     QTC_ASSERT(button, return );
 378     // qDebug() << "CHECKABLE BUTTON: " << sender();
 379     if (m_applyMode == ImmediateApply) {
 380         setValue(button->isChecked());
 381     }
 382 }
 383
 384 void SavedAction::lineEditEditingFinished()
 385 {
 386     QLineEdit *lineEdit = qobject_cast<QLineEdit *>(sender());
 387
 388     QTC_ASSERT(lineEdit, return );
 389     if (m_applyMode == ImmediateApply) {
 390         setValue(lineEdit->text());
 391     }
 392 }
 393
 394 void SavedAction::spinBoxValueChanged(int value)
 395 {
 396     QSpinBox *spinBox = qobject_cast<QSpinBox *>(sender());
 397
 398     QTC_ASSERT(spinBox, return );
 399     if (m_applyMode == ImmediateApply) {
 400         setValue(value);
 401     }
 402 }
 403
 404 void SavedAction::spinBoxValueChanged(QString value)
 405 {
 406     QSpinBox *spinBox = qobject_cast<QSpinBox *>(sender());
 407
 408     QTC_ASSERT(spinBox, return );
 409     if (m_applyMode == ImmediateApply) {
 410         setValue(value);
 411     }
 412 }
 413
 414 void SavedAction::doubleSpinBoxValueChanged(double value)
 415 {
 416     QDoubleSpinBox *doubleSpinBox = qobject_cast<QDoubleSpinBox *>(sender());
 417
 418     QTC_ASSERT(doubleSpinBox, return );
 419     if (m_applyMode == ImmediateApply) {
 420         setValue(value);
 421     }
 422 }
 423
 424 void SavedAction::doubleSpinBoxValueChanged(QString value)
 425 {
 426     QDoubleSpinBox *doubleSpinBox = qobject_cast<QDoubleSpinBox *>(sender());
 427
 428     QTC_ASSERT(doubleSpinBox, return );
 429     if (m_applyMode == ImmediateApply) {
 430         setValue(value);
 431     }
 432 }
 433
 434 void SavedAction::pathChooserEditingFinished()
 435 {
 436     PathChooser *pathChooser = qobject_cast<PathChooser *>(sender());
 437
 438     QTC_ASSERT(pathChooser, return );
 439     if (m_applyMode == ImmediateApply) {
 440         setValue(pathChooser->path());
 441     }
 442 }
 443
 444 void SavedAction::actionTriggered(bool)
 445 {
 446     if (isCheckable()) {
 447         setValue(isChecked());
 448     }
 449     if (actionGroup() && actionGroup()->isExclusive()) {
 450         // FIXME: should be taken care of more directly
 451         foreach(QAction * act, actionGroup()->actions())
 452         if (SavedAction * dact = qobject_cast<SavedAction *>(act)) {
 453             dact->setValue(bool(act == this));
 454         }
 455     }
 456 }
 457
 458 void SavedAction::trigger(const QVariant &data)
 459 {
 460     setData(data);
 461     QAction::trigger();
 462 }
 463
 464
 465 //////////////////////////////////////////////////////////////////////////
 466 //
 467 // SavedActionSet
 468 //
 469 //////////////////////////////////////////////////////////////////////////
 470
 471 void SavedActionSet::insert(SavedAction *action, QWidget *widget)
 472 {
 473     m_list.append(action);
 474     if (widget) {
 475         action->connectWidget(widget);
 476     }
 477 }
 478
 479 void SavedActionSet::apply(QSettings *settings)
 480 {
 481     foreach(SavedAction * action, m_list)
 482     action->apply(settings);
 483 }
 484
 485 void SavedActionSet::finish()
 486 {
 487     foreach(SavedAction * action, m_list)
 488     action->disconnectWidget();
 489 }