Refactor soft keys implementation.

Reviewed-by: Alessandro Portale

Squashed commit of the following:

commit dae5eda6996d48c12c4a5efd3f6042eb293bacbf
Author: Jason Barron <jbarron@trolltech.com>
Date:   Fri Sep 18 10:32:26 2009 +0200

    Only update soft keys when KEYPAD_NAVIGATION is enabled.

    For 4.6, let's just call these functions when keypad navigation is
    defined to minimize the impact on other platforms. They should
    probably get thier own define some day.

commit 30a730553531f0f138de5eddb30413936a34fa36
Author: Jason Barron <jbarron@trolltech.com>
Date:   Fri Sep 18 10:30:23 2009 +0200

    Add/remove the menu bar action when menu bar is added/removed.

commit a83343a2870b34c228c8bc5e6274607b0e97baf6
Author: Jason Barron <jbarron@trolltech.com>
Date:   Fri Sep 18 10:28:55 2009 +0200

    Compile fix for other platforms

commit 39c9e3a0a1d3d62bf6ebd3212cfd2a81b86b9b2a
Author: Jason Barron <jbarron@trolltech.com>
Date:   Thu Sep 17 21:37:59 2009 +0200

    Fix 'softkeys' example after API re-factoring.

    Clean up this example and use the simplified soft key API. Now the
    actions are only allocated in the constructor and dynamically updated
    by calling addAction and removeAction.

commit 314e45c33f40552db74e61755c2a3b0f8c77a41a
Author: Jason Barron <jbarron@trolltech.com>
Date:   Thu Sep 17 21:30:32 2009 +0200

    Re-factor and simplify the soft keys API.

    Several things here:
    - Move all the logic into QSoftKeyManager
    - Move the files into 'kernel' since it is not a widget
    - Remove QWidget::setSoftKey*(). Use addAction/removeAction instead
    - Made soft keys update on focus, window activation, and action
      changes.
    - Fixed several memory leaks where QAction's were created too often
    - QAction ownership pushed out to widget's
    - Added Select/Cancel soft keys for comboboxes and menus to be more
      consistent to platform look-and-feel.

commit fb4c240d970262e9872dc5737df6808879143c75
Author: Jason Barron <jbarron@trolltech.com>
Date:   Mon Sep 7 15:49:31 2009 +0200

    Merge the Symbian implementation with the other platforms nativeMenuBar

    It seems this has been refactored to share more code across the various
    platforms that support native menubars so the Symbian code can be
    mostly removed.

commit aa55e4bcd1f009ab35c9519e18aa325fd212dd23
Author: Jason Barron <jbarron@trolltech.com>
Date:   Wed Aug 26 17:00:34 2009 +0200

    Change filenames and move softkey stuff from 'widgets' to 'kernel'.

    This thing isn't a widget and therefore should not be in the 'widgets'
    subdirectory of gui. Also rename the files in preparation for
    refactoring and extending.

1 files changed, 260 insertions, 0 deletions

