Changeset 8858 for code/trunk/src/libraries

code/trunk

Property svn:ignore

old	new
1	1	build
2	2	codeblocks
	3	vs
3	4	dependencies

Property svn:mergeinfo changed

/code/branches/output (added)

merged: 8739-8740,8765,8771-8772,8774-8780,8787-8789,8794-8799,8801,8803-8812,8814,8816-8817,8820,8822,8825-8837,8840,8844,8846,8848-8850,8853-8854

code/trunk/src/libraries/core/BaseObject.cc

r8706	r8858
109	109	void BaseObject::registerEventListener(BaseObject* object)
110	110	{
111		~~COUT(4) << "New EventListener: " << object->getIdentifier()->getName() << " &(" << object << ")." << std::~~endl;
	111	orxout(verbose, context::events) << "New EventListener: " << object->getIdentifier()->getName() << " &(" << object << ")." << endl;
112	112	this->eventListeners_.insert(object);
113	113	}
…	…
186	186	this->addTemplate(temp);
187	187	else
188		~~COUT(1) << "Error: \"" << name << "\" is not a valid Template name (in class: " << this->getIdentifier()->getName() << ", name: " << this->getName() << ")." << std::~~endl;
	188	orxout(internal_error) << "\"" << name << "\" is not a valid Template name (in class: " << this->getIdentifier()->getName() << ", name: " << this->getName() << ")." << endl;
189	189	}
190	190
…	…
312	312	if (it != this->eventStates_.end())
313	313	{
314		~~COUT(2) << "Warning: Overwriting EventState in class " << this->getIdentifier()->getName() << '.' << std::~~endl;
	314	orxout(internal_warning, context::events) << "Overwriting EventState in class " << this->getIdentifier()->getName() << '.' << endl;
315	315	delete (it->second);
316	316	}
…	…
379	379	this->registerEventStates();
380	380
381		COUT(4) << this->getIdentifier()->getName() << " (&" << this << ") processing event. originator: " << event.originator_->getIdentifier()->getName() << " (&" << event.originator_ << "), activate: " << event.activate_ << ", name: " << event.name_ << ", statename: " << event.statename_ << "." << std::endl;
	381	orxout(verbose, context::events) << this->getIdentifier()->getName() << " (&" << this << ") processing event. originator: " << event.originator_->getIdentifier()->getName() << " (&" << event.originator_ << "), activate: " << event.activate_ << ", name: " << event.name_ << ", statename: " << event.statename_ << "." << endl;
382	382
383	383	std::map<std::string, EventState*>::const_iterator it = this->eventStates_.find(event.statename_);
…	…
385	385	it->second->process(event, this);
386	386	else if (!event.statename_.empty())
387		~~COUT(2) << "Warning: \"" << event.statename_ << "\" is not a valid state in object \"" << this->getName() << "\" of class " << this->getIdentifier()->getName() << "." << std::~~endl;
388		else
389		~~COUT(2) << "Warning: Event with invalid source sent to object \"" << this->getName() << "\" of class " << this->getIdentifier()->getName() << "." << std::~~endl;
	387	orxout(internal_warning, context::events) << "\"" << event.statename_ << "\" is not a valid state in object \"" << this->getName() << "\" of class " << this->getIdentifier()->getName() << "." << endl;
	388	else
	389	orxout(internal_warning, context::events) << "Event with invalid source sent to object \"" << this->getName() << "\" of class " << this->getIdentifier()->getName() << "." << endl;
390	390	}
391	391
…	…
412	412	}
413	413	else
414		~~COUT(2) << "Warning: No MainState defined in object \"" << this->getName() << "\" (" << this->getIdentifier()->getName() << ")" << std::~~endl;
	414	orxout(internal_warning, context::events) << "No MainState defined in object \"" << this->getName() << "\" (" << this->getIdentifier()->getName() << ")" << endl;
415	415	}
416	416
…	…
432	432	this->mainStateFunctor_ = it->second->getFunctor();
433	433	else
434		~~COUT(2) << "Warning: Can't use \"" << this->mainStateName_ << "\" as MainState because it needs a second argument." << std::~~endl;
	434	orxout(internal_warning, context::events) << "Can't use \"" << this->mainStateName_ << "\" as MainState because it needs a second argument." << endl;
435	435	}
436	436	else
437		~~COUT(2) << "Warning: \"" << this->mainStateName_ << "\" is not a valid MainState." << std::~~endl;
	437	orxout(internal_warning, context::events) << "\"" << this->mainStateName_ << "\" is not a valid MainState." << endl;
438	438	}
439	439	}

code/trunk/src/libraries/core/CMakeLists.txt

r8729	r8858
86	86	input/KeyBinder.h
87	87	input/KeyBinderManager.h
	88	../util/output/OutputDefinitions.h
88	89	PCH_FILE
89	90	CorePrecompiledHeaders.h

code/trunk/src/libraries/core/ClassFactory.h

-                      r7401
+                      r8858
 #include <string>
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "Identifier.h"
 …
             ClassFactory(const std::string& name, bool bLoadable = true)
+            {
                 COUT(4) << "*** ClassFactory: Create entry for " << name << " in Factory." << std::endl;
+                orxout(verbose, context::misc::factory) << "Create entry for " << name << " in Factory." << endl;
                 ClassIdentifier<T>::getIdentifier(name)->addFactory(this);
                 ClassIdentifier<T>::getIdentifier()->setLoadable(bLoadable);

code/trunk/src/libraries/core/CommandLineParser.cc

-                      r8729
+                      r8858
 #include "util/Convert.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/Exception.h"
 #include "util/StringUtils.h"
 …
         catch (const ArgumentException& ex)
+        {
             COUT(0) << "Could not parse command line: " << ex.what() << std::endl;
             COUT(0) << CommandLineParser::getUsageInformation() << std::endl;
+            orxout(user_error) << "Could not parse command line: " << ex.what() << endl;
+            orxout(user_error) << CommandLineParser::getUsageInformation() << endl;
             throw GeneralException("");
+        }
 …
+        }
         infoStr << std::endl;
         infoStr << "Usage: orxonox [options]" << std::endl;
         infoStr << "Available options:" << std::endl;
+        infoStr << endl;
+        infoStr << "Usage: orxonox [options]" << endl;
+        infoStr << "Available options:" << endl;
         for (std::map<std::string, CommandLineArgument*>::const_iterator it = inst.cmdLineArgs_.begin();
 …
             infoStr << std::string(maxNameSize - it->second->getName().size(), ' ');
             infoStr << ": " << it->second->getInformation();
             infoStr << std::endl;
+            infoStr << endl;
+        }
         return infoStr.str();

code/trunk/src/libraries/core/CommandLineParser.h

r8729	r8858
218	218	"Cannot add a command line argument with name '" + name + "' twice.");
219	219	OrxAssert(MultiType(defaultValue).getType() != MT_Type::Bool \|\| MultiType(defaultValue).getBool() != true,
220		"Boolean command line arguments with positive default values are not supported." << ~~std::~~endl
	220	"Boolean command line arguments with positive default values are not supported." << endl
221	221	<< "Please use SetCommandLineSwitch and adjust your argument: " << name);
222	222

code/trunk/src/libraries/core/ConfigFileManager.cc

r7401	r8858
123	123	for (std::list<ConfigFileEntry*>::const_iterator it = this->entries_.begin(); it != this->entries_.end(); ++it)
124	124	if ((*it)->getName() == name)
125		if ((*it)->getIndex() > size)
126		size = (*it)->getIndex();
127		if (size == 0)
128		return 0;
129		else
130		return (size + 1);
	125	if ((*it)->getIndex() >= size)
	126	size = (*it)->getIndex() + 1;
	127	return size;
131	128	}
132	129
…	…
274	271	{
275	272	boost::filesystem::copy_file(defaultFilepath, filepath);
276		~~COUT(3) << "Copied " << this->filename_ << " from the default config folder." << std::~~endl;
	273	orxout(internal_info, context::config) << "Copied " << this->filename_ << " from the default config folder." << endl;
277	274	}
278	275	catch (const boost::filesystem::filesystem_error& ex)
279		{ ~~COUT(1) << "Error in ConfigFile: " << ex.what() << std::~~endl; }
	276	{ orxout(user_error, context::config) << "Error in ConfigFile: " << ex.what() << endl; }
280	277	}
281	278	}
…	…
375	372	file.close();
376	373
377		~~COUT(3) << "Loaded config file \"" << this->filename_ << "\"." << std::~~endl;
	374	orxout(internal_info, context::config) << "Loaded config file \"" << this->filename_ << "\"." << endl;
378	375
379	376	// DO NOT save the file --> we can open supposedly read only config files
…	…
404	401	if (!file.is_open())
405	402	{
406		~~COUT(1) << "Error: Couldn't open config-file \"" << filename << "\"." << std::~~endl;
	403	orxout(user_error, context::config) << "Couldn't open config-file \"" << filename << "\"." << endl;
407	404	return;
408	405	}
…	…
410	407	for (std::list<ConfigFileSection*>::const_iterator it = this->sections_.begin(); it != this->sections_.end(); ++it)
411	408	{
412		file << (*it)->getFileEntry() << ~~std::~~endl;
	409	file << (*it)->getFileEntry() << endl;
413	410
414	411	for (std::list<ConfigFileEntry>::const_iterator it_entries = (it)->getEntriesBegin(); it_entries != (*it)->getEntriesEnd(); ++it_entries)
415		file << (*it_entries)->getFileEntry() << ~~std::~~endl;
416
417		file << ~~std::~~endl;
	412	file << (*it_entries)->getFileEntry() << endl;
	413
	414	file << endl;
418	415	}
419	416
420	417	file.close();
421	418
422		~~COUT(4) << "Saved config file \"" << filename << "\"." << std::~~endl;
	419	orxout(verbose, context::config) << "Saved config file \"" << filename << "\"." << endl;
423	420	}
424	421
…	…
669	666	{
670	667	if (!this->configImpl(section, entry, value, &ConfigValueContainer::set))
671		~~COUT(1) << "Error: Config value \"" << entry << "\" in section \"" << section << "\" doesn't exist." << std::~~endl;
	668	orxout(user_error, context::config) << "Config value \"" << entry << "\" in section \"" << section << "\" doesn't exist." << endl;
672	669	}
673	670
…	…
682	679	{
683	680	if (!this->configImpl(section, entry, value, &ConfigValueContainer::tset))
684		~~COUT(1) << "Error: Config value \"" << entry << "\" in section \"" << section << "\" doesn't exist." << std::~~endl;
	681	orxout(user_error, context::config) << "Config value \"" << entry << "\" in section \"" << section << "\" doesn't exist." << endl;
685	682	}
686	683

code/trunk/src/libraries/core/ConfigValueContainer.cc

r8351	r8858
143	143	else
144	144	{
145		~~COUT(1) << "Error: Config-value '" << this->varname_ << "' in " << this->sectionname_ << " is not a vector." << std::~~endl;
	145	orxout(user_error, context::config) << "Config-value '" << this->varname_ << "' in " << this->sectionname_ << " is not a vector." << endl;
146	146	}
147	147	return false;
…	…
182	182	if (index > MAX_VECTOR_INDEX)
183	183	{
184		~~COUT(1) << "Error: Index " << index << " is too large." << std::~~endl;
	184	orxout(user_error, context::config) << "Index " << index << " is too large." << endl;
185	185	return false;
186	186	}
…	…
203	203	else
204	204	{
205		~~COUT(1) << "Error: Config-value '" << this->varname_ << "' in " << this->sectionname_ << " is not a vector." << std::~~endl;
	205	orxout(user_error, context::config) << "Config-value '" << this->varname_ << "' in " << this->sectionname_ << " is not a vector." << endl;
206	206	return false;
207	207	}
…	…
218	218	return this->set(this->valueVector_.size(), input);
219	219
220		~~COUT(1) << "Error: Config-value '" << this->varname_ << "' in " << this->sectionname_ << " is not a vector." << std::~~endl;
	220	orxout(user_error, context::config) << "Config-value '" << this->varname_ << "' in " << this->sectionname_ << " is not a vector." << endl;
221	221	return false;
222	222	}
…	…
241	241	return true;
242	242	}
243		~~COUT(1) << "Error: Invalid vector-index." << std::~~endl;
244		}
245
246		~~COUT(1) << "Error: Config-value '" << this->varname_ << "' in " << this->sectionname_ << " is not a vector." << std::~~endl;
	243	orxout(user_error, context::config) << "Invalid vector-index." << endl;
	244	}
	245
	246	orxout(user_error, context::config) << "Config-value '" << this->varname_ << "' in " << this->sectionname_ << " is not a vector." << endl;
247	247	return false;
248	248	}
…	…
312	312	if (!success)
313	313	{
314		~~COUT(1) << "Error: Config-value '" << this->varname_ << "' in " << this->sectionname_ << " is a vector." << std::~~endl;
	314	orxout(user_error, context::config) << "Config-value '" << this->varname_ << "' in " << this->sectionname_ << " is a vector." << endl;
315	315	}
316	316	else
317	317	{
318		~~COUT(1) << "Error: Invalid vector-index." << std::~~endl;
	318	orxout(user_error, context::config) << "Invalid vector-index." << endl;
319	319	}
320	320	return false;

code/trunk/src/libraries/core/ConfigValueIncludes.h

-                      r8729
+                      r8858
     @code
     MyObject orxonoxobject;
     std::cout << "Name:    " << orxonoxobject.getName() << std::endl;
     std::cout << "Version: " << orxonoxobject.getVersion() << std::endl;
+    orxout() << "Name:    " << orxonoxobject.getName() << endl;
+    orxout() << "Version: " << orxonoxobject.getVersion() << endl;
     @endcode
 …
         else
+        {
             COUT(2) << "Warning: Couldn't reset config-value '" << entryName << "' in class '"
                     << ClassIdentifier<T>::getIdentifier()->getName() << "', corresponding container doesn't exist." << std::endl;
+            orxout(user_warning, context::config) << "Couldn't reset config-value '" << entryName << "' in class '"
+                                                  << ClassIdentifier<T>::getIdentifier()->getName() << "', corresponding container doesn't exist." << endl;
+        }
+    }
 …
     else \
     { \
         COUT(2) << "Warning: Couln't modify config-value '" << entryName << "' in class '" \
                 << ClassByObjectType(object)->getName() << "', corresponding container doesn't exist." << std::endl; \
+        orxout(user_warning, context::config) << "Couldn't modify config-value '" << entryName << "' in class '" \
+                                              << ClassByObjectType(object)->getName() << "', corresponding container doesn't exist." << endl; \
+    }

code/trunk/src/libraries/core/Core.cc

-                      r8729
+                      r8858
 #include "util/Clock.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/Exception.h"
+#include "util/output/LogWriter.h"
 #include "util/Scope.h"
 #include "util/ScopedSingletonManager.h"
 …
         , destructionHelper_(this)
+    {
+        orxout(internal_status) << "initializing Core object..." << endl;
         // Set the hard coded fixed paths
         this->pathConfig_ = new PathConfig();
 …
         // Load modules
+        orxout(internal_info) << "Loading modules:" << endl;
         const std::vector<std::string>& modulePaths = this->pathConfig_->getModulePaths();
         for (std::vector<std::string>::const_iterator it = modulePaths.begin(); it != modulePaths.end(); ++it)
 …
             catch (...)
+            {
                 COUT(1) << "Couldn't load module \"" << *it << "\": " << Exception::handleMessage() << std::endl;
+                orxout(user_error) << "Couldn't load module \"" << *it << "\": " << Exception::handleMessage() << endl;
+            }
+        }
 …
         // Set configurable paths like log, config and media
         this->pathConfig_->setConfigurablePaths();
+        orxout(internal_info) << "Root path:       " << PathConfig::getRootPathString() << endl;
+        orxout(internal_info) << "Executable path: " << PathConfig::getExecutablePathString() << endl;
+        orxout(internal_info) << "Data path:       " << PathConfig::getDataPathString() << endl;
+        orxout(internal_info) << "Ext. data path:  " << PathConfig::getExternalDataPathString() << endl;
+        orxout(internal_info) << "Config path:     " << PathConfig::getConfigPathString() << endl;
+        orxout(internal_info) << "Log path:        " << PathConfig::getLogPathString() << endl;
+        orxout(internal_info) << "Modules path:    " << PathConfig::getModulePathString() << endl;
         // create a signal handler (only active for Linux)
 …
         this->signalHandler_ = new SignalHandler();
         this->signalHandler_->doCatch(PathConfig::getExecutablePathString(), PathConfig::getLogPathString() + "orxonox_crash.log");
-        // Set the correct log path. Before this call, /tmp (Unix) or %TEMP% (Windows) was used
-        OutputHandler::getInstance().setLogPath(PathConfig::getLogPathString());
 #ifdef ORXONOX_PLATFORM_WINDOWS
 …
         // Manage ini files and set the default settings file (usually orxonox.ini)
+        orxout(internal_info) << "Loading config:" << endl;
         this->configFileManager_ = new ConfigFileManager();
         this->configFileManager_->setFilename(ConfigFileType::Settings,
 …
         // Required as well for the config values
+        orxout(internal_info) << "Loading language:" << endl;
         this->languageInstance_ = new Language();
 …
         // possibility to configure everything below here
         RegisterRootObject(Core);
+        orxout(internal_info) << "configuring Core" << endl;
         this->setConfigValues();
+        // Rewrite the log file with the correct log levels
+        OutputHandler::getInstance().rewriteLogFile();
+        // Set the correct log path and rewrite the log file with the correct log levels
+        LogWriter::getInstance().setLogPath(PathConfig::getLogPathString());
 #if !defined(ORXONOX_PLATFORM_APPLE) && !defined(ORXONOX_USE_WINMAIN)
 …
+        }
         if (this->bStartIOConsole_)
+        {
+            orxout(internal_info) << "creating IO console" << endl;
             this->ioConsole_ = new IOConsole();
+        }
 #endif
         // creates the class hierarchy for all classes with factories
+        orxout(internal_info) << "creating class hierarchy" << endl;
         Identifier::createClassHierarchy();
         // Load OGRE excluding the renderer and the render window
+        orxout(internal_info) << "creating GraphicsManager:" << endl;
         this->graphicsManager_ = new GraphicsManager(false);
 …
         // Create singletons that always exist (in other libraries)
+        orxout(internal_info) << "creating root scope:" << endl;
         this->rootScope_ = new Scope<ScopeID::Root>();
 …
+            }
             else
+                COUT(0) << "Error: Could not open file for documentation writing" << endl;
+        }
+                orxout(internal_error) << "Could not open file for documentation writing" << endl;
+        }
+        orxout(internal_status) << "finished initializing Core object" << endl;
+    }
     void Core::destroy()
+    {
+        orxout(internal_status) << "destroying Core object..." << endl;
         // Remove us from the object lists again to avoid problems when destroying them
         this->unregisterObject();
 …
         safeObjectDelete(&dynLibManager_);
         safeObjectDelete(&pathConfig_);
+    }
+    namespace DefaultLevelLogFile
+    {
+        const OutputLevel::Value Dev  = OutputLevel::Debug;
+        const OutputLevel::Value User = OutputLevel::Info;
+        orxout(internal_status) << "finished destroying Core object" << endl;
+    }
 …
     void Core::setConfigValues()
