#include "LyXAction.h"
#include "Lexer.h"
-#include "frontends/LyXKeySym.h"
+#include "frontends/KeySymbol.h"
#include "support/filetools.h"
using std::string;
-string const KeyMap::printKeySym(LyXKeySym const & key,
+string const KeyMap::printKeySym(KeySymbol const & key,
key_modifier::state mod)
{
string buf;
FuncRequest const &
-KeyMap::lookup(LyXKeySymPtr key,
+KeyMap::lookup(KeySymbolPtr key,
key_modifier::state mod, KeySequence * seq) const
{
static FuncRequest const unknown(LFUN_UNKNOWN_ACTION);
void KeyMap::defkey(KeySequence * seq, FuncRequest const & func, unsigned int r)
{
- LyXKeySymPtr code = seq->sequence[r];
+ KeySymbolPtr code = seq->sequence[r];
if (!code->isOK())
return;
}
-std::pair<LyXKeySym const *, key_modifier::state>
+std::pair<KeySymbol const *, key_modifier::state>
KeyMap::find1keybinding(FuncRequest const & func) const
{
Table::const_iterator end = table.end();
return std::make_pair(cit->code.get(), cit->mod.first);
}
- return std::make_pair<LyXKeySym const *, key_modifier::state>(0, key_modifier::none);
+ return std::make_pair<KeySymbol const *, key_modifier::state>(0, key_modifier::none);
}
#include "FuncRequest.h"
#include "frontends/key_state.h"
-#include "frontends/LyXKeySym.h"
+#include "frontends/KeySymbol.h"
#include "support/docstream.h"
* @return the action / LFUN_COMMAND_PREFIX / LFUN_UNKNOWN_ACTION
*/
FuncRequest const &
- lookup(LyXKeySymPtr key,
+ lookup(KeySymbolPtr key,
key_modifier::state mod, KeySequence * seq) const;
///
/**
* Given an action, find the first 1-key binding (if it exists).
- * The LyXKeySym pointer is 0 is no key is found.
+ * The KeySymbol pointer is 0 is no key is found.
* [only used by the Qt/Mac frontend]
*/
- std::pair<LyXKeySym const *, key_modifier::state>
+ std::pair<KeySymbol const *, key_modifier::state>
find1keybinding(FuncRequest const & func) const;
* @param key the key as a keysym
* @param mod the modifiers
*/
- static std::string const printKeySym(LyXKeySym const & key,
+ static std::string const printKeySym(KeySymbol const & key,
key_modifier::state mod);
typedef std::pair<key_modifier::state, key_modifier::state> modifier_pair;
///
struct Key {
/// Keysym
- LyXKeySymPtr code;
+ KeySymbolPtr code;
/// Modifier masks
modifier_pair mod;
#include "KeyMap.h"
#include "lfuns.h"
-#include "frontends/LyXKeySym.h"
-#include "frontends/LyXKeySymFactory.h"
+#include "frontends/KeySymbol.h"
namespace lyx {
FuncRequest const &
-KeySequence::addkey(LyXKeySymPtr key,
+KeySequence::addkey(KeySymbolPtr key,
key_modifier::state mod, key_modifier::state nmod)
{
// adding a key to a deleted sequence
for (; j < s.length() && s[j] != ' '; ++j)
tbuf += s[j]; // (!!!check bounds :-)
- LyXKeySymPtr key(LyXKeySymFactory::create());
+ KeySymbolPtr key(createKeySymbol());
key->init(tbuf);
if (!key->isOK())
#define KB_SEQUENCE_H
#include "frontends/key_state.h"
-#include "frontends/LyXKeySym.h"
+#include "frontends/KeySymbol.h"
#include <string>
#include <vector>
/// Holds a key sequence and the current and standard keymaps
class KeySequence {
public:
- typedef std::vector<LyXKeySymPtr> Sequence;
+ typedef std::vector<KeySymbolPtr> Sequence;
friend class KeyMap;
* @return the action matching this key sequence or LFUN_UNKNOWN_ACTION
*/
FuncRequest const &
- addkey(LyXKeySymPtr keysym, key_modifier::state mod,
+ addkey(KeySymbolPtr keysym, key_modifier::state mod,
key_modifier::state nmod = key_modifier::none);
/**
#include "frontends/FileDialog.h"
#include "frontends/FontLoader.h"
#include "frontends/Gui.h"
-#include "frontends/LyXKeySym.h"
+#include "frontends/KeySymbol.h"
#include "frontends/LyXView.h"
#include "frontends/Menubar.h"
#include "frontends/Toolbars.h"
}
-void LyXFunc::processKeySym(LyXKeySymPtr keysym, key_modifier::state state)
+void LyXFunc::processKeySym(KeySymbolPtr keysym, key_modifier::state state)
{
LYXERR(Debug::KEY) << "KeySym is " << keysym->getSymbolName() << endl;
class BufferView;
class FuncRequest;
class FuncStatus;
-class LyXKeySym;
+class KeySymbol;
class LyXText;
class LyXView;
docstring const viewStatusMessage();
///
- void processKeySym(LyXKeySymPtr key, key_modifier::state state);
+ void processKeySym(KeySymbolPtr key, key_modifier::state state);
///
FuncStatus getStatus(FuncRequest const & action) const;
--- /dev/null
+// -*- C++ -*-
+/**
+ * \file KeySymbol.h
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
+ *
+ * \author Asger and Jürgen
+ *
+ * Full author contact details are available in file CREDITS.
+ */
+
+#ifndef KEYSYMBOL_H
+#define KEYSYMBOL_H
+
+#include <string>
+
+#include "key_state.h"
+
+#include "support/docstring.h"
+
+#include <boost/shared_ptr.hpp>
+
+
+namespace lyx {
+
+/**
+ * This is a base class for representing a keypress.
+ * Each frontend has to implement this to provide
+ * the functionality that LyX needs in regards to
+ * key presses.
+ */
+class KeySymbol {
+public:
+ KeySymbol() {}
+
+ virtual ~KeySymbol() {}
+
+ ///
+ virtual bool operator==(KeySymbol const& ks) const = 0;
+
+ /// Initialize with the name of a key. F. ex. "space" or "a"
+ virtual void init(std::string const & symbolname) = 0;
+
+ /// Is this a valid key?
+ virtual bool isOK() const = 0;
+
+ /// Is this a modifier key only?
+ virtual bool isModifier() const = 0;
+
+ /// Is this normal insertable text ? (last ditch attempt only)
+ virtual bool isText() const = 0;
+
+ /// What is the symbolic name of this key? F.ex. "Return" or "c"
+ virtual std::string getSymbolName() const = 0;
+
+ /**
+ * Return the value of the keysym into the UCS-4 encoding.
+ * This converts the KeySymbol to a 32-bit encoded character.
+ */
+ virtual char_type getUCSEncoded() const = 0;
+
+ /**
+ * Return a string describing the KeySym with modifier mod.
+ * Use the native UI format when \c forgui is true.
+ */
+ virtual docstring const print(key_modifier::state mod, bool forgui) const = 0;
+};
+
+
+typedef boost::shared_ptr<KeySymbol> KeySymbolPtr;
+
+
+/**
+ * Make a KeySymbol. Used because we want to
+ * generate a toolkit-specific instance.
+ */
+KeySymbol * createKeySymbol();
+
+
+} // namespace lyx
+
+#endif
+++ /dev/null
-// -*- C++ -*-
-/**
- * \file LyXKeySym.h
- * This file is part of LyX, the document processor.
- * Licence details can be found in the file COPYING.
- *
- * \author Asger and Jürgen
- *
- * Full author contact details are available in file CREDITS.
- */
-
-#ifndef LYXKEYSYM_H
-#define LYXKEYSYM_H
-
-#include <string>
-
-#include "key_state.h"
-
-#include "support/docstring.h"
-
-#include <boost/shared_ptr.hpp>
-
-
-namespace lyx {
-
-/**
- * This is a base class for representing a keypress.
- * Each frontend has to implement this to provide
- * the functionality that LyX needs in regards to
- * key presses.
- */
-class LyXKeySym {
-public:
- LyXKeySym() {}
-
- virtual ~LyXKeySym() {}
-
- ///
- virtual bool operator==(LyXKeySym const& ks) const = 0;
-
- /// Initialize with the name of a key. F. ex. "space" or "a"
- virtual void init(std::string const & symbolname) = 0;
-
- /// Is this a valid key?
- virtual bool isOK() const = 0;
-
- /// Is this a modifier key only?
- virtual bool isModifier() const = 0;
-
- /// Is this normal insertable text ? (last ditch attempt only)
- virtual bool isText() const = 0;
-
- /// What is the symbolic name of this key? F.ex. "Return" or "c"
- virtual std::string getSymbolName() const = 0;
-
- /**
- * Return the value of the keysym into the UCS-4 encoding.
- * This converts the LyXKeySym to a 32-bit encoded character.
- */
- virtual char_type getUCSEncoded() const = 0;
-
- /**
- * Return a string describing the KeySym with modifier mod.
- * Use the native UI format when \c forgui is true.
- */
- virtual docstring const print(key_modifier::state mod, bool forgui) const = 0;
-};
-
-
-typedef boost::shared_ptr<LyXKeySym> LyXKeySymPtr;
-
-
-} // namespace lyx
-
-#endif
+++ /dev/null
-// -*- C++ -*-
-/**
- * \file LyXKeySymFactory.h
- * This file is part of LyX, the document processor.
- * Licence details can be found in the file COPYING.
- *
- * \author Asger & Jürgen
- *
- * Full author contact details are available in file CREDITS.
- */
-
-#ifndef LYXKEYSYMFACTORY_H
-#define LYXKEYSYMFACTORY_H
-
-namespace lyx {
-
-class LyXKeySym;
-
-namespace LyXKeySymFactory {
- /**
- * Make a LyXKeySym. Used because we want to
- * generate a toolkit-specific instance.
- */
- LyXKeySym * create();
-}
-
-} // namespace lyx
-
-#endif // LYXKEYSYM_FACTORY_H
FileDialog.h \
FontLoader.h \
FontMetrics.h \
- LyXKeySym.h \
- LyXKeySymFactory.h \
+ KeySymbol.h \
+ KeySymbolFactory.h \
LyXView.cpp \
LyXView.h \
Menubar.h \
}
-void WorkArea::processKeySym(LyXKeySymPtr key, key_modifier::state state)
+void WorkArea::processKeySym(KeySymbolPtr key, key_modifier::state state)
{
// In order to avoid bad surprise in the middle of an operation, we better stop
// the blinking cursor.
#define BASE_WORKAREA_H
#include "frontends/key_state.h"
-#include "frontends/LyXKeySym.h"
+#include "frontends/KeySymbol.h"
#include "frontends/Timeout.h"
#include "support/docstring.h"
/// Process Key pressed event.
/// This needs to be public because it is accessed externally by GuiView.
- void processKeySym(LyXKeySymPtr key, key_modifier::state state);
+ void processKeySym(KeySymbolPtr key, key_modifier::state state);
protected:
/// cause the display of the given area of the work area
virtual void expose(int x, int y, int w, int h) = 0;
#include "GuiImplementation.h"
#include "GuiWorkArea.h"
-#include "QLyXKeySym.h"
+#include "QKeySymbol.h"
#include "QLMenubar.h"
#include "QLToolbar.h"
#include "QCommandBuffer.h"
if (e->type() == QEvent::ShortcutOverride) {
QKeyEvent * ke = static_cast<QKeyEvent*>(e);
if (ke->key() == Qt::Key_Tab || ke->key() == Qt::Key_Backtab) {
- boost::shared_ptr<QLyXKeySym> sym(new QLyXKeySym);
+ boost::shared_ptr<QKeySymbol> sym(new QKeySymbol);
sym->set(ke);
BOOST_ASSERT(work_area_);
work_area_->processKeySym(sym, key_modifier::none);
#include "GuiApplication.h"
#include "QLPainter.h"
-#include "QLyXKeySym.h"
+#include "QKeySymbol.h"
#include "qt_helpers.h"
#include "LyXView.h"
<< " key=" << e->key()
<< endl;
- boost::shared_ptr<QLyXKeySym> sym(new QLyXKeySym);
+ boost::shared_ptr<QKeySymbol> sym(new QKeySymbol);
sym->set(e);
processKeySym(sym, q_key_state(e->modifiers()));
}
--- /dev/null
+/**
+ * \file qt4/KeySymbolFactory.cpp
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
+ *
+ * \author Asger & Jürgen
+ *
+ * Full author contact details are available in file CREDITS.
+ */
+
+#include <config.h>
+
+#include "frontends/KeySymbol.h"
+
+#include "QKeySymbol.h"
+
+namespace lyx {
+
+KeySymbol * createKeySymbol()
+{
+ return new QKeySymbol;
+}
+
+} // namespace lyx
+++ /dev/null
-/**
- * \file qt4/LyXKeySymFactory.cpp
- * This file is part of LyX, the document processor.
- * Licence details can be found in the file COPYING.
- *
- * \author Asger & Jürgen
- *
- * Full author contact details are available in file CREDITS.
- */
-
-#include <config.h>
-
-#include "frontends/LyXKeySymFactory.h"
-
-#include "QLyXKeySym.h"
-
-
-namespace lyx {
-
-namespace LyXKeySymFactory {
-
-LyXKeySym * create()
-{
- return new QLyXKeySym;
-}
-
-} // namespace LyXKeySymFactory
-
-
-} // namespace lyx
GuiFontLoader.h GuiFontLoader.cpp \
GuiFontMetrics.h GuiFontMetrics.cpp \
GuiSelection.h GuiSelection.cpp \
- LyXKeySymFactory.cpp \
+ KeySymbol.cpp \
QLMenubar.cpp QLMenubar.h \
QBox.cpp QBox.h \
QBranches.cpp QBranches.h \
QLImage.cpp QLImage.h \
QViewSource.cpp QViewSource.h \
QLPainter.cpp QLPainter.h \
- QLyXKeySym.cpp QLyXKeySym.h \
+ QKeySymbol.cpp QKeySymbol.h \
QPrint.cpp QPrint.h \
Qt2BC.cpp Qt2BC.h \
CheckedLineEdit.cpp CheckedLineEdit.h \
--- /dev/null
+/**
+ * \file QKeySymbol.cpp
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
+ *
+ * \author Asger and Jürgen
+ * \author John Levon
+ *
+ * Full author contact details are available in file CREDITS.
+ */
+
+#include <config.h>
+
+#include "QKeySymbol.h"
+#include "qlkey.h"
+#include "qt_helpers.h"
+
+
+#include "debug.h"
+
+#include <QKeyEvent>
+#include <QKeySequence>
+#include <QEvent>
+#include <QTextCodec>
+
+#include <map>
+#include "support/lstrings.h"
+#include "support/environment.h"
+#include "support/unicode.h"
+
+#include "Encoding.h"
+#include "Language.h"
+
+
+namespace lyx {
+
+using std::endl;
+using std::string;
+using std::map;
+using lyx::support::contains;
+using lyx::support::getEnv;
+
+
+namespace {
+
+typedef map<string, QTextCodec *> EncodingMap;
+EncodingMap encoding_map;
+
+char const encode(string const & encoding, QString const & str)
+{
+ QTextCodec * codec = 0;
+
+ EncodingMap::const_iterator cit = encoding_map.find(encoding);
+ if (cit == encoding_map.end()) {
+ LYXERR(Debug::KEY) << "Unrecognised encoding '" << encoding
+ << "'." << endl;
+ codec = encoding_map.find("")->second;
+ } else {
+ codec = cit->second;
+ }
+
+ if (!codec) {
+ LYXERR(Debug::KEY) << "No codec for encoding '" << encoding
+ << "' found." << endl;
+ return 0;
+ }
+
+ LYXERR(Debug::KEY) << "Using codec " << fromqstr(codec->name()) << endl;
+
+ if (!codec->canEncode(str)) {
+ LYXERR(Debug::KEY) << "Oof. Can't encode the text !" << endl;
+ return 0;
+ }
+
+ return codec->fromUnicode(str).data()[0];
+}
+
+}
+
+
+QKeySymbol::QKeySymbol()
+ : KeySymbol(), key_(0)
+{
+}
+
+
+void QKeySymbol::set(QKeyEvent * ev)
+{
+ key_ = ev->key();
+ if (ev->text().isNull()) {
+ LYXERR(Debug::KEY) << "keyevent has isNull() text !" << endl;
+ text_ = "";
+ return;
+ }
+ text_ = ev->text();
+ LYXERR(Debug::KEY) << "Setting key to " << key_ << ", " << fromqstr(text_) << endl;
+}
+
+
+void QKeySymbol::init(string const & symbolname)
+{
+ key_ = string_to_qkey(symbolname);
+ text_ = toqstr(symbolname);
+ LYXERR(Debug::KEY) << "Init key to " << key_ << ", " << fromqstr(text_) << endl;
+}
+
+
+bool QKeySymbol::isOK() const
+{
+ bool const ok(!(text_.isEmpty() && key_ == Qt::Key_unknown));
+ LYXERR(Debug::KEY) << "isOK is " << ok << endl;
+ return ok;
+}
+
+
+bool QKeySymbol::isModifier() const
+{
+ bool const mod(q_is_modifier(key_));
+ LYXERR(Debug::KEY) << "isMod is " << mod << endl;
+ return mod;
+}
+
+
+string QKeySymbol::getSymbolName() const
+{
+ string sym(qkey_to_string(key_));
+
+ // e.g. A-Za-z, and others
+ if (sym.empty())
+ sym = fromqstr(text_);
+
+ return sym;
+}
+
+
+char_type QKeySymbol::getUCSEncoded() const
+{
+ if (text_.isEmpty())
+ return 0;
+
+ // UTF16 has a maximum of two characters.
+ BOOST_ASSERT(text_.size() <= 2);
+
+ if (lyxerr.debugging() && text_.size() > 1) {
+ // We don't know yet how well support the full ucs4 range.
+ LYXERR(Debug::KEY) << "QKeySymbol::getUCSEncoded()" << endl;
+ for (int i = 0; i < text_.size(); ++i) {
+ LYXERR(Debug::KEY) << "char " << i << ": "
+ << text_[i].unicode() << endl;
+ }
+ }
+
+ // Only one UCS4 character at the end.
+ docstring ucs4_text = qstring_to_ucs4(text_);
+ return ucs4_text[0];
+}
+
+
+docstring const QKeySymbol::print(key_modifier::state mod, bool forgui) const
+{
+ int tmpkey = key_;
+
+ if (mod & key_modifier::shift)
+ tmpkey += Qt::SHIFT;
+ if (mod & key_modifier::ctrl)
+ tmpkey += Qt::CTRL;
+ if (mod & key_modifier::alt)
+ tmpkey += Qt::ALT;
+
+ QKeySequence seq(tmpkey);
+
+ return qstring_to_ucs4(seq.toString(forgui ? QKeySequence::NativeText
+ : QKeySequence::PortableText));
+}
+
+
+bool QKeySymbol::isText() const
+{
+ if (text_.isEmpty()) {
+ LYXERR(Debug::KEY) << "text_ empty, isText() == false" << endl;
+ return false;
+ }
+
+ return true;
+}
+
+
+bool QKeySymbol::operator==(KeySymbol const & ks) const
+{
+ QKeySymbol const & qks = static_cast<QKeySymbol const &>(ks);
+
+ // we do not have enough info for a fair comparison, so return
+ // false. This works out OK because unknown text from Qt will
+ // get inserted anyway after the isText() check
+ if (key_ == Qt::Key_unknown || qks.key_ == Qt::Key_unknown)
+ return false;
+
+ return key_ == qks.key_;
+}
+
+
+} // namespace lyx
--- /dev/null
+// -*- C++ -*-
+/**
+ * \file QKeySymbol.h
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
+ *
+ * \author Asger and Jürgen
+ * \author John Levon
+ *
+ * Full author contact details are available in file CREDITS.
+ */
+
+#ifndef QLYXKEYSYM_H
+#define QLYXKEYSYM_H
+
+#include "frontends/KeySymbol.h"
+
+#include <QString>
+#include <QKeyEvent>
+
+
+class QKeyEvent;
+
+namespace lyx {
+
+/**
+ * Qt-specific key press.
+ *
+ * This is some really sick stuff.
+ */
+class QKeySymbol : public KeySymbol {
+public:
+ QKeySymbol();
+
+ virtual ~QKeySymbol() {}
+
+ /// .
+ /// inlined out because of profiling results under linux when
+ /// opening a document.
+ inline bool operator==(KeySymbol const& ks) const;
+
+ /// delayed constructor
+ void set(QKeyEvent * ev);
+
+ /// set from a LyX symbolic name
+ virtual void init(std::string const & symbolname);
+
+ /// Is this a valid key?
+ virtual bool isOK() const;
+
+ /// Is this a modifier key only?
+ virtual bool isModifier() const;
+
+ /// return the LyX symbolic name
+ virtual std::string getSymbolName() const;
+
+ /// Is this normal insertable text ? (last ditch attempt only)
+ virtual bool isText() const;
+
+ /**
+ * Return the value of the keysym into the UCS-4 encoding.
+ * This converts the KeySymbol to a 32-bit encoded character.
+ */
+ virtual char_type getUCSEncoded() const;
+
+ /**
+ * Return a human-readable version of a key+modifier pair.
+ * This will be the GUI version (translated and with special
+ * characters for Mac OS X) when \c forgui is true.
+ */
+ virtual docstring const print(key_modifier::state mod, bool forgui) const;
+
+ ///
+ int key() const {
+ return key_;
+ }
+private:
+ /// the Qt sym value
+ int key_;
+ /// the event string value
+ QString text_;
+};
+
+
+} // namespace lyx
+
+#endif // QLYXKEYSYM_H
+++ /dev/null
-/**
- * \file QLyXKeySym.cpp
- * This file is part of LyX, the document processor.
- * Licence details can be found in the file COPYING.
- *
- * \author Asger and Jürgen
- * \author John Levon
- *
- * Full author contact details are available in file CREDITS.
- */
-
-#include <config.h>
-
-#include "QLyXKeySym.h"
-#include "qlkey.h"
-#include "qt_helpers.h"
-
-
-#include "debug.h"
-
-#include <QKeyEvent>
-#include <QKeySequence>
-#include <QEvent>
-#include <QTextCodec>
-
-#include <map>
-#include "support/lstrings.h"
-#include "support/environment.h"
-#include "support/unicode.h"
-
-#include "Encoding.h"
-#include "Language.h"
-
-
-namespace lyx {
-
-using std::endl;
-using std::string;
-using std::map;
-using lyx::support::contains;
-using lyx::support::getEnv;
-
-
-namespace {
-
-typedef map<string, QTextCodec *> EncodingMap;
-EncodingMap encoding_map;
-
-char const encode(string const & encoding, QString const & str)
-{
- QTextCodec * codec = 0;
-
- EncodingMap::const_iterator cit = encoding_map.find(encoding);
- if (cit == encoding_map.end()) {
- LYXERR(Debug::KEY) << "Unrecognised encoding '" << encoding
- << "'." << endl;
- codec = encoding_map.find("")->second;
- } else {
- codec = cit->second;
- }
-
- if (!codec) {
- LYXERR(Debug::KEY) << "No codec for encoding '" << encoding
- << "' found." << endl;
- return 0;
- }
-
- LYXERR(Debug::KEY) << "Using codec " << fromqstr(codec->name()) << endl;
-
- if (!codec->canEncode(str)) {
- LYXERR(Debug::KEY) << "Oof. Can't encode the text !" << endl;
- return 0;
- }
-
- return codec->fromUnicode(str).data()[0];
-}
-
-}
-
-
-QLyXKeySym::QLyXKeySym()
- : LyXKeySym(), key_(0)
-{
-}
-
-
-void QLyXKeySym::set(QKeyEvent * ev)
-{
- key_ = ev->key();
- if (ev->text().isNull()) {
- LYXERR(Debug::KEY) << "keyevent has isNull() text !" << endl;
- text_ = "";
- return;
- }
- text_ = ev->text();
- LYXERR(Debug::KEY) << "Setting key to " << key_ << ", " << fromqstr(text_) << endl;
-}
-
-
-void QLyXKeySym::init(string const & symbolname)
-{
- key_ = string_to_qkey(symbolname);
- text_ = toqstr(symbolname);
- LYXERR(Debug::KEY) << "Init key to " << key_ << ", " << fromqstr(text_) << endl;
-}
-
-
-bool QLyXKeySym::isOK() const
-{
- bool const ok(!(text_.isEmpty() && key_ == Qt::Key_unknown));
- LYXERR(Debug::KEY) << "isOK is " << ok << endl;
- return ok;
-}
-
-
-bool QLyXKeySym::isModifier() const
-{
- bool const mod(q_is_modifier(key_));
- LYXERR(Debug::KEY) << "isMod is " << mod << endl;
- return mod;
-}
-
-
-string QLyXKeySym::getSymbolName() const
-{
- string sym(qkey_to_string(key_));
-
- // e.g. A-Za-z, and others
- if (sym.empty())
- sym = fromqstr(text_);
-
- return sym;
-}
-
-
-char_type QLyXKeySym::getUCSEncoded() const
-{
- if (text_.isEmpty())
- return 0;
-
- // UTF16 has a maximum of two characters.
- BOOST_ASSERT(text_.size() <= 2);
-
- if (lyxerr.debugging() && text_.size() > 1) {
- // We don't know yet how well support the full ucs4 range.
- LYXERR(Debug::KEY) << "QLyXKeySym::getUCSEncoded()" << endl;
- for (int i = 0; i < text_.size(); ++i) {
- LYXERR(Debug::KEY) << "char " << i << ": "
- << text_[i].unicode() << endl;
- }
- }
-
- // Only one UCS4 character at the end.
- docstring ucs4_text = qstring_to_ucs4(text_);
- return ucs4_text[0];
-}
-
-
-docstring const QLyXKeySym::print(key_modifier::state mod, bool forgui) const
-{
- int tmpkey = key_;
-
- if (mod & key_modifier::shift)
- tmpkey += Qt::SHIFT;
- if (mod & key_modifier::ctrl)
- tmpkey += Qt::CTRL;
- if (mod & key_modifier::alt)
- tmpkey += Qt::ALT;
-
- QKeySequence seq(tmpkey);
-
- return qstring_to_ucs4(seq.toString(forgui ? QKeySequence::NativeText
- : QKeySequence::PortableText));
-}
-
-
-bool QLyXKeySym::isText() const
-{
- if (text_.isEmpty()) {
- LYXERR(Debug::KEY) << "text_ empty, isText() == false" << endl;
- return false;
- }
-
- return true;
-}
-
-
-bool QLyXKeySym::operator==(LyXKeySym const & ks) const
-{
- QLyXKeySym const & qks = static_cast<QLyXKeySym const &>(ks);
-
- // we do not have enough info for a fair comparison, so return
- // false. This works out OK because unknown text from Qt will
- // get inserted anyway after the isText() check
- if (key_ == Qt::Key_unknown || qks.key_ == Qt::Key_unknown)
- return false;
-
- return key_ == qks.key_;
-}
-
-
-} // namespace lyx
+++ /dev/null
-// -*- C++ -*-
-/**
- * \file QLyXKeySym.h
- * This file is part of LyX, the document processor.
- * Licence details can be found in the file COPYING.
- *
- * \author Asger and Jürgen
- * \author John Levon
- *
- * Full author contact details are available in file CREDITS.
- */
-
-#ifndef QLYXKEYSYM_H
-#define QLYXKEYSYM_H
-
-#include "frontends/LyXKeySym.h"
-
-#include <QString>
-#include <QKeyEvent>
-
-
-class QKeyEvent;
-
-namespace lyx {
-
-/**
- * Qt-specific key press.
- *
- * This is some really sick stuff.
- */
-class QLyXKeySym : public LyXKeySym {
-public:
- QLyXKeySym();
-
- virtual ~QLyXKeySym() {}
-
- /// .
- /// inlined out because of profiling results under linux when
- /// opening a document.
- inline bool operator==(LyXKeySym const& ks) const;
-
- /// delayed constructor
- void set(QKeyEvent * ev);
-
- /// set from a LyX symbolic name
- virtual void init(std::string const & symbolname);
-
- /// Is this a valid key?
- virtual bool isOK() const;
-
- /// Is this a modifier key only?
- virtual bool isModifier() const;
-
- /// return the LyX symbolic name
- virtual std::string getSymbolName() const;
-
- /// Is this normal insertable text ? (last ditch attempt only)
- virtual bool isText() const;
-
- /**
- * Return the value of the keysym into the UCS-4 encoding.
- * This converts the LyXKeySym to a 32-bit encoded character.
- */
- virtual char_type getUCSEncoded() const;
-
- /**
- * Return a human-readable version of a key+modifier pair.
- * This will be the GUI version (translated and with special
- * characters for Mac OS X) when \c forgui is true.
- */
- virtual docstring const print(key_modifier::state mod, bool forgui) const;
-
- ///
- int key() const {
- return key_;
- }
-private:
- /// the Qt sym value
- int key_;
- /// the event string value
- QString text_;
-};
-
-
-} // namespace lyx
-
-#endif // QLYXKEYSYM_H
projects / features.git / commitdiff