diff --git a/src/gui/kernel/qsoftkeymanager.cpp b/src/gui/kernel/qsoftkeymanager.cpp
new file mode 100644
index 0000000..b1ebd38
--- /dev/null
+++ b/src/gui/kernel/qsoftkeymanager.cpp
@@ -0,0 +1,260 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qapplication.h"
+#include "qevent.h"
+#ifdef Q_WS_S60
+#include "private/qt_s60_p.h"
+#endif
+#include "private/qsoftkeymanager_p.h"
+
+QT_BEGIN_NAMESPACE
+
+#ifdef Q_WS_S60
+static const int s60CommandStart = 6000;
+#endif
+
+QWidget *QSoftKeyManager::softKeySource = 0;
+QSoftKeyManager *QSoftKeyManager::self = 0;
+
+const char *QSoftKeyManager::standardSoftKeyText(QAction::SoftKeyRole role)
+{
+    const char *softKeyText = 0;
+    switch (role) {
+    case QAction::OptionsSoftKey:
+        softKeyText = QT_TRANSLATE_NOOP("QSoftKeyManager", "Options");
+        break;
+    case QAction::SelectSoftKey:
+        softKeyText = QT_TRANSLATE_NOOP("QSoftKeyManager", "Select");
+        break;
+    case QAction::BackSoftKey:
+        softKeyText = QT_TRANSLATE_NOOP("QSoftKeyManager", "Back");
+        break;
+    case QAction::NextSoftKey:
+        softKeyText = QT_TRANSLATE_NOOP("QSoftKeyManager", "Next");
+        break;
+    case QAction::PreviousSoftKey:
+        softKeyText = QT_TRANSLATE_NOOP("QSoftKeyManager", "Previous");
+        break;
+    case QAction::OkSoftKey:
+        softKeyText = QT_TRANSLATE_NOOP("QSoftKeyManager", "Ok");
+        break;
+    case QAction::CancelSoftKey:
+        softKeyText = QT_TRANSLATE_NOOP("QSoftKeyManager", "Cancel");
+        break;
+    case QAction::EditSoftKey:
+        softKeyText = QT_TRANSLATE_NOOP("QSoftKeyManager", "Edit");
+        break;
+    case QAction::ViewSoftKey:
+        softKeyText = QT_TRANSLATE_NOOP("QSoftKeyManager", "View");
+        break;
+    default:
+        ;
+    };
+
+    return softKeyText;
+}
+
+QSoftKeyManager *QSoftKeyManager::instance()
+{
+    if (!QSoftKeyManager::self)
+        QSoftKeyManager::self = new QSoftKeyManager;
+
+    return self;
+}
+
+QSoftKeyManager::QSoftKeyManager() : QObject()
+{
+}
+
+QAction *QSoftKeyManager::createAction(QAction::SoftKeyRole softKeyRole, QWidget *actionWidget)
+{
+    const char* text = standardSoftKeyText(softKeyRole);
+    QAction *action = new QAction(QSoftKeyManager::tr(text), actionWidget);
+    action->setSoftKeyRole(softKeyRole);
+    return action;
+}
+
+/*! \internal
+
+  Creates a QAction and registers the 'triggered' signal to send the given key event to
+  \a actionWidget as a convenience.
+
+*/
+QAction *QSoftKeyManager::createKeyedAction(QAction::SoftKeyRole softKeyRole, Qt::Key key, QWidget *actionWidget)
+{
+    QScopedPointer<QAction> action(createAction(softKeyRole, actionWidget));
+
+    connect(action.data(), SIGNAL(triggered()), QSoftKeyManager::instance(), SLOT(sendKeyEvent()));
+
+    QSoftKeyManager::instance()->keyedActions.insert(action.data(), key);
+    return action.take();
+}
+
+void QSoftKeyManager::sendKeyEvent()
+{
+    QAction *action = qobject_cast<QAction*>(sender());
+
+    if (!action)
+        return;
+
+    Qt::Key keyToSend = keyedActions.value(action, Qt::Key_unknown);
+
+    if (keyToSend != Qt::Key_unknown)
+        QApplication::postEvent(action->parentWidget(),
+                                new QKeyEvent(QEvent::KeyPress, keyToSend, Qt::NoModifier));
+}
+
+void QSoftKeyManager::updateSoftKeys(bool force)
+{
+    QList<QAction*> softKeys;
+    QWidget *source = QApplication::focusWidget();
+    do {
+        if (source) {
+            QList<QAction*> actions = source->actions();
+            for (int i = 0; i < actions.count(); ++i) {
+                if (actions.at(i)->softKeyRole() != QAction::NoSoftKey)
+                    softKeys.append(actions.at(i));
+            }
+
+            QWidget *parent = source->parentWidget();
+            if (parent && softKeys.isEmpty())
+                source = parent;
+            else
+                break;
+        } else {
+            source = QApplication::activeWindow();
+        }
+    } while (source);
+
+    if (force || (source != QSoftKeyManager::softKeySource)) {
+            QSoftKeyManager::softKeySource = source;
+            QSoftKeyManager::updateSoftKeys_sys(softKeys);
+    }
+}
+
+#ifdef Q_WS_S60
+void QSoftKeyManager::updateSoftKeys_sys(const QList<QAction*> &softkeys)
+{
+
+    CEikButtonGroupContainer* nativeContainer = S60->buttonGroupContainer();
+    QT_TRAP_THROWING(nativeContainer->SetCommandSetL(R_AVKON_SOFTKEYS_EMPTY_WITH_IDS));
+
+    int position = -1;
+    int command;
+    bool needsExitButton = true;
+
+    for (int index = 0; index < softkeys.count(); index++) {
+        const QAction* softKeyAction = softkeys.at(index);
+        switch (softKeyAction->softKeyRole()) {
+        // Positive Actions go on LSK
+        case QAction::OptionsSoftKey:
+        case QAction::MenuSoftKey:
+        case QAction::ContextMenuSoftKey:
+            command = EAknSoftkeyOptions; //Calls DynInitMenuPane in AppUI
+            position = 0;
+            break;
+        case QAction::SelectSoftKey:
+        case QAction::PreviousSoftKey:
+        case QAction::OkSoftKey:
+        case QAction::EditSoftKey:
+        case QAction::ViewSoftKey:
+        case QAction::EndEditSoftKey:
+        case QAction::FinishSoftKey:
+            command = s60CommandStart + index;
+            position = 0;
+            break;
+        // Negative Actions on the RSK
+        case QAction::BackSoftKey:
+        case QAction::NextSoftKey:
+        case QAction::CancelSoftKey:
+        case QAction::BackSpaceSoftKey:
+        case QAction::RevertEditSoftKey:
+        case QAction::DeselectSoftKey:
+            needsExitButton = false;
+            command = s60CommandStart + index;
+            position = 2;
+            break;
+        case QAction::ExitSoftKey:
+            needsExitButton = false;
+            command = EAknSoftkeyExit; //Calls HandleCommand in AppUI
+            position = 2;
+            break;
+        default:
+            break;
+        }
+
+        if (position != -1) {
+            TPtrC text = qt_QString2TPtrC(softKeyAction->text());
+            QT_TRAP_THROWING(nativeContainer->SetCommandL(position, command, text));
+        }
+    }
+
+    if (needsExitButton)
+        QT_TRAP_THROWING(nativeContainer->SetCommandL(2, EAknSoftkeyExit, qt_QString2TPtrC(QObject::tr("Exit"))));
+
+    nativeContainer->DrawDeferred(); // 3.1 needs an extra invitation
+}
+
+bool QSoftKeyManager::handleCommand(int command)
+{
+    if (command >= s60CommandStart && QSoftKeyManager::softKeySource) {
+        int index = command - s60CommandStart;
+        const QList<QAction*>& softKeys = QSoftKeyManager::softKeySource->actions();
+        if (index < softKeys.count()) {
+            softKeys.at(index)->activate(QAction::Trigger);
+            return true;
+        }
+    }
+
+    return false;
+}
+
+#else
+
+void QSoftKeyManager::updateSoftKeys_sys(const QList<QAction*> &)
+{
+}
+
+#endif
+
+QT_END_NAMESPACE
+