+    {
+        // Choose the default level according to the path Orxonox was started (build directory or not)
+        OutputLevel::Value defaultLogLevel = (PathConfig::buildDirectoryRun() ? DefaultLevelLogFile::Dev : DefaultLevelLogFile::User);
+        SetConfigValueExternal(debugLevelLogFile_, "OutputHandler", "debugLevelLogFile", defaultLogLevel)
+            .description("The maximum level of debug output written to the log file");
+        OutputHandler::getInstance().setSoftDebugLevel("LogFile", debugLevelLogFile_);
+        SetConfigValueExternal(LogWriter::getInstance().configurableMaxLevel_,
+                               LogWriter::getInstance().getConfigurableSectionName(),
+                               LogWriter::getInstance().getConfigurableMaxLevelName(),
+                               LogWriter::getInstance().configurableMaxLevel_)
+            .description("The maximum level of output shown in the log file")
+            .callback(static_cast<BaseWriter*>(&LogWriter::getInstance()), &BaseWriter::changedConfigurableLevel);
+        SetConfigValueExternal(LogWriter::getInstance().configurableAdditionalContextsMaxLevel_,
+                               LogWriter::getInstance().getConfigurableSectionName(),
+                               LogWriter::getInstance().getConfigurableAdditionalContextsMaxLevelName(),
+                               LogWriter::getInstance().configurableAdditionalContextsMaxLevel_)
+            .description("The maximum level of output shown in the log file for additional contexts")
+            .callback(static_cast<BaseWriter*>(&LogWriter::getInstance()), &BaseWriter::changedConfigurableAdditionalContextsLevel);
+        SetConfigValueExternal(LogWriter::getInstance().configurableAdditionalContexts_,
+                               LogWriter::getInstance().getConfigurableSectionName(),
+                               LogWriter::getInstance().getConfigurableAdditionalContextsName(),
+                               LogWriter::getInstance().configurableAdditionalContexts_)
+            .description("Additional output contexts shown in the log file")
+            .callback(static_cast<BaseWriter*>(&LogWriter::getInstance()), &BaseWriter::changedConfigurableAdditionalContexts);
         SetConfigValue(bDevMode_, PathConfig::buildDirectoryRun())
 …
     void Core::devModeChanged()
+    {
-        bool isNormal = (bDevMode_ == PathConfig::buildDirectoryRun());
-        if (isNormal)
+        {
-            ModifyConfigValueExternal(debugLevelLogFile_, "debugLevelLogFile", update);
+        }
-        else
+        {
-            OutputLevel::Value level = (bDevMode_ ? DefaultLevelLogFile::Dev : DefaultLevelLogFile::User);
-            ModifyConfigValueExternal(debugLevelLogFile_, "debugLevelLogFile", tset, level);
+        }
         // Inform listeners
         ObjectList<DevModeListener>::iterator it = ObjectList<DevModeListener>::begin();
 …
     void Core::loadGraphics()
+    {
+        orxout(internal_info) << "loading graphics in Core" << endl;
         // Any exception should trigger this, even in upgradeToGraphics (see its remarks)
         Loki::ScopeGuard unloader = Loki::MakeObjGuard(*this, &Core::unloadGraphics);
 …
+        {
             // Exit the application if the Ogre config dialog was canceled
             COUT(1) << Exception::handleMessage() << std::endl;
+            orxout(user_error) << Exception::handleMessage() << endl;
             exit(EXIT_FAILURE);
+        }
 …
             // and reloaded between throw and catch (access violation in MSVC).
             // That's why we abort completely and only display the exception.
             COUT(1) << "An exception occurred during upgrade to graphics. "
                     << "That is unrecoverable. The message was:" << endl
                     << Exception::handleMessage() << endl;
+            orxout(user_error) << "An exception occurred during upgrade to graphics. "
+                               << "That is unrecoverable. The message was:" << endl
+                               << Exception::handleMessage() << endl;
             abort();
+        }
 …
         // Create singletons associated with graphics (in other libraries)
+        orxout(internal_info) << "creating graphics scope:" << endl;
         graphicsScope_ = new Scope<ScopeID::Graphics>();
         unloader.Dismiss();
+        orxout(internal_info) << "finished loading graphics in Core" << endl;
+    }
     void Core::unloadGraphics()
+    {
+        orxout(internal_info) << "unloading graphics in Core" << endl;
         safeObjectDelete(&graphicsScope_);
         safeObjectDelete(&guiManager_);
 …
         catch (...)
+        {
             COUT(0) << "An exception occurred during 'unloadGraphics':" << Exception::handleMessage() << std::endl
                     << "Another exception might be being handled which may lead to undefined behaviour!" << std::endl
                     << "Terminating the program." << std::endl;
+            orxout(user_error) << "An exception occurred during 'unloadGraphics':" << Exception::handleMessage() << endl
+                               << "Another exception might be being handled which may lead to undefined behaviour!" << endl
+                               << "Terminating the program." << endl;
             abort();
+        }

code/trunk/src/libraries/core/Core.h

r8729	r8858
136	136
137	137	bool bGraphicsLoaded_;
138		~~int debugLevelLogFile_; //!< The debug level for the log file (belongs to OutputHandler)~~
139	138	std::string language_; //!< The language
140	139	bool bInitRandomNumberGenerator_; //!< If true, srand(time(0)) is called

code/trunk/src/libraries/core/CoreIncludes.h

-                      r8729
+                      r8858
 /**
     @file
     @ingroup Object Factory
+    @ingroup Object Factory Class Identifier
     @brief Defines several very important macros used to register objects, create factories, and to work with identifiers.
 …
 #include "CorePrereqs.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "Identifier.h"
 #include "ClassFactory.h"

code/trunk/src/libraries/core/CorePrecompiledHeaders.h

r7266	r8858
51	51	#include <set> // 50
52	52
53		#include "util/~~Debug~~.h" // 48
	53	#include "util/Output.h" // 48
54	54
55	55	#include <deque> // 43

code/trunk/src/libraries/core/DynLib.cc

-                      r8351
+                      r8858
+    {
         // Log library load
         COUT(2) << "Loading module " << mName << std::endl;
+        orxout(internal_info) << "Loading module " << mName << endl;
         std::string name = mName;
 …
+    {
         // Log library unload
         COUT(4) << "Unloading module " << mName << std::endl;
+        orxout(internal_info) << "Unloading module " << mName << endl;
         if (DYNLIB_UNLOAD( m_hInst ))

code/trunk/src/libraries/core/Event.cc

-                      r7401
+                      r8858
         if (this->bProcessingEvent_)
+        {
             COUT(2) << "Warning: Detected Event loop in section \"" << event.statename_ << "\" of object \"" << object->getName() << "\" and fired by \"" << event.originator_->getName() << '"' << std::endl;
+            orxout(internal_warning, context::events) << "Detected Event loop in section \"" << event.statename_ << "\" of object \"" << object->getName() << "\" and fired by \"" << event.originator_->getName() << '"' << endl;
             return;
+        }
 …
         this->bProcessingEvent_ = true;
         COUT(4) << "Processing event (EventState) : originator: " << event.originator_->getIdentifier()->getName() << " (&" << event.originator_ << "), activate: " << event.activate_ << ", name: " << event.name_ << ", statename: " << event.statename_ << ", object: " << object->getIdentifier()->getName() << " (&" << object << ")" << "." << std::endl;
+        orxout(verbose, context::events) << "Processing event (EventState) : originator: " << event.originator_->getIdentifier()->getName() << " (&" << event.originator_ << "), activate: " << event.activate_ << ", name: " << event.name_ << ", statename: " << event.statename_ << ", object: " << object->getIdentifier()->getName() << " (&" << object << ")" << "." << endl;
         // check if the originator is an instance of the requested class

code/trunk/src/libraries/core/GUIManager.cc

-                      r8729
+                      r8858
 #include "util/Clock.h"
 #include "util/Convert.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/Exception.h"
 #include "util/Math.h"
 #include "util/OrxAssert.h"
+#include "util/output/BaseWriter.h"
 #include "ConfigValueIncludes.h"
 #include "Core.h"
 …
         void logEvent(const CEGUI::String& message, CEGUI::LoggingLevel level = CEGUI::Standard)
+        {
             int orxonoxLevel = CEGUI::Standard;
+            OutputLevel orxonoxLevel = level::debug_output;
             switch (level)
+            {
                 case CEGUI::Errors:      orxonoxLevel = 1; break;
                 case CEGUI::Warnings:    orxonoxLevel = 2; break;
                 case CEGUI::Standard:    orxonoxLevel = 4; break;
                 case CEGUI::Informative: orxonoxLevel = 5; break;
                 case CEGUI::Insane:      orxonoxLevel = 6; break;
+                case CEGUI::Errors:      orxonoxLevel = level::internal_error; break;
+                case CEGUI::Warnings:    orxonoxLevel = level::internal_warning; break;
+                case CEGUI::Standard:    orxonoxLevel = level::verbose; break;
+                case CEGUI::Informative: orxonoxLevel = level::verbose_more; break;
+                case CEGUI::Insane:      orxonoxLevel = level::verbose_ultra; break;
                 default: OrxAssert(false, "CEGUI log level out of range, inspect immediately!");
+            }
+            OutputHandler::getOutStream(orxonoxLevel)
                 << "CEGUI: " << message << std::endl;
+            orxout(orxonoxLevel, context::cegui) << message << endl;
             CEGUI::DefaultLogger::logEvent(message, level);
 …
+    {
         RegisterRootObject(GUIManager);
+        orxout(internal_status) << "initializing GUIManager..." << endl;
         this->setConfigValues();
         using namespace CEGUI;
         COUT(3) << "Initialising CEGUI." << std::endl;
+        orxout(internal_info) << "Initialising CEGUI." << endl;
         this->oldCEGUI_ = false;
         // Note: No SceneManager specified yet
 #ifdef ORXONOX_OLD_CEGUI
 …
         std::auto_ptr<CEGUILogger> ceguiLogger(new CEGUILogger());
         ceguiLogger->setLogFilename(PathConfig::getLogPathString() + "cegui.log");
+        // Set the log level according to ours (translate by subtracting 1)
+        ceguiLogger->setLoggingLevel(
+            static_cast<LoggingLevel>(OutputHandler::getInstance().getSoftDebugLevel("logFile") - 1));
+        ceguiLogger->setLoggingLevel(static_cast<CEGUI::LoggingLevel>(this->outputLevelCeguiLog_));
         this->ceguiLogger_ = ceguiLogger.release();
 …
         // Set up the sheet manager in the Lua framework
         this->luaState_->doFile("SheetManager.lua");
+        orxout(internal_status) << "finished initializing GUIManager" << endl;
+    }
     void GUIManager::destroy()
+    {
+        orxout(internal_status) << "destroying GUIManager..." << endl;
         using namespace CEGUI;
 …
 #endif
         safeObjectDelete(&luaState_);
+        orxout(internal_status) << "finished destroying GUIManager" << endl;
+    }
     void GUIManager::setConfigValues(void)
+    {
         SetConfigValue(guiScheme_, GUIManager::defaultScheme_) .description("Changes the current GUI scheme.") .callback(this, &GUIManager::changedGUIScheme);
+        SetConfigValue(guiScheme_, GUIManager::defaultScheme_).description("Changes the current GUI scheme.").callback(this, &GUIManager::changedGUIScheme);
         SetConfigValue(numScrollLines_, 1).description("How many lines to scroll in a list if the scroll wheel is used");
+        SetConfigValueExternal(outputLevelCeguiLog_, BaseWriter::getConfigurableSectionName(), "outputLevelCeguiLog", CEGUI::Standard).description("The log level of the CEGUI log file").callback(this, &GUIManager::changedCeguiOutputLevel);
+    }
     void GUIManager::changedGUIScheme(void)
+    {
+    }
+    void GUIManager::changedCeguiOutputLevel()
+    {
+        if (this->ceguiLogger_)
+            this->ceguiLogger_->setLoggingLevel(static_cast<CEGUI::LoggingLevel>(this->outputLevelCeguiLog_));
+    }
 …
+        {
             // Display the error and proceed. See @remarks why this can be dangerous.
             COUT(1) << ex.getMessage() << std::endl;
+            orxout(internal_error) << ex.getMessage() << endl;
             return true;
+        }

code/trunk/src/libraries/core/GUIManager.h

-                      r8729
+                      r8858
         bool protectedCall(FunctionType function);
+        void changedCeguiOutputLevel();
         // keyHandler functions
         void buttonPressed (const KeyEvent& evt);
 …
 #ifdef ORXONOX_OLD_CEGUI
         CEGUI::OgreCEGUIRenderer*            guiRenderer_;      //!< CEGUI's interface to the Ogre Engine
         CEGUI::ResourceProvider*             resourceProvider_; //!< CEGUI's resource provider
+        CEGUI::OgreCEGUIRenderer*            guiRenderer_;          //!< CEGUI's interface to the Ogre Engine
+        CEGUI::ResourceProvider*             resourceProvider_;     //!< CEGUI's resource provider
 #else
         CEGUI::OgreRenderer*                 guiRenderer_;      //!< CEGUI's interface to the Ogre Engine
         CEGUI::OgreResourceProvider*         resourceProvider_; //!< CEGUI's resource provider
         Ogre::RenderQueueListener*           rqListener_;       //!< RQ listener so we can draw UNDER Ogre overlays
+        CEGUI::OgreRenderer*                 guiRenderer_;          //!< CEGUI's interface to the Ogre Engine
+        CEGUI::OgreResourceProvider*         resourceProvider_;     //!< CEGUI's resource provider
+        Ogre::RenderQueueListener*           rqListener_;           //!< RQ listener so we can draw UNDER Ogre overlays
         CEGUI::OgreImageCodec*               imageCodec_;
 #endif
+        LuaState*                            luaState_;         //!< LuaState, access point to the Lua engine
+        CEGUI::LuaScriptModule*              scriptModule_;     //!< CEGUI's script module to use Lua
+        CEGUI::System*                       guiSystem_;        //!< CEGUI's main system
+        shared_ptr<ResourceInfo>             rootFileInfo_;     //!< Resource information about the root script
+        CEGUI::Logger*                       ceguiLogger_;      //!< CEGUI's logger to be able to log CEGUI errors in our log
+        CEGUI::Window*                       rootWindow_;       //!< Root node for all windows
+        CEGUI::Window*                       hudRootWindow_;    //!< Root node for the HUD sheets
+        CEGUI::Window*                       menuRootWindow_;   //!< Root node for the menu sheets (used by Lua)
+        std::map<std::string, PlayerInfo*>   players_;          //!< Stores the player (owner) for each GUI
+        Ogre::Camera*                        camera_;           //!< Camera used to render the scene with the GUI
+        LuaState*                            luaState_;             //!< LuaState, access point to the Lua engine
+        CEGUI::LuaScriptModule*              scriptModule_;         //!< CEGUI's script module to use Lua
+        CEGUI::System*                       guiSystem_;            //!< CEGUI's main system
+        shared_ptr<ResourceInfo>             rootFileInfo_;         //!< Resource information about the root script
+        CEGUI::Logger*                       ceguiLogger_;          //!< CEGUI's logger to be able to log CEGUI errors in our log
+        int                                  outputLevelCeguiLog_;  //!< CEGUI's log level
+        CEGUI::Window*                       rootWindow_;           //!< Root node for all windows
+        CEGUI::Window*                       hudRootWindow_;        //!< Root node for the HUD sheets
+        CEGUI::Window*                       menuRootWindow_;       //!< Root node for the menu sheets (used by Lua)
+        std::map<std::string, PlayerInfo*>   players_;              //!< Stores the player (owner) for each GUI
+        Ogre::Camera*                        camera_;               //!< Camera used to render the scene with the GUI
         /// Helper object that executes the surrogate destructor destroy()
         DestructionHelper<GUIManager>        destructionHelper_;
         static GUIManager*                   singletonPtr_s;    //!< Singleton reference to GUIManager
+        static GUIManager*                   singletonPtr_s;        //!< Singleton reference to GUIManager
         // The used CEGUI scheme.
 …
         std::string guiScheme_;
         bool oldCEGUI_;
         int numScrollLines_; ///< How many lines to scroll in a list if the scroll wheel is used

code/trunk/src/libraries/core/Game.cc

-                      r8729
+                      r8858
 #include "util/Clock.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/Exception.h"
 #include "util/Sleep.h"
 …
     SetConsoleCommand("exit", &stop_game);
     static void printFPS()
         { COUT(0) << Game::getInstance().getAvgFPS() << std::endl; }
+        { orxout(message) << Game::getInstance().getAvgFPS() << endl; }
     SetConsoleCommand("Stats", "printFPS", &printFPS);
     static void printTickTime()
         { COUT(0) << Game::getInstance().getAvgTickTime() << std::endl; }
+        { orxout(message) << Game::getInstance().getAvgTickTime() << endl; }
     SetConsoleCommand("Stats", "printTickTime", &printTickTime);
 …
         , destructionHelper_(this)
+    {
+        orxout(internal_status) << "initializing Game object..." << endl;
 #ifdef ORXONOX_PLATFORM_WINDOWS
         minimumSleepTime_ = 1000/*us*/;
 …
         // Create the Core
+        orxout(internal_info) << "creating Core object:" << endl;
         this->core_ = new Core(cmdLine);
 …
         this->loadedTopStateNode_ = this->rootStateNode_;
         this->loadedStates_.push_back(this->getState(rootStateNode_->name_));
+        orxout(internal_status) << "finished initializing Game object" << endl;
+    }
     void Game::destroy()
+    {
+        orxout(internal_status) << "destroying Game object..." << endl;
         // Remove us from the object lists again to avoid problems when destroying them
         this->unregisterObject();
 …
         safeObjectDelete(&core_);
         safeObjectDelete(&gameClock_);
+        orxout(internal_status) << "finished destroying Game object..." << endl;
+    }
 …
+    {
         if (this->requestedStateNodes_.empty())
+            COUT(0) << "Warning: Starting game without requesting GameState. This automatically terminates the program." << std::endl;
+            orxout(user_error) << "Starting game without requesting GameState. This automatically terminates the program." << endl;
+        // Update the GameState stack if required. We do this already here to have a properly initialized game before entering the main loop
+        this->updateGameStateStack();
+        orxout(user_status) << "Game loaded" << endl;
+        orxout(internal_status) << "--------------------------------------------------" << endl;
+        orxout(internal_status) << "starting main loop..." << endl;
         // START GAME
 …
             catch (...)
+            {
                 COUT(0) << "An exception occurred in the Core preUpdate: " << Exception::handleMessage() << std::endl;
                 COUT(0) << "This should really never happen! Closing the program." << std::endl;
+                orxout(user_error) << "An exception occurred in the Core preUpdate: " << Exception::handleMessage() << endl;
+                orxout(user_error) << "This should really never happen! Closing the program." << endl;
                 this->stop();
                 break;
 …
             catch (...)
+            {
                 COUT(0) << "An exception occurred in the Core postUpdate: " << Exception::handleMessage() << std::endl;
                 COUT(0) << "This should really never happen! Closing the program." << std::endl;
+                orxout(user_error) << "An exception occurred in the Core postUpdate: " << Exception::handleMessage() << endl;
+                orxout(user_error) << "This should really never happen! Closing the program." << endl;
                 this->stop();
                 break;
 …
                 this->updateFPSLimiter();
+        }
+        orxout(internal_status) << "finished main loop" << endl;
+        orxout(internal_status) << "--------------------------------------------------" << endl;
         // UNLOAD all remaining states
 …
                 catch (...)
+                {
                     COUT(1) << "Error: Loading GameState '" << requestedStateNode->name_ << "' failed: " << Exception::handleMessage() << std::endl;
+                    orxout(user_error) << "Loading GameState '" << requestedStateNode->name_ << "' failed: " << Exception::handleMessage() << endl;
                     // All scheduled operations have now been rendered inert --> flush them and issue a warning
                     if (this->requestedStateNodes_.size() > 1)
                         COUT(4) << "All " << this->requestedStateNodes_.size() - 1 << " scheduled transitions have been ignored." << std::endl;
+                        orxout(internal_info) << "All " << this->requestedStateNodes_.size() - 1 << " scheduled transitions have been ignored." << endl;
                     this->requestedStateNodes_.clear();
                     break;
 …
             catch (...)
+            {
                 COUT(1) << "An exception occurred while updating '" << (*it)->getName() << "': " << Exception::handleMessage() << std::endl;
                 COUT(1) << "This should really never happen!" << std::endl;
                 COUT(1) << "Unloading all GameStates depending on the one that crashed." << std::endl;
+                orxout(user_error) << "An exception occurred while updating '" << (*it)->getName() << "': " << Exception::handleMessage() << endl;
+                orxout(user_error) << "This should really never happen!" << endl;
+                orxout(user_error) << "Unloading all GameStates depending on the one that crashed." << endl;
                 shared_ptr<GameStateTreeNode> current = this->loadedTopStateNode_;
                 while (current->name_ != (*it)->getName() && current)
 …
     void Game::stop()
+    {
+        orxout(user_status) << "Exit" << endl;
         this->bAbort_ = true;
+    }
 …
         if (!this->checkState(name))
+        {
             COUT(2) << "Warning: GameState named '" << name << "' doesn't exist!" << std::endl;
+            orxout(user_warning) << "GameState named '" << name << "' doesn't exist!" << endl;
             return;
+        }
 …
         if (this->bChangingState_)
+        {
             COUT(2) << "Warning: Requesting GameStates while loading/unloading a GameState is illegal! Ignoring." << std::endl;
+            orxout(user_warning) << "Requesting GameStates while loading/unloading a GameState is illegal! Ignoring." << endl;
             return;
+        }
 …
         if (name == lastRequestedNode->name_)
+        {
             COUT(2) << "Warning: Requesting the currently active state! Ignoring." << std::endl;
+            orxout(user_warning) << "Requesting the currently active state! Ignoring." << endl;
             return;
+        }
 …
         if (requestedNodes.empty())
             COUT(1) << "Error: Requested GameState transition is not allowed. Ignoring." << std::endl;
+            orxout(user_error) << "Requested GameState transition is not allowed. Ignoring." << endl;
         else
             this->requestedStateNodes_.insert(requestedStateNodes_.end(), requestedNodes.begin(), requestedNodes.end());
 …
             this->requestState(lastRequestedNode->parent_.lock()->name_);
         else
             COUT(2) << "Warning: Can't pop the internal dummy root GameState" << std::endl;
+            orxout(internal_warning) << "Can't pop the internal dummy root GameState" << endl;
+    }
 …
             std::map<std::string, GameStateInfo>::const_iterator it = gameStateDeclarations_s.find(name);
             if (it != gameStateDeclarations_s.end())
                 COUT(1) << "Error: GameState '" << name << "' has not yet been loaded." << std::endl;
+                orxout(internal_error) << "GameState '" << name << "' has not yet been loaded." << endl;
             else
                 COUT(1) << "Error: Could not find GameState '" << name << "'." << std::endl;
+                orxout(internal_error) << "Could not find GameState '" << name << "'." << endl;
             return shared_ptr<GameState>();
+        }
 …
         if (!GameMode::showsGraphics())
+        {
+            orxout(user_status) << "Loading graphics" << endl;
+            orxout(internal_info) << "loading graphics in Game" << endl;
             core_->loadGraphics();
             Loki::ScopeGuard graphicsUnloader = Loki::MakeObjGuard(*this, &Game::unloadGraphics);
 …
+            }
             graphicsUnloader.Dismiss();
+            orxout(internal_info) << "finished loading graphics in Game" << endl;
+        }
+    }
 …
         if (GameMode::showsGraphics())
+        {
+            orxout(user_status) << "Unloading graphics" << endl;
+            orxout(internal_info) << "unloading graphics in Game" << endl;
             // Destroy all the GameStates that require graphics
             for (GameStateMap::iterator it = constructedStates_.begin(); it != constructedStates_.end();)
 …
     void Game::loadState(const std::string& name)
+    {
+        orxout(internal_status) << "loading state '" << name << "'" << endl;
         this->bChangingState_ = true;
         LOKI_ON_BLOCK_EXIT_OBJ(*this, &Game::resetChangingState); (void)LOKI_ANONYMOUS_VARIABLE(scopeGuard);
 …
     void Game::unloadState(const std::string& name)
+    {
+        orxout(internal_status) << "unloading state '" << name << "'" << endl;
         this->bChangingState_ = true;
         try
 …
         catch (...)
+        {
             COUT(2) << "Warning: Unloading GameState '" << name << "' threw an exception: " << Exception::handleMessage() << std::endl;
             COUT(2) << "         There might be potential resource leaks involved! To avoid this, improve exception-safety." << std::endl;
+            orxout(internal_warning) << "Unloading GameState '" << name << "' threw an exception: " << Exception::handleMessage() << endl;
+            orxout(internal_warning) << "There might be potential resource leaks involved! To avoid this, improve exception-safety." << endl;
+        }
         // Check if graphics is still required

code/trunk/src/libraries/core/Game.h

-                      r8423
+                      r8858
 #include <boost/preprocessor/cat.hpp>
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/DestructionHelper.h"
 #include "util/Singleton.h"
 …
         else
+        {
             COUT(0) << "Error: Cannot declare two GameStates with the same name." << std::endl;
             COUT(0) << "       Ignoring second one ('" << stateName << "')." << std::endl;
+            orxout(internal_warning) << "Cannot declare two GameStates with the same name." << endl;
+            orxout(internal_warning) << "Ignoring second one ('" << stateName << "')." << endl;
+        }

code/trunk/src/libraries/core/GameState.cc

r6417	r8858
35	35	#include "GameState.h"
36	36
37		~~#include "util/Debug.h"~~
38	37	#include "util/Exception.h"
39	38	#include "util/OrxAssert.h"

code/trunk/src/libraries/core/GraphicsManager.cc

-                      r8423
+                      r8858
         RegisterObject(GraphicsManager);
+        orxout(internal_status) << "initializing GraphicsManager..." << endl;
         this->setConfigValues();
 …
         resources_.reset(new XMLFile("DefaultResources.oxr"));
         resources_->setLuaSupport(false);
         Loader::open(resources_.get());
+        Loader::open(resources_.get(), ClassTreeMask(), false);
         // Only for runs in the build directory (not installed)
 …
         extResources_.reset(new XMLFile("resources.oxr"));
         extResources_->setLuaSupport(false);
         Loader::open(extResources_.get());
+        Loader::open(extResources_.get(), ClassTreeMask(), false);
         if (bLoadRenderer)
 …
             this->upgradeToGraphics();
+        }
+        orxout(internal_status) << "finished initializing GraphicsManager" << endl;
+    }
     void GraphicsManager::destroy()
+    {
+        orxout(internal_status) << "destroying GraphicsManager..." << endl;
         Loader::unload(debugOverlay_.get());
 …
         safeObjectDelete(&ogreLogger_);
         safeObjectDelete(&ogreWindowEventListener_);
+        orxout(internal_status) << "finished destroying GraphicsManager" << endl;
+    }
 …
         SetConfigValue(ogreLogFile_,     "ogre.log")
             .description("Logfile for messages from Ogre. Use \"\" to suppress log file creation.");
-        SetConfigValue(ogreLogLevelTrivial_ , 5)
-            .description("Corresponding orxonox debug level for ogre Trivial");
-        SetConfigValue(ogreLogLevelNormal_  , 4)
-            .description("Corresponding orxonox debug level for ogre Normal");
-        SetConfigValue(ogreLogLevelCritical_, 2)
-            .description("Corresponding orxonox debug level for ogre Critical");
+    }
 …
             return;
+        orxout(internal_info) << "GraphicsManager upgrade to graphics" << endl;
         // load all the required plugins for Ogre
         this->loadOgrePlugins();
 …
         // choose another resource group.
         Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
+        orxout(internal_info) << "GraphicsManager finished upgrade to graphics" << endl;
+    }
 …
     void GraphicsManager::loadOgreRoot()
+    {
         COUT(3) << "Setting up Ogre..." << std::endl;
+        orxout(internal_info) << "Setting up Ogre..." << endl;
         if (ogreConfigFile_.empty())
+        {
             COUT(2) << "Warning: Ogre config file set to \"\". Defaulting to config.cfg" << std::endl;
+            orxout(internal_warning) << "Ogre config file set to \"\". Defaulting to config.cfg" << endl;
             ModifyConfigValue(ogreConfigFile_, tset, "config.cfg");
+        }
         if (ogreLogFile_.empty())
+        {
             COUT(2) << "Warning: Ogre log file set to \"\". Defaulting to ogre.log" << std::endl;
+            orxout(internal_warning) << "Ogre log file set to \"\". Defaulting to ogre.log" << endl;
             ModifyConfigValue(ogreLogFile_, tset, "ogre.log");
+        }
 …
         // Ogre::Root will detect that we've already created a Log
         ogreLogger_ = new Ogre::LogManager();
         COUT(4) << "Ogre LogManager created" << std::endl;
+        orxout(internal_info) << "Ogre LogManager created" << endl;
         // create our own log that we can listen to
         Ogre::Log *myLog;
         myLog = ogreLogger_->createLog(ogreLogFilepath.string(), true, false, false);
         COUT(4) << "Ogre Log created" << std::endl;
+        orxout(internal_info) << "Ogre Log created" << endl;
         myLog->setLogDetail(Ogre::LL_BOREME);
         myLog->addListener(this);
         COUT(4) << "Creating Ogre Root..." << std::endl;
+        orxout(internal_info) << "Creating Ogre Root..." << endl;
         // check for config file existence because Ogre displays (caught) exceptions if not
 …
         ogreRoot_ = new Ogre::Root("", ogreConfigFilepath.string(), ogreLogFilepath.string());
         COUT(3) << "Ogre set up done." << std::endl;
+        orxout(internal_info) << "Ogre set up done." << endl;
+    }
     void GraphicsManager::loadOgrePlugins()
+    {
+        orxout(internal_info) << "loading ogre plugins" << endl;
         // Plugin path can have many different locations...
         std::string pluginPath = specialConfig::ogrePluginsDirectory;
 …
     void GraphicsManager::loadRenderer()
+    {
         CCOUT(4) << "Configuring Renderer" << std::endl;
+        orxout(internal_info) << "GraphicsManager: Configuring Renderer" << endl;
         bool updatedConfig = Core::getInstance().getOgreConfigTimestamp() > Core::getInstance().getLastLevelTimestamp();
         if (updatedConfig)
             COUT(2) << "Ogre config file has changed, but no level was started since then. Displaying config dialogue again to verify the changes." << std::endl;
+            orxout(user_info)<< "Ogre config file has changed, but no level was started since then. Displaying config dialogue again to verify the changes." << endl;
         if (!ogreRoot_->restoreConfig() || updatedConfig)
 …
+        }
         CCOUT(4) << "Creating render window" << std::endl;
+        orxout(internal_info) << "Creating render window" << endl;
         this->renderWindow_ = ogreRoot_->initialise(true, "Orxonox");
 …
+    {
         // Load debug overlay to show info about fps and tick time
         COUT(4) << "Loading Debug Overlay..." << std::endl;
+        orxout(internal_info) << "Loading Debug Overlay..." << endl;
         debugOverlay_.reset(new XMLFile("debug.oxo"));
         Loader::open(debugOverlay_.get());
+        Loader::open(debugOverlay_.get(), ClassTreeMask(), false);
+    }
 …
         Ogre::LogMessageLevel lml, bool maskDebug, const std::string& logName)
+    {
         int orxonoxLevel;
+        OutputLevel orxonoxLevel;
         std::string introduction;
         // Do not show caught OGRE exceptions in front
         if (message.find("EXCEPTION") != std::string::npos)
+        {
             orxonoxLevel = OutputLevel::Debug;
+            orxonoxLevel = level::internal_error;
             introduction = "Ogre, caught exception: ";
+        }
 …
+            {
             case Ogre::LML_TRIVIAL:
                 orxonoxLevel = this->ogreLogLevelTrivial_;
+                orxonoxLevel = level::verbose_more;
                 break;
             case Ogre::LML_NORMAL:
                 orxonoxLevel = this->ogreLogLevelNormal_;
+                orxonoxLevel = level::verbose;
                 break;
             case Ogre::LML_CRITICAL:
                 orxonoxLevel = this->ogreLogLevelCritical_;
+                orxonoxLevel = level::internal_warning;
                 break;
             default:
                 orxonoxLevel = 0;
+                orxonoxLevel = level::debug_output;
+            }
             introduction = "Ogre: ";
+        }
+        OutputHandler::getOutStream(orxonoxLevel)
             << introduction << message << std::endl;
+        orxout(orxonoxLevel, context::ogre) << introduction << message << endl;
+    }

code/trunk/src/libraries/core/GraphicsManager.h

-                      r8706
+                      r8858
         std::string         ogrePlugins_;              //!< Comma separated list of all plugins to load
         std::string         ogreLogFile_;              //!< log filename for Ogre log messages
-        int                 ogreLogLevelTrivial_;      //!< Corresponding Orxonox debug level for LL_TRIVIAL
-        int                 ogreLogLevelNormal_;       //!< Corresponding Orxonox debug level for LL_NORMAL
-        int                 ogreLogLevelCritical_;     //!< Corresponding Orxonox debug level for LL_CRITICAL
         /// Helper object that executes the surrogate destructor destroy()

code/trunk/src/libraries/core/Identifier.cc

