ground/gcs/src/plugins/coreplugin/modemanager.cpp

   1 /**
   2  ******************************************************************************
   3  *
   4  * @file       modemanager.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  * @addtogroup GCSPlugins GCS Plugins
   8  * @{
   9  * @addtogroup CorePlugin Core Plugin
  10  * @{
  11  * @brief The Core GCS plugin
  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 "modemanager.h"
  30
  31 #include "utils/mytabwidget.h"
  32 #include "icore.h"
  33 #include "mainwindow.h"
  34
  35 #include <aggregation/aggregate.h>
  36
  37 #include <coreplugin/actionmanager/actionmanager.h>
  38 #include <coreplugin/actionmanager/command.h>
  39 #include <coreplugin/coreconstants.h>
  40 #include <coreplugin/imode.h>
  41 #include <coreplugin/uniqueidmanager.h>
  42
  43 #include <extensionsystem/pluginmanager.h>
  44
  45 #include <utils/qtcassert.h>
  46
  47 #include <QtCore/QObject>
  48 #include <QtCore/QDebug>
  49 #include <QtCore/QSignalMapper>
  50 #include <QShortcut>
  51
  52 #include <QAction>
  53 #include <QTabWidget>
  54 #include <QVBoxLayout>
  55
  56 using namespace Core;
  57 using namespace Core::Internal;
  58
  59 ModeManager *ModeManager::m_instance = 0;
  60
  61 ModeManager::ModeManager(Internal::MainWindow *mainWindow, MyTabWidget *modeStack) :
  62     m_mainWindow(mainWindow),
  63     m_modeStack(modeStack),
  64     m_signalMapper(new QSignalMapper(this)),
  65     m_isReprioritizing(false)
  66 {
  67     m_instance = this;
  68
  69 // connect((m_modeStack), SIGNAL(currentAboutToShow(int)), SLOT(currentTabAboutToChange(int)));
  70     connect(m_modeStack, SIGNAL(currentChanged(int)), this, SLOT(currentTabChanged(int)));
  71     connect(m_modeStack, SIGNAL(tabMoved(int, int)), this, SLOT(tabMoved(int, int)));
  72     connect(m_signalMapper, SIGNAL(mapped(QString)), this, SLOT(activateMode(QString)));
  73 }
  74
  75 void ModeManager::init()
  76 {
  77     QObject::connect(ExtensionSystem::PluginManager::instance(), SIGNAL(objectAdded(QObject *)),
  78                      this, SLOT(objectAdded(QObject *)));
  79     QObject::connect(ExtensionSystem::PluginManager::instance(), SIGNAL(aboutToRemoveObject(QObject *)),
  80                      this, SLOT(aboutToRemoveObject(QObject *)));
  81 }
  82
  83 void ModeManager::addWidget(QWidget *widget)
  84 {
  85     Q_UNUSED(widget);
  86
  87     // We want the actionbar to stay on the bottom
  88     // so m_modeStack->cornerWidgetCount() -1 inserts it at the position immediately above
  89     // the actionbar
  90 // m_modeStack->insertCornerWidget(m_modeStack->cornerWidgetCount() -1, widget);
  91 }
  92
  93 IMode *ModeManager::currentMode() const
  94 {
  95     if (m_modes.count() > m_modeStack->currentIndex()) {
  96         return m_modes.at(m_modeStack->currentIndex());
  97     } else {
  98         m_modeStack->setCurrentIndex(0); // Fix illegal Index.
  99     }
 100     return 0;
 101 }
 102
 103 int ModeManager::indexOf(const QString &id) const
 104 {
 105     for (int i = 0; i < m_modes.count(); ++i) {
 106         if (m_modes.at(i)->uniqueModeName() == id) {
 107             return i;
 108         }
 109     }
 110 // qDebug() << "Warning, no such mode:" << id;
 111     return -1;
 112 }
 113
 114 IMode *ModeManager::mode(const QString &id) const
 115 {
 116     const int index = indexOf(id);
 117
 118     if (index >= 0) {
 119         return m_modes.at(index);
 120     }
 121     return 0;
 122 }
 123
 124 void ModeManager::activateMode(const QString &id)
 125 {
 126     const int index = indexOf(id);
 127
 128     if (index >= 0) {
 129         m_modeStack->setCurrentIndex(index);
 130     }
 131 }
 132
 133 void ModeManager::activateModeByWorkspaceName(const QString &id)
 134 {
 135     for (int i = 0; i < m_modes.count(); ++i) {
 136         if (m_modes.at(i)->name() == id) {
 137             m_modeStack->setCurrentIndex(i);
 138             return;
 139         }
 140     }
 141 }
 142
 143 void ModeManager::objectAdded(QObject *obj)
 144 {
 145     IMode *mode = Aggregation::query<IMode>(obj);
 146
 147     if (!mode) {
 148         return;
 149     }
 150
 151     m_mainWindow->addContextObject(mode);
 152
 153     // Count the number of modes with a higher priority
 154     int index = 0;
 155     foreach(const IMode * m, m_modes)
 156     if (m->priority() > mode->priority()) {
 157         ++index;
 158     }
 159
 160     m_modes.insert(index, mode);
 161     m_modeStack->insertTab(index, mode->widget(), mode->icon(), mode->name());
 162
 163     // Register mode shortcut
 164     ActionManager *am   = m_mainWindow->actionManager();
 165     const QString shortcutId = QLatin1String("GCS.Mode.") + mode->uniqueModeName();
 166     QShortcut *shortcut = new QShortcut(m_mainWindow);
 167     shortcut->setWhatsThis(tr("Switch to %1 mode").arg(mode->name()));
 168     Command *cmd = am->registerShortcut(shortcut, shortcutId, QList<int>() << Constants::C_GLOBAL_ID);
 169
 170     m_modeShortcuts.insert(index, cmd);
 171     connect(cmd, SIGNAL(keySequenceChanged()), this, SLOT(updateModeToolTip()));
 172
 173     setDefaultKeyshortcuts();
 174
 175     m_signalMapper->setMapping(shortcut, mode->uniqueModeName());
 176     connect(shortcut, SIGNAL(activated()), m_signalMapper, SLOT(map()));
 177 }
 178
 179 void ModeManager::setDefaultKeyshortcuts()
 180 {
 181     for (int i = 0; i < m_modeShortcuts.size(); ++i) {
 182         Command *currentCmd = m_modeShortcuts.at(i);
 183         bool currentlyHasDefaultSequence = (currentCmd->keySequence()
 184                                             == currentCmd->defaultKeySequence());
 185 #ifdef Q_WS_MAC
 186         currentCmd->setDefaultKeySequence(QKeySequence(QString("Meta+%1").arg(i + 1)));
 187 #else
 188         currentCmd->setDefaultKeySequence(QKeySequence(QString("Ctrl+%1").arg(i + 1)));
 189 #endif
 190         if (currentlyHasDefaultSequence) {
 191             currentCmd->setKeySequence(currentCmd->defaultKeySequence());
 192         }
 193     }
 194 }
 195
 196 void ModeManager::updateModeToolTip()
 197 {
 198     Command *cmd = qobject_cast<Command *>(sender());
 199
 200     if (cmd) {
 201         int index = m_modeShortcuts.indexOf(cmd);
 202         if (index != -1) {
 203             m_modeStack->setTabToolTip(index, cmd->stringWithAppendedShortcut(cmd->shortcut()->whatsThis()));
 204         }
 205     }
 206 }
 207
 208 void ModeManager::updateModeNameIcon(IMode *mode, const QIcon &icon, const QString &label)
 209 {
 210     int index = indexOf(mode->uniqueModeName());
 211
 212     if (index < 0) {
 213         return;
 214     }
 215     m_modeStack->setTabIcon(index, icon);
 216     m_modeStack->setTabText(index, label);
 217 }
 218
 219 void ModeManager::aboutToRemoveObject(QObject *obj)
 220 {
 221     IMode *mode = Aggregation::query<IMode>(obj);
 222
 223     if (!mode) {
 224         return;
 225     }
 226
 227     const int index = m_modes.indexOf(mode);
 228     m_modes.remove(index);
 229     m_modeShortcuts.remove(index);
 230     disconnect(m_modeStack, SIGNAL(currentChanged(int)), this, SLOT(currentTabChanged(int)));
 231     m_modeStack->removeTab(index);
 232     connect(m_modeStack, SIGNAL(currentChanged(int)), this, SLOT(currentTabChanged(int)));
 233
 234     m_mainWindow->removeContextObject(mode);
 235 }
 236
 237 void ModeManager::addAction(Command *command, int priority, QMenu *menu)
 238 {
 239     Q_UNUSED(menu);
 240
 241     m_actions.insert(command, priority);
 242
 243     // Count the number of commands with a higher priority
 244     int index = 0;
 245     foreach(int p, m_actions.values())
 246     if (p > priority) {
 247         ++index;
 248     }
 249
 250 // m_actionBar->insertAction(index, command->action(), menu);
 251 }
 252
 253 void ModeManager::currentTabAboutToChange(int index)
 254 {
 255     if (index >= 0) {
 256         IMode *mode = m_modes.at(index);
 257         if (mode) {
 258             emit currentModeAboutToChange(mode);
 259         }
 260     }
 261 }
 262
 263 void ModeManager::currentTabChanged(int index)
 264 {
 265 // qDebug() << "Current tab changed " << index;
 266     // Tab index changes to -1 when there is no tab left.
 267     if (index >= 0) {
 268         IMode *mode = m_modes.at(index);
 269
 270         // FIXME: This hardcoded context update is required for the Debug and Edit modes, since
 271         // they use the editor widget, which is already a context widget so the main window won't
 272         // go further up the parent tree to find the mode context.
 273         ICore *core = ICore::instance();
 274         foreach(const int context, m_addedContexts)
 275         core->removeAdditionalContext(context);
 276
 277         m_addedContexts = mode->context();
 278         foreach(const int context, m_addedContexts)
 279         core->addAdditionalContext(context);
 280         emit currentModeChanged(mode);
 281         core->updateContext();
 282     }
 283 }
 284
 285 void ModeManager::tabMoved(int from, int to)
 286 {
 287     IMode *mode = m_modes.at(from);
 288
 289     m_modes.remove(from);
 290     m_modes.insert(to, mode);
 291     Command *cmd = m_modeShortcuts.at(from);
 292     m_modeShortcuts.remove(from);
 293     m_modeShortcuts.insert(to, cmd);
 294     setDefaultKeyshortcuts();
 295     // Reprioritize, high priority means show to the left
 296     if (!m_isReprioritizing) {
 297         for (int i = 0; i < m_modes.count(); ++i) {
 298             m_modes.at(i)->setPriority(100 - i);
 299         }
 300         emit newModeOrder(m_modes);
 301     }
 302 }
 303
 304 void ModeManager::reorderModes(QMap<QString, int> priorities)
 305 {
 306     foreach(IMode * mode, m_modes)
 307     mode->setPriority(priorities.value(QString(QLatin1String(mode->uniqueModeName())), mode->priority()));
 308
 309     m_isReprioritizing = true;
 310     IMode *current = currentMode();
 311     // Bubble sort
 312     bool swapped   = false;
 313     do {
 314         swapped = false;
 315         for (int i = 0; i < m_modes.count() - 1; ++i) {
 316             IMode *mode1 = m_modes.at(i);
 317             IMode *mode2 = m_modes.at(i + 1);
 318 // qDebug() << "Comparing " << i << " to " << i+1 << " p1 " << mode1->priority() << " p2 " << mode2->priority();
 319             if (mode2->priority() > mode1->priority()) {
 320                 m_modeStack->moveTab(i, i + 1);
 321 // qDebug() << "Tab moved from " << i << " to " << i+1;
 322                 swapped = true;
 323             }
 324         }
 325     } while (swapped);
 326     m_isReprioritizing = false;
 327     m_modeStack->setCurrentIndex(0);
 328     activateMode(current->uniqueModeName());
 329     emit newModeOrder(m_modes);
 330 }
 331
 332
 333 void ModeManager::setFocusToCurrentMode()
 334 {
 335     IMode *mode     = currentMode();
 336
 337     QTC_ASSERT(mode, return );
 338     QWidget *widget = mode->widget();
 339     if (widget) {
 340         QWidget *focusWidget = widget->focusWidget();
 341
 342         if (focusWidget) {
 343             focusWidget->setFocus();
 344         } else {
 345             widget->setFocus();
 346         }
 347     }
 348 }
 349
 350 void ModeManager::triggerAction(const QString &actionId)
 351 {
 352     foreach(Command * command, m_actions.keys()) {
 353         if (command->action()->objectName() == actionId) {
 354             command->action()->trigger();
 355             break;
 356         }
 357     }
 358 }