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 6f3ce34e09064e94a567db8fc392635d95660626..1656967e7011cc619299cbaf1d5b9ff1242a2b58 100644 (file)
--- a/src/support/debug.cpp
+++ b/src/support/debug.cpp
@@ -37,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")},
@@ -79,15 +79,20 @@ int const numErrorTags = sizeof(errorTags)/sizeof(errorTags[0]);
 } // namespace anon
 
 
-const std::vector<Debug::Type> Debug::levels()
+int Debug::levelCount()
 {
-       std::vector<Debug::Type> vec;
-       for (int i = 0 ; i < numErrorTags ; ++i) {
-               vec.push_back(errorTags[i].level);
-       }
-       return vec;
+       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) {
@@ -186,51 +191,52 @@ void LyXErr::endl()
        if (enabled_) {
                stream() << std::endl;
                if (second_used_)
-                       second() << "\n";
+                       second() << std::endl;
        }
 }
 
 
 // It seems not possible to instantiate operator template out of class body
-#define STREAM_OPERATOR(t)     \
-{\
-       if (l.enabled()){\
-               l.stream() << t;\
-               if (l.second_used()){\
-                       l.second() << t;\
-                       ProgressInterface::instance()->lyxerrFlush();\
-               }\
-       }\
-       return l;\
+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)
-STREAM_OPERATOR(t)
+{ return toStream(l, t); }
 LyXErr & operator<<(LyXErr & l, char const * t)
-STREAM_OPERATOR(t)
+{ return toStream(l, t); }
 LyXErr & operator<<(LyXErr & l, char t)
-STREAM_OPERATOR(t)
+{ return toStream(l, t); }
 LyXErr & operator<<(LyXErr & l, int t)
-STREAM_OPERATOR(t)
+{ return toStream(l, t); }
 LyXErr & operator<<(LyXErr & l, unsigned int t)
-STREAM_OPERATOR(t)
+{ return toStream(l, t); }
 LyXErr & operator<<(LyXErr & l, long t)
-STREAM_OPERATOR(t)
+{ return toStream(l, t); }
 LyXErr & operator<<(LyXErr & l, unsigned long t)
-STREAM_OPERATOR(t)
+{ return toStream(l, t); }
 LyXErr & operator<<(LyXErr & l, double t)
-STREAM_OPERATOR(t)
+{ return toStream(l, t); }
 LyXErr & operator<<(LyXErr & l, string const & t)
-STREAM_OPERATOR(t)
+{ return toStream(l, t); }
 LyXErr & operator<<(LyXErr & l, docstring const & t)
-STREAM_OPERATOR(to_utf8(t));
+{ return toStream(l, to_utf8(t)); }
 LyXErr & operator<<(LyXErr & l, FileName const & t)
-STREAM_OPERATOR(t)
+{ return toStream(l, t); }
 LyXErr & operator<<(LyXErr & l, ostream &(*t)(ostream &))
-STREAM_OPERATOR(t)
+{ return toStream(l, t); }
 LyXErr & operator<<(LyXErr & l, ios_base &(*t)(ios_base &))
-STREAM_OPERATOR(t)
+{ return toStream(l, t); }
 
 
 // The global instance