r8267	r8858
130	130	{
131	131	// If no: We have to store the information and initialize the Identifier
132		~~COUT(4) << "*** ClassIdentifier: Register Class in " << this->getName() << "-Singleton -> Initialize Singleton." << std::~~endl;
	132	orxout(verbose, context::identifier) << "Register Class in ClassIdentifier<" << this->getName() << ">-Singleton -> Initialize Singleton." << endl;
133	133	if (bRootClass)
134	134	this->initialize(0); // If a class is derived from two interfaces, the second interface might think it's derived from the first because of the order of constructor-calls. Thats why we set parents to zero in that case.
…	…
144	144	void Identifier::initialize(std::set<const Identifier> parents)
145	145	{
146		~~COUT(4) << "*** Identifier: Initialize " << this->name_ << "-Singleton." << std::~~endl;
	146	orxout(verbose, context::identifier) << "Initialize ClassIdentifier<" << this->name_ << ">-Singleton." << endl;
147	147	this->bCreatedOneObject_ = true;
148	148
…	…
191	191	void Identifier::createClassHierarchy()
192	192	{
193		~~COUT(3) << "*** Identifier: Create class-hierarchy" << std::~~endl;
	193	orxout(internal_status) << "Create class-hierarchy" << endl;
194	194	Identifier::startCreatingHierarchy();
195	195	for (std::map<std::string, Identifier*>::const_iterator it = Identifier::getStringIdentifierMap().begin(); it != Identifier::getStringIdentifierMap().end(); ++it)
…	…
203	203	}
204	204	Identifier::stopCreatingHierarchy();
205		~~COUT(3) << "*** Identifier: Finished class-hierarchy creation" << std::~~endl;
	205	orxout(internal_status) << "Finished class-hierarchy creation" << endl;
206	206	}
207	207
…	…
242	242	else
243	243	{
244		~~COUT(1) << "An error occurred in Identifier.cc:" << std::~~endl;
245		~~COUT(1) << "Error: Cannot fabricate an object of type '" << this->name_ << "'. Class has no factory." << std::~~endl;
246		~~COUT(1) << "Aborting..." << std::~~endl;
	244	orxout(user_error) << "An error occurred in Identifier.cc:" << endl;
	245	orxout(user_error) << "Cannot fabricate an object of type '" << this->name_ << "'. Class has no factory." << endl;
	246	orxout(user_error) << "Aborting..." << endl;
247	247	abort();
248	248	return 0;
…	…
404	404	if (it != this->configValues_.end())
405	405	{
406		~~COUT(2) << "Warning: Overwriting config-value with name " << varname << " in class " << this->getName() << '.' << std::~~endl;
	406	orxout(internal_warning) << "Overwriting config-value with name " << varname << " in class " << this->getName() << '.' << endl;
407	407	delete (it->second);
408	408	}
…	…
450	450	if (it != this->xmlportParamContainers_.end())
451	451	{
452		~~COUT(2) << "Warning: Overwriting XMLPortParamContainer in class " << this->getName() << '.' << std::~~endl;
	452	orxout(internal_warning) << "Overwriting XMLPortParamContainer in class " << this->getName() << '.' << endl;
453	453	delete (it->second);
454	454	}
…	…
481	481	if (it != this->xmlportObjectContainers_.end())
482	482	{
483		~~COUT(2) << "Warning: Overwriting XMLPortObjectContainer in class " << this->getName() << '.' << std::~~endl;
	483	orxout(internal_warning) << "Overwriting XMLPortObjectContainer in class " << this->getName() << '.' << endl;
484	484	delete (it->second);
485	485	}

code/trunk/src/libraries/core/Identifier.h

-                      r8706
+                      r8858
     for (Iterator<BaseObject> it = objects.begin(); it != objects.end(); ++it)  // iterate through the objects
         ++count;
     COUT(0) << count << std::endl;                                              // prints "2" because we created 2 instances of MyClass so far
+    orxout() << count << endl;                                                  // prints "2" because we created 2 instances of MyClass so far
 …
 #include <loki/TypeTraits.h>
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "MetaObjectList.h"
 #include "ObjectList.h"
 …
         if (ClassIdentifier<T>::classIdentifier_s == proposal)
+        {
             COUT(4) << "*** Identifier: Requested Identifier for " << name << " was not yet existing and got created." << std::endl;
+            orxout(verbose, context::identifier) << "Requested Identifier for " << name << " was not yet existing and got created." << endl;
+        }
         else
+        {
             COUT(4) << "*** Identifier: Requested Identifier for " << name << " was already existing and got assigned." << std::endl;
+            orxout(verbose, context::identifier) << "Requested Identifier for " << name << " was already existing and got assigned." << endl;
+        }
+    }
 …
+    {
         if (bRootClass)
             COUT(5) << "*** Register Root-Object: " << className << std::endl;
+            orxout(verbose, context::object_list) << "Register Root-Object: " << className << endl;
         else
             COUT(5) << "*** Register Object: " << className << std::endl;
+            orxout(verbose, context::object_list) << "Register Object: " << className << endl;
         object->identifier_ = this;
 …
         else
+        {
             COUT(5) << "*** ClassIdentifier: Added object to " << this->getName() << "-list." << std::endl;
+            orxout(verbose, context::object_list) << "Added object to " << this->getName() << "-list." << endl;
             object->metaList_->add(this->objects_, this->objects_->add(new ObjectListElement<T>(object)));

code/trunk/src/libraries/core/Language.cc

r7401	r8858
35	35
36	36	#include <fstream>
37		#include "util/~~Debug~~.h"
	37	#include "util/Output.h"
38	38	#include "util/StringUtils.h"
39	39	#include "Core.h"
…	…
131	131	}
132	132
133		~~COUT(2) << "Warning: Language entry " << label << " is duplicate in " << getFilename(this->defaultLanguage_) << '!' << std::~~endl;
	133	orxout(internal_warning, context::language) << "Language entry " << label << " is duplicate in " << getFilename(this->defaultLanguage_) << '!' << endl;
134	134	return it->second;
135	135	}
…	…
142	142	void Language::addEntry(const LanguageEntryLabel& label, const std::string& entry)
143	143	{
144		~~COUT(5) << "Language: Called addEntry with\n label: " << label << "\n entry: " << entry << std::~~endl;
	144	orxout(verbose, context::language) << "Called addEntry with" << '\n' << "label: " << label << '\n' << "entry: " << entry << endl;
145	145	std::map<std::string, LanguageEntry*>::const_iterator it = this->languageEntries_.find(label);
146	146	if (it == this->languageEntries_.end())
…	…
179	179	{
180	180	// Uh, oh, an undefined entry was requested: return the default string
181		~~COUT(2) << "Warning: Language entry \"" << label << "\" not found!" << std::~~endl;
	181	orxout(internal_warning, context::language) << "Language entry \"" << label << "\" not found!" << endl;
182	182	return this->defaultLocalisation_;
183	183	}
…	…
201	201	void Language::readDefaultLanguageFile()
202	202	{
203		~~COUT(4) << "Read default language file." << std::~~endl;
	203	orxout(internal_info, context::language) << "Read default language file." << endl;
204	204
205	205	const std::string& filepath = PathConfig::getConfigPathString() + getFilename(this->defaultLanguage_);
…	…
216	216	if (!file.is_open())
217	217	{
218		~~COUT(1) << "An error occurred in Language.cc:" << std::~~endl;
219		~~COUT(1) << "Error: Couldn't open file " << getFilename(this->defaultLanguage_) << " to read the default language entries!" << std::~~endl;
	218	orxout(internal_error, context::language) << "An error occurred in Language.cc:" << endl;
	219	orxout(internal_error, context::language) << "Couldn't open file " << getFilename(this->defaultLanguage_) << " to read the default language entries!" << endl;
220	220	return;
221	221	}
…	…
237	237	else
238	238	{
239		~~COUT(2) << "Warning: Invalid language entry \"" << lineString << "\" in " << getFilename(this->defaultLanguage_) << std::~~endl;
	239	orxout(internal_warning, context::language) << "Invalid language entry \"" << lineString << "\" in " << getFilename(this->defaultLanguage_) << endl;
240	240	}
241	241	}
…	…
250	250	void Language::readTranslatedLanguageFile()
251	251	{
252		~~COUT(4) << "Read translated language file (" << Core::getInstance().getLanguage() << ")." << std::~~endl;
	252	orxout(internal_info, context::language) << "Read translated language file (" << Core::getInstance().getLanguage() << ")." << endl;
253	253
254	254	const std::string& filepath = PathConfig::getConfigPathString() + getFilename(Core::getInstance().getLanguage());
…	…
260	260	if (!file.is_open())
261	261	{
262		~~COUT(1) << "An error occurred in Language.cc:" << std::~~endl;
263		~~COUT(1) << "Error: Couldn't open file " << getFilename(Core::getInstance().getLanguage()) << " to read the translated language entries!" << std::~~endl;
	262	orxout(internal_error, context::language) << "An error occurred in Language.cc:" << endl;
	263	orxout(internal_error, context::language) << "Couldn't open file " << getFilename(Core::getInstance().getLanguage()) << " to read the translated language entries!" << endl;
264	264	Core::getInstance().resetLanguage();
265		~~COUT(3) << "Info: Reset language to " << this->defaultLanguage_ << '.' << std::~~endl;
	265	orxout(internal_info, context::language) << "Reset language to " << this->defaultLanguage_ << '.' << endl;
266	266	return;
267	267	}
…	…
291	291	else
292	292	{
293		~~COUT(2) << "Warning: Invalid language entry \"" << lineString << "\" in " << getFilename(Core::getInstance().getLanguage()) << std::~~endl;
	293	orxout(internal_warning, context::language) << "Invalid language entry \"" << lineString << "\" in " << getFilename(Core::getInstance().getLanguage()) << endl;
294	294	}
295	295	}
…	…
304	304	void Language::writeDefaultLanguageFile() const
305	305	{
306		~~COUT(4) << "Language: Write default language file." << std::~~endl;
	306	orxout(verbose, context::language) << "Write default language file." << endl;
307	307
308	308	const std::string& filepath = PathConfig::getConfigPathString() + getFilename(this->defaultLanguage_);
…	…
314	314	if (!file.is_open())
315	315	{
316		~~COUT(1) << "An error occurred in Language.cc:" << std::~~endl;
317		~~COUT(1) << "Error: Couldn't open file " << getFilename(this->defaultLanguage_) << " to write the default language entries!" << std::~~endl;
	316	orxout(internal_error, context::language) << "An error occurred in Language.cc:" << endl;
	317	orxout(internal_error, context::language) << "Couldn't open file " << getFilename(this->defaultLanguage_) << " to write the default language entries!" << endl;
318	318	return;
319	319	}
…	…
322	322	for (std::map<std::string, LanguageEntry*>::const_iterator it = this->languageEntries_.begin(); it != this->languageEntries_.end(); ++it)
323	323	{
324		file << it->second->getLabel() << '=' << it->second->getDefault() << ~~std::~~endl;
	324	file << it->second->getLabel() << '=' << it->second->getDefault() << endl;
325	325	}
326	326

code/trunk/src/libraries/core/Language.h

-                      r7401
+                      r8858
      - Get the localisation of the entry in the configured language:
        @code
        std::cout << Language::getInstance()->getLocalisation("name of the entry") << std::endl;
+       orxout() << Language::getInstance()->getLocalisation("name of the entry") << endl;
        @endcode
 …
     int age = 20;
     AddLanguageEntry("user_age", "Age");
     std::cout << GetLocalisation("user_age") << ": " << age << std::endl;
+    orxout() << GetLocalisation("user_age") << ": " << age << endl;
     @endcode

code/trunk/src/libraries/core/Loader.cc

-                      r8108
+                      r8858
 #include <boost/scoped_ptr.hpp>
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/Exception.h"
 #include "util/StringUtils.h"
 …
     ClassTreeMask Loader::currentMask_s;
     bool Loader::open(const XMLFile* file, const ClassTreeMask& mask)
+    bool Loader::open(const XMLFile* file, const ClassTreeMask& mask, bool bVerbose)
+    {
         Loader::add(file, mask);
         return Loader::load(file, mask);
+        return Loader::load(file, mask, bVerbose);
+    }
 …
     @param mask
         A ClassTreeMask, which defines which types of classes are loaded and which aren't.
     @param verbose
+    @param bVerbose
         Whether the loader is verbose (prints its progress in a low output level) or not.
     @return
         Returns true if successful.
     */
     bool Loader::load(const ClassTreeMask& mask, bool verbose)
+    bool Loader::load(const ClassTreeMask& mask, bool bVerbose)
+    {
         bool success = true;
         for (std::vector<std::pair<const XMLFile*, ClassTreeMask> >::iterator it = Loader::files_s.begin(); it != Loader::files_s.end(); ++it)
             if (!Loader::load(it->first, it->second * mask, verbose))
+            if (!Loader::load(it->first, it->second * mask, bVerbose))
                 success = false;
 …
     @param mask
         A ClassTreeMask, which defines which types of classes are reloaded and which aren't.
     @param verbose
+    @param bVerbose
         Whether the loader is verbose (prints its progress in a low output level) or not.
     @return
         Returns true if successful.
     */
     bool Loader::reload(const ClassTreeMask& mask, bool verbose)
+    bool Loader::reload(const ClassTreeMask& mask, bool bVerbose)
+    {
         Loader::unload(mask);
         return Loader::load(mask, verbose);
+        return Loader::load(mask, bVerbose);
+    }
 …
     @param mask
         A ClassTreeMask, which defines which types of classes are loaded and which aren't.
     @param verbose
+    @param bVerbose
         Whether the loader is verbose (prints its progress in a low output level) or not.
     @param bRemoveLuaTags
 …
         Returns true if successful.
     */
     bool Loader::load(const XMLFile* file, const ClassTreeMask& mask, bool verbose, bool bRemoveLuaTags)
+    bool Loader::load(const XMLFile* file, const ClassTreeMask& mask, bool bVerbose, bool bRemoveLuaTags)
+    {
         if (!file)
 …
             if (info == NULL)
+            {
                 COUT(1) << "Error: Could not find XML file '" << file->getFilename() << "'." << std::endl;
+                orxout(user_error, context::loader) << "Could not find XML file '" << file->getFilename() << "'." << endl;
                 return false;
+            }
 …
         try
+        {
             if(verbose)
+            {
                 COUT(0) << "Start loading " << file->getFilename() << "..." << std::endl;
                 COUT(3) << "Mask: " << Loader::currentMask_s << std::endl;
+            }
             else
+            {
                 COUT(4) << "Start loading " << file->getFilename() << "..." << std::endl;
                 COUT(4) << "Mask: " << Loader::currentMask_s << std::endl;
+            if(bVerbose)
+            {
+                orxout(user_info) << "Start loading " << file->getFilename() << "..." << endl;
+                orxout(internal_info, context::loader) << "Mask: " << Loader::currentMask_s << endl;
+            }
+            else
+            {
+                orxout(verbose, context::loader) << "Start loading " << file->getFilename() << "..." << endl;
+                orxout(verbose_more, context::loader) << "Mask: " << Loader::currentMask_s << endl;
+            }
 …
                 rootElement.InsertEndChild(*child);
             COUT(4) << "  creating root-namespace..." << std::endl;
+            orxout(verbose, context::loader) << "  creating root-namespace..." << endl;
             Namespace* rootNamespace = new Namespace(0);
             rootNamespace->setLoaderIndentation("    ");
 …
             rootNamespace->XMLPort(rootElement, XMLPort::LoadObject);
             if(verbose)
                 COUT(0) << "Finished loading " << file->getFilename() << '.' << std::endl;
             else
                 COUT(4) << "Finished loading " << file->getFilename() << '.' << std::endl;
             COUT(4) << "Namespace-tree:" << std::endl << rootNamespace->toString("  ") << std::endl;
+            if(bVerbose)
+                orxout(user_info) << "Finished loading " << file->getFilename() << '.' << endl;
+            else
+                orxout(verbose, context::loader) << "Finished loading " << file->getFilename() << '.' << endl;
+            orxout(verbose, context::loader) << "Namespace-tree:" << '\n' << rootNamespace->toString("  ") << endl;
             return true;
 …
         catch (ticpp::Exception& ex)
+        {
             COUT(1) << std::endl;
             COUT(1) << "An XML-error occurred in Loader.cc while loading " << file->getFilename() << ':' << std::endl;
             COUT(1) << ex.what() << std::endl;
             COUT(1) << "Loading aborted." << std::endl;
+            orxout(user_error, context::loader) << endl;
+            orxout(user_error, context::loader) << "An XML-error occurred in Loader.cc while loading " << file->getFilename() << ':' << endl;
+            orxout(user_error, context::loader) << ex.what() << endl;
+            orxout(user_error, context::loader) << "Loading aborted." << endl;
             return false;
+        }
         catch (Exception& ex)
+        {
             COUT(1) << std::endl;
             COUT(1) << "A loading-error occurred in Loader.cc while loading " << file->getFilename() << ':' << std::endl;
             COUT(1) << ex.what() << std::endl;
             COUT(1) << "Loading aborted." << std::endl;
+            orxout(user_error, context::loader) << endl;
+            orxout(user_error, context::loader) << "A loading-error occurred in Loader.cc while loading " << file->getFilename() << ':' << endl;
+            orxout(user_error, context::loader) << ex.what() << endl;
+            orxout(user_error, context::loader) << "Loading aborted." << endl;
             return false;
+        }
         catch (...)
+        {
             COUT(1) << std::endl;
             COUT(1) << "An error occurred in Loader.cc while loading " << file->getFilename() << ':' << std::endl;
             COUT(1) << Exception::handleMessage() << std::endl;
             COUT(1) << "Loading aborted." << std::endl;
+            orxout(user_error, context::loader) << endl;
+            orxout(user_error, context::loader) << "An error occurred in Loader.cc while loading " << file->getFilename() << ':' << endl;
+            orxout(user_error, context::loader) << Exception::handleMessage() << endl;
+            orxout(user_error, context::loader) << "Loading aborted." << endl;
             return false;
+        }
 …
     @param mask
         A ClassTreeMask, which defines which types of classes are reloaded and which aren't.
     @param verbose
+    @param bVerbose
         Whether the loader is verbose (prints its progress in a low output level) or not.
     @return
         Returns true if successful.
     */
     bool Loader::reload(const XMLFile* file, const ClassTreeMask& mask, bool verbose)
+    bool Loader::reload(const XMLFile* file, const ClassTreeMask& mask, bool bVerbose)
+    {
         Loader::unload(file, mask);
         return Loader::load(file, mask, verbose);
+        return Loader::load(file, mask, bVerbose);
+    }
 …
             if (!expectedValue)
+            {
                 COUT(2) << "Warning: Error in level file" << std::endl;
+                orxout(internal_error, context::loader) << "Error in level file" << endl;
                 // TODO: error handling
                 return false;
+                return false;
+            }
+        }

code/trunk/src/libraries/core/Loader.h

-                      r8079
+                      r8858
+    {
         public:
             static bool open(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask());
+            static bool open(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask(), bool bVerbose = true);
             static void close();
             static void close(const XMLFile* file);
 …
             static void remove(const XMLFile* file);
             static bool load(const ClassTreeMask& mask = ClassTreeMask(), bool verbose = true);
+            static bool load(const ClassTreeMask& mask = ClassTreeMask(), bool bVerbose = true);
             static void unload(const ClassTreeMask& mask = ClassTreeMask());
             static bool reload(const ClassTreeMask& mask = ClassTreeMask(), bool verbose = true);
+            static bool reload(const ClassTreeMask& mask = ClassTreeMask(), bool bVerbose = true);
             static bool load(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask(),
                              bool verbose = true, bool bRemoveLuaTags = false);
+                             bool bVerbose = true, bool bRemoveLuaTags = false);
             static void unload(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask());
             static bool reload(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask(), bool verbose = true);
+            static bool reload(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask(), bool bVerbose = true);
             static std::string replaceLuaTags(const std::string& text);

code/trunk/src/libraries/core/LuaState.cc

-                      r8729
+                      r8858
 #include <loki/ScopeGuard.h>
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/Exception.h"
 #include "Resource.h"
 …
         else
+        {
             COUT(2) << "LuaState: Cannot include file '" << filename << "' (not found)." << std::endl;
+            orxout(internal_warning, context::lua) << "LuaState: Cannot include file '" << filename << "' (not found)." << endl;
             return false;
+        }
 …
         else
+        {
             COUT(2) << "LuaState: Cannot do file '" << filename << "' (not found)." << std::endl;
+            orxout(internal_warning, context::lua) << "LuaState: Cannot do file '" << filename << "' (not found)." << endl;
             return false;
+        }
 …
+        {
         case LUA_ERRSYNTAX: // Syntax error
             COUT(1) << "Lua syntax error: " << lua_tostring(luaState_, -1) << std::endl;
+            orxout(internal_error, context::lua) << "Lua syntax error: " << lua_tostring(luaState_, -1) << endl;
             break;
         case LUA_ERRMEM:    // Memory allocation error
             COUT(1) << "Lua memory allocation error: Consult your dentist immediately!" << std::endl;
+            orxout(internal_error, context::lua) << "Lua memory allocation error: Consult your dentist immediately!" << endl;
             break;
+        }
 …
                     std::string errorString = lua_tostring(this->luaState_, -1);
                     if (errorString.find("Error propagation") == std::string::npos)
                         COUT(1) << "Lua runtime error: " << errorString << std::endl;
+                        orxout(internal_error, context::lua) << "Lua runtime error: " << errorString << endl;
+                }
                 break;
             case LUA_ERRERR: // Error in the error handler
                 COUT(1) << "Lua error in error handler. No message available." << std::endl;
+                orxout(internal_error, context::lua) << "Lua error in error handler. No message available." << endl;
                 break;
             case LUA_ERRMEM: // Memory allocation error
                 COUT(1) << "Lua memory allocation error: Consult your dentist immediately!" << std::endl;
+                orxout(internal_error, context::lua) << "Lua memory allocation error: Consult your dentist immediately!" << endl;
                 break;
+            }
 …
+    }
+    void LuaState::luaLog(unsigned int level, const std::string& message)
+    {
+        OutputHandler::getOutStream(level) << message << std::endl;
+    void LuaState::luaOutput(OutputLevel level, const std::string& context, const std::string& message)
+    {
+        orxout(level, registerContext(context)) << message << endl;
+    }
+    void LuaState::luaOutput(OutputLevel level, const std::string& message)
+    {
+        orxout(level, context::lua) << message << endl;
+    }
+    void LuaState::luaOutput(const std::string& message)
+    {
+        orxout(debug_output, context::lua) << message << endl;
+    }
 …
             if (it->first == name || it->second == function)
+            {
                 COUT(2) << "Warning: Trying to add a Tolua interface with the same name or function." << std::endl;
+                orxout(internal_warning, context::lua) << "Trying to add a Tolua interface with the same name or function." << endl;
                 return true;
+            }
 …
         if (it == getToluaInterfaces().end())
+        {
             COUT(2) << "Warning: Cannot remove Tolua interface '" << name << "': Not found" << std::endl;
+            orxout(internal_warning, context::lua) << "Cannot remove Tolua interface '" << name << "': Not found" << endl;
             return true;
+        }

code/trunk/src/libraries/core/LuaState.h

-                      r8729
+                      r8858
 #include <boost/shared_ptr.hpp>
+#include "util/Output.h"
 namespace orxonox // tolua_export
 { // tolua_export
 …
         void luaPrint(const std::string& str); // tolua_export
+        void luaLog(unsigned int level, const std::string& message); // tolua_export
+        void luaOutput(orxonox::level::OutputLevel level, const std::string& context, const std::string& message); // tolua_export
+        void luaOutput(orxonox::level::OutputLevel level, const std::string& message); // tolua_export
+        void luaOutput(const std::string& message); // tolua_export
         bool fileExists(const std::string& filename); // tolua_export
         std::string getSourceCode(const std::string& filename); // tolua_export

code/trunk/src/libraries/core/MetaObjectList.cc

-                      r5738
+                      r8858
 #include "MetaObjectList.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "Identifier.h"
 #include "ObjectListBase.h"
 …
     MetaObjectListElement::~MetaObjectListElement()
+    {
         COUT(5) << "*** MetaObjectList: Removing Object from " << this->list_->getIdentifier()->getName() << "-list." << std::endl;
+        orxout(verbose, context::object_list) << "Removing Object from " << this->list_->getIdentifier()->getName() << "-list." << endl;
         this->list_->notifyIterators(this->element_->objectBase_);

code/trunk/src/libraries/core/NamespaceNode.cc

r6417	r8858
28	28
29	29	#include "NamespaceNode.h"
30		#include "util/~~Debug~~.h"
	30	#include "util/Output.h"
31	31
32	32	namespace orxonox
…	…
70	70	if (this->bRoot_)
71	71	{
72		~~COUT(2) << "Warning: Can't go to enclosing namespace with '..' operator in namespace " << this->name_ << ", namespace is root." << std::~~endl;
	72	orxout(internal_warning) << "Can't go to enclosing namespace with '..' operator in namespace " << this->name_ << ", namespace is root." << endl;
73	73	nodes = this->getNodeRelative(secondPart);
74	74	}
75	75	else if (!this->parent_)
76	76	{
77		~~COUT(2) << "Warning: Can't go to enclosing namespace with '..' operator in namespace " << this->name_ << ", no parent namespace set." << std::~~endl;
	77	orxout(internal_warning) << "Can't go to enclosing namespace with '..' operator in namespace " << this->name_ << ", no parent namespace set." << endl;
78	78	nodes = this->getNodeRelative(secondPart);
79	79	}
…	…
91	91	if (it->second->isHidden())
92	92	{
93		~~COUT(2) << "Warning: Subnamespace '" << firstPart << "' in namespace '" << this->name_ << "' is hidden and can't be accessed." << std::~~endl;
	93	orxout(internal_warning) << "Subnamespace '" << firstPart << "' in namespace '" << this->name_ << "' is hidden and can't be accessed." << endl;
94	94	nodes.insert(this);
95	95	}
…	…
115	115	if (!bFoundMatchingNamespace)
116	116	{
117		~~COUT(2) << "Warning: No file included with name '" << firstPart.substr(1, std::string::npos) << "' at this part of the level file, using parent namespace instead." << std::~~endl;
	117	orxout(internal_warning) << "No file included with name '" << firstPart.substr(1, std::string::npos) << "' at this part of the level file, using parent namespace instead." << endl;
118	118	nodes = this->getNodeRelative(secondPart);
119	119	}

code/trunk/src/libraries/core/OrxonoxClass.cc

r7849	r8858
60	60	{
61	61	// if (!this->requestedDestruction_)
62		// ~~COUT(2) << "Warning: Destroyed object without destroy() (" << this->getIdentifier()->getName() << ')' << std::~~endl;
	62	// orxout(internal_warning) << "Destroyed object without destroy() (" << this->getIdentifier()->getName() << ')' << endl;
63	63
64	64	assert(this->referenceCount_ <= 0);

code/trunk/src/libraries/core/OrxonoxClass.h

-                      r8729
+                      r8858
 #include <vector>
 #include "Super.h"
-/**
-@def CCOUT
-    Acts almost exactly like COUT(x), but prepends "ClassName: "
-*/
-#define CCOUT(level) \
-    COUT(level) << this->getIdentifier()->getName() << ": "
 namespace orxonox

code/trunk/src/libraries/core/PathConfig.cc

-                      r8729
+                      r8858
 #include "SpecialConfig.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/Exception.h"
 #include "CommandLineParser.h"
 …
         if (bf::exists(executablePath_ / "orxonox_dev_build.keep_me"))
+        {
             COUT(1) << "Running from the build tree." << std::endl;
+            orxout(internal_info) << "Running from the build tree." << endl;
             PathConfig::bBuildDirectoryRun_ = true;
             modulePath_ = specialConfig::moduleDevDirectory;
 …
             if (bf::create_directories(it->first)) // function may not return true at all (bug?)
+            {
                 COUT(4) << "Created " << it->second << " directory" << std::endl;
+                orxout(internal_info) << "Created " << it->second << " directory" << endl;
+            }
+        }

code/trunk/src/libraries/core/SubclassIdentifier.h

-                      r7401
+                      r8858
 #include <cstdlib>
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "Identifier.h"
 …
                 if (!identifier || !identifier->isA(ClassIdentifier<T>::getIdentifier()))
+                {
                     COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
+                    orxout(internal_error) << "An error occurred in SubclassIdentifier (Identifier.h):" << endl;
                     if (identifier)
+                    {
                         COUT(1) << "Error: Class " << identifier->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << '!' << std::endl;
                         COUT(1) << "Error: SubclassIdentifier<" << ClassIdentifier<T>::getIdentifier()->getName() << "> = Class(" << identifier->getName() << ") is forbidden." << std::endl;
+                        orxout(internal_error) << "Class " << identifier->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << '!' << endl;
+                        orxout(internal_error) << "SubclassIdentifier<" << ClassIdentifier<T>::getIdentifier()->getName() << "> = Class(" << identifier->getName() << ") is forbidden." << endl;
+                    }
                     else
+                    {
                         COUT(1) << "Error: Can't assign NULL identifier" << std::endl;
+                        orxout(internal_error) << "Can't assign NULL identifier" << endl;
+                    }
+                }
 …
                     if (this->identifier_)
+                    {
                         COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
                         COUT(1) << "Error: Class " << this->identifier_->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << '!' << std::endl;
                         COUT(1) << "Error: Couldn't fabricate a new Object." << std::endl;
+                        orxout(user_error) << "An error occurred in SubclassIdentifier (Identifier.h):" << endl;
+                        orxout(user_error) << "Class " << this->identifier_->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << '!' << endl;
+                        orxout(user_error) << "Couldn't fabricate a new Object." << endl;
+                    }
                     else
+                    {
                         COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
                         COUT(1) << "Error: Couldn't fabricate a new Object - Identifier is undefined." << std::endl;
+                    }
                     COUT(1) << "Aborting..." << std::endl;
+                        orxout(user_error) << "An error occurred in SubclassIdentifier (Identifier.h):" << endl;
+                        orxout(user_error) << "Couldn't fabricate a new Object - Identifier is undefined." << endl;
+                    }
+                    orxout(user_error) << "Aborting..." << endl;
                     abort();
                     return 0;

code/trunk/src/libraries/core/Super.h

-                      r8729
+                      r8858
 #include "CorePrereqs.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 ///////////////////////
 …
                     if (!((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_) \
                     { \
                         COUT(5) << "Added SuperFunctionCaller for " << #functionname << ": " << ClassIdentifier<T>::getIdentifier()->getName() << " <- " << ((ClassIdentifier<T>*)(*it))->getName() << std::endl; \
+                        orxout(verbose, context::super) << "Added SuperFunctionCaller for " << #functionname << ": " << ClassIdentifier<T>::getIdentifier()->getName() << " <- " << ((ClassIdentifier<T>*)(*it))->getName() << endl; \
                         ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_ = new SuperFunctionClassCaller_##functionname <T>; \
                     } \
 …
+                    {
                         // Add the SuperFunctionCaller
                         COUT(5) << "adding functionpointer to " << ((ClassIdentifier<T>*)(*it))->getName() << std::endl;
+                        orxout(verbose, context::super) << "adding functionpointer to " << ((ClassIdentifier<T>*)(*it))->getName() << endl;
                         ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_ = new SuperFunctionClassCaller_##functionname <T>;
+                    }

code/trunk/src/libraries/core/Template.cc

r7163	r8858
32	32	#include <tinyxml/ticpp.h>
33	33
34		#include "util/~~Debug~~.h"
	34	#include "util/Output.h"
35	35	#include "CoreIncludes.h"
36	36	#include "XMLPort.h"
…	…
88	88	it = Template::getTemplateMap().find(this->getName());
89	89	if (it != Template::getTemplateMap().end())
90		~~COUT(2) << "Warning: Template with name \"" << this->getName() << "\" already exists." << std::~~endl;
	90	orxout(internal_warning, context::templates) << "Template with name \"" << this->getName() << "\" already exists." << endl;
91	91	else
92	92	Template::getTemplateMap()[this->getName()] = this;
…	…
117	117	else
118	118	{
119		~~COUT(2) << "Warning: Linking from " << this->getName() << " to " << this->link_ << " leads to an infinite loop. Returning own element." << std::~~endl;
	119	orxout(internal_warning, context::templates) << "Linking from \"" << this->getName() << "\" to \"" << this->link_ << "\" leads to an infinite loop. Returning own element." << endl;
120	120	}
121	121	}
122	122	else
123	123	{
124		~~COUT(2) << "Warning: " << this->link_ << " is not an existing Template name. Returning own element." << std::~~endl;
	124	orxout(internal_warning, context::templates) << '"' << this->link_ << "\" is not an existing Template name. Returning own element." << endl;
125	125	}
126	126	}
…	…
142	142	if (!object->isA(this->baseclassIdentifier_))
143	143	{
144		COUT(1) << "Error: Can't apply template (name: " << this->getName() << "), object (name: " << object->getName() << ", class: " << object->getIdentifier()->getName() << ") is not a " << this->baseclassIdentifier_->getName() << std::endl;
	144	orxout(internal_error, context::templates) << "Can't apply template (name: " << this->getName() << "), object (name: " << object->getName() << ", class: " << object->getIdentifier()->getName() << ") is not a " << this->baseclassIdentifier_->getName() << endl;
145	145	return;
146	146	}
147	147	}
148	148
149		~~COUT(4) << object->getLoaderIndentation() << " aplying Template \"" << this->getName() << "\"..." << std::~~endl;
	149	orxout(verbose, context::templates) << object->getLoaderIndentation() << " aplying Template \"" << this->getName() << "\"..." << endl;
150	150
151	151	Element temp = &const_cast<TiXmlElement&>(this->getXMLElement());
…	…
170	170	else
171	171	{
172		~~COUT(2) << "Warning: Template with name " << name << " doesn't exist." << std::~~endl;
	172	orxout(internal_warning, context::templates) << "Template with name " << name << " doesn't exist." << endl;
173	173	return 0;
174	174	}

code/trunk/src/libraries/core/WeakPtr.h

r8079	r8858
65	65	void myCallback() // definition of the callback function
66	66	{
67		~~COUT(0) << "Object destroyed" << std::~~endl;
	67	orxout() << "Object destroyed" << endl;
68	68	}
69	69

code/trunk/src/libraries/core/XMLPort.cc

r7163	r8858
64	64	if (!this->sectionname_.empty())
65	65	{
66		~~COUT(2) << object->getLoaderIndentation() << "Warning: '" << child->Value() << "' is not a valid classname." << std::~~endl;
	66	orxout(internal_warning, context::xml) << object->getLoaderIndentation() << "'" << child->Value() << "' is not a valid classname." << endl;
67	67	}
68	68	else
…	…
74	74	if (!identifier->isA(objectIdentifier_))
75	75	{
76		~~COUT(2) << object->getLoaderIndentation() << "Warning: '" << child->Value() << "' is not a '" << objectIdentifier_->getName() << "'." << std::~~endl;
	76	orxout(internal_warning, context::xml) << object->getLoaderIndentation() << "'" << child->Value() << "' is not a '" << objectIdentifier_->getName() << "'." << endl;
77	77	continue;
78	78	}
79	79	if (!identifier->isLoadable())
80	80	{
81		~~COUT(2) << object->getLoaderIndentation() << "Warning: '" << child->Value() << "' is not loadable." << std::~~endl;
	81	orxout(internal_warning, context::xml) << object->getLoaderIndentation() << "'" << child->Value() << "' is not loadable." << endl;
82	82	continue;
83	83	}
…	…
87	87	try
88	88	{
89		~~COUT(4) << object->getLoaderIndentation() << "fabricating " << child->Value() << "..." << std::~~endl;
	89	orxout(verbose, context::xml) << object->getLoaderIndentation() << "fabricating " << child->Value() << "..." << endl;
90	90
91	91	BaseObject* newObject = identifier->fabricate(object);
…	…
95	95	{
96	96	newObject->XMLPort(*child, XMLPort::LoadObject);
97		COUT(4) << object->getLoaderIndentation() << "assigning " << child->Value() << " (objectname " << newObject->getName() << ") to " << this->identifier_->getName() << " (objectname " << static_cast<BaseObject*>(object)->getName() << ')' << std::endl;
	97	orxout(verbose, context::xml) << object->getLoaderIndentation() << "assigning " << child->Value() << " (objectname " << newObject->getName() << ") to " << this->identifier_->getName() << " (objectname " << static_cast<BaseObject*>(object)->getName() << ')' << endl;
98	98	}
99	99	else
100	100	{
101		COUT(4) << object->getLoaderIndentation() << "assigning " << child->Value() << " (object not yet loaded) to " << this->identifier_->getName() << " (objectname " << static_cast<BaseObject*>(object)->getName() << ')' << std::endl;
	101	orxout(verbose, context::xml) << object->getLoaderIndentation() << "assigning " << child->Value() << " (object not yet loaded) to " << this->identifier_->getName() << " (objectname " << static_cast<BaseObject*>(object)->getName() << ')' << endl;
102	102	}
103
104		~~COUT(5) << object->getLoaderIndentation();~~
105	103
106	104	this->callLoadExecutor(object, newObject);
…	…
109	107	newObject->XMLPort(*child, XMLPort::LoadObject);
110	108
111		~~COUT(5) << object->getLoaderIndentation() << "...fabricated " << child->Value() << " (objectname " << newObject->getName() << ")." << std::~~endl;
	109	orxout(verbose, context::xml) << object->getLoaderIndentation() << "fabricated " << child->Value() << " (objectname " << newObject->getName() << ")." << endl;
112	110	}
113	111	catch (AbortLoadingException& ex)
114	112	{
115		~~COUT(1) << "An error occurred while loading object, abort loading..." << std::~~endl;
	113	orxout(internal_error, context::xml) << "An error occurred while loading object, abort loading..." << endl;
116	114	throw ex;
117	115	}
118	116	catch (...)
119	117	{
120		~~COUT(1) << "An error occurred while loading object:" << std::~~endl;
121		~~COUT(1) << Exception::handleMessage() << std::~~endl;
	118	orxout(internal_error, context::xml) << "An error occurred while loading object:" << endl;
	119	orxout(internal_error, context::xml) << Exception::handleMessage() << endl;
122	120	}
123	121	}
…	…
125	123	catch (ticpp::Exception& ex)
126	124	{
127		~~COUT(1) << std::~~endl;
128		COUT(1) << "An error occurred in XMLPort.h while loading a '" << objectIdentifier_->getName() << "' in '" << this->sectionname_ << "' of '" << this->identifier_->getName() << "' (objectname: " << object->getName() << ") in " << object->getFilename() << ':' << std::endl;
129		~~COUT(1) << ex.what() << std::~~endl;
	125	orxout(internal_error, context::xml) << endl;
	126	orxout(internal_error, context::xml) << "An error occurred in XMLPort.h while loading a '" << objectIdentifier_->getName() << "' in '" << this->sectionname_ << "' of '" << this->identifier_->getName() << "' (objectname: " << object->getName() << ") in " << object->getFilename() << ':' << endl;
	127	orxout(internal_error, context::xml) << ex.what() << endl;
130	128	}
131	129	}

code/trunk/src/libraries/core/XMLPort.h

-                      r7851
+                      r8858
 #include <tinyxml/ticpp.h>
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/Exception.h"
 #include "util/MultiType.h"
 …
                         if ((!attributeValue.empty()) || ((mode != XMLPort::ExpandObject) && this->loadexecutor_->allDefaultValuesSet()))
+                        {
                             COUT(5) << this->owner_->getLoaderIndentation() << "Loading parameter " << this->paramname_ << " in " << this->identifier_->getName() << " (objectname " << this->owner_->getName() << ")." << std::endl << this->owner_->getLoaderIndentation();
+                            orxout(verbose_more, context::xml) << this->owner_->getLoaderIndentation() << "Loading parameter " << this->paramname_ << " in " << this->identifier_->getName() << " (objectname " << this->owner_->getName() << ")." << endl;
                             int error;
                             this->loadexecutor_->parse(object, attributeValue, &error, ",");
 …
                     catch (ticpp::Exception& ex)
+                    {
                         COUT(1) << std::endl;
                         COUT(1) << "An error occurred in XMLPort.h while loading attribute '" << this->paramname_ << "' of '" << this->identifier_->getName() << "' (objectname: " << this->owner_->getName() << ") in " << this->owner_->getFilename() << ':' << std::endl;
                         COUT(1) << ex.what() << std::endl;
+                        orxout(internal_error, context::xml) << endl;
+                        orxout(internal_error, context::xml) << "An error occurred in XMLPort.h while loading attribute '" << this->paramname_ << "' of '" << this->identifier_->getName() << "' (objectname: " << this->owner_->getName() << ") in " << this->owner_->getFilename() << ':' << endl;
+                        orxout(internal_error, context::xml) << ex.what() << endl;
+                    }
+                }

code/trunk/src/libraries/core/command/ArgumentCompletionFunctions.cc

-                      r8351
+                      r8858
             ArgumentCompletionList _groupsandcommands(const std::string& fragment, bool bOnlyShowHidden)
+            {
                 // note: this function returns only arguments that begin with "fragment", which would't be necessary for the
+                // note: this function returns only arguments that begin with "fragment", which wouldn't be necessary for the
                 //       auto-completion, but it's necessary to place the line-break "\n" between groups and commands
                 //       only if both groups AND commands are in the list.
 …
                 const std::map<std::string, std::map<std::string, ConsoleCommand*> >& commands = ConsoleCommand::getCommands();
                 for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = commands.begin(); it_group != commands.end(); ++it_group)
                     if (groupIsVisible(it_group->second, bOnlyShowHidden) && it_group->first != "" && (fragmentLC == "" || getLowercase(it_group->first).find_first_of(fragmentLC) == 0))
+                    if (groupIsVisible(it_group->second, bOnlyShowHidden) && it_group->first != "" && (fragmentLC == "" || getLowercase(it_group->first).find(fragmentLC) == 0))
                         groupList.push_back(ArgumentCompletionListElement(it_group->first, getLowercase(it_group->first)));
 …
                     // add the shortcuts
                     for (std::map<std::string, ConsoleCommand*>::const_iterator it_command = it_group->second.begin(); it_command != it_group->second.end(); ++it_command)
                         if (it_command->second->isActive() && it_command->second->hasAccess() && (!it_command->second->isHidden())^bOnlyShowHidden && (fragmentLC == "" || getLowercase(it_command->first).find_first_of(fragmentLC) == 0))
+                        if (it_command->second->isActive() && it_command->second->hasAccess() && (!it_command->second->isHidden())^bOnlyShowHidden && (fragmentLC == "" || getLowercase(it_command->first).find(fragmentLC) == 0))
                             groupList.push_back(ArgumentCompletionListElement(it_command->first, getLowercase(it_command->first)));
+                }

code/trunk/src/libraries/core/command/CommandEvaluation.cc

-                      r7401
+                      r8858
             if (!this->execCommand_)
                 *error = CommandExecutor::Error;
+                *error = CommandExecutor::Inexistent;
             else if (!this->execCommand_->isActive())
                 *error = CommandExecutor::Deactivated;
 …
             if (this->bEvaluatedArguments_)
+            {
                 COUT(6) << "CE_execute (evaluation): " << this->execCommand_->getName() << " with " << this->numberOfEvaluatedArguments_ << " arguments: " << this->arguments_[0] << ' ' << this->arguments_[1] << ' ' << this->arguments_[2] << ' ' << this->arguments_[3] << ' ' << this->arguments_[4] << std::endl;
+                orxout(verbose, context::commands) << "CE_execute (evaluation): " << this->execCommand_->getName() << " with " << this->numberOfEvaluatedArguments_ << " arguments: " << this->arguments_[0] << ' ' << this->arguments_[1] << ' ' << this->arguments_[2] << ' ' << this->arguments_[3] << ' ' << this->arguments_[4] << endl;
                 // pass as many arguments to the executor as were evaluated (thus the executor can still use additional default values)
 …
+        {
             if (bPrintError)
                 COUT(1) << "Error: Can't evaluate arguments, no console command assigned." << std::endl;
             return CommandExecutor::Error;
+                orxout(internal_error, context::commands) << "Can't evaluate arguments, no console command assigned." << endl;
+            return CommandExecutor::Inexistent;
+        }
 …
             this->bEvaluatedArguments_ = true;
         else if (bPrintError)
             COUT(1) << "Error: Can't evaluate arguments, not enough arguments given." << std::endl;
+            orxout(internal_error, context::commands) << "Can't evaluate arguments, not enough arguments given." << endl;
         return error;

code/trunk/src/libraries/core/command/CommandExecutor.cc

-                      r7401
+                      r8858
         @return Returns the error-code (see @ref CommandExecutorErrorCodes "error codes")
     */
     /* static */ int CommandExecutor::execute(const std::string& command, bool useTcl)
+    /* static */ int CommandExecutor::execute(const std::string& command, bool useTcl, bool printErrors)
+    {
         int error;
         CommandExecutor::queryMT(command, &error, useTcl);
+        if (error && printErrors)
+            orxout(user_error) << "Can't execute \"" << command << "\", " << CommandExecutor::getErrorDescription(error) << ". (execute)" << endl;
         return error;
+    }
 …
     /* static */ MultiType CommandExecutor::queryMT(const std::string& command, int* error, bool useTcl)
+    {
+        MultiType result;
+        int error_internal;
         if (useTcl)
+        {
             // pass the command to tcl
             return TclBind::eval(command, error);
+            result = TclBind::eval(command, &error_internal);
+        }
         else
 …
             // query the command and return its return-value
+            return evaluation.query(error);
+        }
+            result = evaluation.query(&error_internal);
+        }
+        if (error)
+            *error = error_internal;
+        else if (error_internal)
+            orxout(user_error) << "Can't execute \"" << command << "\", " << CommandExecutor::getErrorDescription(error_internal) << ". (query)" << endl;
+        return result;
+    }
 …
     /**
+        @brief Returns a description of the error code.
+        @param error The error code
+    */
+    /* static */ std::string CommandExecutor::getErrorDescription(int error)
+    {
+        switch (error)
+        {
+            case CommandExecutor::Inexistent:  return "command doesn't exist";
+            case CommandExecutor::Incomplete:  return "not enough arguments given";
+            case CommandExecutor::Deactivated: return "command is not active";
+            case CommandExecutor::Denied:      return "access denied";
+            case CommandExecutor::Error:       return "an error occurred";
+            default: return "";
+        }
+    }
+    /**
         @brief Gets an evaluated command from the cache.
         @param command The command that should be looked up in the cache
 …
             if ((tokens.size() == 1 && ConsoleCommand::getCommand(tokens[0])) || (tokens.size() == 2 && ConsoleCommand::getCommand(tokens[0], tokens[1])))
+            {
                 COUT(1) << "Error: A command with name \"" << alias << "\" already exists." << std::endl;
+                orxout(user_error) << "A command with name \"" << alias << "\" already exists." << endl;
                 return;
+            }
 …
                 createConsoleCommand(tokens[0], tokens[1], executor);
             else
                 COUT(1) << "Error: \"" << alias << "\" is not a valid alias name (must have one or two words)." << std::endl;
+                orxout(user_error) << "\"" << alias << "\" is not a valid alias name (must have one or two words)." << endl;
+        }
         else
             COUT(1) << "Error: \"" << command << "\" is not a valid command (did you mean \"" << evaluation.getCommandSuggestion() << "\"?)." << std::endl;
+            orxout(user_error) << "\"" << command << "\" is not a valid command (did you mean \"" << evaluation.getCommandSuggestion() << "\"?)." << endl;
+    }
+}

code/trunk/src/libraries/core/command/CommandExecutor.h

-                      r7401
+                      r8858
 // tolua_end
         public:
             static int execute(const std::string& command, bool useTcl = true); // tolua_export
+            static int execute(const std::string& command, bool useTcl = true, bool printErrors = true); // tolua_export
             static MultiType queryMT(const std::string& command, int* error = 0, bool useTcl = true);
 …
             static const int Success = 0;       ///< Error code for "success" (or no error)
             static const int Error = 1;         ///< Error code if the command doesn't exist
+            static const int Inexistent = 1;    ///< Error code if the command doesn't exist
             static const int Incomplete = 2;    ///< Error code if the command needs more arguments
             static const int Deactivated = 3;   ///< Error code if the command is not active
             static const int Denied = 4;        ///< Error code if the command needs a different access level
+            static const int Error = 5;         ///< Error code if the command returned an error
+            static std::string getErrorDescription(int error);
             static MultiType unhide(const std::string& command);

code/trunk/src/libraries/core/command/ConsoleCommand.cc

-                      r8316
+                      r8858
                 if (!this->executor_->defaultValueSet(i))
+                {
                     COUT(2) << "Default value " << i << " is missing" << std::endl;
+                    orxout(internal_warning, context::commands) << "Default value " << i << " is missing" << endl;
                     return false;
+                }
 …
                 if (!executor->defaultValueSet(i))
+                {
                     COUT(2) << "Default value " << i << " is missing" << std::endl;
+                    orxout(internal_warning, context::commands) << "Default value " << i << " is missing" << endl;
                     return false;
+                }
 …
         else
+        {
             COUT(1) << "Error: Couldn't assign new executor to console command \"" << this->baseName_ << "\", headers don't match." << std::endl;
+            orxout(internal_error, context::commands) << "Couldn't assign new executor to console command \"" << this->baseName_ << "\", headers don't match." << endl;
             return false;
+        }
 …
         else
+        {
             COUT(1) << "Error: Couldn't assign new functor to console command \"" << this->baseName_ << "\", headers don't match." << std::endl;
+            orxout(internal_error, context::commands) << "Couldn't assign new functor to console command \"" << this->baseName_ << "\", headers don't match." << endl;
             return false;
+        }
 …
             this->pushFunction(new Executor(*this->executor_.get()));
         else
             COUT(1) << "Error: Couldn't push copy of executor in console command \"" << this->baseName_ << "\", no executor set." << std::endl;
+            orxout(internal_error, context::commands) << "Couldn't push copy of executor in console command \"" << this->baseName_ << "\", no executor set." << endl;
+    }
 …
+            }
             else if (object)
                 COUT(1) << "Error: Can't assign object to console command \"" << this->baseName_ << "\", no functor set." << std::endl;
+                orxout(internal_error, context::commands) << "Can't assign object to console command \"" << this->baseName_ << "\", no functor set." << endl;
+        }
         else if (object)
             COUT(1) << "Error: Can't assign object to console command \"" << this->baseName_ << "\", no executor set." << std::endl;
+            orxout(internal_error, context::commands) << "Can't assign object to console command \"" << this->baseName_ << "\", no executor set." << endl;
         return false;
 …
             this->executor_->setDefaultValues(arg1);
         else
             COUT(1) << "Error: Can't set default values in console command \"" << this->baseName_ << "\", no executor set." << std::endl;
+            orxout(internal_error, context::commands) << "Can't set default values in console command \"" << this->baseName_ << "\", no executor set." << endl;
         return *this;
 …
             this->executor_->setDefaultValues(arg1, arg2);
         else
             COUT(1) << "Error: Can't set default values in console command \"" << this->baseName_ << "\", no executor set." << std::endl;
+            orxout(internal_error, context::commands) << "Can't set default values in console command \"" << this->baseName_ << "\", no executor set." << endl;
         return *this;
 …
             this->executor_->setDefaultValues(arg1, arg2, arg3);
         else
             COUT(1) << "Error: Can't set default values in console command \"" << this->baseName_ << "\", no executor set." << std::endl;
+            orxout(internal_error, context::commands) << "Can't set default values in console command \"" << this->baseName_ << "\", no executor set." << endl;
         return *this;
 …
             this->executor_->setDefaultValues(arg1, arg2, arg3, arg4);
         else
             COUT(1) << "Error: Can't set default values in console command \"" << this->baseName_ << "\", no executor set." << std::endl;
+            orxout(internal_error, context::commands) << "Can't set default values in console command \"" << this->baseName_ << "\", no executor set." << endl;
         return *this;
 …
             this->executor_->setDefaultValues(arg1, arg2, arg3, arg4, arg5);
         else
             COUT(1) << "Error: Can't set default values in console command \"" << this->baseName_ << "\", no executor set." << std::endl;
+            orxout(internal_error, context::commands) << "Can't set default values in console command \"" << this->baseName_ << "\", no executor set." << endl;
         return *this;
 …
             this->executor_->setDefaultValue(index, arg);
         else
             COUT(1) << "Error: Can't set default values in console command \"" << this->baseName_ << "\", no executor set." << std::endl;
+            orxout(internal_error, context::commands) << "Can't set default values in console command \"" << this->baseName_ << "\", no executor set." << endl;
         return *this;
 …
             this->argumentCompleter_[index] = completer;
         else
             COUT(2) << "Warning: Couldn't add autocompletion-function for index " << index << " in console command \"" << this->baseName_ << "\": index out of bound." << std::endl;
+            orxout(internal_warning, context::commands) << "Couldn't add autocompletion-function for index " << index << " in console command \"" << this->baseName_ << "\": index out of bound." << endl;
         return *this;
 …
+        {
             if (group == "")
                 COUT(1) << "Error: Couldn't find console command with shortcut \"" << name << "\"" << std::endl;
+                orxout(internal_error, context::commands) << "Couldn't find console command with shortcut \"" << name << "\"" << endl;
             else
                 COUT(1) << "Error: Couldn't find console command with group \"" << group << "\" and name \"" << name << "\"" << std::endl;
+                orxout(internal_error, context::commands) << "Couldn't find console command with group \"" << group << "\" and name \"" << name << "\"" << endl;
+        }
         return 0;
 …
+        {
             if (group == "")
                 COUT(1) << "Error: Couldn't find console command with shortcut \"" << name << "\"" << std::endl;
+                orxout(internal_error, context::commands) << "Couldn't find console command with shortcut \"" << name << "\"" << endl;
             else
                 COUT(1) << "Error: Couldn't find console command with group \"" << group << "\" and name \"" << name << "\"" << std::endl;
+                orxout(internal_error, context::commands) << "Couldn't find console command with group \"" << group << "\" and name \"" << name << "\"" << endl;
+        }
         return 0;
 …
+        {
             if (group == "")
                 COUT(2) << "Warning: A console command with shortcut \"" << name << "\" already exists." << std::endl;
+                orxout(internal_warning, context::commands) << "A console command with shortcut \"" << name << "\" already exists." << endl;
             else
                 COUT(2) << "Warning: A console command with name \"" << name << "\" already exists in group \"" << group << "\"." << std::endl;
+                orxout(internal_warning, context::commands) << "A console command with name \"" << name << "\" already exists in group \"" << group << "\"." << endl;
+        }
         else

code/trunk/src/libraries/core/command/ConsoleCommand.h

r8418	r8858
53	53	void myCoutFunction(const std::string& text) // Define a static function
54	54	{
55		~~COUT(0) << "Text: " << text << std::endl;~~ // Print the text to the console
	55	orxout() << "Text: " << text << endl; // Print the text to the console
56	56	}
57	57
…	…
125	125	void myOtherCoutFunction(const std::string& text) // Define a new static function
126	126	{
127		~~COUT(0) << "Uppercase: " << getUppercase(text) << std::endl;~~ // Print the text in uppercase to the console
	127	orxout() << "Uppercase: " << getUppercase(text) << endl; // Print the text in uppercase to the console
128	128	}
129	129

code/trunk/src/libraries/core/command/ConsoleCommandCompilation.cc

-                      r8079
+                      r8858
 #include <string>
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/ExprParser.h"
 #include "util/StringUtils.h"
 …
 namespace orxonox
+{
+    SetConsoleCommand("echo", echo);
+    SetConsoleCommand("orxout", orxout_level);
+    SetConsoleCommand("orxout_context", orxout_level_context);
+    SetConsoleCommand("log"    , log    );
+    SetConsoleCommand("error"  , error  ).hide();
+    SetConsoleCommand("warning", warning).hide();
+    SetConsoleCommand("status" , status ).hide();
+    SetConsoleCommand("info"   , info   ).hide();
+    SetConsoleCommand("debug"  , debug  ).hide();
 //    SetConsoleCommand("source", source).argumentCompleter(0, autocompletion::files());  // disabled because we use the implementation in Tcl
-    SetConsoleCommand("echo", echo);
-//    SetConsoleCommand("puts", puts);                                                    // disabled because we use the implementation in Tcl
 //    SetConsoleCommand("read", read).argumentCompleter(0, autocompletion::files());      // disabled because we use the implementation in Tcl
 //    SetConsoleCommand("append", append).argumentCompleter(0, autocompletion::files());  // disabled because we use the implementation in Tcl
 …
     /**
+        @brief Simply returns the arguments.
+    */
+    std::string echo(const std::string& text)
+    {
+        return text;
+    }
+    /**
+        @brief Builds a map that maps the levels of all output levels to their ID.
+    */
+    std::map<std::string, OutputLevel> getOutputLevelsMap()
+    {
+        std::map<std::string, OutputLevel> levels;
+        levels["message"]          = level::message;
+        levels["debug_output"]     = level::debug_output;
+        levels["user_error"]       = level::user_error;
+        levels["user_warning"]     = level::user_warning;
+        levels["user_status"]      = level::user_status;
+        levels["user_info"]        = level::user_info;
+        levels["internal_error"]   = level::internal_error;
+        levels["internal_warning"] = level::internal_warning;
+        levels["internal_status"]  = level::internal_status;
+        levels["internal_info"]    = level::internal_info;
+        levels["verbose"]          = level::verbose;
+        levels["verbose_more"]     = level::verbose_more;
+        levels["verbose_ultra"]    = level::verbose_ultra;
+        return levels;
+    }
+    /**
+        @brief Prints text to the console.
+        @param level_name The name of the output level
+    */
+    void orxout_level(const std::string& level_name, const std::string& text)
+    {
+        static std::map<std::string, OutputLevel> levels = getOutputLevelsMap();
+        OutputLevel level = level::debug_output;
+        std::map<std::string, OutputLevel>::iterator it = levels.find(level_name);
+        if (it != levels.end())
+            level = it->second;
+        else
+            orxout(internal_warning) << "'" << level_name << "' is not a valid output level" << endl;
+        orxout(level) << text << endl;
+    }
+    /**
+        @brief Prints text to the console.
+        @param level_name The name of the output level
+        @param context_name The name of the output context
+    */
+    void orxout_level_context(const std::string& level_name, const std::string& context_name, const std::string& text)
+    {
+        static std::map<std::string, OutputLevel> levels = getOutputLevelsMap();
+        OutputLevel level = level::debug_output;
+        std::map<std::string, OutputLevel>::iterator it = levels.find(level_name);
+        if (it != levels.end())
+            level = it->second;
+        else
+            orxout(internal_warning) << "'" << level_name << "' is not a valid output level" << endl;
+        OutputContextContainer context = registerContext(context_name);
+        orxout(level, context) << text << endl;
+    }
+    /// @brief Prints text to the console and the logfile.
+    void log(const std::string& text)
+    { orxout() << text << endl; }
+    /// @brief Prints output with error level.
+    void error(const std::string& text)
+    { orxout(user_error) << text << endl; }
+    /// @brief Prints output with warning level.
+    void warning(const std::string& text)
+    { orxout(user_warning) << text << endl; }
+    /// @brief Prints output with status level.
+    void status(const std::string& text)
+    { orxout(user_status) << text << endl; }
+    /// @brief Prints output with info level.
+    void info(const std::string& text)
+    { orxout(user_info) << text << endl; }
+    /// @brief Prints debug output with verbose level.
+    void debug(const std::string& text)
+    { orxout(verbose, context::tcl) << text << endl; }
+    /**
         @brief Reads the content of a file and executes the commands in it line by line.
     */
 …
         if (it != executingFiles.end())
+        {
             COUT(1) << "Error: Recurring source command in \"" << filename << "\". Stopped execution." << std::endl;
+            orxout(user_error) << "Recurring source command in \"" << filename << "\". Stopped execution." << endl;
             return;
+        }
 …
         if (!file.is_open())
+        {
             COUT(1) << "Error: Couldn't open file \"" << filename << "\"." << std::endl;
+            orxout(user_error) << "Couldn't open file \"" << filename << "\"." << endl;
             return;
+        }
 …
     /**
-        @brief Simply returns the arguments.
-    */
-    std::string echo(const std::string& text)
+    {
-        return text;
+    }
-    /**
-        @brief Writes text to the console, depending on the first argument with or without a line-break after it.
-    */
-    void puts(bool newline, const std::string& text)
+    {
-        if (newline)
+        {
-            COUT(0) << stripEnclosingBraces(text) << std::endl;
+        }
-        else
+        {
-            COUT(0) << stripEnclosingBraces(text);
+        }
+    }
-    /**
         @brief Writes text to a file.
     */
 …
         if (!file.is_open())
+        {
             COUT(1) << "Error: Couldn't write to file \"" << filename << "\"." << std::endl;
             return;
+        }
         file << text << std::endl;
+            orxout(user_error) << "Couldn't write to file \"" << filename << "\"." << endl;
+            return;
+        }
+        file << text << endl;
         file.close();
