Only load from preferences when really needed, which might help reducing the processo...

[inkscape.git] / src / debug / logger.cpp

diff --git a/src/debug/logger.cpp b/src/debug/logger.cpp
index 6fb1aee05e685bb661b590e29acf26c25be4eff5..f28d2750bdd7f00d051a40ecef722928dc57a200 100644 (file)
--- a/src/debug/logger.cpp
+++ b/src/debug/logger.cpp
@@ -12,6 +12,7 @@
 #include <fstream>
 #include <vector>
 #include <glib/gmessages.h>
+#include "inkscape-version.h"
 #include "debug/logger.h"
 #include "debug/simple-event.h"
 #include "gc-alloc.h"
@@ -25,7 +26,7 @@ bool Logger::_category_mask[Event::N_CATEGORIES];
 
 namespace {
 
-static void write_escaped_value(std::ostream &os, Util::shared_ptr<char> value) {
+static void write_escaped_value(std::ostream &os, Util::ptr_shared<char> value) {
     for ( char const *current=value ; *current ; ++current ) {
         switch (*current) {
         case '&':
@@ -57,7 +58,7 @@ static void write_indent(std::ostream &os, unsigned depth) {
 
 static std::ofstream log_stream;
 static bool empty_tag=false;
-typedef std::vector<Util::shared_ptr<char>, GC::Alloc<Util::shared_ptr<char>, GC::MANUAL> > TagStack;
+typedef std::vector<Util::ptr_shared<char>, GC::Alloc<Util::ptr_shared<char>, GC::MANUAL> > TagStack;
 static TagStack &tag_stack() {
     static TagStack stack;
     return stack;
@@ -93,20 +94,32 @@ static void set_category_mask(bool * const mask, char const *filter) {
     while (*end) {
         while ( *end && *end != ',' ) { end++; }
         if ( start != end ) {
-            if (equal_range("CORE", start, end)) {
-                mask[Event::CORE] = true;
-            } else if (equal_range("XML", start, end)) {
-                mask[Event::XML] = true;
-            } else if (equal_range("SPOBJECT", start, end)) {
-                mask[Event::SPOBJECT] = true;
-            } else if (equal_range("DOCUMENT", start, end)) {
-                mask[Event::DOCUMENT] = true;
-            } else if (equal_range("REFCOUNT", start, end)) {
-                mask[Event::REFCOUNT] = true;
-            } else if (equal_range("EXTENSION", start, end)) {
-                mask[Event::EXTENSION] = true;
-            } else {
-                g_warning("Unknown debugging category %*s", end - start, start);
+            struct CategoryName {
+                char const *name;
+                Event::Category category;
+            };
+            static const CategoryName category_names[] = {
+                { "CORE", Event::CORE },
+                { "XML", Event::XML },
+                { "SPOBJECT", Event::SPOBJECT },
+                { "DOCUMENT", Event::DOCUMENT },
+                { "REFCOUNT", Event::REFCOUNT },
+                { "EXTENSION", Event::EXTENSION },
+                { "FINALIZERS", Event::FINALIZERS },
+                { "INTERACTION", Event::INTERACTION },
+                { "CONFIGURATION", Event::CONFIGURATION },
+                { "OTHER", Event::OTHER },
+                { NULL, Event::OTHER }
+            };
+            CategoryName const *iter;
+            for ( iter = category_names ; iter->name ; iter++ ) {
+                if (equal_range(iter->name, start, end)) {
+                    mask[iter->category] = true;
+                    break;
+                }
+            }
+            if (!iter->name) {
+                g_warning("Unknown debugging category %*s", (int)(end - start), start);
             }
         }
         if (*end) {
@@ -115,6 +128,15 @@ static void set_category_mask(bool * const mask, char const *filter) {
     }
 }
 
+typedef SimpleEvent<Event::CORE> CoreEvent;
+
+class SessionEvent : public CoreEvent {
+public:
+    SessionEvent() : CoreEvent(Util::share_static_string("session")) {
+        _addProperty("inkscape-version", Inkscape::version_string);
+    }
+};
+
 }
 
 void Logger::init() {
@@ -128,7 +150,7 @@ void Logger::init() {
                 log_stream << "<?xml version=\"1.0\"?>\n";
                 log_stream.flush();
                 _enabled = true;
-                start<SimpleEvent<Event::CORE> >(Util::share_static("session"));
+                start<SessionEvent>();
                 std::atexit(&do_shutdown);
             }
         }
@@ -136,7 +158,7 @@ void Logger::init() {
 }
 
 void Logger::_start(Event const &event) {
-    Util::shared_ptr<char> name=event.name();
+    Util::ptr_shared<char> name=event.name();
 
     if (empty_tag) {
         log_stream << ">\n";
@@ -158,10 +180,12 @@ void Logger::_start(Event const &event) {
 
     tag_stack().push_back(name);
     empty_tag = true;
+
+    event.generateChildEvents();
 }
 
 void Logger::_skip() {
-    tag_stack().push_back(Util::shared_ptr<char>());
+    tag_stack().push_back(Util::ptr_shared<char>());
 }
 
 void Logger::_finish() {