header cleanup

[lyx.git] / src / frontends / qt4 / GuiKeySymbol.cpp

diff --git a/src/frontends/qt4/GuiKeySymbol.cpp b/src/frontends/qt4/GuiKeySymbol.cpp
index 0d9a3438051e1f244c36cd9df254468c07bb2842..d3ba7f29650687201d08b67f632513982e9a05ee 100644 (file)
--- a/src/frontends/qt4/GuiKeySymbol.cpp
+++ b/src/frontends/qt4/GuiKeySymbol.cpp
@@ -1,5 +1,5 @@
 /**
- * \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.
  *
@@ -10,18 +10,12 @@
 
 #include <config.h>
 
-#include "frontends/KeySymbol.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"
@@ -31,21 +25,16 @@
 #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;
-
-
-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;
@@ -54,43 +43,45 @@ char encode(string const & encoding, QString const & str)
 
        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];
 }
-
-} // anon namespace
+#endif
 
 
 void setKeySymbol(KeySymbol * sym, QKeyEvent * ev)
 {
        sym->setKey(ev->key());
        if (ev->text().isNull()) {
-               LYXERR(Debug::KEY) << "keyevent has isNull() text !" << endl;
+               LYXERR(Debug::KEY, "keyevent has isNull() text !");
                sym->setText(docstring());
                return;
        }
+       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()) << endl;
+       LYXERR(Debug::KEY, "Setting key to " << sym->key() << ", "
+               << to_utf8(sym->text()));
 }
 
 
@@ -98,15 +89,14 @@ void KeySymbol::init(string const & symbolname)
 {
        key_ = string_to_qkey(symbolname);
        text_ = from_utf8(symbolname);
-       LYXERR(Debug::KEY) << "Init key to " << key_ << ", "
-               << to_utf8(text_) << endl;
+       LYXERR(Debug::KEY, "Init key to " << key_ << ", " << to_utf8(text_));
 }
 
 
 bool KeySymbol::isOK() const
 {
        bool const ok = !(text_.empty() && key_ == Qt::Key_unknown);
-       LYXERR(Debug::KEY) << "isOK is " << ok << endl;
+       LYXERR(Debug::KEY, "isOK is " << ok);
        return ok;
 }
 
@@ -114,7 +104,7 @@ bool KeySymbol::isOK() const
 bool KeySymbol::isModifier() const
 {
        bool const mod = q_is_modifier(key_);
-       LYXERR(Debug::KEY) << "isMod is " << mod << endl;
+       LYXERR(Debug::KEY, "isModifier is " << mod);
        return mod;
 }
 
@@ -123,7 +113,7 @@ string KeySymbol::getSymbolName() const
 {
        string name = qkey_to_string(key_);
 
-       // e.g. A-Za-z, and others
+       // others
        if (name.empty())
                name = to_utf8(text_);
 
@@ -141,27 +131,25 @@ char_type KeySymbol::getUCSEncoded() const
 
        if (lyxerr.debugging() && text_.size() > 1) {
                // We don't know yet how well support the full ucs4 range.
-               LYXERR(Debug::KEY) << "KeySymbol::getUCSEncoded()" << endl;
-               for (int i = 0; i != int(text_.size()); ++i) {
-                       LYXERR(Debug::KEY) << "char " << i << ": "
-                               << int(text_[i]) << endl;
-               }
+               LYXERR(Debug::KEY, "KeySymbol::getUCSEncoded()");
+               for (int i = 0; i != int(text_.size()); ++i)
+                       LYXERR(Debug::KEY, "char " << i << ": " << int(text_[i]));
        }
 
        return text_[0];
 }
 
 
-docstring const KeySymbol::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);
 
@@ -174,7 +162,7 @@ bool KeySymbol::isText() const
 {
        if (!text_.empty())
                return true;
-       LYXERR(Debug::KEY) << "text_ empty, isText() == false" << endl;
+       LYXERR(Debug::KEY, "text_ empty, isText() == false");
        return false;
 }
 
@@ -190,15 +178,15 @@ bool KeySymbol::operator==(KeySymbol const & ks) const
 }
 
 
-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;
 }