+    }
 …
         if (!file.is_open())
+        {
             COUT(1) << "Error: Couldn't append to file \"" << filename << "\"." << std::endl;
             return;
+        }
         file << text << std::endl;
+            orxout(user_error) << "Couldn't append to file \"" << filename << "\"." << endl;
+            return;
+        }
+        file << text << endl;
         file.close();
+    }
 …
         if (!file.is_open())
+        {
             COUT(1) << "Error: Couldn't read from file \"" << filename << "\"." << std::endl;
+            orxout(user_error) << "Couldn't read from file \"" << filename << "\"." << endl;
             return "";
+        }
 …
             if (expr.getResult() == 42.0)
+            {
                 COUT(3) << "Greetings from the restaurant at the end of the universe." << std::endl;
+                orxout(user_info) << "Greetings from the restaurant at the end of the universe." << endl;
+            }
             if (!expr.getRemains().empty())
+            {
                 COUT(2) << "Warning: Expression could not be parsed to the end! Remains: '" << expr.getRemains() << '\'' << std::endl;
+                orxout(user_warning) << "Expression could not be parsed to the end! Remains: '" << expr.getRemains() << '\'' << endl;
+            }
             return static_cast<float>(expr.getResult());
 …
         else
+        {
             COUT(1) << "Error: Cannot calculate expression: Parse error." << std::endl;
+            orxout(user_error) << "Cannot calculate expression: Parse error." << endl;
             return 0;
+        }

code/trunk/src/libraries/core/command/ConsoleCommandCompilation.h

-                      r7401
+                      r8858
     _CoreExport void source(const std::string& filename);
     _CoreExport std::string echo(const std::string& text);
+    _CoreExport void puts(bool newline, const std::string& test);
+    _CoreExport void orxout_level(const std::string& level_name, const std::string& text);
+    _CoreExport void orxout_level_context(const std::string& level_name, const std::string& context_name, const std::string& text);
+    _CoreExport void log(const std::string& text);
+    _CoreExport void error(const std::string& text);
+    _CoreExport void warning(const std::string& text);
+    _CoreExport void status(const std::string& text);
+    _CoreExport void info(const std::string& text);
+    _CoreExport void debug(const std::string& text);
     _CoreExport void write(const std::string& filename, const std::string& text);

code/trunk/src/libraries/core/command/Executor.cc

-                      r7401
+                      r8858
 #include "util/Convert.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/StringUtils.h"
 #include "util/SubString.h"
 …
+        {
             if (bPrintError)
                 COUT(2) << "Warning: Can't call executor " << this->name_ << " through parser: Not enough arguments or default values given (input: " << arguments.join() << ")." << std::endl;
+                orxout(internal_warning) << "Can't call executor " << this->name_ << " through parser: Not enough arguments or default values given (input: " << arguments.join() << ")." << endl;
             return MT_Type::Null;
+        }
         COUT(5) << "Executor::parse: \"" << arguments.join(delimiter) << "\" -> " << argCount << " arguments: " << arg[0] << " / " << arg[1] << " / " << arg[2] << " / " << arg[3] << " / " << arg[4] << std::endl;
+        orxout(verbose, context::misc::executor) << "Executor::parse: \"" << arguments.join(delimiter) << "\" -> " << argCount << " arguments: " << arg[0] << " / " << arg[1] << " / " << arg[2] << " / " << arg[3] << " / " << arg[4] << endl;
         // execute the function with the evaluated arguments (the default values of the executor are also included in these arguments)

code/trunk/src/libraries/core/command/Executor.h

r7401	r8858
57	57	void myFunction(int a, int b) // declare a static function
58	58	{
59		~~COUT(0) << "The sum is " << (a + b) << std::endl;~~ // print the sum of a and b to the console
	59	orxout() << "The sum is " << (a + b) << endl; // print the sum of a and b to the console
60	60	}
61	61

code/trunk/src/libraries/core/command/Functor.h

-                      r8729
+                      r8858
 #include <typeinfo>
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/MultiType.h"
 #include "core/OrxonoxClass.h"
 …
                 else
+                {
                     COUT(1) << "Error: Can't execute FunctorMember, no object set." << std::endl;
+                    orxout(internal_error) << "Can't execute FunctorMember, no object set." << endl;
                     return MT_Type::Null;
+                }
 …
             // see Functor::setRawObjectPointer()
             inline void setRawObjectPointer(void*)
                 { COUT(2) << "Warning: Can't assign an object pointer to a static functor" << std::endl; }
+                { orxout(internal_warning) << "Can't assign an object pointer to a static functor" << endl; }
             // see Functor::getRawObjectPointer()
             inline void* getRawObjectPointer() const

code/trunk/src/libraries/core/command/IOConsolePOSIX.cc

-                      r8729
+                      r8858
 #include "util/Clock.h"
 #include "util/Math.h"
+#include "util/output/ConsoleWriter.h"
 #include "core/Game.h"
 #include "core/input/InputBuffer.h"
 …
     IOConsole::IOConsole()
         : shell_(new Shell("IOConsole", false))
+        : shell_(new Shell("Console", false))
         , buffer_(shell_->getInputBuffer())
         , cout_(std::cout.rdbuf())
 …
         // Disable standard std::cout logging
         OutputHandler::getInstance().disableCout();
+        ConsoleWriter::getInstance().disable();
         // Redirect std::cout to an ostringstream
         // (Other part is in the initialiser list)
 …
         std::cout.flush();
         if (!this->origCout_.str().empty())
             this->shell_->addOutput(this->origCout_.str(), Shell::None);
+            this->shell_->addOutput(this->origCout_.str(), Shell::Cout);
         // Erase input and status lines
         this->cout_ << "\033[1G\033[J";
 …
         std::cout.rdbuf(this->cout_.rdbuf());
         // Enable standard std::cout logging again
         OutputHandler::getInstance().enableCout();
+        ConsoleWriter::getInstance().enable();
+    }
 …
         if (!this->origCout_.str().empty())
+        {
             this->shell_->addOutput(this->origCout_.str(), Shell::None);
+            this->shell_->addOutput(this->origCout_.str(), Shell::Cout);
             this->origCout_.str("");
+        }
 …
         switch (type)
+        {
+        case Shell::Error:   this->cout_ << "\033[91m"; break;
+        case Shell::Warning: this->cout_ << "\033[93m"; break;
+        case Shell::Info:    this->cout_ << "\033[90m"; break;
+        case Shell::Debug:   this->cout_ << "\033[90m"; break;
+        case Shell::Verbose: this->cout_ << "\033[90m"; break;
+        case Shell::Ultra:   this->cout_ << "\033[90m"; break;
+        case Shell::Command: this->cout_ << "\033[36m"; break;
+        case Shell::Hint:    this->cout_ << "\033[33m"; break;
+        case Shell::TDebug:  this->cout_ << "\033[95m"; break;
+        default: break;
+            case Shell::Message:
+            case Shell::DebugOutput:     this->cout_ << "\033[0m"; break;
+            case Shell::UserError:       this->cout_ << "\033[91m"; break;
+            case Shell::UserWarning:     this->cout_ << "\033[93m"; break;
+            case Shell::UserStatus:      this->cout_ << "\033[92m"; break;
+            case Shell::UserInfo:        this->cout_ << "\033[96m"; break;
+            case Shell::InternalError:   this->cout_ << "\033[31m"; break;
+            case Shell::InternalWarning: this->cout_ << "\033[33m"; break;
+            case Shell::InternalStatus:  this->cout_ << "\033[32m"; break;
+            case Shell::InternalInfo:    this->cout_ << "\033[36m"; break;
+            case Shell::Verbose:         this->cout_ << "\033[94m"; break;
+            case Shell::VerboseMore:     this->cout_ << "\033[34m"; break;
+            case Shell::VerboseUltra:    this->cout_ << "\033[34m"; break;
+            case Shell::Command:         this->cout_ << "\033[95m"; break;
+            case Shell::Hint:            this->cout_ << "\033[35m"; break;
+            default:                     this->cout_ << "\033[37m"; break;
+        }
 …
     void IOConsole::executed()
+    {
         this->shell_->addOutput(this->promptString_ + this->shell_->getInput() + '\n', Shell::Command);
+        this->shell_->addOutput(this->promptString_ + this->shell_->getInput(), Shell::Command);
+    }
 …
+    {
         // Exit is not an option, just do nothing (Shell doesn't really exit too)
+    }
-    //! Called if only the last output-line has changed
-    void IOConsole::onlyLastLineChanged()
+    {
-        // Save cursor position and move it to the beginning of the first output line
-        this->cout_ << "\033[s\033[1A\033[1G";
-        // Erase the line
-        this->cout_ << "\033[K";
-        // Reprint the last output line
-        this->printOutputLine(this->shell_->getNewestLineIterator()->first, this->shell_->getNewestLineIterator()->second);
-        // Restore cursor
-        this->cout_ << "\033[u";
-        this->cout_.flush();
+    }

code/trunk/src/libraries/core/command/IOConsolePOSIX.h

r7401	r8858
66	66	// Methods from ShellListener
67	67	void linesChanged();
68		~~void onlyLastLineChanged();~~
69	68	void lineAdded();
70	69	void inputChanged();

code/trunk/src/libraries/core/command/IOConsoleWindows.cc

-                      r8729
+                      r8858
 #include "util/Clock.h"
 #include "util/Math.h"
+#include "util/output/ConsoleWriter.h"
 #include "core/Game.h"
 #include "core/input/InputBuffer.h"
 …
     //! Redirects std::cout, creates the corresponding Shell and changes the terminal mode
     IOConsole::IOConsole()
         : shell_(new Shell("IOConsole", false))
+        : shell_(new Shell("Console", false))
         , buffer_(shell_->getInputBuffer())
         , cout_(std::cout.rdbuf())
 …
+    {
         // Disable standard this->cout_ logging
         OutputHandler::getInstance().disableCout();
+        ConsoleWriter::getInstance().disable();
         // Redirect std::cout to an ostringstream
         // (Other part is in the initialiser list)
 …
         std::cout.flush();
         if (!this->origCout_.str().empty())
             this->shell_->addOutput(this->origCout_.str(), Shell::None);
+            this->shell_->addOutput(this->origCout_.str(), Shell::Cout);
         this->shell_->unregisterListener(this);
 …
         std::cout.rdbuf(this->cout_.rdbuf());
         // Enable standard this->cout_ logging again
         OutputHandler::getInstance().enableCout();
+        ConsoleWriter::getInstance().enable();
         resetTerminalMode();
 …
         if (!this->origCout_.str().empty())
+        {
             this->shell_->addOutput(this->origCout_.str(), Shell::None);
+            this->shell_->addOutput(this->origCout_.str(), Shell::Cout);
             this->origCout_.str("");
+        }
 …
         switch (type)
+        {
+        case Shell::Error:   colour = FOREGROUND_INTENSITY                    | FOREGROUND_RED; break;
+        case Shell::Warning: colour = FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED; break;
+        case Shell::Info:
+        case Shell::Debug:
+        case Shell::Verbose:
+        case Shell::Ultra:   colour = FOREGROUND_INTENSITY                                     ; break;
+        case Shell::Command: colour =                        FOREGROUND_GREEN                  | FOREGROUND_BLUE; break;
+        case Shell::Hint:    colour =                        FOREGROUND_GREEN | FOREGROUND_RED                  ; break;
+        case Shell::TDebug:  colour = FOREGROUND_INTENSITY                    | FOREGROUND_RED | FOREGROUND_BLUE; break;
+        default:             colour =                        FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE; break;
+            case Shell::Message:
+            case Shell::DebugOutput:     colour = FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; break;
+            case Shell::UserError:       colour = FOREGROUND_INTENSITY | FOREGROUND_RED | 0                | 0              ; break;
+            case Shell::UserWarning:     colour = FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | 0              ; break;
+            case Shell::UserStatus:      colour = FOREGROUND_INTENSITY | 0              | FOREGROUND_GREEN | 0              ; break;
+            case Shell::UserInfo:        colour = FOREGROUND_INTENSITY | 0              | FOREGROUND_GREEN | FOREGROUND_BLUE; break;
+            case Shell::InternalError:   colour = 0                    | FOREGROUND_RED | 0                | 0              ; break;
+            case Shell::InternalWarning: colour = 0                    | FOREGROUND_RED | FOREGROUND_GREEN | 0              ; break;
+            case Shell::InternalStatus:  colour = 0                    | 0              | FOREGROUND_GREEN | 0              ; break;
+            case Shell::InternalInfo:    colour = 0                    | 0              | FOREGROUND_GREEN | FOREGROUND_BLUE; break;
+            case Shell::Verbose:         colour = FOREGROUND_INTENSITY | 0              | 0                | FOREGROUND_BLUE; break;
+            case Shell::VerboseMore:     colour = FOREGROUND_INTENSITY | 0              | 0                | FOREGROUND_BLUE; break;
+            case Shell::VerboseUltra:    colour = FOREGROUND_INTENSITY | 0              | 0                | FOREGROUND_BLUE; break;
+            case Shell::Command:         colour = FOREGROUND_INTENSITY | FOREGROUND_RED | 0                | FOREGROUND_BLUE; break;
+            case Shell::Hint:            colour = 0                    | FOREGROUND_RED | 0                | FOREGROUND_BLUE; break;
+            default:                     colour = 0                    | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; break;
+        }
 …
             || !SetConsoleMode(this->stdInHandle_, 0))
+        {
             COUT(1) << "Error: Could not set Windows console settings" << std::endl;
+            orxout(user_error) << "Could not set Windows console settings" << endl;
             return;
+        }
 …
     void IOConsole::executed()
+    {
         this->shell_->addOutput(this->promptString_ + this->shell_->getInput() + '\n', Shell::Command);
+        this->shell_->addOutput(this->promptString_ + this->shell_->getInput(), Shell::Command);
+    }
 …
+    }
-    //! Called if only the last output-line has changed
-    void IOConsole::onlyLastLineChanged()
+    {
-        int newLineHeight = 1 + this->shell_->getNewestLineIterator()->first.size() / this->terminalWidth_;
-        // Compute the number of new lines needed
-        int newLines = newLineHeight - this->lastOutputLineHeight_;
-        this->lastOutputLineHeight_ = newLineHeight;
-        // Scroll console if necessary
-        if (newLines > 0) // newLines < 0 is assumed impossible
-            this->createNewOutputLines(newLines);
-        Shell::LineList::const_iterator it = this->shell_->getNewestLineIterator();
-        this->printOutputLine(it->first, it->second, makeCOORD(0, this->inputLineRow_ - newLineHeight));
+    }
     //! Called if a new output line was added
     void IOConsole::lineAdded()

code/trunk/src/libraries/core/command/IOConsoleWindows.h

r8729	r8858
68	68	// Methods from ShellListener
69	69	void linesChanged();
70		~~void onlyLastLineChanged();~~
71	70	void lineAdded();
72	71	void inputChanged();

code/trunk/src/libraries/core/command/IRC.cc

r7401	r8858
85	85	}
86	86	catch (Tcl::tcl_error const &e)
87		{ ~~COUT(1) << "Tcl (IRC) error: " << e.what()~~; }
	87	{ orxout(user_error, context::tcl) << "Tcl (IRC) error: " << e.what() << endl; }
88	88
89	89	this->nickname_ = "orx" + multi_cast<std::string>(static_cast<unsigned int>(rand()));
…	…
100	100	{
101	101	IRC::getInstance().initialize();
102		~~COUT(1) << "Error: IRC client wasn't yet initialized, please try again." << std::~~endl;
	102	orxout(user_error) << "IRC client wasn't yet initialized, please try again." << endl;
103	103	return false;
104	104	}
…	…
110	110	}
111	111	catch (Tcl::tcl_error const &e)
112		{ ~~COUT(1) << "Tcl (IRC) error: " << e.what()~~; }
	112	{ orxout(user_error, context::tcl) << "Tcl (IRC) error: " << e.what() << endl; }
113	113
114	114	return false;
…	…
139	139	void IRC::tcl_say(Tcl::object const &channel, Tcl::object const &nick, Tcl::object const &args)
140	140	{
141		~~COUT(0) << "IRC> " << nick.get() << ": " << stripEnclosingBraces(args.get()) << std::~~endl;
	141	orxout(message) << "IRC> " << nick.get() << ": " << stripEnclosingBraces(args.get()) << endl;
142	142	}
143	143
…	…
145	145	void IRC::tcl_privmsg(Tcl::object const &query, Tcl::object const &nick, Tcl::object const &args)
146	146	{
147		~~COUT(0) << "IRC (" << query.get() << ")> " << nick.get() << ": " << stripEnclosingBraces(args.get()) << std::~~endl;
	147	orxout(message) << "IRC (" << query.get() << ")> " << nick.get() << ": " << stripEnclosingBraces(args.get()) << endl;
148	148	}
149	149
…	…
151	151	void IRC::tcl_action(Tcl::object const &channel, Tcl::object const &nick, Tcl::object const &args)
152	152	{
153		~~COUT(0) << "IRC> * " << nick.get() << ' ' << stripEnclosingBraces(args.get()) << std::~~endl;
	153	orxout(message) << "IRC> * " << nick.get() << ' ' << stripEnclosingBraces(args.get()) << endl;
154	154	}
155	155
…	…
157	157	void IRC::tcl_info(Tcl::object const &channel, Tcl::object const &args)
158	158	{
159		~~COUT(0) << "IRC> --> " << stripEnclosingBraces(args.get()) << std::~~endl;
	159	orxout(message) << "IRC> --> " << stripEnclosingBraces(args.get()) << endl;
160	160	}
161	161	}

