add generic helper class for calling functions in gui thread

[lyx.git] / src / support / debug.cpp

diff --git a/src/support/debug.cpp b/src/support/debug.cpp
index 2c88a6f38eca39d7af32a581407cb0e29633f914..1656967e7011cc619299cbaf1d5b9ff1242a2b58 100644 (file)
--- a/src/support/debug.cpp
+++ b/src/support/debug.cpp
@@ -5,6 +5,7 @@
  *
  * \author Lars Gullik Bjønnes
  * \author Jean-Marc Lasgouttes
+ * \author Pavel Sanda
  *
  * Full author contact details are available in file CREDITS.
  */
@@ -16,6 +17,7 @@
 #include "support/gettext.h"
 #include "support/lstrings.h"
 #include "support/FileName.h"
+#include "support/ProgressInterface.h"
 
 #include <iostream>
 #include <iomanip>
@@ -35,7 +37,7 @@ struct ErrorItem {
 
 
 ErrorItem errorTags[] = {
-       { Debug::NONE,      "none",      N_("No debugging message")},
+       { Debug::NONE,      "none",      N_("No debugging messages")},
        { Debug::INFO,      "info",      N_("General information")},
        { Debug::INIT,      "init",      N_("Program initialisation")},
        { Debug::KEY,       "key",       N_("Keyboard events handling")},
@@ -77,6 +79,40 @@ int const numErrorTags = sizeof(errorTags)/sizeof(errorTags[0]);
 } // namespace anon
 
 
+int Debug::levelCount()
+{
+       return numErrorTags;
+}
+
+
+Debug::Type Debug::value(int idx)
+{
+       if (idx > 0 && idx < numErrorTags)
+               return errorTags[idx].level;
+       return Debug::NONE;
+}
+
+
+string const Debug::description(Debug::Type val)
+{
+       for (int i = 0 ; i < numErrorTags ; ++i) {
+               if (errorTags[i].level == val)
+                       return errorTags[i].desc;
+       }
+       return "unknown level";
+}
+
+
+string const Debug::name(Debug::Type val)
+{
+       for (int i = 0 ; i < numErrorTags ; ++i) {
+               if (errorTags[i].level == val)
+                       return errorTags[i].name;
+       }
+       return "unknown level";
+}
+
+
 Debug::Type Debug::value(string const & val)
 {
        Type l = Debug::NONE;
@@ -152,37 +188,55 @@ bool LyXErr::debugging(Debug::Type t) const
 
 void LyXErr::endl()
 {
-       if (enabled_)
+       if (enabled_) {
                stream() << std::endl;
+               if (second_used_)
+                       second() << std::endl;
+       }
+}
+
+
+// It seems not possible to instantiate operator template out of class body
+template<class T>
+LyXErr & toStream(LyXErr & l, T t)     
+{
+       if (l.enabled()){
+               l.stream() << t;
+                if (l.second_used()) {
+                       l.second() << t;
+                       ProgressInterface::instance()->lyxerrFlush();
+               }
+       }
+       return l;
 }
 
 
 LyXErr & operator<<(LyXErr & l, void const * t)
-{ if (l.enabled()) l.stream() << t; return l; }
+{ return toStream(l, t); }
 LyXErr & operator<<(LyXErr & l, char const * t)
-{ if (l.enabled()) l.stream() << t; return l; }
+{ return toStream(l, t); }
 LyXErr & operator<<(LyXErr & l, char t)
-{ if (l.enabled()) l.stream() << t; return l; }
+{ return toStream(l, t); }
 LyXErr & operator<<(LyXErr & l, int t)
-{ if (l.enabled()) l.stream() << t; return l; }
+{ return toStream(l, t); }
 LyXErr & operator<<(LyXErr & l, unsigned int t)
-{ if (l.enabled()) l.stream() << t; return l; }
+{ return toStream(l, t); }
 LyXErr & operator<<(LyXErr & l, long t)
-{ if (l.enabled()) l.stream() << t; return l; }
+{ return toStream(l, t); }
 LyXErr & operator<<(LyXErr & l, unsigned long t)
-{ if (l.enabled()) l.stream() << t; return l; }
+{ return toStream(l, t); }
 LyXErr & operator<<(LyXErr & l, double t)
-{ if (l.enabled()) l.stream() << t; return l; }
+{ return toStream(l, t); }
 LyXErr & operator<<(LyXErr & l, string const & t)
-{ if (l.enabled()) l.stream() << t; return l; }
+{ return toStream(l, t); }
 LyXErr & operator<<(LyXErr & l, docstring const & t)
-{ if (l.enabled()) l.stream() << to_utf8(t); return l; }
+{ return toStream(l, to_utf8(t)); }
 LyXErr & operator<<(LyXErr & l, FileName const & t)
-{ if (l.enabled()) l.stream() << t; return l; }
+{ return toStream(l, t); }
 LyXErr & operator<<(LyXErr & l, ostream &(*t)(ostream &))
-{ if (l.enabled()) l.stream() << t; return l; }
+{ return toStream(l, t); }
 LyXErr & operator<<(LyXErr & l, ios_base &(*t)(ios_base &))
-{ if (l.enabled()) l.stream() << t; return l; }
+{ return toStream(l, t); }
 
 
 // The global instance