/**
- * \file qt4/KeySymbolFactory.cpp
+ * \file qt4/GuiKeySymbol.cpp
* This file is part of LyX, the document processor.
* Licence details can be found in the file COPYING.
*
#include <config.h>
-#include "frontends/KeySymbol.h"
-
-#include "GuiKeySymbol.h"
+#include "KeySymbol.h"
#include "qlkey.h"
#include "qt_helpers.h"
-#include "debug.h"
-
-#include "support/lstrings.h"
-#include "support/environment.h"
-#include "support/unicode.h"
+#include "support/debug.h"
#include "Encoding.h"
#include "Language.h"
#include <QEvent>
#include <QTextCodec>
+#include "boost/assert.hpp"
+
#include <map>
+using namespace std;
namespace lyx {
-using std::endl;
-using std::string;
-using std::map;
-using lyx::support::contains;
-using lyx::support::getEnv;
-
-
-KeySymbol * createKeySymbol()
-{
- return new GuiKeySymbol;
-}
-
-
-namespace {
-
-char encode(string const & encoding, QString const & str)
+#if 0
+static char encode(string const & encoding, QString const & str)
{
typedef map<string, QTextCodec *> EncodingMap;
EncodingMap encoding_map;
EncodingMap::const_iterator cit = encoding_map.find(encoding);
if (cit == encoding_map.end()) {
- LYXERR(Debug::KEY) << "Unrecognised encoding '" << encoding
- << "'." << endl;
+ LYXERR(Debug::KEY, "Unrecognised encoding '" << encoding << "'.");
codec = encoding_map.find("")->second;
} else {
codec = cit->second;
}
if (!codec) {
- LYXERR(Debug::KEY) << "No codec for encoding '" << encoding
- << "' found." << endl;
+ LYXERR(Debug::KEY, "No codec for encoding '" << encoding << "' found.");
return 0;
}
- LYXERR(Debug::KEY) << "Using codec " << fromqstr(codec->name()) << endl;
+ LYXERR(Debug::KEY, "Using codec " << fromqstr(codec->name()));
if (!codec->canEncode(str)) {
- LYXERR(Debug::KEY) << "Oof. Can't encode the text !" << endl;
+ LYXERR(Debug::KEY, "Oof. Can't encode the text !");
return 0;
}
return codec->fromUnicode(str).data()[0];
}
+#endif
-} // anon namespace
-GuiKeySymbol::GuiKeySymbol()
- : KeySymbol(), key_(0)
+void setKeySymbol(KeySymbol * sym, QKeyEvent * ev)
{
-}
-
-
-void GuiKeySymbol::set(QKeyEvent * ev)
-{
- key_ = ev->key();
+ sym->setKey(ev->key());
if (ev->text().isNull()) {
- LYXERR(Debug::KEY) << "keyevent has isNull() text !" << endl;
- text_ = "";
+ LYXERR(Debug::KEY, "keyevent has isNull() text !");
+ sym->setText(docstring());
return;
}
- text_ = ev->text();
- LYXERR(Debug::KEY) << "Setting key to " << key_ << ", " << fromqstr(text_) << endl;
+ LYXERR(Debug::KEY, "Getting key " << ev->key() << ", with text '"
+ << fromqstr(ev->text()) << "'");
+ // This is unsafe because ev->text() is the unicode representation of the
+ // key, not the name of the key. For example, Ctrl-x and Alt-x produce
+ // different texts.
+ sym->setText(qstring_to_ucs4(ev->text()));
+ LYXERR(Debug::KEY, "Setting key to " << sym->key() << ", "
+ << to_utf8(sym->text()));
}
-void GuiKeySymbol::init(string const & symbolname)
+void KeySymbol::init(string const & symbolname)
{
key_ = string_to_qkey(symbolname);
- text_ = toqstr(symbolname);
- LYXERR(Debug::KEY) << "Init key to " << key_ << ", " << fromqstr(text_) << endl;
+ text_ = from_utf8(symbolname);
+ LYXERR(Debug::KEY, "Init key to " << key_ << ", " << to_utf8(text_));
}
-bool GuiKeySymbol::isOK() const
+bool KeySymbol::isOK() const
{
- bool const ok(!(text_.isEmpty() && key_ == Qt::Key_unknown));
- LYXERR(Debug::KEY) << "isOK is " << ok << endl;
+ bool const ok = !(text_.empty() && key_ == Qt::Key_unknown);
+ LYXERR(Debug::KEY, "isOK is " << ok);
return ok;
}
-bool GuiKeySymbol::isModifier() const
+bool KeySymbol::isModifier() const
{
- bool const mod(q_is_modifier(key_));
- LYXERR(Debug::KEY) << "isMod is " << mod << endl;
+ bool const mod = q_is_modifier(key_);
+ LYXERR(Debug::KEY, "isModifier is " << mod);
return mod;
}
-string GuiKeySymbol::getSymbolName() const
+string KeySymbol::getSymbolName() const
{
- string sym(qkey_to_string(key_));
+ string name = qkey_to_string(key_);
- // e.g. A-Za-z, and others
- if (sym.empty())
- sym = fromqstr(text_);
+ // others
+ if (name.empty())
+ name = to_utf8(text_);
- return sym;
+ return name;
}
-char_type GuiKeySymbol::getUCSEncoded() const
+char_type KeySymbol::getUCSEncoded() const
{
- if (text_.isEmpty())
+ if (text_.empty())
return 0;
// UTF16 has a maximum of two characters.
if (lyxerr.debugging() && text_.size() > 1) {
// We don't know yet how well support the full ucs4 range.
- LYXERR(Debug::KEY) << "GuiKeySymbol::getUCSEncoded()" << endl;
- for (int i = 0; i < text_.size(); ++i) {
- LYXERR(Debug::KEY) << "char " << i << ": "
- << text_[i].unicode() << endl;
- }
+ LYXERR(Debug::KEY, "KeySymbol::getUCSEncoded()");
+ for (int i = 0; i != int(text_.size()); ++i)
+ LYXERR(Debug::KEY, "char " << i << ": " << int(text_[i]));
}
- // Only one UCS4 character at the end.
- docstring ucs4_text = qstring_to_ucs4(text_);
- return ucs4_text[0];
+ return text_[0];
}
-docstring const GuiKeySymbol::print(key_modifier::state mod, bool forgui) const
+docstring const KeySymbol::print(KeyModifier 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;
+ if (mod & ShiftModifier)
+ tmpkey += Qt::ShiftModifier;
+ if (mod & ControlModifier)
+ tmpkey += Qt::ControlModifier;
+ if (mod & AltModifier)
+ tmpkey += Qt::AltModifier;
QKeySequence seq(tmpkey);
}
-bool GuiKeySymbol::isText() const
+bool KeySymbol::isText() const
{
- if (text_.isEmpty()) {
- LYXERR(Debug::KEY) << "text_ empty, isText() == false" << endl;
- return false;
- }
-
- return true;
+ if (!text_.empty())
+ return true;
+ LYXERR(Debug::KEY, "text_ empty, isText() == false");
+ return false;
}
-bool GuiKeySymbol::operator==(KeySymbol const & ks) const
+bool KeySymbol::operator==(KeySymbol const & ks) const
{
- GuiKeySymbol const & qks = static_cast<GuiKeySymbol 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)
+ if (key_ == Qt::Key_unknown || ks.key_ == Qt::Key_unknown)
return false;
-
- return key_ == qks.key_;
+ return key_ == ks.key_;
}
-key_modifier::state q_key_state(Qt::KeyboardModifiers state)
+KeyModifier q_key_state(Qt::KeyboardModifiers state)
{
- key_modifier::state k = key_modifier::none;
+ KeyModifier k = NoModifier;
if (state & Qt::ControlModifier)
- k |= key_modifier::ctrl;
+ k |= ControlModifier;
if (state & Qt::ShiftModifier)
- k |= key_modifier::shift;
+ k |= ShiftModifier;
if (state & Qt::AltModifier || state & Qt::MetaModifier)
- k |= key_modifier::alt;
+ k |= AltModifier;
return k;
}