code/trunk/src/libraries/core/command/Shell.cc

-                      r8729
+                      r8858
 #include "util/Math.h"
-#include "util/OutputHandler.h"
 #include "util/StringUtils.h"
 #include "util/SubString.h"
+#include "util/output/OutputManager.h"
+#include "util/output/MemoryWriter.h"
 #include "core/CoreIncludes.h"
 #include "core/ConfigFileManager.h"
 …
 #include "core/input/InputBuffer.h"
 #include "CommandExecutor.h"
-#include "ConsoleCommand.h"
 namespace orxonox
+{
-    SetConsoleCommand("log",     OutputHandler::log    );
-    SetConsoleCommand("error",   OutputHandler::error  ).hide();
-    SetConsoleCommand("warning", OutputHandler::warning).hide();
-    SetConsoleCommand("info",    OutputHandler::info   ).hide();
-    SetConsoleCommand("debug",   OutputHandler::debug  ).hide();
     unsigned int Shell::cacheSize_s;
+    /**
+        @brief Constructor: Initializes the values and registers itself at OutputHandler.
+    namespace DefaultLogLevel
+    {
+        const OutputLevel Dev  = level::internal_warning;
+        const OutputLevel User = level::user_info;
+    }
+    /**
+        @brief Constructor: Initializes the values.
         @param consoleName The name of the shell - used to define the name of the soft-debug-level config-value
         @param bScrollable If true, the user is allowed to scroll through the output-lines
     */
     Shell::Shell(const std::string& consoleName, bool bScrollable)
         : OutputListener(consoleName)
+        : BaseWriter(consoleName, false)
         , inputBuffer_(new InputBuffer())
-        , consoleName_(consoleName)
         , bScrollable_(bScrollable)
+    {
         RegisterRootObject(Shell);
+        OutputManager::getInstance().registerListener(this);
         this->scrollPosition_ = 0;
 …
         this->historyPosition_ = 0;
         this->historyOffset_ = 0;
-        this->bFinishedLastLine_ = true;
         this->clearOutput();
 …
         ConfigFileManager::getInstance().setFilename(ConfigFileType::CommandHistory, "commandHistory.ini");
+        // Use a stringstream object to buffer the output
+        this->outputStream_ = &this->outputBuffer_;
+        // Choose the default level according to the path Orxonox was started (build directory or not)
+        OutputLevel defaultDebugLevel = (PathConfig::buildDirectoryRun() ? DefaultLogLevel::Dev : DefaultLogLevel::User);
+        this->setLevelMax(defaultDebugLevel);
         this->setConfigValues();
         // Get the previous output and add it to the Shell
+        OutputHandler::OutputVector::const_iterator it = OutputHandler::getInstance().getOutput().begin();
+        for (;it != OutputHandler::getInstance().getOutput().end(); ++it)
+        {
+            if (it->first <= debugLevel_)
+            {
+                this->outputBuffer_ << it->second;
+                this->outputChanged(it->first);
+            }
+        }
+        // Register the shell as output listener
+        OutputHandler::getInstance().registerOutputListener(this);
+        OutputHandler::getInstance().setSoftDebugLevel(consoleName_, debugLevel_);
+    }
+    /**
+        @brief Destructor: Unregisters the shell from OutputHandler.
+        MemoryWriter::getInstance().resendOutput(this);
+    }
+    /**
+        @brief Destructor
     */
     Shell::~Shell()
+    {
-        OutputHandler::getInstance().unregisterOutputListener(this);
         this->inputBuffer_->destroy();
+    }
+    namespace DefaultLogLevel
+    {
+        const OutputLevel::Value Dev  = OutputLevel::Info;
+        const OutputLevel::Value User = OutputLevel::Error;
+        OutputManager::getInstance().unregisterListener(this);
+    }
 …
         SetConfigValue(cacheSize_s, 32);
+        // Choose the default level according to the path Orxonox was started (build directory or not)
+        OutputLevel::Value defaultDebugLevel = (PathConfig::buildDirectoryRun() ? DefaultLogLevel::Dev : DefaultLogLevel::User);
+        SetConfigValueExternal(debugLevel_, "OutputHandler", "debugLevel" + consoleName_, defaultDebugLevel)
+            .description("The maximum level of debug output shown in the " + consoleName_);
+        OutputHandler::getInstance().setSoftDebugLevel(consoleName_, debugLevel_);
+        SetConfigValueExternal(this->configurableMaxLevel_,
+                               this->getConfigurableSectionName(),
+                               this->getConfigurableMaxLevelName(),
+                               this->configurableMaxLevel_)
+            .description("The maximum level of output shown in the " + this->getName())
+            .callback(static_cast<BaseWriter*>(this), &BaseWriter::changedConfigurableLevel);
+        SetConfigValueExternal(this->configurableAdditionalContextsMaxLevel_,
+                               this->getConfigurableSectionName(),
+                               this->getConfigurableAdditionalContextsMaxLevelName(),
+                               this->configurableAdditionalContextsMaxLevel_)
+            .description("The maximum level of output shown in the " + this->getName() + " for additional contexts")
+            .callback(static_cast<BaseWriter*>(this), &BaseWriter::changedConfigurableAdditionalContextsLevel);
+        SetConfigValueExternal(this->configurableAdditionalContexts_,
+                               this->getConfigurableSectionName(),
+                               this->getConfigurableAdditionalContextsName(),
+                               this->configurableAdditionalContexts_)
+            .description("Additional output contexts shown in the " + this->getName())
+            .callback(static_cast<BaseWriter*>(this), &BaseWriter::changedConfigurableAdditionalContexts);
+    }
 …
         if (isNormal)
+        {
             ModifyConfigValueExternal(debugLevel_, "debugLevel" + consoleName_, update);
+            ModifyConfigValueExternal(this->configurableMaxLevel_, this->getConfigurableMaxLevelName(), update);
+        }
         else
+        {
             OutputLevel::Value level = (value ? DefaultLogLevel::Dev : DefaultLogLevel::User);
             ModifyConfigValueExternal(debugLevel_, "debugLevel" + consoleName_, tset, level);
+            OutputLevel level = (value ? DefaultLogLevel::Dev : DefaultLogLevel::User);
+            ModifyConfigValueExternal(this->configurableMaxLevel_, this->getConfigurableMaxLevelName(), tset, level);
+        }
+    }
 …
     /**
         @brief Sends output to the internal output buffer.
+        @brief Adds multiple lines to the internal output buffer.
     */
     void Shell::addOutput(const std::string& text, LineType type)
+    {
+        this->outputBuffer_ << text;
+        this->outputChanged(type);
+        std::vector<std::string> lines;
+        vectorize(text, '\n', &lines);
+        for (size_t i = 0; i < lines.size(); ++i)
+            this->addLine(lines[i], type);
+    }
+    /**
+        @brief Adds a line to the internal output buffer.
+    */
+    void Shell::addLine(const std::string& line, LineType type)
+    {
+        // yes it was - push the new line to the list
+        this->outputLines_.push_front(std::make_pair(line, static_cast<LineType>(type)));
+        // adjust the scroll position if needed
+        if (this->scrollPosition_)
+            this->scrollPosition_++;
+        else
+            this->scrollIterator_ = this->outputLines_.begin();
+        if (!this->scrollPosition_)
+            this->updateListeners<&ShellListener::lineAdded>();
+    }
 …
         this->scrollPosition_ = 0;
-        this->bFinishedLastLine_ = true;
         this->updateListeners<&ShellListener::linesChanged>();
+    }
+    /**
+        @brief Inherited from BaseWriter (LogListener), called if a new line of output was sent.
+    */
+    void Shell::printLine(const std::string& line, OutputLevel level)
+    {
+        this->addLine(line, static_cast<LineType>(level));
+    }
 …
     /**
-        @brief Called by OutputHandler or internally whenever output was sent to the output buffer. Reads from the buffer and writes the new output-lines to the list.
-    */
-    void Shell::outputChanged(int lineType)
+    {
-        bool newline = false;
-        do
+        {
-            // get the first line from the buffer
-            std::string output;
-            std::getline(this->outputBuffer_, output);
-            // check the state of the buffer
-            bool eof = this->outputBuffer_.eof();
-            bool fail = this->outputBuffer_.fail();
-            if (eof)
-                this->outputBuffer_.flush(); // check if more output was received in the meantime
-            if (eof || fail)
-                this->outputBuffer_.clear(); // clear the error flags
-            // the line is terminated with a line-break if neither an error occurred nor the end of the file was reached
-            newline = (!eof && !fail);
-            // no output retrieved - break the loop
-            if (!newline && output.empty())
-                break;
-            // check if the last line was terminated with a line-break
-            if (this->bFinishedLastLine_)
+            {
-                // yes it was - push the new line to the list
-                this->outputLines_.push_front(std::make_pair(output, static_cast<LineType>(lineType)));
-                // adjust the scroll position if needed
-                if (this->scrollPosition_)
-                    this->scrollPosition_++;
-                else
-                    this->scrollIterator_ = this->outputLines_.begin();
-                if (!this->scrollPosition_)
-                    this->updateListeners<&ShellListener::lineAdded>();
+            }
-            else
+            {
-                // no it wasn't - add the new output to the last line
-                this->outputLines_.front().first += output;
-                this->updateListeners<&ShellListener::onlyLastLineChanged>();
+            }
-            // remember if the last line was terminated with a line-break
-            this->bFinishedLastLine_ = newline;
-        } while (newline); // loop as long as more lines are in the buffer
+    }
-    /**
         @brief Clears the text in the input buffer.
     */
 …
         const std::string& result = CommandExecutor::query(this->inputBuffer_->get(), &error);
         if (error)
+        {
+            switch (error)
+            {
+                case CommandExecutor::Error:       this->outputBuffer_ << "Error: Can't execute \"" << this->inputBuffer_->get() << "\", command doesn't exist. (S)" << std::endl; break;
+                case CommandExecutor::Incomplete:  this->outputBuffer_ << "Error: Can't execute \"" << this->inputBuffer_->get() << "\", not enough arguments given. (S)" << std::endl; break;
+                case CommandExecutor::Deactivated: this->outputBuffer_ << "Error: Can't execute \"" << this->inputBuffer_->get() << "\", command is not active. (S)" << std::endl; break;
+                case CommandExecutor::Denied:      this->outputBuffer_ << "Error: Can't execute \"" << this->inputBuffer_->get() << "\", access denied. (S)" << std::endl; break;
+            }
+            this->outputChanged(Error);
+        }
+            this->addOutput("Error: Can't execute \"" + this->inputBuffer_->get() + "\", " + CommandExecutor::getErrorDescription(error) + ". (Shell)", UserError);
         else if (result != "")
+        {
+            this->outputBuffer_ << result << std::endl;
+            this->outputChanged(Command);
+        }
+            this->addOutput(result, Result);
         this->clearInput();
 …
+    {
         this->inputBuffer_->set(CommandExecutor::evaluate(this->inputBuffer_->get()).complete());
+        this->outputBuffer_ << CommandExecutor::evaluate(this->inputBuffer_->get()).hint() << std::endl;
+        this->outputChanged(Hint);
+        this->addOutput(CommandExecutor::evaluate(this->inputBuffer_->get()).hint(), Hint);
         this->inputChanged();

code/trunk/src/libraries/core/command/Shell.h

-                      r8729
+                      r8858
 #include <vector>
 #include "util/OutputHandler.h"
+#include "util/output/BaseWriter.h"
 #include "core/Core.h"
 #include "core/OrxonoxClass.h"
 …
         private:
             virtual void linesChanged() {}          ///< Called if all output-lines have changed
-            virtual void onlyLastLineChanged() {}   ///< Called if only the last output-line has changed
             virtual void lineAdded() {}             ///< Called if a new line was added to the output
             virtual void inputChanged() {}          ///< Called if the input has changed
 …
         @brief The Shell is the logical component of the console that displays output to the user and allows him to enter commands.
         The Shell gathers output sent from OutputHandler by inheriting from OutputListener.
+        The Shell gathers output sent from OutputManager by inheriting from BaseWriter.
         The output-lines are stored in the shell, so they can be displayed in a graphical
         console. Additionally the Shell has an InputBuffer which is needed by the user to
 …
         Different graphical consoles build upon a Shell, for example InGameConsole and IOConsole.
     */
     class _CoreExport Shell : public OutputListener, public DevModeListener
+    class _CoreExport Shell : public BaseWriter, public DevModeListener
+    {
         public:
 …
             enum LineType
+            {
+                TDebug  = OutputLevel::TDebug,
+                None    = OutputLevel::None,
+                Warning = OutputLevel::Warning,
+                Error   = OutputLevel::Error,
+                Info    = OutputLevel::Info,
+                Debug   = OutputLevel::Debug,
+                Verbose = OutputLevel::Verbose,
+                Ultra   = OutputLevel::Ultra,
+                DebugOutput     = debug_output,
+                Message         = message,
+                UserError       = user_error,
+                UserWarning     = user_warning,
+                UserStatus      = user_status,
+                UserInfo        = user_info,
+                InternalError   = internal_error,
+                InternalWarning = internal_warning,
+                InternalStatus  = internal_status,
+                InternalInfo    = internal_info,
+                Verbose         = verbose,
+                VerboseMore     = verbose_more,
+                VerboseUltra    = verbose_ultra,
+                Cout,
                 Input,
                 Command,
+                Result,
                 Hint
             };
 …
             LineList::const_iterator getEndIterator() const;
+            void addOutput(const std::string& text, LineType type = None);
+            void addOutput(const std::string& text, LineType type = DebugOutput);
+            void addLine(const std::string& line, LineType type = DebugOutput);
             void clearOutput();
 …
             const std::string& getFromHistory() const;
             void clearInput();
             // OutputListener
             void outputChanged(int level);
+            // BaseWriter
+            virtual void printLine(const std::string& line, OutputLevel level);
             void configureInputBuffer();
 …
             std::list<ShellListener*> listeners_;           ///< The registered shell listeners
             InputBuffer*              inputBuffer_;         ///< The input buffer that is needed by the user to enter text
-            std::stringstream         outputBuffer_;        ///< The output buffer that is used to retrieve lines of output from OutputListener
-            bool                      bFinishedLastLine_;   ///< Stores if the most recent output-line was terminated with a line-break or if more output is expected for this line
             LineList                  outputLines_;         ///< A list of all output-lines that were displayed in the shell so far
             LineList::const_iterator  scrollIterator_;      ///< An iterator to an entry of the list of output-lines, changes if the user scrolls through the output in the shell
             unsigned int              scrollPosition_;      ///< The number of the line that is currently being referenced by scrollIterator_
             unsigned int              historyPosition_;     ///< If the user scrolls through the history of entered commands (stored in commandHistory_), this contains the currently viewed history entry
-            const std::string         consoleName_;         ///< The name of this shell - used to define the name of the soft-debug-level config-value
             const bool                bScrollable_;         ///< If true, the user can scroll through the output-lines
 …
             unsigned int              historyOffset_;       ///< The command history is a circular buffer, this variable defines the current write-offset
             std::vector<std::string>  commandHistory_;      ///< The history of commands that were entered by the user
-            int                       debugLevel_;          //!< The maximum level of output that is displayed in the shell (will be passed to OutputListener to filter output)
             static unsigned int       cacheSize_s;          ///< The maximum cache size of the CommandExecutor - this is stored here for better readability of the config file and because CommandExecutor is no OrxonoxClass
     };

code/trunk/src/libraries/core/command/TclBind.cc

-                      r8366
+                      r8858
 #include "SpecialConfig.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/Exception.h"
 #include "util/StringUtils.h"
 …
+            }
             catch (Tcl::tcl_error const &e)
             {   COUT(1) << "Tcl error while creating Tcl-interpreter: " << e.what() << std::endl;   }
+            {   orxout(internal_error, context::tcl) << "Tcl error while creating Tcl-interpreter: " << e.what() << endl;   }
+        }
+    }
 …
+        }
         catch (Tcl::tcl_error const &e)
+        {   COUT(1) << "Tcl error while creating Tcl-interpreter: " << e.what() << std::endl; COUT(1) << "Error: Tcl isn't properly initialized. Orxonox might possibly not work like that." << std::endl;   }
+        {
+            orxout(internal_error, context::tcl) << "Tcl error while creating Tcl-interpreter: " << e.what() << endl;
+            orxout(user_error, context::tcl) << "Tcl isn't properly initialized. Orxonox might possibly not work like that." << endl;
+        }
         return interpreter;
 …
     std::string TclBind::tcl_query(Tcl::object const &args)
+    {
         COUT(4) << "Tcl_query: " << args.get() << std::endl;
+        orxout(verbose, context::commands) << "Tcl_query: " << args.get() << endl;
         return TclBind::tcl_helper(args, true);
+    }
 …
     void TclBind::tcl_execute(Tcl::object const &args)
+    {
         COUT(4) << "Tcl_execute: " << args.get() << std::endl;
+        orxout(verbose, context::commands) << "Tcl_execute: " << args.get() << endl;
         TclBind::tcl_helper(args, false);
+    }
 …
             error = evaluation.execute();
+        switch (error)
+        {
+            case CommandExecutor::Error:       COUT(1) << "Error: Can't execute command \"" << command << "\", command doesn't exist. (B)" << std::endl; break;
+            case CommandExecutor::Incomplete:  COUT(1) << "Error: Can't execute command \"" << command << "\", not enough arguments given. (B)" << std::endl; break;
+            case CommandExecutor::Deactivated: COUT(1) << "Error: Can't execute command \"" << command << "\", command is not active. (B)" << std::endl; break;
+            case CommandExecutor::Denied:      COUT(1) << "Error: Can't execute command \"" << command << "\", access denied. (B)" << std::endl; break;
+        }
+        if (error == CommandExecutor::Error)
+            COUT(3) << "Did you mean \"" << evaluation.getCommandSuggestion() << "\"?" << std::endl;
+        if (error)
+        {
+            orxout(user_error) << "Can't execute command \"" << command << "\", " + CommandExecutor::getErrorDescription(error) + ". (TclBind)" << endl;
+            if (error == CommandExecutor::Inexistent)
+                orxout(user_info) << "Did you mean \"" << evaluation.getCommandSuggestion() << "\"?" << endl;
+        }
         return result;
 …
+            }
             catch (Tcl::tcl_error const &e)
             {   COUT(1) << "Tcl error: " << e.what() << std::endl;   }
+            {   orxout(user_error, context::tcl) << "Tcl error: " << e.what() << endl;   }
+        }
 …
     void TclBind::bgerror(const std::string& error)
+    {
         COUT(1) << "Tcl background error: " << stripEnclosingBraces(error) << std::endl;
+        orxout(user_error, context::tcl) << "Tcl background error: " << stripEnclosingBraces(error) << endl;
+    }
 …
+        }
         catch (Tcl::tcl_error const &e)
         {   COUT(1) << "Tcl error: " << e.what() << std::endl;   }
+        {   orxout(user_error, context::tcl) << "Tcl error: " << e.what() << endl;   }
         if (error)

code/trunk/src/libraries/core/command/TclThreadManager.cc

-                      r8351
+                      r8858
         TclThreadManager::getInstance().numInterpreterBundles_++;
         TclThreadManager::createWithId(TclThreadManager::getInstance().numInterpreterBundles_);
         COUT(0) << "Created new Tcl-interpreter with ID " << TclThreadManager::getInstance().numInterpreterBundles_ << std::endl;
+        orxout(user_info) << "Created new Tcl-interpreter with ID " << TclThreadManager::getInstance().numInterpreterBundles_ << endl;
         return TclThreadManager::getInstance().numInterpreterBundles_;
+    }
 …
+        }
         catch (const Tcl::tcl_error& e)
+        {   bundle->interpreter_ = 0; COUT(1) << "Tcl error while creating Tcl-interpreter (" << id_string << "): " << e.what() << std::endl;   }
+        {
+            bundle->interpreter_ = 0;
+            orxout(user_error, context::tcl) << "Tcl error while creating Tcl-interpreter (" << id_string << "): " << e.what() << endl;
+        }
+    }
 …
+            {
                 // This query would lead to a deadlock - return with an error
                 TclThreadManager::error("Error: Circular query (" + this->dumpList(source_bundle->queriers_.getList()) + ' ' + multi_cast<std::string>(source_bundle->id_) \
+                TclThreadManager::error("Circular query (" + this->dumpList(source_bundle->queriers_.getList()) + ' ' + multi_cast<std::string>(source_bundle->id_) \
                             + " -> " + multi_cast<std::string>(target_bundle->id_) \
                             + "), couldn't query Tcl-interpreter with ID " + multi_cast<std::string>(target_bundle->id_) \
 …
                         int error;
                         output = CommandExecutor::query(command, &error, false);
+                        switch (error)
+                        {
+                            case CommandExecutor::Error:       TclThreadManager::error("Error: Can't execute command \"" + command + "\", command doesn't exist. (T)"); break;
+                            case CommandExecutor::Incomplete:  TclThreadManager::error("Error: Can't execute command \"" + command + "\", not enough arguments given. (T)"); break;
+                            case CommandExecutor::Deactivated: TclThreadManager::error("Error: Can't execute command \"" + command + "\", command is not active. (T)"); break;
+                            case CommandExecutor::Denied:      TclThreadManager::error("Error: Can't execute command \"" + command + "\", access denied. (T)"); break;
+                        }
+                        if (error)
+                            TclThreadManager::error("Can't execute command \"" + command + "\", " + CommandExecutor::getErrorDescription(error) + ". (TclThreadManager)");
+                    }
                     else
 …
                     // This happens if the main thread tries to query a busy interpreter
                     // To avoid a lock of the main thread, we simply don't proceed with the query in this case
                     TclThreadManager::error("Error: Couldn't query Tcl-interpreter with ID " + multi_cast<std::string>(target_bundle->id_) + ", interpreter is busy right now.");
+                    TclThreadManager::error("Couldn't query Tcl-interpreter with ID " + multi_cast<std::string>(target_bundle->id_) + ", interpreter is busy right now.");
+                }
+            }
 …
         else
+        {
             TclThreadManager::error("Error: No Tcl-interpreter with ID " + multi_cast<std::string>(id) + " existing.");
+            TclThreadManager::error("No Tcl-interpreter with ID " + multi_cast<std::string>(id) + " existing.");
             return 0;
+        }

code/trunk/src/libraries/core/input/Button.cc

r7891	r8858
38	38	#include "util/SubString.h"
39	39	#include "util/StringUtils.h"
40		#include "util/~~Debug~~.h"
	40	#include "util/Output.h"
41	41	#include "core/command/ConsoleCommand.h"
42	42	#include "core/command/CommandEvaluation.h"
…	…
255	255	if (serious)
256	256	{
257		~~COUT(2~~) << "Error while parsing binding for button/axis " << this->name_ << ". "
258		<< message << ~~std::~~endl;
	257	orxout(internal_error, context::input) << "Error while parsing binding for button/axis " << this->name_ << ". "
	258	<< message << endl;
259	259	}
260	260	else
261	261	{
262		~~COUT(3~~) << "Warning while parsing binding for button/axis " << this->name_ << ". "
263		<< message << ~~std::~~endl;
	262	orxout(internal_warning, context::input) << "Warning while parsing binding for button/axis " << this->name_ << ". "
	263	<< message << endl;
264	264	}
265	265	}

code/trunk/src/libraries/core/input/InputDevice.h

-                      r8351
+                      r8858
 #include "util/Clock.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/Exception.h"
 #include "InputState.h"
 …
             //       invalid right until the subclass has been constructed!
             oisDevice_->setEventCallback(static_cast<DeviceClass*>(this));
             COUT(4) << "Instantiated a " << this->getClassName() << std::endl;
+            orxout(verbose, context::input) << "Instantiated a " << this->getClassName() << endl;
+        }
 …
             catch (const OIS::Exception& ex)
+            {
                 COUT(1) << this->getClassName() << " destruction failed: " << ex.eText << std::endl
                         << "    Potential resource leak!" << std::endl;
+                orxout(internal_error, context::input) << this->getClassName() << " destruction failed: " << ex.eText << '\n'
+                                                       << "Potential resource leak!" << endl;
+            }
+        }

code/trunk/src/libraries/core/input/InputManager.cc

-                      r8729
+                      r8858
         RegisterRootObject(InputManager);
         CCOUT(4) << "Constructing..." << std::endl;
+        orxout(internal_status, context::input) << "InputManager: Constructing..." << endl;
         // Allocate space for the function call buffer
 …
         ModifyConsoleCommand(__CC_InputManager_name, __CC_reload_name).setObject(this);
         CCOUT(4) << "Construction complete." << std::endl;
+        orxout(internal_status, context::input) << "InputManager: Construction complete." << endl;
         internalState_ = Nothing;
+    }
 …
     void InputManager::loadDevices()
+    {
         CCOUT(4) << "Loading input devices..." << std::endl;
+        orxout(verbose, context::input) << "InputManager: Loading input devices..." << endl;
         // When loading the devices they should not already be loaded
 …
             // Exception-safety
             Loki::ScopeGuard guard = Loki::MakeGuard(OIS::InputManager::destroyInputSystem, oisInputManager_);
             CCOUT(4) << "Created OIS input manager." << std::endl;
+            orxout(verbose, context::input) << "Created OIS input manager." << endl;
             if (oisInputManager_->getNumberOfDevices(OIS::OISKeyboard) > 0)
 …
         this->updateActiveStates();
         CCOUT(4) << "Input devices loaded." << std::endl;
+        orxout(verbose, context::input) << "Input devices loaded." << endl;
+    }
 …
             catch (const std::exception& ex)
+            {
                 CCOUT(2) << "Warning: Failed to create Mouse:" << ex.what() << std::endl
                          << "Proceeding without mouse support." << std::endl;
+            }
+        }
         else
             CCOUT(2) << "Warning: No mouse found! Proceeding without mouse support." << std::endl;
+                orxout(user_warning, context::input) << "Failed to create Mouse:" << ex.what() << '\n'
+                                                     << "Proceeding without mouse support." << endl;
+            }
+        }
+        else
+            orxout(user_warning, context::input) << "No mouse found! Proceeding without mouse support." << endl;
+    }
 …
             catch (const std::exception& ex)
+            {
                 CCOUT(2) << "Warning: Failed to create joy stick: " << ex.what() << std::endl;
+                orxout(user_warning, context::input) << "Failed to create joy stick: " << ex.what() << endl;
+            }
+        }
 …
     InputManager::~InputManager()
+    {
         CCOUT(3) << "Destroying..." << std::endl;
+        orxout(internal_status, context::input) << "InputManager: Destroying..." << endl;
         // Leave all active InputStates (except "empty")
 …
         ModifyConsoleCommand(__CC_InputManager_name, __CC_reload_name).setObject(0);
         CCOUT(3) << "Destruction complete." << std::endl;
+        orxout(internal_status, context::input) << "InputManager: Destruction complete." << endl;
+    }
 …
     void InputManager::destroyDevices()
+    {
         CCOUT(4) << "Destroying devices..." << std::endl;
+        orxout(verbose, context::input) << "InputManager: Destroying devices..." << endl;
         BOOST_FOREACH(InputDevice*& device, devices_)
 …
             delete device;
             device = 0;
             CCOUT(4) << className << " destroyed." << std::endl;
+            orxout(verbose, context::input) << className << " destroyed." << endl;
+        }
         devices_.resize(InputDeviceEnumerator::FirstJoyStick);
 …
         catch (const OIS::Exception& ex)
+        {
             COUT(1) << "OIS::InputManager destruction failed" << ex.eText << std::endl
                     << "    Potential resource leak!" << std::endl;
+            orxout(internal_error, context::input) << "OIS::InputManager destruction failed" << ex.eText << '\n'
+                                                   << "Potential resource leak!" << endl;
+        }
         oisInputManager_ = NULL;
         internalState_ |= Bad;
         CCOUT(4) << "Destroyed devices." << std::endl;
+        orxout(verbose, context::input) << "Destroyed devices." << endl;
+    }
 …
+    {
         if (internalState_ & Calibrating)
             CCOUT(2) << "Warning: Cannot reload input system. Joy sticks are currently being calibrated." << std::endl;
+            orxout(internal_warning, context::input) << "Cannot reload input system. Joy sticks are currently being calibrated." << endl;
         else
             reloadInternal();
 …
     void InputManager::reloadInternal()
+    {
         CCOUT(4) << "Reloading ..." << std::endl;
+        orxout(verbose, context::input) << "InputManager: Reloading ..." << endl;
         this->destroyDevices();
 …
         internalState_ &= ~Bad;
         CCOUT(4) << "Reloading complete." << std::endl;
+        orxout(verbose, context::input) << "InputManager: Reloading complete." << endl;
+    }
 …
     void InputManager::calibrate()
+    {
         COUT(0) << "Move all joy stick axes fully in all directions." << std::endl
                 << "When done, put the axex in the middle position and press enter." << std::endl;
+        orxout(message) << "Move all joy stick axes fully in all directions." << '\n'
+                        << "When done, put the axex in the middle position and press enter." << endl;
         BOOST_FOREACH(InputDevice* device, devices_)
 …
         this->clearBuffers();
         COUT(0) << "Calibration has been stored." << std::endl;
+        orxout(message) << "Calibration has been stored." << endl;
+    }
 …
                     if (it->second->getPriority() == priority)
+                    {
                         COUT(2) << "Warning: Could not add an InputState with the same priority '"
                             << static_cast<int>(priority) << "' != 0." << std::endl;
+                        orxout(internal_warning, context::input) << "Could not add an InputState with the same priority '"
+                            << static_cast<int>(priority) << "' != 0." << endl;
                         return 0;
+                    }
 …
         else
+        {
             COUT(2) << "Warning: Could not add an InputState with the same name '" << name << "'." << std::endl;
+            orxout(internal_warning, context::input) << "Could not add an InputState with the same name '" << name << "'." << endl;
             return 0;
+        }
 …
         if (name == "empty")
+        {
             COUT(2) << "InputManager: Leaving the empty state is not allowed!" << std::endl;
+            orxout(internal_warning, context::input) << "InputManager: Leaving the empty state is not allowed!" << endl;
             return false;
+        }
 …
         if (name == "empty")
+        {
             COUT(2) << "InputManager: Removing the empty state is not allowed!" << std::endl;
+            orxout(internal_warning, context::input) << "InputManager: Removing the empty state is not allowed!" << endl;
             return false;
+        }
 …
         if (name == "empty")
+        {
             COUT(2) << "InputManager: Changing the empty state is not allowed!" << std::endl;
+            orxout(internal_warning, context::input) << "InputManager: Changing the empty state is not allowed!" << endl;
             return false;
+        }

code/trunk/src/libraries/core/input/JoyStick.cc

r6536	r8858
80	80	}
81	81
82		~~COUT(4) << "Created OIS joy stick with ID " << deviceName_ << std::~~endl;
	82	orxout(verbose, context::input) << "Created OIS joy stick with ID " << deviceName_ << endl;
83	83
84	84	// Load calibration

code/trunk/src/libraries/core/input/KeyBinder.cc

-                      r8366
+                      r8858
 #include <sstream>
 #include "util/Convert.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/Exception.h"
 #include "core/ConfigValueIncludes.h"
 …
     void KeyBinder::loadBindings()
+    {
         COUT(3) << "KeyBinder: Loading key bindings..." << std::endl;
+        orxout(internal_info, context::input) << "KeyBinder: Loading key bindings..." << endl;
         this->configFile_ = new ConfigFile(this->filename_, !PathConfig::buildDirectoryRun());
 …
+        }
         COUT(3) << "KeyBinder: Loading key bindings done." << std::endl;
+        orxout(internal_info, context::input) << "KeyBinder: Loading key bindings done." << endl;
+    }
 …
         else
+        {
             COUT(2) << "Could not find key/button/axis with name '" << name << "'." << std::endl;
+            orxout(internal_warning, context::input) << "Could not find key/button/axis with name '" << name << "'." << endl;
             return false;
+        }

code/trunk/src/libraries/core/input/KeyBinderManager.cc

