r14610 by cbradney - Enable new prefs keyboard shortcuts pane
scribus-commit
scribus-commit at lists.scribus.net
Mon Feb 1 19:56:32 CET 2010
Revision: 14610
Author: cbradney
Date: 2010-01-31T22:05:46.850041Z
Commit message: Enable new prefs keyboard shortcuts pane
Changeset:
M /trunk/Scribus/scribus/ui/prefs_keyboardshortcuts.cpp
M /trunk/Scribus/scribus/ui/preferencesdialog.cpp
M /trunk/Scribus/scribus/ui/prefs_keyboardshortcuts.h
M /trunk/Scribus/scribus/ui/prefs_imagecache.cpp
Diffs:
Index: scribus/ui/prefs_imagecache.cpp
===================================================================
--- scribus/ui/prefs_imagecache.cpp (revision 14609)
+++ scribus/ui/prefs_imagecache.cpp (revision 14610)
@@ -45,3 +45,4 @@
prefsData->imageCachePrefs.maxCacheEntries = cacheEntryLimitSpinBox->value();
prefsData->imageCachePrefs.compressionLevel = compressionLevelSpinBox->value();
}
+
Index: scribus/ui/prefs_keyboardshortcuts.h
===================================================================
--- scribus/ui/prefs_keyboardshortcuts.h (revision 14609)
+++ scribus/ui/prefs_keyboardshortcuts.h (revision 14610)
@@ -8,16 +8,69 @@
#ifndef PREFS_KEYBOARDSHORTCUTS_H
#define PREFS_KEYBOARDSHORTCUTS_H
+#include <QMap>
+#include <QPair>
+#include <QString>
+#include <QStringList>
+#include <QKeyEvent>
+#include <QEvent>
+
#include "ui_prefs_keyboardshortcutsbase.h"
+#include "prefs_pane.h"
#include "scribusapi.h"
+#include "scribusstructs.h"
-class SCRIBUS_API Prefs_KeyboardShortcuts : public QWidget, Ui::Prefs_KeyboardShortcuts
+
+class SCRIBUS_API Prefs_KeyboardShortcuts : public Prefs_Pane, Ui::Prefs_KeyboardShortcuts
{
Q_OBJECT
public:
Prefs_KeyboardShortcuts(QWidget* parent=0);
~Prefs_KeyboardShortcuts();
+ virtual void restoreDefaults(struct ApplicationPrefs *prefsData);
+ virtual void saveGuiToPrefs(struct ApplicationPrefs *prefsData) const;
+
+ bool event( QEvent* ev );
+ void keyPressEvent(QKeyEvent *k);
+ void keyReleaseEvent(QKeyEvent *k);
+ static QString getKeyText(int KeyC);
+
+ public slots:
+ void languageChange();
+
+protected:
+ QMap<QString,Keys> keyMap;
+ QMap<QString,Keys>::Iterator currentKeyMapRow;
+ QMap<QString, QString> keySetList;
+ QMap<QTreeWidgetItem*, QString> lviToActionMap;
+ QList<QTreeWidgetItem*> lviToMenuMap;
+ QVector< QPair<QString, QStringList> >* defMenus;
+ QVector< QPair<QString, QStringList> >* defNonMenuActions;
+ QTreeWidgetItem * selectedLVI;
+ int keyCode;
+ QString Part0;
+ QString Part1;
+ QString Part2;
+ QString Part3;
+ QString Part4;
+
+ void insertActions();
+ void importKeySet(QString);
+ bool exportKeySet(QString);
+ QStringList scanForSets();
+ bool checkKey(int Code);
+
+protected slots:
+ void setKeyText();
+ void dispKey(QTreeWidgetItem* current, QTreeWidgetItem* previous=0);
+ void setNoKey();
+ void loadKeySetFile();
+ void importKeySetFile();
+ void exportKeySetFile();
+ void resetKeySet();
+ void clearSearchString();
+ void applySearch( const QString & newss );
};
#endif // PREFS_KEYBOARDSHORTCUTS_H
Index: scribus/ui/preferencesdialog.cpp
===================================================================
--- scribus/ui/preferencesdialog.cpp (revision 14609)
+++ scribus/ui/preferencesdialog.cpp (revision 14610)
@@ -128,6 +128,7 @@
prefs_PreflightVerifier->restoreDefaults(&localPrefs);
prefs_DocumentItemAttributes->restoreDefaults(&localPrefs);
prefs_TableOfContents->restoreDefaults(&localPrefs);
+ prefs_KeyboardShortcuts->restoreDefaults(&localPrefs);
prefs_ColorManagement->restoreDefaults(&localPrefs);
prefs_ColorManagement->setProfiles(&localPrefs, &ScCore->InputProfiles, &ScCore->InputProfilesCMYK, &ScCore->PrinterProfiles, &ScCore->MonitorProfiles);
prefs_Scrapbook->restoreDefaults(&localPrefs);
@@ -153,6 +154,7 @@
prefs_PreflightVerifier->saveGuiToPrefs(&localPrefs);
prefs_DocumentItemAttributes->saveGuiToPrefs(&localPrefs);
prefs_TableOfContents->saveGuiToPrefs(&localPrefs);
+ prefs_KeyboardShortcuts->saveGuiToPrefs(&localPrefs);
prefs_ColorManagement->saveGuiToPrefs(&localPrefs);
prefs_Scrapbook->saveGuiToPrefs(&localPrefs);
prefs_Display->saveGuiToPrefs(&localPrefs);
Index: scribus/ui/prefs_keyboardshortcuts.cpp
===================================================================
--- scribus/ui/prefs_keyboardshortcuts.cpp (revision 14609)
+++ scribus/ui/prefs_keyboardshortcuts.cpp (revision 14610)
@@ -5,16 +5,578 @@
for which a new license (GPL+exception) is in place.
*/
-#include "prefs_keyboardshortcuts.h"
+#include <QDomDocument>
+#include <QFileDialog>
+#include <QInputDialog>
+#include <QMessageBox>
+#include "ui/prefs_keyboardshortcuts.h"
+#include "actionmanager.h"
+#include "commonstrings.h"
+#include "pluginmanager.h"
+#include "prefsmanager.h"
+#include "prefsstructs.h"
+#include "prefsfile.h"
+#include "prefscontext.h"
+#include "scpaths.h"
+#include "scplugin.h"
+#include "scraction.h"
+#include "util.h"
+#include "util_icon.h"
+
Prefs_KeyboardShortcuts::Prefs_KeyboardShortcuts(QWidget* parent)
- : QWidget(parent)
+ : Prefs_Pane(parent)
{
setupUi(this);
+ languageChange();
+ defMenus=ActionManager::defaultMenus();
+ defNonMenuActions=ActionManager::defaultNonMenuActions();
+
+ QVector< QPair<QString, QStringList> >::Iterator itnmenua = defNonMenuActions->begin();
+ PluginManager& pluginManager(PluginManager::instance());
+ QStringList pluginNames(pluginManager.pluginNames(false));
+ ScPlugin* plugin;
+ ScActionPlugin* ixplug;
+ QString pName;
+ for (int i = 0; i < pluginNames.count(); ++i)
+ {
+ pName = pluginNames.at(i);
+ plugin = pluginManager.getPlugin(pName, true);
+ Q_ASSERT(plugin); // all the returned names should represent loaded plugins
+ if (plugin->inherits("ScActionPlugin"))
+ {
+ ixplug = dynamic_cast<ScActionPlugin*>(plugin);
+ Q_ASSERT(ixplug);
+ ScActionPlugin::ActionInfo ai(ixplug->actionInfo());
+ itnmenua->second << ai.name;
+ }
+ }
+
+ Q_CHECK_PTR(defMenus);
+ lviToActionMap.clear();
+ lviToMenuMap.clear();
+ keyTable->clear();
+ keyMap.clear();
+ //keyMap = oldKeyMap;
+ Part0 = "";
+ Part1 = "";
+ Part2 = "";
+ Part3 = "";
+ Part4 = "";
+ keyCode = 0;
+ keyDisplay->setMinimumWidth(fontMetrics().width("CTRL+ALT+SHIFT+W"));
+ keyDisplay->setText("");
+
+ clearSearchButton->setIcon(loadIcon("clear_right.png"));
+ // signals and slots connections
+ connect( keyTable, SIGNAL(currentItemChanged(QTreeWidgetItem *, QTreeWidgetItem *)),
+ this, SLOT(dispKey(QTreeWidgetItem *, QTreeWidgetItem *)));
+ connect( noKey, SIGNAL(clicked()), this, SLOT(setNoKey()));
+ connect( setKeyButton, SIGNAL(clicked()), this, SLOT(setKeyText()));
+ connect( loadSetButton, SIGNAL(clicked()), this, SLOT(loadKeySetFile()));
+ connect( importSetButton, SIGNAL(clicked()), this, SLOT(importKeySetFile()));
+ connect( exportSetButton, SIGNAL(clicked()), this, SLOT(exportKeySetFile()));
+ connect( resetSetButton, SIGNAL(clicked()), this, SLOT(resetKeySet()));
+ connect( clearSearchButton, SIGNAL(clicked()), this, SLOT(clearSearchString()));
+ connect( searchTextLineEdit, SIGNAL(textChanged(const QString &)), this, SLOT(applySearch(const QString&)));
+
}
Prefs_KeyboardShortcuts::~Prefs_KeyboardShortcuts()
{
}
+void Prefs_KeyboardShortcuts::languageChange()
+{
+}
+
+void Prefs_KeyboardShortcuts::restoreDefaults(struct ApplicationPrefs *prefsData)
+{
+ keyMap=prefsData->keyShortcutPrefs.KeyActions;
+ loadableSets->clear();
+ loadableSets->addItems(scanForSets());
+ insertActions();
+ dispKey(0);
+}
+
+void Prefs_KeyboardShortcuts::saveGuiToPrefs(struct ApplicationPrefs *prefsData) const
+{
+ prefsData->keyShortcutPrefs.KeyActions=keyMap;
+}
+
+void Prefs_KeyboardShortcuts::setNoKey()
+{
+ if (noKey->isChecked())
+ {
+ if (selectedLVI!=0)
+ {
+ selectedLVI->setText(1,"");
+ keyMap[lviToActionMap[selectedLVI]].keySequence=QKeySequence();
+ }
+ keyDisplay->setText("");
+ noKey->setChecked(true);
+ }
+}
+
+void Prefs_KeyboardShortcuts::loadKeySetFile()
+{
+ if (keySetList.contains(loadableSets->currentText()))
+ importKeySet(keySetList[loadableSets->currentText()]);
+}
+
+void Prefs_KeyboardShortcuts::importKeySetFile()
+{
+ PrefsContext* dirs = PrefsManager::instance()->prefsFile->getContext("dirs");
+ QString currentPath = dirs->get("keymapprefs_import", ScPaths::instance().shareDir() + "keysets/");
+ QString s = QFileDialog::getOpenFileName(this, tr("Select a Key set file to read"), currentPath, tr("Key Set XML Files (*.xml)"));
+ if (!s.isEmpty())
+ importKeySet(s);
+}
+void Prefs_KeyboardShortcuts::exportKeySetFile()
+{
+ PrefsContext* dirs = PrefsManager::instance()->prefsFile->getContext("dirs");
+ QString currentPath= dirs->get("keymapprefs_export", ".");
+ QString s = QFileDialog::getSaveFileName(this, tr("Select a Key set file to save to"), currentPath, tr("Key Set XML Files (*.xml)") );
+ if (!s.isEmpty())
+ exportKeySet(s);
+}
+
+void Prefs_KeyboardShortcuts::importKeySet(QString filename)
+{
+ searchTextLineEdit->clear();
+ QFileInfo fi = QFileInfo(filename);
+ if (fi.exists())
+ {
+ //import the file into qdomdoc
+ QDomDocument doc( "keymapentries" );
+ QFile file1( filename );
+ if ( !file1.open( QIODevice::ReadOnly ) )
+ return;
+ QTextStream ts(&file1);
+ ts.setCodec("UTF-8");
+ QString errorMsg;
+ int eline;
+ int ecol;
+ if ( !doc.setContent( ts.readAll(), &errorMsg, &eline, &ecol ))
+ {
+ qDebug("%s", QString("Could not open key set file: %1\nError:%2 at line: %3, row: %4").arg(filename).arg(errorMsg).arg(eline).arg(ecol).toAscii().constData());
+ file1.close();
+ return;
+ }
+ file1.close();
+ //load the file now
+ QDomElement docElem = doc.documentElement();
+ if (docElem.tagName()=="shortcutset" && docElem.hasAttribute("name"))
+ {
+ QDomAttr keysetAttr = docElem.attributeNode( "name" );
+
+ //clear current menu entries
+ for (QMap<QString,Keys>::Iterator it=keyMap.begin(); it!=keyMap.end(); ++it)
+ it.value().keySequence = QKeySequence();
+
+ //load in new set
+ QDomNode n = docElem.firstChild();
+ while( !n.isNull() )
+ {
+ QDomElement e = n.toElement(); // try to convert the node to an element.
+ if( !e.isNull() )
+ {
+ if (e.hasAttribute("name") && e.hasAttribute( "shortcut" ))
+ {
+ QDomAttr nameAttr = e.attributeNode( "name" );
+ QDomAttr shortcutAttr = e.attributeNode( "shortcut" );
+ if (keyMap.contains(nameAttr.value()))
+ keyMap[nameAttr.value()].keySequence=QKeySequence(shortcutAttr.value());
+ }
+ }
+ n = n.nextSibling();
+ }
+ }
+ }
+ insertActions();
+}
+
+bool Prefs_KeyboardShortcuts::exportKeySet(QString filename)
+{
+ QFileInfo fi = QFileInfo(filename);
+ QString exportFileName;
+ if (filename.endsWith(".xml"))
+ exportFileName = filename;
+ else
+ exportFileName = filename+".xml";
+ if (overwrite(this, exportFileName))
+ {
+ bool ok;
+ QString setName = QInputDialog::getText(this, tr("Export Keyboard Shortcuts to File"), tr("Enter the name of the shortcut set:"), QLineEdit::Normal, QString::null, &ok);
+ if (!( ok && !setName.isEmpty()) )
+ return false;
+
+ QDomDocument doc( "keymapentries" );
+ QString keyset=QString("<shortcutset name=\"%1\"></shortcutset>").arg(setName);
+ doc.setContent(keyset);
+ QDomElement keySetElement=doc.documentElement();
+ QMap<QString,Keys>::Iterator itEnd=keyMap.end();
+ for (QMap<QString,Keys>::Iterator it=keyMap.begin(); it!=itEnd; ++it)
+ {
+ if (it.value().keySequence.isEmpty() && it.key().isEmpty())
+ continue;
+ QDomElement function_shortcut=doc.createElement("function");
+ function_shortcut.setAttribute("name",it.key());
+ function_shortcut.setAttribute("shortcut",getKeyText(it.value().keySequence));
+ keySetElement.appendChild(function_shortcut);
+ }
+ QFile f(filename);
+ if(!f.open(QIODevice::WriteOnly))
+ return false;
+ QDataStream s(&f);
+ QByteArray xmltag("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
+ s.writeRawData(xmltag.data(), xmltag.length());
+ QByteArray xmldoc = doc.toByteArray(4);
+ s.writeRawData(xmldoc, xmldoc.length());
+ f.close();
+ }
+ return true;
+}
+
+void Prefs_KeyboardShortcuts::resetKeySet()
+{
+ QString location=ScPaths::instance().shareDir();
+ QString defaultKeySetFileName=QDir::convertSeparators(location+"keysets/scribus13.xml");
+ importKeySet(defaultKeySetFileName);
+}
+
+QStringList Prefs_KeyboardShortcuts::scanForSets()
+{
+ keySetList.clear();
+ QString location=ScPaths::instance().shareDir();
+ QString keySetLocation=QDir::convertSeparators(location+"keysets/");
+ QDir keySetsDir(keySetLocation, "*.xml", QDir::Name, QDir::Files | QDir::NoSymLinks);
+ if ((keySetsDir.exists()) && (keySetsDir.count() != 0))
+ {
+ QStringList appNames;
+ for (uint fileCounter = 0; fileCounter < keySetsDir.count(); ++fileCounter)
+ {
+ QString filename=QDir::convertSeparators(location+"keysets/"+keySetsDir[fileCounter]);
+
+ QDomDocument doc( "keymapentries" );
+ QFile file( filename );
+ if ( !file.open( QIODevice::ReadOnly ) )
+ continue;
+ QString errorMsg;
+ int eline;
+ int ecol;
+
+ if ( !doc.setContent( &file, &errorMsg, &eline, &ecol ))
+ {
+ qDebug("%s", QString("Could not open key set file: %1\nError:%2 at line: %3, row: %4").arg(keySetsDir[fileCounter]).arg(errorMsg).arg(eline).arg(ecol).toAscii().constData());
+ file.close();
+ continue;
+ }
+ file.close();
+
+ QDomElement docElem = doc.documentElement();
+ if (docElem.tagName()=="shortcutset" && docElem.hasAttribute("name"))
+ {
+ QDomAttr nameAttr = docElem.attributeNode( "name" );
+ appNames.append(nameAttr.value());
+ keySetList.insert(nameAttr.value(), filename);
+ }
+ }
+ return QStringList(appNames);
+ }
+ return QStringList();
+}
+
+QString Prefs_KeyboardShortcuts::getKeyText(int KeyC)
+{
+ if ((KeyC & ~(Qt::META | Qt::CTRL | Qt::ALT | Qt::SHIFT)) == 0)
+ return "";
+ // on OSX Qt translates modifiers to forsaken symbols, arrows and the like
+ // we prefer plain English
+ QString res;
+ if ((KeyC & Qt::META) != 0)
+ res += "Meta+";
+ if ((KeyC & Qt::CTRL) != 0)
+ res += "Ctrl+";
+ if ((KeyC & Qt::ALT) != 0)
+ res += "Alt+";
+ if ((KeyC & Qt::SHIFT) != 0)
+ res += "Shift+";
+ return res + QString(QKeySequence(KeyC & ~(Qt::META | Qt::CTRL | Qt::ALT | Qt::SHIFT)));
+}
+
+void Prefs_KeyboardShortcuts::setKeyText()
+{
+ if (keyTable->currentItem()==0)
+ {
+ setKeyButton->setChecked(false);
+ return;
+ }
+ if (setKeyButton->isChecked())
+ {
+ keyCode = 0;
+ Part0 = "";
+ Part1 = "";
+ Part2 = "";
+ Part3 = "";
+ Part4 = "";
+ grabKeyboard();
+ }
+ else
+ releaseKeyboard();
+}
+
+void Prefs_KeyboardShortcuts::insertActions()
+{
+ lviToActionMap.clear();
+ lviToMenuMap.clear();
+ keyTable->clear();
+ bool first, firstMenu=true;
+ QTreeWidgetItem *currLVI = NULL;
+ QTreeWidgetItem *currMenuLVI = NULL;
+ QTreeWidgetItem *prevLVI = NULL;
+ QTreeWidgetItem *prevMenuLVI = NULL;
+ for (QVector< QPair<QString, QStringList> >::Iterator itmenu = defMenus->begin(); itmenu != defMenus->end(); ++itmenu )
+ {
+ if (firstMenu)
+ {
+ currMenuLVI = new QTreeWidgetItem(keyTable);
+ firstMenu = false;
+ }
+ else
+ currMenuLVI = new QTreeWidgetItem(keyTable, prevMenuLVI);
+ Q_CHECK_PTR(currMenuLVI);
+ lviToMenuMap.append(currMenuLVI);
+ currMenuLVI->setText(0, itmenu->first);
+ currMenuLVI->setExpanded(true);
+ prevMenuLVI=currMenuLVI;
+ first=true;
+ currLVI=0;
+ prevLVI=0;
+ for ( QStringList::Iterator it = itmenu->second.begin(); it != itmenu->second.end(); ++it )
+ {
+ if (first)
+ {
+ currLVI = new QTreeWidgetItem(currMenuLVI);
+ first = false;
+ }
+ else
+ currLVI = new QTreeWidgetItem(currMenuLVI, prevLVI);
+ Q_CHECK_PTR(currLVI);
+ lviToActionMap.insert(currLVI, *it);
+ currLVI->setText(0, keyMap[*it].cleanMenuText);
+ currLVI->setText(1, keyMap[*it].keySequence);
+ prevLVI=currLVI;
+ }
+ }
+ //Non menu actions
+ for (QVector< QPair<QString, QStringList> >::Iterator itmenu = defNonMenuActions->begin(); itmenu != defNonMenuActions->end(); ++itmenu )
+ {
+ if (firstMenu)
+ {
+ currMenuLVI = new QTreeWidgetItem(keyTable);
+ firstMenu = false;
+ }
+ else
+ currMenuLVI = new QTreeWidgetItem(keyTable, prevMenuLVI);
+ Q_CHECK_PTR(currMenuLVI);
+ lviToMenuMap.append(currMenuLVI);
+ currMenuLVI->setText(0, itmenu->first);
+ currMenuLVI->setExpanded(true);
+ prevMenuLVI=currMenuLVI;
+ first=true;
+ currLVI=0;
+ prevLVI=0;
+ for ( QStringList::Iterator it = itmenu->second.begin(); it != itmenu->second.end(); ++it )
+ {
+ if (first)
+ {
+ currLVI=new QTreeWidgetItem(currMenuLVI);
+ first=false;
+ }
+ else
+ currLVI=new QTreeWidgetItem(currMenuLVI, prevLVI);
+ Q_CHECK_PTR(currLVI);
+ lviToActionMap.insert(currLVI, *it);
+ currLVI->setText(0, keyMap[*it].cleanMenuText);
+ currLVI->setText(1, keyMap[*it].keySequence);
+ prevLVI=currLVI;
+ }
+ }
+ keyTable->resizeColumnToContents(0);
+}
+
+void Prefs_KeyboardShortcuts::applySearch( const QString & newss )
+{
+ //Must run this as if newss is not empty and we go to the next for loop, the set visible doesnt work
+ for (QList<QTreeWidgetItem*>::iterator it=lviToMenuMap.begin(); it!=lviToMenuMap.end(); ++it)
+ (*it)->setHidden(false);
+ if (newss.isEmpty())
+ {
+ for (QMap<QTreeWidgetItem*, QString>::iterator it=lviToActionMap.begin(); it!=lviToActionMap.end(); ++it)
+ it.key()->setHidden(false);
+ return;
+ }
+ //Seem to need to do this.. isOpen doesnt seem to do what it says
+ for (QMap<QTreeWidgetItem*, QString>::iterator it=lviToActionMap.begin(); it!=lviToActionMap.end(); ++it)
+ {
+ if (it.key()->text(0).contains(newss, Qt::CaseInsensitive))
+ it.key()->setHidden(false);
+ else
+ it.key()->setHidden(true);
+ }
+}
+
+void Prefs_KeyboardShortcuts::dispKey(QTreeWidgetItem* qlvi, QTreeWidgetItem*)
+{
+ if (qlvi!=0 && lviToActionMap.contains(qlvi))
+ {
+ selectedLVI=qlvi;
+ QString actionName=lviToActionMap[qlvi];
+ if (actionName.isEmpty())
+ return;
+ keyDisplay->setText(keyMap[actionName].keySequence);
+ if (keyMap[actionName].keySequence.isEmpty())
+ noKey->setChecked(true);
+ else
+ userDef->setChecked(true);
+ }
+ else
+ {
+ noKey->setChecked(true);
+ keyDisplay->setText("");
+ selectedLVI=0;
+ }
+}
+
+bool Prefs_KeyboardShortcuts::event( QEvent* ev )
+{
+ bool ret = QWidget::event( ev );
+ if ( ev->type() == QEvent::KeyPress )
+ keyPressEvent((QKeyEvent*)ev);
+ if ( ev->type() == QEvent::KeyRelease )
+ keyReleaseEvent((QKeyEvent*)ev);
+ return ret;
+}
+
+void Prefs_KeyboardShortcuts::keyPressEvent(QKeyEvent *k)
+{
+ if (setKeyButton->isChecked())
+ {
+ QStringList tl;
+ Part4 = "";
+ if (!keyDisplay->text().isEmpty())
+ {
+ tl = keyDisplay->text().split("+", QString::SkipEmptyParts);
+ if (tl.count() > 0)
+ {
+ Part4 = tl[tl.count()-1];
+ if (Part4 == tr("Alt") || Part4 == tr("Ctrl") || Part4 == tr("Shift") || Part4 == tr("Meta"))
+ Part4 = "";
+ }
+ }
+ switch (k->key())
+ {
+ case Qt::Key_Meta:
+ Part0 = tr("Meta+");
+ keyCode |= Qt::META;
+ break;
+ case Qt::Key_Shift:
+ Part3 = tr("Shift+");
+ keyCode |= Qt::SHIFT;
+ break;
+ case Qt::Key_Alt:
+ Part2 = tr("Alt+");
+ keyCode |= Qt::ALT;
+ break;
+ case Qt::Key_Control:
+ Part1 = tr("Ctrl+");
+ keyCode |= Qt::CTRL;
+ break;
+ default:
+ keyCode |= k->key();
+ keyDisplay->setText(getKeyText(keyCode));
+ releaseKeyboard();
+ if (checkKey(keyCode))
+ {
+ QMessageBox::information(this, CommonStrings::trWarning,
+ tr("This key sequence is already in use"),
+ CommonStrings::tr_OK);
+ selectedLVI->setText(1,keyMap[lviToActionMap[selectedLVI]].keySequence);
+ keyDisplay->setText(keyMap[lviToActionMap[selectedLVI]].keySequence);
+ }
+ else
+ {
+ QKeySequence newKeySequence(keyCode);
+ selectedLVI->setText(1, QString(newKeySequence));
+ keyMap[lviToActionMap[selectedLVI]].keySequence=newKeySequence;
+ userDef->setChecked(true);
+ }
+ setKeyButton->setChecked(false);
+ }
+ }
+ if (setKeyButton->isChecked())
+ keyDisplay->setText(Part0+Part1+Part2+Part3+Part4);
+}
+
+void Prefs_KeyboardShortcuts::keyReleaseEvent(QKeyEvent *k)
+{
+ if (setKeyButton->isChecked())
+ {
+ Part4 = "";
+ if (!keyDisplay->text().isEmpty())
+ {
+ QStringList tl;
+ tl = keyDisplay->text().split("+", QString::SkipEmptyParts);
+ if (tl.count() > 0)
+ {
+ Part4 = tl[tl.count()-1];
+ if (Part4 == tr("Alt") || Part4 == tr("Ctrl") || Part4 == tr("Shift") || Part4 == tr("Meta"))
+ Part4 = "";
+ }
+ }
+ if (k->key() == Qt::Key_Meta)
+ {
+ Part0 = "";
+ keyCode &= ~Qt::META;
+ }
+ if (k->key() == Qt::Key_Shift)
+ {
+ Part3 = "";
+ keyCode &= ~Qt::SHIFT;
+ }
+ if (k->key() == Qt::Key_Alt)
+ {
+ Part2 = "";
+ keyCode &= ~Qt::ALT;
+ }
+ if (k->key() == Qt::Key_Control)
+ {
+ Part1 = "";
+ keyCode &= ~Qt::CTRL;
+ }
+ keyDisplay->setText(Part0+Part1+Part2+Part3+Part4);
+ }
+}
+
+bool Prefs_KeyboardShortcuts::checkKey(int code)
+{
+ bool ret = false;
+ QKeySequence key = QKeySequence(code);
+ for (QMap<QString,Keys>::Iterator it=keyMap.begin(); it!=keyMap.end(); ++it)
+ {
+ if (key.matches(it.value().keySequence) != QKeySequence::NoMatch)
+ {
+ ret = true;
+ break;
+ }
+ }
+ return ret;
+}
+
+void Prefs_KeyboardShortcuts::clearSearchString( )
+{
+ searchTextLineEdit->clear();
+}
+
More information about the scribus-commit
mailing list