-                      r7284
+                      r8858
 #include "KeyBinderManager.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/Exception.h"
 #include "util/ScopedSingletonManager.h"
 …
         if (!this->bBinding_)
+        {
             COUT(0) << "Press any button/key or move a mouse/joystick axis" << std::endl;
+            orxout(message) << "Press any button/key or move a mouse/joystick axis" << endl;
             KeyDetector::getInstance().setCallback(createFunctor(&KeyBinderManager::keybindKeyPressed, this));
             InputManager::getInstance().enterState("detector");
 …
             if (keyName == "Keys.KeyEscape")
+            {
                 COUT(0) << "Keybinding aborted." << std::endl;
+                orxout(message) << "Keybinding aborted." << endl;
+            }
             else
+            {
                 COUT(0) << "Binding string \"" << command_ << "\" on key '" << keyName << "'" << std::endl;
+                orxout(message) << "Binding string \"" << command_ << "\" on key '" << keyName << "'" << endl;
                 this->currentBinder_->setBinding(command_, keyName, bTemporary_);
+            }

code/trunk/src/libraries/network/CMakeLists.txt

-                      r8351
+                      r8858
 SET_SOURCE_FILES(NETWORK_SRC_FILES
-  ChatListener.cc
   Client.cc
   ClientConnection.cc
 …
 SET_SOURCE_FILES(NETWORK_HDR_FILES
-  ChatListener.h
   Client.h
   ClientConnection.h
 …
   WANDiscovery.h
   MasterServerComm.h
+  NetworkChatListener.h
   NetworkFunction.h
   NetworkPrecompiledHeaders.h

code/trunk/src/libraries/network/Client.cc

-                      r8327
+                      r8858
 #include "util/Clock.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/ScopedSingletonManager.h"
 #include "synchronisable/Synchronisable.h"
 …
+  }
-  bool Client::processChat(const std::string& message, unsigned int playerID)
+  {
-//    COUT(1) << "Player " << playerID << ": " << message << std::endl;
-    return true;
+  }
   void Client::printRTT()
+  {
     COUT(0) << "Round trip time to server is " << ClientConnection::getRTT() << " ms" << endl;
+  }
   /**
    * This function implements the method of sending a chat message to the server
+    orxout(message) << "Round trip time to server is " << ClientConnection::getRTT() << " ms" << endl;
+  }
+  /**
+   * @brief Sends a chat message to the server.
    * @param message message to be sent
+   * @return result(true/false)
+   * @param sourceID the ID of the sender
+   * @param targetID the ID of the receiver
    */
+  bool Client::chat(const std::string& message)
+  {
+    packet::Chat *m = new packet::Chat(message, Host::getPlayerID());
+    return m->send(static_cast<Host*>(this));
+  }
+  void Client::doSendChat(const std::string& message, unsigned int sourceID, unsigned int targetID)
+  {
+    // send the message to the server
+    packet::Chat* packet = new packet::Chat(message, sourceID, targetID);
+    packet->send(static_cast<Host*>(this));
+  }
+  /**
+   * @brief Gets called if a packet::Chat packet is received. Calls the parent function which passes the message to the listeners.
+   */
+  void Client::doReceiveChat(const std::string& message, unsigned int sourceID, unsigned int targetID)
+  {
+    // call the parent function which passes the message to the listeners
+    Host::doReceiveChat(message, sourceID, targetID);
+  }
   /**
 …
+    {
       timeSinceLastUpdate_ -= static_cast<unsigned int>( timeSinceLastUpdate_ / NETWORK_PERIOD ) * NETWORK_PERIOD;
-      //     COUT(3) << '.';
       if ( isConnected() && isSynched_ )
+      {
         COUT(4) << "popping partial gamestate: " << std::endl;
+        orxout(verbose, context::network) << "popping partial gamestate: " << endl;
 //         packet::Gamestate *gs = GamestateClient::getGamestate();
         if( GamestateManager::update() )
 …
         //assert(gs); <--- there might be the case that no data has to be sent, so its commented out now
 //         if(gs){
 //           COUT(4) << "client tick: sending gs " << gs << std::endl;
+//           orxout(verbose, context::network) << "client tick: sending gs " << gs << endl;
 //           if( !gs->send() )
 //             COUT(2) << "Problem adding partial gamestate to queue" << std::endl;
+//             orxout(internal_warning, context::network) << "Problem adding partial gamestate to queue" << endl;
 //         // gs gets automatically deleted by enet callback
 //         }
 …
     Game::getInstance().popState();
+  }
   void Client::processPacket(packet::Packet* packet)
+  {
 …
       packet->process(static_cast<Host*>(this));
+  }
+}

code/trunk/src/libraries/network/Client.h

-                      r7801
+                      r8858
     Client();
     ~Client();
     static Client* getInstance(){ return singletonPtr_s; } // tolua_export
 …
     void queuePacket(ENetPacket* packet, int clientID, uint8_t channelID);
     virtual bool sendPacket( packet::Packet* packet ){ return packet->send( static_cast<Host*>(this) ); }
+    bool processChat(const std::string& message, unsigned int playerID);
+    virtual bool chat(const std::string& message);
+    virtual bool broadcast(const std::string& message) { return false; }
+    virtual void doSendChat(const std::string& message, unsigned int sourceID, unsigned int targetID);
+    virtual void doReceiveChat(const std::string& message, unsigned int sourceID, unsigned int targetID);
     virtual void printRTT();

code/trunk/src/libraries/network/ClientConnection.cc

-                      r8327
+                      r8858
 #define WIN32_LEAN_AND_MEAN
 #include <enet/enet.h>
 #include "util/Debug.h"
+#include "util/Output.h"
 namespace orxonox
 …
   void ClientConnection::setServerAddress( const std::string& serverAddress ) {
     if (enet_address_set_host (this->serverAddress_, serverAddress.c_str()) < 0)
         COUT(1) << "Error: Could not resolve \"" << serverAddress << "\"." << std::endl;
+        orxout(internal_error, context::network) << "Could not resolve \"" << serverAddress << "\"." << endl;
+  }
 …
     if ( this->host_ == NULL )
+    {
       COUT(1) << "ClientConnection: host_ == NULL" << std::endl;
+      orxout(internal_error, context::network) << "ClientConnection: host_ == NULL" << endl;
       // error handling
       return false;
 …
     assert( this->host_->socket4 != ENET_SOCKET_NULL || this->host_->socket6 != ENET_SOCKET_NULL );
     if (this->host_->socket4 == ENET_SOCKET_NULL)
         COUT(2) << "Warning: IPv4 Socket failed." << std::endl;
+        orxout(internal_warning, context::network) << "IPv4 Socket failed." << endl;
     else if (this->host_->socket6 == ENET_SOCKET_NULL)
         COUT(2) << "Warning: IPv6 Socket failed." << std::endl;
+        orxout(internal_warning, context::network) << "IPv6 Socket failed." << endl;
     else
         COUT(3) << "Info: Using IPv4 and IPv6 Sockets." << std::endl;
+        orxout(internal_info, context::network) << "Using IPv4 and IPv6 Sockets." << endl;
     this->server_ = enet_host_connect(this->host_, serverAddress_, NETWORK_CHANNEL_COUNT, 0);
     if ( this->server_==NULL )
+    {
       COUT(1) << "ClientConnection: server_ == NULL" << std::endl;
+      orxout(internal_error, context::network) << "ClientConnection: server_ == NULL" << endl;
       // error handling
       return false;
 …
+      }
+    }
     COUT(1) << "Could not connect to server" << endl;
+    orxout(user_error, context::network) << "Could not connect to server" << endl;
     return false;
+  }
 …
             break;
           case ENET_EVENT_TYPE_DISCONNECT:
             COUT(4) << "received disconnect confirmation from server" << endl;
+            orxout(verbose, context::network) << "received disconnect confirmation from server" << endl;
             this->connectionClosed();
             return true;
 …
+  {
     this->established_=false;
     COUT(1) << "Received disconnect Packet from Server!" << endl;
+    orxout(internal_error, context::network) << "Received disconnect Packet from Server!" << endl;
         // server closed the connection
     this->stopCommunicationThread();

code/trunk/src/libraries/network/Connection.cc

r8327	r8858
144	144	while( outgoingEventsCount > 0 )
145	145	{
146		// ~~COUT(0~~) << "outgoing event" << endl;
	146	// orxout(verbose, context::network) << "outgoing event" << endl;
147	147	this->outgoingEventsMutex_->lock();
148	148	outgoingEvent outEvent = this->outgoingEvents_.front();

code/trunk/src/libraries/network/GamestateManager.cc

-                      r8407
+                      r8858
 #include "core/command/Executor.h"
 #include "core/GameMode.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/Clock.h"
 #include "util/OrxAssert.h"
 …
     if( !this->sendPacket(ack))
+    {
       COUT(3) << "could not ack gamestate: " << gamestateID << std::endl;
+      orxout(internal_warning, context::network) << "could not ack gamestate: " << gamestateID << endl;
       return false;
+    }
     else
+    {
       COUT(5) << "acked a gamestate: " << gamestateID << std::endl;
+      orxout(verbose_more, context::network) << "acked a gamestate: " << gamestateID << endl;
       return true;
+    }
 …
       if( !peerIt->second.isSynched )
+      {
         COUT(5) << "Server: not sending gamestate" << std::endl;
+        orxout(verbose_more, context::network) << "Server: not sending gamestate" << endl;
         continue;
+      }
       COUT(5) << "client id: " << peerIt->first << std::endl;
       COUT(5) << "Server: doing gamestate gamestate preparation" << std::endl;
+      orxout(verbose_more, context::network) << "client id: " << peerIt->first << endl;
+      orxout(verbose_more, context::network) << "Server: doing gamestate gamestate preparation" << endl;
       int peerID = peerIt->first; //get client id
 …
 //     OrxVerify(gs->compressData(), "");
     clock.capture();
     COUT(5) << "diff and compress time: " << clock.getDeltaTime() << endl;
 //     COUT(5) << "sending gamestate with id " << gs->getID();
+    orxout(verbose_more, context::network) << "diff and compress time: " << clock.getDeltaTime() << endl;
+//     orxout(verbose_more, context::network) << "sending gamestate with id " << gs->getID();
 //     if(gamestate->isDiffed())
 //       COUT(5) << " and baseid " << gs->getBaseID() << endl;
+//       orxout(verbose_more, context::network) << " and baseid " << gs->getBaseID() << endl;
 //     else
 //       COUT(5) << endl;
+//       orxout(verbose_more, context::network) << endl;
     gs->setPeerID(peerID);
     destgamestate = gs;
 …
     if( gamestateID <= curid && curid != GAMESTATEID_INITIAL )
         return true;
 COUT(4) << "acking gamestate " << gamestateID << " for peerID: " << peerID << " curid: " << curid << std::endl;
+orxout(verbose, context::network) << "acking gamestate " << gamestateID << " for peerID: " << peerID << " curid: " << curid << endl;
     std::map<uint32_t, packet::Gamestate*>::iterator it2;
     for( it2=it->second.gamestates.begin(); it2!=it->second.gamestates.end(); )

code/trunk/src/libraries/network/Host.cc

-                      r8408
+                      r8858
 #include <string>
+#include "core/CoreIncludes.h"
 #include "core/ObjectList.h"
 #include "core/command/ConsoleCommand.h"
 #include "ChatListener.h"
+#include "NetworkChatListener.h"
 namespace orxonox {
 …
   static const std::string __CC_printRTT_name = "printRTT";
-  SetConsoleCommand("chat", &Host::Chat);
   SetConsoleCommand(__CC_printRTT_group, __CC_printRTT_name, &Host::printRTT);
 …
+  }
+  void Host::Chat(const std::string& message)
+  /**
+   * @brief Sends a chat message through the network.
+   * @param message message to be sent
+   * @param sourceID the ID of the sender
+   * @param targetID the ID of the receiver
+   */
+  void Host::sendChat(const std::string& message, unsigned int sourceID, unsigned int targetID)
+  {
+    if(instances_s.size()==0)
+    {
+      for (ObjectList<ChatListener>::iterator it = ObjectList<ChatListener>::begin(); it != ObjectList<ChatListener>::end(); ++it)
+        it->incomingChat(message, 0);
+//      return true;
+    }
+    else
+    {
+      bool result = true;
+      for( std::vector<Host*>::iterator it = instances_s.begin(); it!=instances_s.end(); ++it )
+      {
+        if( (*it)->isActive() )
+        {
+          if( !(*it)->chat(message) )
+            result = false;
+        }
+      }
+//      return result;
+    }
+    for( std::vector<Host*>::iterator it = instances_s.begin(); it!=instances_s.end(); ++it )
+      if( (*it)->isActive() )
+        (*it)->doSendChat(message, sourceID, targetID);
+  }
+  bool Host::Broadcast(const std::string& message)
+  /**
+   * @brief Gets called if a packet::Chat packet is received. Passes the message to the listeners.
+   */
+  void Host::doReceiveChat(const std::string& message, unsigned int sourceID, unsigned int targetID)
+  {
+    if(instances_s.size()==0)
+    {
+      for (ObjectList<ChatListener>::iterator it = ObjectList<ChatListener>::begin(); it != ObjectList<ChatListener>::end(); ++it)
+        it->incomingChat(message, NETWORK_PEER_ID_BROADCAST);
+      return true;
+    }
+    else
+    {
+      bool result = true;
+      for( std::vector<Host*>::iterator it = instances_s.begin(); it!=instances_s.end(); ++it )
+      {
+        if( (*it)->isActive() )
+        {
+          if( !(*it)->broadcast(message) )
+            result = false;
+        }
+      }
+      return result;
+    }
+    for (ObjectList<NetworkChatListener>::iterator it = ObjectList<NetworkChatListener>::begin(); it != ObjectList<NetworkChatListener>::end(); ++it)
+      it->incomingChat(message, sourceID);
+  }
-  bool Host::incomingChat(const std::string& message, unsigned int playerID)
+  {
-    for (ObjectList<ChatListener>::iterator it = ObjectList<ChatListener>::begin(); it != ObjectList<ChatListener>::end(); ++it)
-      it->incomingChat(message, playerID);
-    bool result = true;
-    for( std::vector<Host*>::iterator it = instances_s.begin(); it!=instances_s.end(); ++it )
+    {
-      if( (*it)->isActive() )
+      {
-        if( !(*it)->processChat(message, playerID) )
-          result = false;
+      }
+    }
-    return result;
+  }
   bool Host::isServer()
 …
     for (std::vector<Host*>::iterator it=instances_s.begin(); it!=instances_s.end(); ++it )
+    {
+      if( (*it)->isServer_() )
+        return true;
+      if( (*it)->isActive() )
+      {
+        if( (*it)->isServer_() )
+          return true;
+      }
+    }
     return false;
+  }
   Host* Host::getActiveInstance()
+  {
 …
+  //////////////////////////////////////////////////////////////////////////
+  // NetworkChatListener                                                  //
+  //////////////////////////////////////////////////////////////////////////
+  NetworkChatListener::NetworkChatListener()
+  {
+      RegisterRootObject(NetworkChatListener);
+  }
 }//namespace orxonox

code/trunk/src/libraries/network/Host.h

-                      r8403
+                      r8858
 class _NetworkExport Host: public GamestateManager
+{
+  friend class packet::Chat;
   private:
-    //TODO add these functions or adequate
-    //virtual bool processChat(packet::Chat *message, unsigned int clientID)=0;
-    //virtual bool sendChat(packet::Chat *chat)=0;
     virtual void queuePacket(ENetPacket *packet, int clientID, uint8_t channelID)=0;
-    virtual bool chat(const std::string& message)=0;
-    virtual bool broadcast(const std::string& message)=0;
-    virtual bool processChat(const std::string& message, unsigned int playerID)=0;
     virtual bool isServer_()=0;
   protected:
 …
     virtual ~Host();
     void setActive( bool bActive ){ bIsActive_ = bActive; }
+//     static Host *instance_;
+    virtual void doSendChat(const std::string& message, unsigned int sourceID, unsigned int targetID)=0;
+    virtual void doReceiveChat(const std::string& message, unsigned int sourceID, unsigned int targetID)=0;
   public:
 …
     static bool running(){ return instances_s.size(); }
     static void addPacket(ENetPacket* packet, int clientID = NETWORK_PEER_ID_SERVER, uint8_t channelID = 0);
-    //static bool chat(std::string& message);
-//     static bool receiveChat(packet::Chat *message, unsigned int clientID);
     static unsigned int getPlayerID(){ return clientID_s; }
     static void setClientID(unsigned int id){ clientID_s = id; }
     static bool isServer();
+    static void Chat(const std::string& message);
+    static bool Broadcast(const std::string& message);
+    static bool incomingChat(const std::string& message, unsigned int playerID);
+    static void sendChat(const std::string& message, unsigned int sourceID, unsigned int targetID);
     virtual void printRTT()=0;
     bool isActive(){ return bIsActive_; }

code/trunk/src/libraries/network/LANDiscoverable.cc

-                      r8351
+                      r8858
 #include <cstring>
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "packet/ServerInformation.h"
 …
       this->host_ = enet_host_create( &bindAddress, 10, 0, 0, 0 );
       if ( this->host_ == NULL )
           COUT(1) << "LANDiscoverable: host_ == NULL" << std::endl;
+          orxout(internal_error, context::network) << "LANDiscoverable: host_ == NULL" << endl;
+    }
     else
 …
+      {
         case ENET_EVENT_TYPE_CONNECT:
             COUT(4) << "Received LAN discovery connect from client " << event.peer->host->receivedAddress << std::endl;
+            orxout(verbose, context::network) << "Received LAN discovery connect from client " << event.peer->host->receivedAddress << endl;
             break;
         case ENET_EVENT_TYPE_DISCONNECT:
 …
           if( strcmp( LAN_DISCOVERY_MESSAGE, (char*)event.packet->data ) == 0 )      // check for a suitable orxonox client
+          {
             COUT(3) << "Received LAN discovery message from client " << event.peer->host->receivedAddress << std::endl;
+            orxout(internal_info, context::network) << "Received LAN discovery message from client " << event.peer->host->receivedAddress << endl;
             packet::ServerInformation info;
             info.setServerName("Orxonox Server");

code/trunk/src/libraries/network/LANDiscovery.cc

-                      r8706
+                      r8858
+ *
  *   Author:
  *      Fabian 'x3n' Landau
+ *      Oliver Scheuss
  *   Co-authors:
  *      ...
 …
     this->host_ = enet_host_create(NULL, 10, 0, 0, 0 );
     if ( this->host_ == NULL )
         COUT(1) << "LANDiscovery: host_ == NULL" << std::endl;
+        orxout(internal_error, context::network) << "LANDiscovery: host_ == NULL" << endl;
+  }
 …
     peer = enet_host_connect(this->host_, &address, 0, 0);
     if (peer == NULL)
         COUT(1) << "Error: Could not send LAN discovery to IPv4 Broadcast." << std::endl;
+        orxout(internal_error, context::network) << "Could not send LAN discovery to IPv4 Broadcast." << endl;
     /* IPv6 */
 …
     peer = enet_host_connect(this->host_, &address, 0, 0);
     if (peer == NULL)
         COUT(1) << "Error: Could not send LAN discovery to IPv6 Multicast." << std::endl;
+        orxout(internal_error, context::network) << "Could not send LAN discovery to IPv6 Multicast." << endl;
     ENetEvent event;
 …
         case ENET_EVENT_TYPE_CONNECT:
+        {
           COUT(4) << "Received LAN discovery connect from server " << event.peer->host->receivedAddress << std::endl;
+          orxout(verbose, context::network) << "Received LAN discovery connect from server " << event.peer->host->receivedAddress << endl;
           ENetPacket* packet = enet_packet_create(LAN_DISCOVERY_MESSAGE, strlen(LAN_DISCOVERY_MESSAGE)+1, ENET_PACKET_FLAG_RELIABLE);
           enet_peer_send(event.peer, 0, packet);
 …
+          {
             packet::ServerInformation info(&event);
             COUT(3) << "Received LAN discovery server information; Name: " << info.getServerName() << ", Address: " << info.getServerIP() << ", RTT: " << info.getServerRTT() << endl;
+            orxout(internal_info, context::network) << "Received LAN discovery server information; Name: " << info.getServerName() << ", Address: " << info.getServerIP() << ", RTT: " << info.getServerRTT() << endl;
             std::vector<packet::ServerInformation>::iterator it;
             for( it=this->servers_.begin(); it!=this->servers_.end(); ++it )

code/trunk/src/libraries/network/LANDiscovery.h

r8351	r8858
21	21	*
22	22	* Author:
23		* ~~Fabian 'x3n' Landau~~
	23	* Oliver Scheuss
24	24	* Co-authors:
25	25	* ...

code/trunk/src/libraries/network/MasterServer.cc

-                      r8351
+                      r8858
   helper_output_debug( ENetEvent *event, char *addrconv )
+  {
+    COUT(4) << "A packet of length"
+    orxout(verbose, context::master_server)
+      << "A packet of length"
       << event->packet->dataLength
       << " containing "
 …
       << addrconv
       << " on channel "
       << event->channelID << "\n";
+      << event->channelID << endl;
+  }
 …
           + MSPROTO_SERVERLIST_ITEM_LEN + 2,1 );
       if( !tosend )
       { COUT(2) << "Masterserver.cc: Memory allocation failed.\n";
+      { orxout(internal_warning, context::master_server) << "Masterserver.cc: Memory allocation failed." << endl;
         continue;
+      }
 …
   { /* check for bad parameters */
     if( !event )
     { COUT(2) << "MasterServer::eventConnect: No event given.\n" ;
+    { orxout(internal_warning, context::master_server) << "MasterServer::eventConnect: No event given." << endl;
       return -1;
+    }
 …
     /* output debug info */
     COUT(4) << "A new client connected from "
+    orxout(verbose, context::master_server) << "A new client connected from "
       << addrconv
       << " on port "
       << event->peer->address.port << "\n";
+      << event->peer->address.port << endl;
     /* store string form of address here */
 …
   { /* check for bad parameters */
     if( !event )
     { COUT(2) << "No event given.\n";
+    { orxout(internal_warning, context::master_server) << "No event given." << endl;
       return -1;
+    }
     /* output that the disconnect happened */
     COUT(4) << (char*)event->peer->data << " disconnected.\n";
+    orxout(verbose, context::master_server) << (char*)event->peer->data << " disconnected." << endl;
     /* create string from peer data */
 …
   { /* validate packet */
     if( !event || !(event->packet) || !(event->peer) )
     { COUT(2) << "No complete event given.\n";
+    { orxout(internal_warning, context::master_server) << "No complete event given." << endl;
       return -1;
+    }
 …
         /* tell people we did so */
         COUT(2) << "Added new server to list: " <<
           packet::ServerInformation( event ).getServerIP() << "\n";
+        orxout(internal_info, context::master_server) << "Added new server to list: " <<
+          packet::ServerInformation( event ).getServerIP() << endl;
+      }
 …
         /* tell the user */
         COUT(2) << "Removed server " << name << " from list.\n";
+        orxout(internal_info, context::master_server) << "Removed server " << name << " from list." << endl;
+      }
 …
     if( event == NULL )
+    {
       COUT(1) << "Could not create ENetEvent structure, exiting.\n";
+      orxout(user_error, context::master_server) << "Could not create ENetEvent structure, exiting." << endl;
       exit( EXIT_FAILURE );
+    }
 …
     /***** INITIALIZE NETWORKING *****/
     if( enet_initialize () != 0)
     { COUT(1) << "An error occurred while initializing ENet.\n";
+    { orxout(user_error, context::master_server) << "An error occurred while initializing ENet." << endl;
       exit( EXIT_FAILURE );
+    }
 …
     /* see if creation worked */
     if( !this->server )
     { COUT(1) <<
         "An error occurred while trying to create an ENet server host.\n";
+    { orxout(user_error, context::master_server) <<
+        "An error occurred while trying to create an ENet server host." << endl;
       exit( EXIT_FAILURE );
+    }
 …
     /* tell people we're now initialized */
     COUT(0) << "MasterServer initialized, waiting for connections.\n";
+    orxout(internal_status, context::master_server) << "MasterServer initialized, waiting for connections." << endl;
+  }

code/trunk/src/libraries/network/MasterServerComm.cc

-                      r8351
+                      r8858
 #include "MasterServerComm.h"
+#include "util/Debug.h"
+#include "util/Output.h"
+#include "WANDiscovery.h"
 namespace orxonox
 …
     /* initialize Enet */
     if( enet_initialize () != 0 )
     { COUT(1) << "An error occurred while initializing ENet.\n";
+    { orxout(internal_error, context::master_server) << "An error occurred while initializing ENet." << endl;
       return 1;
+    }
 …
     /* see if it worked */
     if (this->client == NULL)
     { COUT(1) << "An error occurred while trying to create an "
         << "ENet client host.\n";
+    { orxout(internal_error, context::master_server) << "An error occurred while trying to create an "
+        << "ENet client host." << endl;
       return 1;
+    }
 …
     if( this->peer == NULL )
     { COUT(2) << "ERROR: No available peers for initiating an ENet"
         << " connection.\n";
+    { orxout(internal_error, context::master_server) << "No available peers for initiating an ENet"
+        << " connection." << endl;
       return -1;
+    }
 …
     if (enet_host_service (this->client, &this->event, 500) > 0 &&
         this->event.type == ENET_EVENT_TYPE_CONNECT )
       COUT(3) << "Connection to master server succeeded.\n";
+      orxout(internal_info, context::master_server) << "Connection to master server succeeded." << endl;
     else
+    {
       enet_peer_reset (this->peer);
       COUT(2) << "ERROR: connection to " << address << " failed.\n";
+      orxout(internal_warning, context::master_server) << "Connection to " << address << " failed." << endl;
       return -1;
+    }
 …
         case ENET_EVENT_TYPE_DISCONNECT:
           COUT(4) << "Disconnect from master server successful.\n";
+          orxout(verbose, context::master_server) << "Disconnect from master server successful." << endl;
           return 0;
         default: break;
 …
    * so we can also make callbacks from objects
    */
+  int MasterServerComm::pollForReply( int (*callback)( char*, ENetEvent* ),
+    int delayms )
+  int MasterServerComm::pollForReply( WANDiscovery* listener, int delayms )
+  {
     /* see whether anything happened */
     /* WORK MARK REMOVE THIS OUTPUT */
     COUT(2) << "polling masterserver...\n";
+    orxout(verbose, context::master_server) << "polling masterserver..." << endl;
     /* address buffer */
 …
           addrconv = (char *) calloc( 50, 1 );
           if( !addrconv )
           { COUT(2) << "MasterServerComm.cc: Could not allocate memory!\n";
+          { orxout(internal_warning, context::master_server) << "MasterServerComm.cc: Could not allocate memory!" << endl;
             break;
+          }
 …
           /* DEBUG */
           COUT(3) << "MasterServer Debug: A packet of length "
+          orxout(verbose, context::master_server) << "MasterServer Debug: A packet of length "
             << this->event.packet->dataLength
             << " containing " << this->event.packet->data
 …
           /* call the supplied callback, if any. */
           if( (*callback) != NULL )
             retval = (*callback)( addrconv, &(this->event) );
+          if( listener != NULL )
+            retval = listener->rhandler( addrconv, &(this->event) );
           /* clean up */

code/trunk/src/libraries/network/MasterServerComm.h

r8351	r8858
93	93	*
94	94	* Poll the master server for new data and act accordingly */
95		int pollForReply( ~~int (callback)( char, ENetEvent* )~~, int delayms );
	95	int pollForReply( WANDiscovery* listener, int delayms );
96	96
97	97	private:

code/trunk/src/libraries/network/NetworkPrecompiledHeaders.h

r8351	r8858
52	52	#include <set> // 20
53	53
54		#include "util/~~Debug~~.h" // 20
	54	#include "util/Output.h" // 20
55	55	#include <loki/TypeTraits.h> // 18
56	56

code/trunk/src/libraries/network/NetworkPrereqs.h

-                      r8351
+                      r8858
 namespace orxonox
+{
-  class ChatListener;
   class Client;
   class ClientConnection;
 …
   class GamestateManager;
   class Host;
+  class MasterServer;
+  class MasterServerComm;
+  class NetworkChatListener;
   class NetworkFunctionBase;
   struct NetworkFunctionPointer;
 …
   class NetworkMemberFunction;
   class NetworkMemberFunctionBase;
+  class PeerList;
   class Server;
   class ServerConnection;
   class TrafficControl;
+  class WANDiscoverable;
+  class WANDiscovery;
   // packet

code/trunk/src/libraries/network/PeerList.cc

-                      r8351
+                      r8858
 #include "PeerList.h"
+#include <network/packet/ServerInformation.h>
 #include <cstdio>
+#include "util/Output.h"
+#include "network/packet/ServerInformation.h"
 namespace orxonox
 …
   { /* error correction */
     if( toadd == NULL )
     { fprintf( stderr, "PeerList::addPeer: empty peer given.\n" );
+    { orxout(internal_error, context::master_server) << "PeerList::addPeer: empty peer given." << endl;
       return -1;
+    }

code/trunk/src/libraries/network/Server.cc

-                      r8706
+                      r8858
 #include "util/Clock.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "core/ObjectList.h"
 #include "core/command/Executor.h"
 …
 #include "packet/Gamestate.h"
 #include "packet/Welcome.h"
-#include "ChatListener.h"
 // #include "ClientInformation.h"
 #include "FunctionCallManager.h"
 #include "GamestateManager.h"
-#include "WANDiscovery.h"
 namespace orxonox
 …
+  }
-  /** helper that connects to the master server */
-  void Server::helper_ConnectToMasterserver()
+  {
-//     WANDiscovery::getInstance().msc.sendRequest( MSPROTO_GAME_SERVER " "
-//       MSPROTO_REGISTER_SERVER );
+  }
   /**
   * This function opens the server by creating the listener thread
 …
+  {
     Host::setActive(true);
     COUT(4) << "opening server" << endl;
+    orxout(verbose, context::network) << "opening server" << endl;
     this->openListener();
     /* make discoverable on LAN */
     LANDiscoverable::setActivity(true);
 …
     /* make discoverable on WAN */
     WANDiscoverable::setActivity(true);
-    /* TODO this needs to be optional, we need a switch from the UI to
-     * enable/disable this
-     */
-//     helper_ConnectToMasterserver();
     /* done */
 …
+  {
     Host::setActive(false);
     COUT(4) << "closing server" << endl;
+    orxout(verbose, context::network) << "closing server" << endl;
     this->disconnectClients();
     this->closeListener();
     /* tell master server we're closing */
     COUT(2) << "disconnecting." << endl;
     WANDiscoverable::setActivity(false);
     COUT(2) << "disconnecting done" << endl;
+    orxout(internal_info, context::network) << "disconnecting." << endl;
+    WANDiscoverable::setActivity(false);
+    orxout(internal_info, context::network) << "disconnecting done" << endl;
     LANDiscoverable::setActivity(false);
     return;
+  }
-  bool Server::processChat(const std::string& message, unsigned int playerID)
+  {
-//     ClientInformation *temp = ClientInformation::getBegin();
-    packet::Chat *chat;
-//     while(temp){
-    chat = new packet::Chat(message, playerID);
-    chat->setPeerID(NETWORK_PEER_ID_BROADCAST);
-    chat->send( static_cast<Host*>(this) );
-//         COUT(3) << "could not send Chat message to client ID: " << temp->getID() << std::endl;
-//       temp = temp->next();
-//     }
-//    COUT(1) << "Player " << playerID << ": " << message << std::endl;
-    return true;
+  }
-  /* handle incoming data */
-  int rephandler( char *addr, ENetEvent *ev )
+  {
-    /* reply to pings */
-    if( !strncmp( (char *)ev->packet->data, MSPROTO_PING_GAMESERVER,
-      MSPROTO_PING_GAMESERVER_LEN ) )
-      //this->msc.sendRequest( MSPROTO_ACK );
-      /* NOTE implement this after pollForReply
-       * reimplementation
-       */
-      return 0;
-    /* done handling, return all ok code 0 */
-    return 0;
+  }
-  void Server::helper_HandleMasterServerRequests()
+  {
-    /* poll the master server for replies and see whether something
-     * has to be done or changed.
-     */
-    //WANDiscovery::getInstance().msc.pollForReply( rhandler, 10 );
+  }
 …
     // receive and process incoming discovery packets
     LANDiscoverable::update();
-    // receive and process requests from master server
-    /* todo */
-    //helper_HandleMasterServerRequests();
     if ( GamestateManager::hasPeers() )
 …
+  {
 //     for( ClientInformation* temp=ClientInformation::getBegin(); temp!=0; temp=temp->next() )
 //       COUT(0) << "Round trip time to client with ID: " << temp->getID() << " is " << temp->getRTT() << " ms" << endl;
+//       orxout(message) << "Round trip time to client with ID: " << temp->getID() << " is " << temp->getRTT() << " ms" << endl;
+  }
 …
       return;
     GamestateManager::update();
 //     COUT(5) << "Server: one gamestate update complete, goig to sendGameState" << std::endl;
     //std::cout << "updated gamestate, sending it" << std::endl;
+//     orxout(verbose_more, context::network) << "Server: one gamestate update complete, goig to sendGameState" << endl;
+    //orxout(verbose_more, context::network) << "updated gamestate, sending it" << endl;
     //if(clients->getGamestateID()!=GAMESTATEID_INITIAL)
     sendGameStates();
     sendObjectDeletes();
 //     COUT(5) << "Server: one sendGameState turn complete, repeat in next tick" << std::endl;
     //std::cout << "sent gamestate" << std::endl;
+//     orxout(verbose_more, context::network) << "Server: one sendGameState turn complete, repeat in next tick" << endl;
+    //orxout(verbose_more, context::network) << "sent gamestate" << endl;
+  }
 …
       return true;  //everything ok (no deletes this tick)
+    }
 //     COUT(3) << "sending DeleteObjects" << std::endl;
+//     orxout(verbose, context::network) << "sending DeleteObjects" << endl;
 //     while(temp != NULL){
 //       if( !(temp->getSynched()) )
 //       {
 //         COUT(5) << "Server: not sending gamestate" << std::endl;
+//         orxout(verbose_more, context::network) << "Server: not sending gamestate" << endl;
 //         temp=temp->next();
 //         continue;
 …
     del->setPeerID(NETWORK_PEER_ID_BROADCAST);
     if ( !del->send( static_cast<Host*>(this) ) )
       COUT(3) << "Server: could not broadcast deleteObjects packet" << std::endl;
+      orxout(internal_warning, context::network) << "Server: could not broadcast deleteObjects packet" << endl;
 //       temp=temp->next();
       // gs gets automatically deleted by enet callback
 …
+  {
 //     static unsigned int newid=1;
 //
 //     COUT(2) << "Server: adding client" << std::endl;
+//
+//     orxout(internal_info, context::network) << "Server: adding client" << endl;
 //     ClientInformation *temp = ClientInformation::insertBack(new ClientInformation);
 //     if(!temp)
 //     {
 //       COUT(2) << "Server: could not add client" << std::endl;
+//       orxout(internal_warning, context::network) << "Server: could not add client" << endl;
 //     }
 //     temp->setID(newid);
 …
 //     ++newid;
     COUT(3) << "Server: added client id: " << peerID << std::endl;
+    orxout(internal_info, context::network) << "Server: added client id: " << peerID << endl;
     createClient(peerID);
+}
 …
   void Server::removePeer(uint32_t peerID)
+  {
     COUT(4) << "removing client from list" << std::endl;
+    orxout(verbose, context::network) << "removing client from list" << endl;
 //     ClientInformation *client = ClientInformation::findClient(&event->peer->address);
 //     if(!client)
 …
 //     }
+  }
   void Server::processPacket(packet::Packet* packet)
+  {
 …
 //     if(!temp)
 //     {
 //       COUT(2) << "Server. could not create client with id: " << clientID << std::endl;
+//       orxout(internal_error, context::network) << "Server. could not create client with id: " << clientID << endl;
 //       return false;
 //     }
 //     COUT(4) << "Con.Man: creating client id: " << temp->getID() << std::endl;
+//     orxout(verbose, context::network) << "Con.Man: creating client id: " << temp->getID() << endl;
     // synchronise class ids
 …
 //     temp->setSynched(true);
     GamestateManager::setSynched(clientID);
     COUT(4) << "sending welcome" << std::endl;
+    orxout(verbose, context::network) << "sending welcome" << endl;
     packet::Welcome *w = new packet::Welcome(clientID);
     w->setPeerID(clientID);
 …
+  }
+  bool Server::chat(const std::string& message)
+  {
+      return this->sendChat(message, Host::getPlayerID());
+  }
+  bool Server::broadcast(const std::string& message)
+  {
+      return this->sendChat(message, NETWORK_PEER_ID_BROADCAST);
+  }
+  bool Server::sendChat(const std::string& message, unsigned int clientID)
+  {
+//     ClientInformation *temp = ClientInformation::getBegin();
+    packet::Chat *chat;
+//     while(temp)
+    {
+      chat = new packet::Chat(message, clientID);
+      chat->setPeerID(NETWORK_PEER_ID_BROADCAST);
+      chat->send( static_cast<Host*>(this) );
+//         COUT(3) << "could not send Chat message to client ID: " << temp->getID() << std::endl;
+//       temp = temp->next();
+    }
+//    COUT(1) << "Player " << Host::getPlayerID() << ": " << message << std::endl;
+    for (ObjectList<ChatListener>::iterator it = ObjectList<ChatListener>::begin(); it != ObjectList<ChatListener>::end(); ++it)
+      it->incomingChat(message, clientID);
+    return true;
+  /**
+   * @brief Sends a chat message to the given target ID.
+   * @param message message to be sent
+   * @param sourceID the ID of the sender
+   * @param targetID the ID of the receiver
+   */
+  void Server::doSendChat(const std::string& message, unsigned int sourceID, unsigned int targetID)
+  {
+    // check if the target exists. just ignore the message otherwise
+    if (!this->isValidTarget(targetID)) // TODO: remove this if an invalid clientIDs don't trigger assertions anymore
+      return;
+    // send the message to the target
+    packet::Chat* packet = new packet::Chat(message, sourceID, targetID);
+    packet->setPeerID(targetID);
+    packet->send( static_cast<Host*>(this) );
+    // if the target is (or includes) this host as well, call the parent function which passes the message to the listeners
+    if (targetID == NETWORK_PEER_ID_BROADCAST || targetID == Host::getPlayerID())
+      Host::doReceiveChat(message, sourceID, targetID);
+  }
+  /**
+   * @brief Gets called if a packet::Chat packet is received. Forwards the packet to the target
+   * and calls the parent function if necessary.
+   */
+  void Server::doReceiveChat(const std::string& message, unsigned int sourceID, unsigned int targetID)
+  {
+      this->doSendChat(message, sourceID, targetID);
+  }
+  /**
+   * @brief Returns true if the target ID is in the list of clients (or if it
+   * corresponds to the broadcast or the server ID).
+   */
+  bool Server::isValidTarget(unsigned int targetID)
+  {
+    if (targetID == NETWORK_PEER_ID_BROADCAST || targetID == NETWORK_PEER_ID_SERVER)
+      return true;
+    std::vector<uint32_t>::iterator it;
+    for( it=this->clientIDs_.begin(); it!=this->clientIDs_.end(); ++it )
+      if( *it == targetID )
+        return true;
+    return false;
+  }
 …
+    }
     assert(failures<10);
     COUT(4) << "syncClassid:\tall synchClassID packets have been sent" << std::endl;
+    orxout(verbose, context::network) << "syncClassid:\tall synchClassID packets have been sent" << endl;
+  }

code/trunk/src/libraries/network/Server.h

-                      r8351
+                      r8858
 #include "LANDiscoverable.h"
 #include "WANDiscoverable.h"
-// #include "MasterServerComm.h"
-// #include "MasterServerProtocol.h"
 …
     ~Server();
-    /* helpers */
-    void helper_ConnectToMasterserver();
-    void helper_HandleMasterServerRequests();
-    int replyhandler( char *addr, ENetEvent *ev );
     void open();
     void close();
-    bool processChat(const std::string& message, unsigned int playerID);
     void queuePacket(ENetPacket *packet, int clientID, uint8_t channelID);
     virtual bool sendPacket( packet::Packet* packet ){ return packet->send( static_cast<Host*>(this) ); }
 …
     bool sendGameStates();
     bool sendObjectDeletes();
     virtual bool chat(const std::string& message);
     virtual bool broadcast(const std::string& message);
     bool sendChat(const std::string& message, unsigned int clientID);
+    bool isValidTarget(unsigned int targetID);
+    virtual void doSendChat(const std::string& message, unsigned int sourceID, unsigned int targetID);
+    virtual void doReceiveChat(const std::string& message, unsigned int sourceID, unsigned int targetID);
     void syncClassid(unsigned int clientID);

code/trunk/src/libraries/network/ServerConnection.cc

-                      r8358
+                      r8858
 #include <enet/enet.h>
 #include "util/Debug.h"
+#include "util/Output.h"
 #include <util/Sleep.h>
 // #include "ClientInformation.h"
 …
+  {
     if (enet_address_set_host (this->bindAddress_, bindAddress.c_str()) < 0)
         COUT(1) << "Error: Could not resolve \"" << bindAddress << "\"." << std::endl;
+        orxout(internal_error, context::network) << "Could not resolve \"" << bindAddress << "\"." << endl;
+  }
 …
     if ( this->host_ == NULL )
+    {
         COUT(1) << "ServerConnection: host_ == NULL" << std::endl;
+        orxout(internal_error, context::network) << "ServerConnection: host_ == NULL" << endl;
         return false;
+    }
 …
     assert( this->host_->socket4 != ENET_SOCKET_NULL || this->host_->socket6 != ENET_SOCKET_NULL );
     if (this->host_->socket4 == ENET_SOCKET_NULL)
         COUT(2) << "Warning: IPv4 Socket failed." << std::endl;
+        orxout(internal_warning, context::network) << "IPv4 Socket failed." << endl;
     else if (this->host_->socket6 == ENET_SOCKET_NULL)
         COUT(2) << "Warning: IPv6 Socket failed." << std::endl;
+        orxout(internal_warning, context::network) << "IPv6 Socket failed." << endl;
     else
         COUT(3) << "Info: Using IPv4 and IPv6 Sockets." << std::endl;
+        orxout(internal_info, context::network) << "Using IPv4 and IPv6 Sockets." << endl;
     // start communication thread
 …
 //       ClientInformation *temp = ClientInformation::findClient(clientID);
 //       if(!temp){
 //         COUT(3) << "C.Man: addPacket findClient failed" << std::endl;
+//         orxout(internal_warning, context::network) << "C.Man: addPacket findClient failed" << endl;
 //       }
       Connection::addPacket(packet, clientID, channelID);

code/trunk/src/libraries/network/TrafficControl.cc

r6417	r8858
287	287	{
288	288	std::list<obj>::iterator it;
289		~~COUT(0~~) << "=========== Objectlist ===========" << endl;
	289	orxout(debug_output, context::network) << "=========== Objectlist ===========" << endl;
290	290	for( it=list.begin(); it!=list.end(); it++)
291		~~COUT(0~~) << "ObjectID: " << it->objID << " creatorID: " << it->objCreatorID << " Priority: " << clientListPerm_[clientID][it->objID].objValuePerm + clientListPerm_[clientID][it->objID].objValueSched << " size: " << it->objSize << endl;
	291	orxout(debug_output, context::network) << "ObjectID: " << it->objID << " creatorID: " << it->objCreatorID << " Priority: " << clientListPerm_[clientID][it->objID].objValuePerm + clientListPerm_[clientID][it->objID].objValueSched << " size: " << it->objSize << endl;
292	292	}
293	293

code/trunk/src/libraries/network/WANDiscoverable.cc

-                      r8351
+                      r8858
+ *
  *   Author:
  *      Fabian 'x3n' Landau (original)
+ *      Sandro 'smerkli' Merkli
  *   Co-authors:
+ *      Sandro 'smerkli' Merkli (adaptions to WAN)
+ *      ...
+ *      Oliver Scheuss (original)
+ *
  */
 …
+  {
     /* debugging output */
     COUT(4) << "Creating WANDiscoverable.\n";
+    orxout(verbose, context::master_server) << "Creating WANDiscoverable." << endl;
     /* register object in orxonox */
 …
     if( msc.initialize() )
+    {
       COUT(2) << "Error: could not initialize master server communications!\n";
+      orxout(internal_error, context::master_server) << "Could not initialize master server communications!" << endl;
       return false;
+    }
 …
     if( msc.connect( this->msaddress.c_str(), ORX_MSERVER_PORT ) )
+    {
       COUT(2) << "Error: could not connect to master server at "
                  << this->msaddress << std::endl;
+      orxout(internal_error, context::master_server) << "Could not connect to master server at "
+                 << this->msaddress << endl;
       return false;
+    }
     /* debugging output */
     COUT(4) << "Initialization of WANDiscoverable complete.\n";
+    orxout(verbose, context::master_server) << "Initialization of WANDiscoverable complete." << endl;

code/trunk/src/libraries/network/WANDiscoverable.h

-                      r8729
+                      r8858
  *   Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author: Fabian 'x3n' Landau (original) Co-authors: Sandro 'smerkli' Merkli
+ *   (copied and adapted to WAN)
+ *   Author:
+ *      Sandro 'smerkli' Merkli
+ *   Co-authors:
+ *      Oliver Scheuss (original)
+ *
  */

code/trunk/src/libraries/network/WANDiscovery.cc

-                      r8351
+                      r8858
+ *
  *   Author:
  *      Fabian 'x3n' Landau (original)
+ *      Sandro 'smerkli' Merkli
  *   Co-authors:
+ *      Sandro 'smerkli' Merkli (adaptions to WAN)
+ *      ...
+ *      Oliver Scheuss (original)
+ *
  */
 …
 #include <cstring>
-#include "util/ScopedSingletonManager.h"
 #include "core/CoreIncludes.h"
 …
 namespace orxonox
+{
-  ManageScopedSingleton(WANDiscovery, ScopeID::Graphics, true);
   WANDiscovery::WANDiscovery()
+  {
     /* debugging output */
     COUT(4) << "Creating WANDiscovery.\n";
+    orxout(verbose, context::master_server) << "Creating WANDiscovery." << endl;
     /* register object in orxonox */
 …
     /* initialize it and see if it worked */
     if( msc.initialize() )
       COUT(2) << "Error: could not initialize master server communications!\n";
+      orxout(internal_error, context::master_server) << "Could not initialize master server communications!" << endl;
     /* connect and see if it worked */
     if( msc.connect( this->msaddress.c_str(), ORX_MSERVER_PORT ) )
       COUT(2) << "Error: could not connect to master server at "
         << this->msaddress << std::endl;
+      orxout(internal_error, context::master_server) << "Could not connect to master server at "
+        << this->msaddress << endl;
     /* debugging output */
     COUT(4) << "Initialization of WANDiscovery complete.\n";
+    orxout(verbose, context::master_server) << "Initialization of WANDiscovery complete." << endl;
+  }
 …
   /* callback for the network reply poller */
   int rhandler( char *addr, ENetEvent *ev )
+  int WANDiscovery::rhandler( char *addr, ENetEvent *ev )
+  {
     /* error recognition */
     if( !ev || !ev->packet || !ev->packet->data )
     { COUT(2) << "Bad arguments received in WANDiscovery's reply handler.\n";
+    { orxout(internal_warning, context::master_server) << "Bad arguments received in WANDiscovery's reply handler." << endl;
       return 0;
+    }
 …
       /* add to list */
       WANDiscovery::getInstance().servers_.push_back( toadd );
+      this->servers_.push_back( toadd );
+    }
     else if( !strncmp( (char*)ev->packet->data, MSPROTO_SERVERLIST_END,
 …
+    {
       /* poll for reply and act according to what was received */
       switch( this->msc.pollForReply( rhandler, 500 ) )
+      switch( this->msc.pollForReply( this, 500 ) )
       { case 0: /* no event occured, decrease timeout */
           --i; break;

code/trunk/src/libraries/network/WANDiscovery.h

-                      r8351
+                      r8858
  *   Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author: Fabian 'x3n' Landau (original) Co-authors: Sandro 'smerkli' Merkli
+ *   (copied and adapted to WAN)
+ *   Author:
+ *      Sandro 'smerkli' Merkli
+ *   Co-authors:
+ *      Oliver Scheuss (original)
+ *
  */
 …
 #include "packet/ServerInformation.h"
 #include "core/ConfigFileManager.h"
-#include "util/Singleton.h"
 #include "core/OrxonoxClass.h"
 #include "core/ConfigValueIncludes.h"
 …
   class _NetworkExport WANDiscovery
 // tolua_end
     : public Singleton<WANDiscovery>, public OrxonoxClass
+    : public OrxonoxClass
   { // tolua_export
-    friend class Singleton<WANDiscovery>;
     public:
       /** constructor */
       WANDiscovery();
+      WANDiscovery(); // tolua_export
       /** destructor */
 …
       std::string getServerListItemIP( unsigned int index ); // tolua_export
-      /** \return an instance of WANDiscovery
+       *
-       * Create and return an instance of WANDiscovery.
-       */
-      static WANDiscovery& getInstance() { return Singleton<WANDiscovery>::getInstance(); } // tolua_export
       /* todo: might make this private and use getter/setter methods
        * at some later time.
 …
       /** Master server communications object */
       MasterServerComm msc;
+      int rhandler( char *addr, ENetEvent *ev );
     private:
-      /** Singleton pointer */
-      static WANDiscovery* singletonPtr_s;
       /** master server address */
       std::string msaddress;

code/trunk/src/libraries/network/packet/Acknowledgement.cc

-                      r7801
+                      r8858
 #include "Acknowledgement.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "network/GamestateHandler.h"
 #include "network/Host.h"
 …
 bool Acknowledgement::process(orxonox::Host* host){
   COUT(5) << "processing ACK with ID: " << getAckID() << endl;
+  orxout(verbose_more, context::packets) << "processing ACK with ID: " << getAckID() << endl;
   bool b = host->ackGamestate(getAckID(), peerID_);
   delete this;

code/trunk/src/libraries/network/packet/Chat.cc

-                      r7801
+                      r8858
 /* Some lengths */
+#define   _PACKETID         0
+const int _PLAYERID     =   _PACKETID + sizeof(Type::Value);
+#define   _MESSAGELENGTH    _PLAYERID + sizeof(uint32_t)
+#define   _MESSAGE          _MESSAGELENGTH + sizeof(uint32_t)
+#define _PACKETID         0
+#define _SOURCEID         _PACKETID + sizeof(Type::Value)
+#define _TARGETID         _SOURCEID + sizeof(uint32_t)
+#define _MESSAGELENGTH    _TARGETID + sizeof(uint32_t)
+#define _MESSAGE          _MESSAGELENGTH + sizeof(uint32_t)
 Chat::Chat( const std::string& message, unsigned int playerID )
+Chat::Chat( const std::string& message, unsigned int sourceID, unsigned int targetID )
  : Packet()
+{
 …
   *(Type::Value *)(data_ + _PACKETID ) = Type::Chat;
+  *(unsigned int *)(data_ + _PLAYERID ) = playerID;
+  *(unsigned int *)(data_ + _SOURCEID ) = sourceID;
+  *(unsigned int *)(data_ + _TARGETID ) = targetID;
   *(unsigned int *)(data_ + _MESSAGELENGTH ) = messageLength_;
 …
 bool Chat::process(orxonox::Host* host){
   bool b = host->incomingChat(std::string((const char*)data_+_MESSAGE), *(uint32_t *)(data_+_PLAYERID));
+  host->doReceiveChat(std::string((const char*)data_+_MESSAGE), *(uint32_t *)(data_+_SOURCEID), *(uint32_t *)(data_+_TARGETID));
   delete this;
   return b;
+  return true;
+}

code/trunk/src/libraries/network/packet/Chat.h

r7801	r8858
42	42	public:
43	43	/* constructors */
44		Chat( const std::string& message, unsigned int ~~player~~ID );
	44	Chat( const std::string& message, unsigned int sourceID, unsigned int targetID );
45	45	Chat( uint8_t* data, unsigned int clientID );
46	46

code/trunk/src/libraries/network/packet/ClassID.cc

-                      r7801
+                      r8858
   assert(tempsize==packetSize);
   COUT(5) << "classid packetSize is " << packetSize << endl;
+  orxout(verbose_more, context::packets) << "classid packetSize is " << packetSize << endl;
+}
 …
   Identifier::clearNetworkIDs();
   COUT(4) << "=== processing classids: " << endl;
+  orxout(verbose, context::packets) << "=== processing classids: " << endl;
   std::pair<uint32_t, std::string> tempPair;
   Identifier *id;
 …
     classname = temp+2*sizeof(uint32_t);
     id=ClassByString( std::string((const char*)classname) );
     COUT(3) << "processing classid: " << networkID << " name: " << classname << " id: " << id << std::endl;
+    orxout(internal_info, context::packets) << "processing classid: " << networkID << " name: " << classname << " id: " << id << endl;
     if(id==NULL){
       COUT(0) << "Received a bad classname" << endl;
+      orxout(user_error, context::packets) << "Received a bad classname" << endl;
       abort();
+    }

code/trunk/src/libraries/network/packet/DeleteObjects.cc

-                      r7801
+                      r8858
 #include <cassert>
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "network/synchronisable/Synchronisable.h"
 …
   if(number==0)
     return false;
   COUT(4) << "sending DeleteObjects: ";
+  orxout(verbose, context::packets) << "sending DeleteObjects: ";
   unsigned int size = sizeof(Type::Value) + sizeof(uint32_t)*(number+1);
   data_ = new uint8_t[size];
 …
     unsigned int temp = Synchronisable::popDeletedObject();
     *reinterpret_cast<uint32_t*>(tdata) = temp;
     COUT(4) << temp << ' ';
+    orxout(verbose, context::packets) << temp << ' ';
     tdata += sizeof(uint32_t);
+  }
   COUT(4) << std::endl;
+  orxout(verbose, context::packets) << endl;
   return true;
+}
 …
   for(unsigned int i=0; i<*(unsigned int *)(data_+_QUANTITY); i++)
+  {
     COUT(4) << "deleting object with id: " << *(uint32_t*)(data_+_OBJECTIDS+i*sizeof(uint32_t)) << std::endl;
+    orxout(verbose, context::packets) << "deleting object with id: " << *(uint32_t*)(data_+_OBJECTIDS+i*sizeof(uint32_t)) << endl;
     Synchronisable::deleteObject( *(uint32_t*)(data_+_OBJECTIDS+i*sizeof(uint32_t)) );
+  }

code/trunk/src/libraries/network/packet/FunctionIDs.cc

-                      r7801
+                      r8858
 #include <string>
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "core/ObjectList.h"
 #include "network/NetworkFunction.h"
 …
+  }
   COUT(5) << "FunctionIDs packetSize is " << packetSize << endl;
+  orxout(verbose_more, context::packets) << "FunctionIDs packetSize is " << packetSize << endl;
+}
 …
   unsigned char *functionname;
   COUT(4) << "=== processing functionids: " << endl;
+  orxout(verbose, context::packets) << "=== processing functionids: " << endl;
   std::pair<uint32_t, std::string> tempPair;
   // read the total number of classes
 …
     stringsize = *(uint32_t*)(temp+sizeof(uint32_t));
     functionname = temp+2*sizeof(uint32_t);
     COUT(3) << "processing functionid: " << networkID << " name: " << functionname << std::endl;
+    orxout(internal_info, context::packets) << "processing functionid: " << networkID << " name: " << functionname << endl;
     NetworkFunctionBase::setNetworkID((const char*)functionname, networkID);
     temp += 2*sizeof(uint32_t) + stringsize;

code/trunk/src/libraries/network/packet/Gamestate.cc

-                      r8394
+                      r8858
 #include <zlib.h>
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/OrxAssert.h"
 #include "core/GameMode.h"
 …
   uint32_t size = calcGamestateSize(id, mode);
   COUT(5) << "G.ST.Man: producing gamestate with id: " << id << std::endl;
+  orxout(verbose_more, context::packets) << "G.ST.Man: producing gamestate with id: " << id << endl;
   if(size==0)
     return false;
 …
   if(!data_)
+  {
     COUT(2) << "GameStateManager: could not allocate memory" << std::endl;
+    orxout(internal_warning, context::packets) << "GameStateManager: could not allocate memory" << endl;
     return false;
+  }
 …
       assert(0); // if we don't use multithreading this part shouldn't be neccessary
       // start allocate additional memory
       COUT(3) << "Gamestate: need additional memory" << std::endl;
+      orxout(internal_info, context::packets) << "Gamestate: need additional memory" << endl;
       ObjectList<Synchronisable>::iterator temp = it;
       uint32_t addsize=tempsize;
 …
   //stop write gamestate header
   COUT(5) << "Gamestate: Gamestate size: " << currentsize << std::endl;
   COUT(5) << "Gamestate: 'estimated' (and corrected) Gamestate size: " << size << std::endl;
+  orxout(verbose_more, context::packets) << "Gamestate: Gamestate size: " << currentsize << endl;
+  orxout(verbose_more, context::packets) << "Gamestate: 'estimated' (and corrected) Gamestate size: " << size << endl;
   return true;
+}
 …
 bool Gamestate::spreadData(uint8_t mode)
+{
   COUT(5) << "processing gamestate with id " << header_.getID() << endl;
+  orxout(verbose_more, context::packets) << "processing gamestate with id " << header_.getID() << endl;
   assert(data_);
   assert(!header_.isCompressed());
 …
       else
+      {
 //         COUT(4) << "not creating object of classid " << objectheader.getClassID() << endl;
+//         orxout(verbose, context::packets) << "not creating object of classid " << objectheader.getClassID() << endl;
         mem += objectheader.getDataSize() + ( objectheader.isDiffed() ? SynchronisableHeaderLight::getSize() : SynchronisableHeader::getSize() );
+      }
 …
     else
+    {
 //       COUT(4) << "updating object of classid " << objectheader.getClassID() << endl;
+//       orxout(verbose, context::packets) << "updating object of classid " << objectheader.getClassID() << endl;
       OrxVerify(s->updateData(mem, mode), "ERROR: could not update Synchronisable with Gamestate data");
+    }
 …
         if (it->objectMode_ != 0x0)
+        {
           COUT(0) << "Found object with OBJECTID_UNKNOWN on the client with objectMode != 0x0!" << std::endl;
           COUT(0) << "Possible reason for this error: Client created a synchronized object without the Server's approval." << std::endl;
           COUT(0) << "Objects class: " << it->getIdentifier()->getName() << std::endl;
+          orxout(user_error, context::packets) << "Found object with OBJECTID_UNKNOWN on the client with objectMode != 0x0!" << endl;
+          orxout(user_error, context::packets) << "Possible reason for this error: Client created a synchronized object without the Server's approval." << endl;
+          orxout(user_error, context::packets) << "Objects class: " << it->getIdentifier()->getName() << endl;
           assert(false);
+        }
 …
           if (it->getObjectID() == *it2)
+          {
             COUT(0) << "Found duplicate objectIDs on the client!" << std::endl
                     << "Are you sure you don't create a Sychnronisable objcect with 'new' \
                         that doesn't have objectMode = 0x0?" << std::endl;
+            orxout(user_error, context::packets) << "Found duplicate objectIDs on the client!" << endl
+                                                 << "Are you sure you don't create a Sychnronisable objcect with 'new' \
+                                                     that doesn't have objectMode = 0x0?" << endl;
             assert(false);
+          }
 …
   switch ( retval )
+  {
     case Z_OK: COUT(5) << "G.St.Man: compress: successfully compressed" << std::endl; break;
     case Z_MEM_ERROR: COUT(1) << "G.St.Man: compress: not enough memory available in gamestate.compress" << std::endl; return false;
     case Z_BUF_ERROR: COUT(2) << "G.St.Man: compress: not enough memory available in the buffer in gamestate.compress" << std::endl; return false;
     case Z_DATA_ERROR: COUT(2) << "G.St.Man: compress: data corrupted in gamestate.compress" << std::endl; return false;
+    case Z_OK: orxout(verbose_more, context::packets) << "G.St.Man: compress: successfully compressed" << endl; break;
+    case Z_MEM_ERROR: orxout(internal_error, context::packets) << "G.St.Man: compress: not enough memory available in gamestate.compress" << endl; return false;
+    case Z_BUF_ERROR: orxout(internal_warning, context::packets) << "G.St.Man: compress: not enough memory available in the buffer in gamestate.compress" << endl; return false;
+    case Z_DATA_ERROR: orxout(internal_warning, context::packets) << "G.St.Man: compress: data corrupted in gamestate.compress" << endl; return false;
+  }
 …
   header_.setCompSize( buffer );
   header_.setCompressed( true );
   COUT(4) << "gamestate compress datasize: " << header_.getDataSize() << " compsize: " << header_.getCompSize() << std::endl;
+  orxout(verbose, context::packets) << "gamestate compress datasize: " << header_.getDataSize() << " compsize: " << header_.getCompSize() << endl;
   return true;
+}
 …
   assert(data_);
   assert(header_.isCompressed());
   COUT(4) << "GameStateClient: uncompressing gamestate. id: " << header_.getID() << ", baseid: " << header_.getBaseID() << ", datasize: " << header_.getDataSize() << ", compsize: " << header_.getCompSize() << std::endl;
+  orxout(verbose, context::packets) << "GameStateClient: uncompressing gamestate. id: " << header_.getID() << ", baseid: " << header_.getBaseID() << ", datasize: " << header_.getDataSize() << ", compsize: " << header_.getCompSize() << endl;
   uint32_t datasize = header_.getDataSize();
   uint32_t compsize = header_.getCompSize();
 …
   switch ( retval )
+  {
     case Z_OK: COUT(5) << "successfully decompressed" << std::endl; break;
     case Z_MEM_ERROR: COUT(1) << "not enough memory available" << std::endl; return false;
     case Z_BUF_ERROR: COUT(2) << "not enough memory available in the buffer" << std::endl; return false;
     case Z_DATA_ERROR: COUT(2) << "data corrupted (zlib)" << std::endl; return false;
+    case Z_OK: orxout(verbose_more, context::packets) << "successfully decompressed" << endl; break;
+    case Z_MEM_ERROR: orxout(internal_error, context::packets) << "not enough memory available" << endl; return false;
+    case Z_BUF_ERROR: orxout(internal_warning, context::packets) << "not enough memory available in the buffer" << endl; return false;
+    case Z_DATA_ERROR: orxout(internal_warning, context::packets) << "data corrupted (zlib)" << endl; return false;
+  }
 …
   if( memcmp( origDataPtr+objectOffset, baseDataPtr+objectOffset, objectHeader.getDataSize()) == 0 )
+  {
 //     COUT(4) << "skip object " << Synchronisable::getSynchronisable(objectHeader.getObjectID())->getIdentifier()->getName() << endl;
+//     orxout(verbose, context::packets) << "skip object " << Synchronisable::getSynchronisable(objectHeader.getObjectID())->getIdentifier()->getName() << endl;
     origDataPtr += objectOffset + objectHeader.getDataSize(); // skip the whole object
     baseDataPtr += objectOffset + objectHeader.getDataSize();
 …
 inline void /*Gamestate::*/copyObject( uint8_t*& newData, uint8_t*& origData, uint8_t*& baseData, SynchronisableHeader& objectHeader, std::vector<uint32_t>::iterator& sizes )
+{
   //       COUT(4) << "docopy" << endl;
+  //       orxout(verbose, context::packets) << "docopy" << endl;
   // Just copy over the whole Object
   memcpy( newData, origData, objectHeader.getDataSize()+SynchronisableHeader::getSize() );
 …
 //   SynchronisableHeader baseHeader( baseData );
 //   baseData += baseHeader.getDataSize()+SynchronisableHeader::getSize();
   //       COUT(4) << "copy " << h.getObjectID() << endl;
   //       COUT(4) << "copy " << h.getObjectID() << ":";
+  //       orxout(verbose, context::packets) << "copy " << h.getObjectID() << endl;
+  //       orxout(verbose, context::packets) << "copy " << h.getObjectID() << ":";
   sizes += Synchronisable::getSynchronisable(objectHeader.getObjectID())->getNrOfVariables();
 //   for( unsigned int i = 0; i < Synchronisable::getSynchronisable(objectHeader.getObjectID())->getNrOfVariables(); ++i )
 //   {
 //     //         COUT(4) << " " << *sizes;
+//     //         orxout(verbose, context::packets) << " " << *sizes;
 //     ++sizes;
 //   }
     //       COUT(4) << endl;
+    //       orxout(verbose, context::packets) << endl;
+}
 …
       if( SynchronisableHeader(baseDataPtr).getDataSize()==origHeader.getDataSize() )
+      {
 //         COUT(4) << "diffing object in order: " << Synchronisable::getSynchronisable(origHeader.getObjectID())->getIdentifier()->getName() << endl;
+//         orxout(verbose, context::packets) << "diffing object in order: " << Synchronisable::getSynchronisable(origHeader.getObjectID())->getIdentifier()->getName() << endl;
         diffObject(destDataPtr, origDataPtr, baseDataPtr, origHeader, sizesIt);
         diffedObject = true;
 …
       else
+      {
 //         COUT(4) << "copy object because of different data sizes (1): " << Synchronisable::getSynchronisable(origHeader.getObjectID())->getIdentifier()->getName() << endl;
+//         orxout(verbose, context::packets) << "copy object because of different data sizes (1): " << Synchronisable::getSynchronisable(origHeader.getObjectID())->getIdentifier()->getName() << endl;
         copyObject(destDataPtr, origDataPtr, baseDataPtr, origHeader, sizesIt);
         assert(sizesIt != this->sizes_.end() || origDataPtr==origDataEnd);
 …
         if( SynchronisableHeader(baseDataPtr).getDataSize()==origHeader.getDataSize() )
+        {
 //           COUT(4) << "diffing object out of order: " << Synchronisable::getSynchronisable(origHeader.getObjectID())->getIdentifier()->getName() << endl;
+//           orxout(verbose, context::packets) << "diffing object out of order: " << Synchronisable::getSynchronisable(origHeader.getObjectID())->getIdentifier()->getName() << endl;
           diffObject(destDataPtr, origDataPtr, baseDataPtr, origHeader, sizesIt);
           diffedObject = true;
 …
         else
+        {
 //           COUT(4) << "copy object because of different data sizes (2): " << Synchronisable::getSynchronisable(origHeader.getObjectID())->getIdentifier()->getName() << endl;
+//           orxout(verbose, context::packets) << "copy object because of different data sizes (2): " << Synchronisable::getSynchronisable(origHeader.getObjectID())->getIdentifier()->getName() << endl;
           copyObject(destDataPtr, origDataPtr, baseDataPtr, origHeader, sizesIt);
           assert(sizesIt != this->sizes_.end() || origDataPtr==origDataEnd);
 …
       else
+      {
 //         COUT(4) << "copy object: " << Synchronisable::getSynchronisable(origHeader.getObjectID())->getIdentifier()->getName() << endl;
+//         orxout(verbose, context::packets) << "copy object: " << Synchronisable::getSynchronisable(origHeader.getObjectID())->getIdentifier()->getName() << endl;
         assert(baseDataPtr == oldBaseDataPtr);
         copyObject(destDataPtr, origDataPtr, baseDataPtr, origHeader, sizesIt);
 …
   //copy in the zeros
 //   std::list<obj>::iterator itt;
 //   COUT(0) << "myvector contains:";
+//   orxout() << "myvector contains:";
 //   for ( itt=dataVector_.begin() ; itt!=dataVector_.end(); itt++ )
 //     COUT(0) << " " << (*itt).objID;
 //   COUT(0) << endl;
+//     orxout() << " " << (*itt).objID;
+//   orxout() << endl;
   for(it=dataVector_.begin(); it!=dataVector_.end();){
     SynchronisableHeader oldobjectheader(origdata);
 …
     nrOfVariables += it->getNrOfVariables();
+  }
 //   COUT(0) << "allocating " << nrOfVariables << " ints" << endl;
+//   orxout() << "allocating " << nrOfVariables << " ints" << endl;
   this->sizes_.reserve(nrOfVariables);
   return size;

code/trunk/src/libraries/network/packet/Packet.cc

-                      r8327
+                      r8858
 #include <boost/thread/mutex.hpp>
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "Acknowledgement.h"
 #include "Chat.h"
 …
 //     peerID = NETWORK_PEER_ID_SERVER;
   Packet *p = 0;
 //   COUT(6) << "packet type: " << *(Type::Value *)&data[_PACKETID] << std::endl;
+//   orxout(verbose_ultra, context::packets) << "packet type: " << *(Type::Value *)&data[_PACKETID] << endl;
   switch( *(Type::Value *)(data + _PACKETID) )
+  {
     case Type::Acknowledgement:
 //       COUT(5) << "ack" << std::endl;
+//       orxout(verbose_more, context::packets) << "ack" << endl;
     p = new Acknowledgement( data, peerID );
       break;
     case Type::Chat:
 //       COUT(5) << "chat" << std::endl;
+//       orxout(verbose_more, context::packets) << "chat" << endl;
       p = new Chat( data, peerID );
       break;
     case Type::ClassID:
 //       COUT(5) << "classid" << std::endl;
+//       orxout(verbose_more, context::packets) << "classid" << endl;
       p = new ClassID( data, peerID );
       break;
     case Type::Gamestate:
 //       COUT(5) << "gamestate" << std::endl;
+//       orxout(verbose_more, context::packets) << "gamestate" << endl;
       p = new Gamestate( data, peerID );
       break;
     case Type::Welcome:
 //       COUT(5) << "welcome" << std::endl;
+//       orxout(verbose_more, context::packets) << "welcome" << endl;
       p = new Welcome( data, peerID );
       break;
     case Type::DeleteObjects:
 //       COUT(5) << "deleteobjects" << std::endl;
+//       orxout(verbose_more, context::packets) << "deleteobjects" << endl;
       p = new DeleteObjects( data, peerID );
       break;
     case Type::FunctionCalls:
 //       COUT(5) << "functionCalls" << std::endl;
+//       orxout(verbose_more, context::packets) << "functionCalls" << endl;
       p = new FunctionCalls( data, peerID );
       break;
     case Type::FunctionIDs:
 //       COUT(5) << "functionIDs" << std::endl;
+//       orxout(verbose_more, context::packets) << "functionIDs" << endl;
       p = new FunctionIDs( data, peerID );
       break;
 …
   packetMap_.erase(it);
   Packet::packetMapMutex_.unlock();
 //   COUT(6) << "PacketMap size: " << packetMap_.size() << std::endl;
+//   orxout(verbose_ultra, context::packets) << "PacketMap size: " << packetMap_.size() << endl;
+}

code/trunk/src/libraries/network/packet/Welcome.cc

-                      r8706
+                      r8858
 #include <cassert>
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "network/Host.h"
 #include "network/synchronisable/Synchronisable.h"
 …
   assert(*(uint32_t *)(data_ + _ENDIANTEST ) == 0xFEDC4321);
   host->setClientID(clientID);
   COUT(3) << "Welcome set clientId: " << clientID << endl;
+  orxout(internal_info, context::packets) << "Welcome set clientId: " << clientID << endl;
   Synchronisable::setClient(true);
   delete this;

code/trunk/src/libraries/network/synchronisable/Synchronisable.cc

-                      r8706
+                      r8858
 //     assert( !header.isDiffed() );
     COUT(4) << "fabricating object with id: " << header.getObjectID() << std::endl;
+    orxout(verbose, context::network) << "fabricating object with id: " << header.getObjectID() << endl;
     Identifier* id = ClassByID(header.getClassID());
 …
+    {
         for(int i = 0; i<160; i++)
             COUT(0) << "classid: " << i << " identifier: " << ClassByID(i) << endl;
         COUT(0) << "Assertion failed: id" << std::endl;
         COUT(0) << "Possible reason for this error: Client received a synchronizable object whose class has no factory." << std::endl;
+            orxout(user_error, context::network) << "classid: " << i << " identifier: " << ClassByID(i) << endl;
+        orxout(user_error, context::network) << "Assertion failed: id" << endl;
+        orxout(user_error, context::network) << "Possible reason for this error: Client received a synchronizable object whose class has no factory." << endl;
         abort();
+    }
 …
       bo->setLevel(creator->getLevel());          // Note: this ensures that the level is known on the client for child objects of the scene (and the scene itself)
     //assert(no->classID_ == header.getClassID());
     COUT(4) << "fabricate objectID_: " << no->objectID_ << " classID_: " << no->classID_ << std::endl;
+    orxout(verbose, context::network) << "fabricate objectID_: " << no->objectID_ << " classID_: " << no->classID_ << endl;
           // update data and create object/entity...
     bool b = no->updateData(mem, mode, true);
 …
     uint8_t* oldmem = mem;
     if (this->classID_==0)
       COUT(3) << "classid 0 " << this->getIdentifier()->getName() << std::endl;
+      orxout(internal_info, context::network) << "classid 0 " << this->getIdentifier()->getName() << endl;
 #endif
 …
     // end copy header
     CCOUT(5) << "getting data from objectID_: " << objectID_ << ", classID_: " << classID_ << std::endl;
 //     COUT(4) << "objectid: " << this->objectID_ << ":";
+    orxout(verbose_more, context::network) << "getting data from objectID_: " << objectID_ << ", classID_: " << classID_ << endl;
+//     orxout(verbose, context::network) << "objectid: " << this->objectID_ << ":";
     // copy to location
     for(i=syncList_.begin(); i!=syncList_.end(); ++i)
+    {
       uint32_t varsize = (*i)->getData( mem, mode );
 //       COUT(4) << " " << varsize;
+//       orxout(verbose, context::network) << " " << varsize;
       tempsize += varsize;
       sizes.push_back(varsize);
 …
+    }
     assert(tempsize!=0);  // if this happens an empty object (with no variables) would be transmitted
 //     COUT(4) << endl;
+//     orxout(verbose, context::network) << endl;
     header.setObjectID( this->objectID_ );
 …
     if(syncList_.empty())
+    {
+      orxout(internal_warning, context::network) << "Synchronisable::updateData syncList_ is empty" << endl;
       assert(0);
-      COUT(2) << "Synchronisable::updateData syncList_ is empty" << std::endl;
       return false;
+    }
 …
+    }
     //COUT(5) << "Synchronisable: objectID_ " << syncHeader.getObjectID() << ", classID_ " << syncHeader.getClassID() << " size: " << syncHeader.getDataSize() << " synchronising data" << std::endl;
+    //orxout(verbose_more, context::network) << "Synchronisable: objectID_ " << syncHeader.getObjectID() << ", classID_ " << syncHeader.getClassID() << " size: " << syncHeader.getDataSize() << " synchronising data" << endl;
     if( !syncHeaderLight.isDiffed() )
+    {
 …
+    {
       mem += SynchronisableHeaderLight::getSize();
 //       COUT(0) << "objectID: " << this->objectID_ << endl;
+//       orxout(debug_output, context::network) << "objectID: " << this->objectID_ << endl;
       while( mem < data+syncHeaderLight.getDataSize()+SynchronisableHeaderLight::getSize() )
+      {
         VariableID varID = *(VariableID*)mem;
 //         COUT(0) << "varID: " << varID << endl;
+//         orxout(debug_output, context::network) << "varID: " << varID << endl;
         assert( varID < syncList_.size() );
         mem += sizeof(VariableID);

code/trunk/src/libraries/network/synchronisable/Synchronisable.h

r8706	r8858
232	232	it++;
233	233	}
234		~~COUT(1~~) << "Tried to unregister not registered variable" << endl;
	234	orxout(internal_error, context::network) << "Tried to unregister not registered variable" << endl;
235	235	assert(false); //if we reach this point something went wrong:
236	236	// the variable has not been registered before

code/trunk/src/libraries/network/synchronisable/SynchronisableVariable.h

r7266	r8858
202	202	if ( static_cast<uint8_t>(mem) != this->varReference_ )
203	203	{ // wrong reference number, so discard the data
204		// ~~COUT(0~~) << "discharding data" << endl;
	204	// orxout(debug_output, context::network) << "discharding data" << endl;
205	205	mem += getSize( mode ); // SynchronisableVariableBidirectional::getSize returns size of variable + reference
206	206	return;

code/trunk/src/libraries/tools/BillboardSet.cc

r6417	r8858
80	80	catch (...)
81	81	{
82		~~COUT(1) << "Error: Couln't load billboard \"" << file << '"' << std::~~endl;
	82	orxout(internal_error) << "Couldn't load billboard \"" << file << '"' << endl;
83	83	this->billboardSet_ = 0;
84	84	}
…	…
103	103	catch (...)
104	104	{
105		~~COUT(1) << "Error: Couln't load billboard \"" << file << '"' << std::~~endl;
	105	orxout(internal_error) << "Couldn't load billboard \"" << file << '"' << endl;
106	106	this->billboardSet_ = 0;
107	107	}

code/trunk/src/libraries/tools/Mesh.cc

r8351	r8858
72	72	catch (...)
73	73	{
74		~~COUT(1) << "Error: Couln't load mesh \"" << meshsource << '"' << std::~~endl;
	74	orxout(internal_error) << "Couldn't load mesh \"" << meshsource << '"' << endl;
75	75	this->entity_ = 0;
76	76	}

code/trunk/src/libraries/tools/ParticleInterface.cc

r7166	r8858
78	78	catch (...)
79	79	{
80		~~COUT(1) << "Error: Couln't load particle system \"" << templateName << '"' << std::~~endl;
	80	orxout(internal_error) << "Couldn't load particle system \"" << templateName << '"' << endl;
81	81	this->particleSystem_ = 0;
82	82	}

code/trunk/src/libraries/tools/ResourceCollection.cc

r8351	r8858
62	62	if (resourceGroup.empty())
63	63	{
64		~~COUT(2) << "Warning: \"\" is not a valid resource group." << std::~~endl;
	64	orxout(internal_warning) << "\"\" is not a valid resource group." << endl;
65	65	return;
66	66	}

code/trunk/src/libraries/tools/ResourceLocation.cc

r8366	r8858
80	80	else
81	81	{
82		~~COUT(2) << "Warning: ResourceLocation '" << this->getPath() << "' does not seem to exist" << std::~~endl;
	82	orxout(internal_warning) << "ResourceLocation '" << this->getPath() << "' does not seem to exist" << endl;
83	83	return;
84	84	}
…	…
101	101	catch (const Ogre::Exception& ex)
102	102	{
103		~~COUT(1) << "Removing of a ResourceLocation failed: " << ex.what() << std::~~endl;
	103	orxout(internal_error) << "Removing of a ResourceLocation failed: " << ex.what() << endl;
104	104	}
105	105	}

code/trunk/src/libraries/tools/Shader.cc

r8079	r8858
141	141	}
142	142	else
143		~~COUT(2) << "Warning: Couldn't load compositor with name \"" << this->compositorName_ << "\"." << std::~~endl;
	143	orxout(internal_warning) << "Couldn't load compositor with name \"" << this->compositorName_ << "\"." << endl;
144	144	}
145	145	this->oldcompositorName_ = this->compositorName_;
…	…
217	217	}
218	218	else
219		~~COUT(2) << "Warning: No pass " << it->pass_ << " in technique " << it->technique_ << " in compositor \"" << this->compositorName_ << "\" or pass has no shader." << std::~~endl;
	219	orxout(internal_warning) << "No pass " << it->pass_ << " in technique " << it->technique_ << " in compositor \"" << this->compositorName_ << "\" or pass has no shader." << endl;
220	220	}
221	221	else
222		~~COUT(2) << "Warning: No technique " << it->technique_ << " in compositor \"" << this->compositorName_ << "\" or technique has no pass with shader." << std::~~endl;
	222	orxout(internal_warning) << "No technique " << it->technique_ << " in compositor \"" << this->compositorName_ << "\" or technique has no pass with shader." << endl;
223	223	}
224	224	this->parameters_.clear();

code/trunk/src/libraries/tools/Timer.h

r8729	r8858
66	66	void MyClass::myFunction()
67	67	{
68		~~COUT(0) << "Hello World" << std::~~endl;
	68	orxout() << "Hello World" << endl;
69	69	}
70	70	@endcode

code/trunk/src/libraries/util/CMakeLists.txt

-                      r8729
+                      r8858
   CRC32.cc
   ExprParser.cc
-  OutputHandler.cc
   Scope.cc
   ScopedSingletonManager.cc
 …
+)
+ADD_SUBDIRECTORY(output)
 ORXONOX_ADD_LIBRARY(util
   FIND_HEADER_FILES

code/trunk/src/libraries/util/Clipboard.cc

-                      r7401
+                      r8858
 #undef min
 #undef max
 #include "Debug.h"
+#include "Output.h"
 namespace orxonox
 …
         catch (...)
+        {
             COUT(1) << "Error: Unable to copy the following text to the clipboard:" << std::endl;
             COUT(1) << "       \"" << text << '"' << std::endl;
+            orxout(user_error) << "Unable to copy the following text to the clipboard:" << endl;
+            orxout(user_error) << '"' << text << '"' << endl;
+        }
         return false;
 …
         catch (...)
+        {
             COUT(1) << "Error: Unable to retrieve text from the clipboard." << std::endl;
+            orxout(user_error) << "Unable to retrieve text from the clipboard." << endl;
+        }
         return "";

code/trunk/src/libraries/util/Convert.h

-                      r8729
+                      r8858
 #include <loki/TypeManip.h>
 #include "Debug.h"
+#include "Output.h"
 #include "ImplicitConversion.h"
 …
         ORX_FORCEINLINE static bool convert(ToType* /*output*/, const FromType& /*input*/)
+        {
             COUT(2) << "Could not convert value of type " << typeid(FromType).name()
                     << " to type " << typeid(ToType).name() << std::endl;
+            orxout(internal_warning) << "Could not convert value of type " << typeid(FromType).name()
+                                     << " to type " << typeid(ToType).name() << endl;
             return false;
+        }

code/trunk/src/libraries/util/Exception.cc

-                      r8410
+                      r8858
 #include <cstddef>
 #include <CEGUIExceptions.h>
 #include "Debug.h"
+#include "Output.h"
 namespace orxonox
 …
         catch (...)
+        {
             COUT(0) << "BIG WARNING: Unknown exception type encountered."
                     << "Rethrowing" << endl;
+            orxout(user_error) << "BIG WARNING: Unknown exception type encountered."
+                               << " Rethrowing" << endl;
             throw;
+        }

code/trunk/src/libraries/util/Exception.h

-                      r8706
+                      r8858
 #include <sstream>
 #include <string>
 #include "Debug.h"
+#include "Output.h"
 namespace orxonox
 …
     inline const T& exceptionThrowerHelper(const T& exception)
+    {
         // let the catcher decide whether to display the message below level 4
         COUT(4) << exception.getFullDescription() << std::endl;
+        // let the catcher decide whether to display the message also to the user
+        orxout(internal_error) << exception.getFullDescription() << endl;
         return exception;
+    }

code/trunk/src/libraries/util/ExprParser.h

r8351	r8858
55	55	if (!expr.getRemains().empty())
56	56	{
57		~~COUT(2) << "Warning: Expression could not be parsed to the end! Remains: '" << expr.getRemains() << '\'' << std::~~endl;
	57	orxout(user_warning) << "Expression could not be parsed to the end! Remains: '" << expr.getRemains() << '\'' << endl;
58	58	}
59	59	float result = expr.getResult();
60	60	}
61	61	else
62		~~COUT(1) << "Error: Cannot calculate expression: Parse error." << std::~~endl;
	62	orxout(user_error) << "Cannot calculate expression: Parse error." << endl;
63	63	@endcode
64	64	getRemains() returns the expression after what could be parsed. For instance

code/trunk/src/libraries/util/MultiType.h

r7401	r8858
78	78	void myfunction(int value)
79	79	{
80		~~COUT(0) << "doubled value is " << (2 * value) << std::~~endl;
	80	orxout() << "doubled value is " << (2 * value) << endl;
81	81	}
82	82

code/trunk/src/libraries/util/OrxAssert.h

-                      r8372
+                      r8858
 #include <cassert>
 #include "Debug.h"
+#include "Output.h"
 #ifndef NDEBUG
 …
 /** Run time assertion like assert(), but with an embedded message.
 @details
     The message will be printed as error with COUT(1). <br>
+    The message will be printed as error with orxout(user_error). <br>
     You can use the same magic here as you can with \ref ThrowException
     @code
 …
         if (!(condition)) \
         { \
             COUT(1) << __FILE__ << "(" << __LINE__ << "): "; \
             COUT(1) << "Assertion failed in " << __FUNCTIONNAME__ << std::endl; \
             COUT(1) << "Expression: " << #condition << std::endl; \
             COUT(1) << "Message   : " << errorMessage << std::endl; \
+            orxout(user_error) << __FILE__ << "(" << __LINE__ << "): "; \
+            orxout(user_error) << "Assertion failed in " << __FUNCTIONNAME__ << endl; \
+            orxout(user_error) << "Expression: " << #condition << endl; \
+            orxout(user_error) << "Message   : " << errorMessage << endl; \
             /* Don't use the condition again to avoid double evaluation */ \
             /* Instead, stringify the expression and negate it */ \
 …
     mode (no abort() triggered then).
 @details
     The message will be printed as error with COUT(1). <br>
+    The message will be printed as error with orxout(user_error). <br>
     You can use the same magic here as you can with \ref ThrowException
     @code
 …
         if (!(condition)) \
         { \
             COUT(1) << __FILE__ << "(" << __LINE__ << "): "; \
             COUT(1) << "Verification failed in " << __FUNCTIONNAME__ << std::endl; \
             COUT(1) << "Expression: " << #condition << std::endl; \
             COUT(1) << "Message   : " << errorMessage << std::endl; \
+            orxout(user_error) << __FILE__ << "(" << __LINE__ << "): "; \
+            orxout(user_error) << "Verification failed in " << __FUNCTIONNAME__ << endl; \
+            orxout(user_error) << "Expression: " << #condition << endl; \
+            orxout(user_error) << "Message   : " << errorMessage << endl; \
             /* Don't use the condition again to avoid double evaluation */ \
             /* Instead, stringify the expression and negate it */ \
 …
         if (!(condition)) \
         { \
             COUT(1) << __FILE__ << "(" << __LINE__ << "): "; \
             COUT(1) << "Verification failed in " << __FUNCTIONNAME__ << std::endl; \
             COUT(1) << "Expression: " << #condition << std::endl; \
             COUT(1) << "Message   : " << errorMessage << std::endl; \
+            orxout(user_error) << __FILE__ << "(" << __LINE__ << "): "; \
+            orxout(user_error) << "Verification failed in " << __FUNCTIONNAME__ << endl; \
+            orxout(user_error) << "Expression: " << #condition << endl; \
+            orxout(user_error) << "Message   : " << errorMessage << endl; \
             /* No assert() in release configuration */ \
         } \

code/trunk/src/libraries/util/Scope.h

r7401	r8858
60	60	#include <loki/ScopeGuard.h>
61	61
62		#include "~~Debug~~.h"
	62	#include "Output.h"
63	63
64	64	namespace orxonox
…	…
128	128	Scope()
129	129	{
	130	orxout(internal_status) << "creating scope... (" << scope << ")" << endl;
	131
130	132	try
131	133	{
…	…
148	150	throw;
149	151	}
	152
	153	orxout(internal_status) << "created scope (" << scope << ")" << endl;
150	154	}
151	155
…	…
153	157	~Scope()
154	158	{
	159	orxout(internal_status) << "destroying scope... (" << scope << ")" << endl;
	160
155	161	ScopeManager::instanceCounts_s[scope]--;
156	162
…	…
162	168	if (ScopeManager::instanceCounts_s[scope] == 0)
163	169	this->deactivateListeners();
	170
	171	orxout(internal_status) << "destroyed scope (" << scope << ")" << endl;
164	172	}
165	173
…	…
174	182	{ (*it)->deactivated(); }
175	183	catch (...)
176		{ ~~COUT(0) << "ScopeListener::deactivated() failed! This MUST NOT happen, fix it!" << std::~~endl; }
	184	{ orxout(internal_warning) << "ScopeListener::deactivated() failed! This MUST NOT happen, fix it!" << endl; }
177	185	(*(it++))->bActivated_ = false;
178	186	}

code/trunk/src/libraries/util/ScopedSingletonManager.h

-                      r8706
+                      r8858
                 { singletonPtr_ = new T(); }
             catch (const InitialisationAbortedException& ex)
                 { COUT(3) << ex.getDescription() << std::endl; }
+                { orxout(internal_error) << ex.getDescription() << endl; }
             catch (...)
                 { COUT(1) << "Singleton creation failed: " << Exception::handleMessage() << std::endl; }
+                { orxout(internal_error) << "Singleton creation failed: " << Exception::handleMessage() << endl; }
+        }

code/trunk/src/libraries/util/SignalHandler.cc

-                      r8351
+                      r8858
 #include <cstdio>
 #include "Debug.h"
+#include "Output.h"
 namespace orxonox
 …
       if( SignalHandler::singletonPtr_s == 0 )
+      {
         COUT(0) << "Received signal " << sigName.c_str() << std::endl << "Can't write backtrace because SignalHandler is already destroyed" << std::endl;
+        orxout(user_error) << "Received signal " << sigName.c_str() << endl << "Can't write backtrace because SignalHandler is already destroyed" << endl;
         exit(EXIT_FAILURE);
+      }
 …
       COUT(0) << "Received signal " << sigName.c_str() << std::endl << "Try to write backtrace to file orxonox_crash.log" << std::endl;
+      orxout(user_error) << "Received signal " << sigName.c_str() << endl << "Try to write backtrace to file orxonox_crash.log" << endl;
 …
 #ifdef PR_SET_PTRACER
         if( prctl(PR_SET_PTRACER, gdbPid, 0, 0, 0) == -1 )
           COUT(0) << "could not set proper permissions for GDB to attach to process..." << endl;
+          orxout(user_error) << "could not set proper permissions for GDB to attach to process..." << endl;
 #endif
 …
         if( read( sigPipe[0], &someData, sizeof(someData) ) != sizeof(someData) )
           COUT(0) << "something went wrong :(" << std::endl;
+          orxout(user_error) << "something went wrong :(" << endl;
         if ( someData != 0x12345678 )
+        {
           COUT(0) << "something went wrong :(" << std::endl;
+          orxout(user_error) << "something went wrong :(" << endl;
+        }
 …
       if ( fwrite( bt.c_str(), 1, bt.length(), f ) != bt.length() )
+      {
         COUT(0) << "could not write " << bt.length() << " byte to " << getInstance().filename << std::endl;
+        orxout(user_error) << "could not write " << bt.length() << " byte to " << getInstance().filename << endl;
         exit(EXIT_FAILURE);
+      }
 …
 _UtilExport void __cdecl abort()
+{
+    COUT(1) << "This application has requested the Runtime to terminate it in an unusual way." << std::endl;
+    COUT(1) << "Please contact the application's support team for more information." << std::endl;
+    using namespace orxonox;
+    orxout(user_error) << "This application has requested the Runtime to terminate it in an unusual way." << endl;
+    orxout(user_error) << "Please contact the application's support team for more information." << endl;
     DebugBreak();
     exit(0x3);
 …
 _UtilExport void __cdecl _assert(const char* expression, const char* file, int line)
+{
+    COUT(1) << "Assertion failed: " << expression << ", file " << file << ", line " << line << std::endl;
+    COUT(1) << std::endl;
+    using namespace orxonox;
+    orxout(user_error) << "Assertion failed: " << expression << ", file " << file << ", line " << line << endl;
+    orxout(user_error) << endl;
     abort();
+}
 …
             bExecuting = true;
             COUT(1) << std::endl;
+            orxout(user_error) << endl;
             // if the signalhandler has already been destroyed then don't do anything
             if (SignalHandler::singletonPtr_s == 0)
+            {
                 COUT(1) << "Caught an unhandled exception" << std::endl << "Can't write backtrace because SignalHandler is already destroyed" << std::endl;
+                orxout(user_error) << "Caught an unhandled exception" << endl << "Can't write backtrace because SignalHandler is already destroyed" << endl;
                 exit(EXIT_FAILURE);
+            }
             COUT(1) << "Caught an unhandled exception" << std::endl << "Try to write backtrace to orxonox_crash.log..." << std::endl;
+            orxout(user_error) << "Caught an unhandled exception" << endl << "Try to write backtrace to orxonox_crash.log..." << endl;
             // write the crash log
 …
             time_t now = time(NULL);
             crashlog << "=======================================================" << std::endl;
+            crashlog << "=======================================================" << endl;
             crashlog << "= Time: " << std::string(ctime(&now));
             crashlog << "=======================================================" << std::endl;
             crashlog << std::endl;
+            crashlog << "=======================================================" << endl;
+            crashlog << endl;
             const std::string& error = SignalHandler::getExceptionType(pExceptionInfo);
             crashlog << error << std::endl;
             crashlog << std::endl;
+            crashlog << error << endl;
+            crashlog << endl;
             const std::string& callstack = SignalHandler::getStackTrace(pExceptionInfo);
             crashlog << "Call stack:" << std::endl;
             crashlog << callstack << std::endl;
+            crashlog << "Call stack:" << endl;
+            crashlog << callstack << endl;
             crashlog.close();
             // print the same information also to the console
             COUT(1) << std::endl;
             COUT(1) << error << std::endl;
             COUT(1) << std::endl;
             COUT(1) << "Call stack:" << std::endl;
             COUT(1) << callstack << std::endl;
+            orxout(user_error) << endl;
+            orxout(user_error) << error << endl;
+            orxout(user_error) << endl;
+            orxout(user_error) << "Call stack:" << endl;
+            orxout(user_error) << callstack << endl;
             bExecuting = false;
 …
         else
+        {
             COUT(1) << "An error occurred while writing the backtrace" << std::endl;
+            orxout(user_error) << "An error occurred while writing the backtrace" << endl;
+        }

code/trunk/src/libraries/util/Singleton.h

r7904	r8858
100	100	void TestSingleton::testFunction() // implement testFunction
101	101	{
102		~~COUT(0) << "My value is " << this->testValue_ << std::~~endl;
	102	orxout() << "My value is " << this->testValue_ << endl;
103	103	}
104	104

code/trunk/src/libraries/util/Sleep.cc

-                      r5738
+                      r8858
 #include "Sleep.h"
 #include "Debug.h"
+#include "Output.h"
 #ifdef ORXONOX_PLATFORM_WINDOWS
 …
+    {
         //if (microseconds < 1000)
         //    COUT(2) << "Warning: Windows cannot sleep less than 1ms, ignoring" << std::endl;
+        //    orxout(internal_warning) << "Windows cannot sleep less than 1ms, ignoring" << endl;
         Sleep(microseconds / 1000);
+    }

code/trunk/src/libraries/util/StringUtils.cc

-                      r8232
+                      r8858
         for (; pos2 > 0         && (str[pos2] == ' ' || str[pos2] == '\t' || str[pos2] == '\n'); pos2--);
         return str.substr(pos1, pos2 - pos1 + 1);
+    }
+    /// Splits a given string by a delimiter and stores it in an output vector
+    void vectorize(const std::string& str, char delimiter, std::vector<std::string>* output)
+    {
+        for (size_t start = 0, end = 0; end != std::string::npos; start = end + 1)
+        {
+            end = str.find_first_of(delimiter, start);
+            output->push_back(str.substr(start, end - start));
+        }
+    }
 …
         return matrix[(rows-1)*cols + cols-1];
+    }
     /**
     @brief

code/trunk/src/libraries/util/StringUtils.h

-                      r8232
+                      r8858
 #include "UtilPrereqs.h"
 #include <string>
+#include <vector>
 namespace orxonox
 …
     _UtilExport std::string  removeTrailingWhitespaces(const std::string& str);
+    _UtilExport void         vectorize(const std::string& str, char delimiter, std::vector<std::string>* output);
     _UtilExport size_t       getNextQuote(const std::string& str, size_t start);
 …
     _UtilExport unsigned int getLevenshteinDistance(const std::string& str1, const std::string& str2);
     _UtilExport std::string  getTimestamp(void);
+}

code/trunk/src/libraries/util/SubString.cc

-                      r7401
+                      r8858
 #include "SubString.h"
 #include <cstdio>
 #include "Debug.h"
+#include "Output.h"
 namespace orxonox
 …
     void SubString::debug() const
+    {
         COUT(0) << "Substring-information::count=" << this->tokens_.size() << " ::";
+        orxout(debug_output) << "Substring-information::count=" << this->tokens_.size() << " ::";
         for (unsigned int i = 0; i < this->tokens_.size(); ++i)
             COUT(0) << "s" << i << "='" << this->tokens_[i].c_str() << "'::";
         COUT(0) << std::endl;
+            orxout(debug_output) << "s" << i << "='" << this->tokens_[i].c_str() << "'::";
+        orxout(debug_output) << endl;
+    }
+}

code/trunk/src/libraries/util/SubString.h

r8706	r8858
59	59
60	60	for (unsigned int i = 0; i < tokens.size(); ++i)
61		~~COUT(0) << i << ": " << tokens[i] << std::~~endl;
	61	orxout() << i << ": " << tokens[i] << endl;
62	62	@endcode
63	63

code/trunk/src/libraries/util/UtilPrereqs.h

-                      r8729
+                      r8858
     class ExprParser;
     class MultiType;
-    class OutputHandler;
     class OutputListener;
+    class OutputManager;
+    class OutputStream;
     template <ScopeID::Value>
     class Scope;

Context Navigation

Legend:

Download in other formats: