Windows console color support. Replaced color param in API with new functions

README.md

@@ -74,34 +74,25 @@ int main(int, char*[])
 {
     try
     {
-        // Multithreaded color console
-        auto console = spd::stdout_logger_mt("console", true);
+        // Console logger with color
+        auto console = spd::stdout_color_mt("console");
         console->info("Welcome to spdlog!");
-        console->info("An info message example {}..", 1);
+        console->error("Some error message with arg{}..", 1);
 
         // Formatting examples
         console->warn("Easy padding in numbers like {:08d}", 12);
         console->critical("Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
         console->info("Support for floats {:03.2f}", 1.23456);
         console->info("Positional args are {1} {0}..", "too", "supported");
-
         console->info("{:<30}", "left aligned");
-        console->info("{:>30}", "right aligned");
-        console->info("{:^30}", "centered");
         
-        spd::get("console")->info("loggers can be retrieved from a global registry using the spdlog::get(logger_name) function");
 
-        // Runtime log levels
-        spd::set_level(spd::level::info); //Set global log level to info
-        console->debug("This message shold not be displayed!");
-        console->set_level(spd::level::debug); // Set specific logger's log level
-        console->debug("This message shold be displayed..");
+        spd::get("console")->info("loggers can be retrieved from a global registry using the spdlog::get(logger_name) function");
         
         // Create basic file logger (not rotated)
         auto my_logger = spd::basic_logger_mt("basic_logger", "logs/basic.txt");
         my_logger->info("Some log message");
 
-
         // Create a file rotating logger with 5mb size max and 3 rotated files
         auto rotating_logger = spd::rotating_logger_mt("some_logger_name", "logs/mylogfile", 1048576 * 5, 3);
         for (int i = 0; i < 10; ++i)
@@ -109,14 +100,23 @@ int main(int, char*[])
 
         // Create a daily logger - a new file is created every day on 2:30am
         auto daily_logger = spd::daily_logger_mt("daily_logger", "logs/daily", 2, 30);
+        // trigger flush if the log severity is error or higher
+        daily_logger->flush_on(spd::level::err);
         daily_logger->info(123.44);
 
         // Customize msg format for all messages
         spd::set_pattern("*** [%H:%M:%S %z] [thread %t] %v ***");
         rotating_logger->info("This is another message with custom format");
 
-        // Compile time debug or trace macros.
-        // Enabled #ifdef SPDLOG_DEBUG_ON or #ifdef SPDLOG_TRACE_ON
+
+		// Runtime log levels
+		spd::set_level(spd::level::info); //Set global log level to info
+		console->debug("This message shold not be displayed!");
+		console->set_level(spd::level::debug); // Set specific logger's log level
+		console->debug("This message shold be displayed..");
+
+        // Compile time log levels
+        // define SPDLOG_DEBUG_ON or SPDLOG_TRACE_ON
         SPDLOG_TRACE(console, "Enabled only #ifdef SPDLOG_TRACE_ON..{} ,{}", 1, 3.23);
         SPDLOG_DEBUG(console, "Enabled only #ifdef SPDLOG_DEBUG_ON.. {} ,{}", 1, 3.23);
 
@@ -124,17 +124,23 @@ int main(int, char*[])
         // Just call spdlog::set_async_mode(q_size) and all created loggers from now on will be asynchronous..
         async_example();
 
-        // syslog example. linux/osx only..
+        // syslog example. linux/osx only
         syslog_example();
 
-        // Log user-defined types example..
+        // android example. compile with NDK
+        android_example();
+
+        // Log user-defined types example
         user_defined_example();
 
         // Change default log error handler
         err_handler_example();
 
         // Apply a function on all registered loggers
-        spd::apply_all([&](std::shared_ptr<spdlog::logger> l) {l->info("End of example."); });
+        spd::apply_all([&](std::shared_ptr<spdlog::logger> l)
+        {
+            l->info("End of example.");
+        });
 
         // Release and close all loggers
         spdlog::drop_all();

example/example.cpp

@@ -22,28 +22,21 @@ int main(int, char*[])
 {
     try
     {
-        // Multithreaded color console
-        auto console = spd::stdout_logger_mt("console", true);
+		// Console logger with color
+        auto console = spd::stdout_color_mt("console");
         console->info("Welcome to spdlog!");
-        console->error("An error message example {}..", 1);
+		console->error("Some error message with arg{}..", 1);
 
         // Formatting examples
         console->warn("Easy padding in numbers like {:08d}", 12);
         console->critical("Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
         console->info("Support for floats {:03.2f}", 1.23456);
         console->info("Positional args are {1} {0}..", "too", "supported");
-
         console->info("{:<30}", "left aligned");
-        console->info("{:>30}", "right aligned");
-        console->info("{:^30}", "centered");
+        
 
         spd::get("console")->info("loggers can be retrieved from a global registry using the spdlog::get(logger_name) function");
 
-        // Runtime log levels
-        spd::set_level(spd::level::info); //Set global log level to info
-        console->debug("This message shold not be displayed!");
-        console->set_level(spd::level::debug); // Set specific logger's log level
-        console->debug("This message shold be displayed..");
         
         // Create basic file logger (not rotated)
         auto my_logger = spd::basic_logger_mt("basic_logger", "logs/basic.txt");
@@ -64,8 +57,15 @@ int main(int, char*[])
         spd::set_pattern("*** [%H:%M:%S %z] [thread %t] %v ***");
         rotating_logger->info("This is another message with custom format");
 
-        // Compile time debug or trace macros.
-        // Enabled #ifdef SPDLOG_DEBUG_ON or #ifdef SPDLOG_TRACE_ON
+
+		// Runtime log levels
+		spd::set_level(spd::level::info); //Set global log level to info
+		console->debug("This message shold not be displayed!");
+		console->set_level(spd::level::debug); // Set specific logger's log level
+		console->debug("This message shold be displayed..");
+
+        // Compile time log levels
+        // define SPDLOG_DEBUG_ON or SPDLOG_TRACE_ON
         SPDLOG_TRACE(console, "Enabled only #ifdef SPDLOG_TRACE_ON..{} ,{}", 1, 3.23);
         SPDLOG_DEBUG(console, "Enabled only #ifdef SPDLOG_DEBUG_ON.. {} ,{}", 1, 3.23);
 

example/example.vcxproj

@@ -42,6 +42,7 @@
     <ClInclude Include="..\include\spdlog\sinks\sink.h" />
     <ClInclude Include="..\include\spdlog\sinks\stdout_sinks.h" />
     <ClInclude Include="..\include\spdlog\sinks\syslog_sink.h" />
+    <ClInclude Include="..\include\spdlog\sinks\wincolor_sink.h" />
     <ClInclude Include="..\include\spdlog\spdlog.h" />
     <ClInclude Include="..\include\spdlog\tweakme.h" />
   </ItemGroup>

include/spdlog/details/spdlog_impl.h

@@ -15,7 +15,13 @@
 #ifdef SPDLOG_ENABLE_SYSLOG
 #include <spdlog/sinks/syslog_sink.h>
 #endif
+
+#ifdef _WIN32
+#include <spdlog/sinks/wincolor_sink.h>
+#else
 #include <spdlog/sinks/ansicolor_sink.h>
+#endif
+
 
 #ifdef __ANDROID__
 #include <spdlog/sinks/android_sink.h>
@@ -74,34 +80,86 @@ inline std::shared_ptr<spdlog::logger> spdlog::daily_logger_st(const std::string
 	return create<spdlog::sinks::daily_file_sink_st>(logger_name, filename, SPDLOG_FILENAME_T("txt"), hour, minute);
 }
 
-// Create stdout/stderr loggers (with optinal color support)
-inline std::shared_ptr<spdlog::logger> create_console_logger(const std::string& logger_name, spdlog::sink_ptr sink, bool color)
+
+//
+// stdout/stderr loggers
+//
+inline std::shared_ptr<spdlog::logger> spdlog::stdout_logger_mt(const std::string& logger_name)
+{							
+	return spdlog::details::registry::instance().create(logger_name, spdlog::sinks::stdout_sink_mt::instance());	
+}
+
+inline std::shared_ptr<spdlog::logger> spdlog::stdout_logger_st(const std::string& logger_name)
+{
+	return spdlog::details::registry::instance().create(logger_name, spdlog::sinks::stdout_sink_st::instance());
+}
+
+inline std::shared_ptr<spdlog::logger> spdlog::stderr_logger_mt(const std::string& logger_name)
+{
+	return spdlog::details::registry::instance().create(logger_name, spdlog::sinks::stderr_sink_mt::instance());
+}
+
+inline std::shared_ptr<spdlog::logger> spdlog::stderr_logger_st(const std::string& logger_name)
+{
+	return spdlog::details::registry::instance().create(logger_name, spdlog::sinks::stderr_sink_st::instance());
+}
+
+//
+// stdout/stderr color loggers
+//
+#ifdef _WIN32		
+inline std::shared_ptr<spdlog::logger> spdlog::stdout_color_mt(const std::string& logger_name)
 {
-    if (color) //use color wrapper sink
-        sink = std::make_shared<spdlog::sinks::ansicolor_sink>(sink);
+	auto sink = std::make_shared<spdlog::sinks::wincolor_stdout_sink_mt>();
 	return spdlog::details::registry::instance().create(logger_name, sink);
 }
 
-inline std::shared_ptr<spdlog::logger> spdlog::stdout_logger_mt(const std::string& logger_name, bool color)
+inline std::shared_ptr<spdlog::logger> spdlog::stdout_color_st(const std::string& logger_name)
 {
-    return create_console_logger(logger_name, sinks::stdout_sink_mt::instance(), color);
+	auto sink = std::make_shared<spdlog::sinks::wincolor_stdout_sink_st>();
+	return spdlog::details::registry::instance().create(logger_name, sink);
+}
+
+inline std::shared_ptr<spdlog::logger> spdlog::stderr_color_mt(const std::string& logger_name)
+{
+	auto sink = std::make_shared<spdlog::sinks::wincolor_stderr_sink_mt>();
+	return spdlog::details::registry::instance().create(logger_name, sink);
 }
 
-inline std::shared_ptr<spdlog::logger> spdlog::stdout_logger_st(const std::string& logger_name, bool color)
+
+inline std::shared_ptr<spdlog::logger> spdlog::stderr_color_st(const std::string& logger_name)
 {
-    return create_console_logger(logger_name, sinks::stdout_sink_st::instance(), color);
+	auto sink = std::make_shared<spdlog::sinks::wincolor_stderr_sink_st>();
+	return spdlog::details::registry::instance().create(logger_name, sink);
 }
 
-inline std::shared_ptr<spdlog::logger> spdlog::stderr_logger_mt(const std::string& logger_name, bool color)
+#else //ansi terminal colors
+
+inline std::shared_ptr<spdlog::logger> spdlog::stdout_color_mt(const std::string& logger_name)
 {
-    return create_console_logger(logger_name, sinks::stderr_sink_mt::instance(), color);
+	auto sink = std::make_shared<spdlog::sinks::ansicolor_sink>(spdlog::sinks::stdout_sink_mt::instance());
+	return spdlog::details::registry::instance().create(logger_name, sink);
 }
 
-inline std::shared_ptr<spdlog::logger> spdlog::stderr_logger_st(const std::string& logger_name, bool color)
+inline std::shared_ptr<spdlog::logger> spdlog::stdout_color_st(const std::string& logger_name)
 {
-    return create_console_logger(logger_name, sinks::stderr_sink_st::instance(), color);
+	auto sink = std::make_shared<spdlog::sinks::ansicolor_sink>(spdlog::sinks::stdout_sink_st::instance());
+	return spdlog::details::registry::instance().create(logger_name, sink);
 }
 
+inline std::shared_ptr<spdlog::logger> spdlog::stderr_color_mt(const std::string& logger_name)
+{
+	auto sink = std::make_shared<spdlog::sinks::ansicolor_sink>(spdlog::sinks::stderr_sink_mt::instance());
+	return spdlog::details::registry::instance().create(logger_name, sink);
+}
+
+inline std::shared_ptr<spdlog::logger> spdlog::stderr_color_st(const std::string& logger_name)
+{
+	auto sink = std::make_shared<spdlog::sinks::ansicolor_sink>(spdlog::sinks::stderr_sink_st::instance());
+	return spdlog::details::registry::instance().create(logger_name, sink);
+}
+#endif
+
 #ifdef SPDLOG_ENABLE_SYSLOG
 // Create syslog logger
 inline std::shared_ptr<spdlog::logger> spdlog::syslog_logger(const std::string& logger_name, const std::string& syslog_ident, int syslog_option)

include/spdlog/sinks/stdout_sinks.h

@@ -14,15 +14,16 @@
 
 namespace spdlog
 {
-namespace sinks
-{
+	namespace sinks
+	{
 
-template <class Mutex>
-class stdout_sink : public base_sink<Mutex>
-{
+		template <class Mutex>
+		class stdout_sink: public base_sink<Mutex>
+		{
 			using MyType = stdout_sink<Mutex>;
-public:
-    stdout_sink() {}
+		public:
+			stdout_sink()
+			{}
 			static std::shared_ptr<MyType> instance()
 			{
 				static std::shared_ptr<MyType> instance = std::make_shared<MyType>();
@@ -39,18 +40,19 @@ public:
 			{
 				fflush(stdout);
 			}
-};
+		};
 
-typedef stdout_sink<details::null_mutex> stdout_sink_st;
-typedef stdout_sink<std::mutex> stdout_sink_mt;
+		typedef stdout_sink<details::null_mutex> stdout_sink_st;
+		typedef stdout_sink<std::mutex> stdout_sink_mt;
 
 
-template <class Mutex>
-class stderr_sink : public base_sink<Mutex>
-{
+		template <class Mutex>
+		class stderr_sink: public base_sink<Mutex>
+		{
 			using MyType = stderr_sink<Mutex>;
-public:
-    stderr_sink() {}
+		public:
+			stderr_sink()
+			{}
 			static std::shared_ptr<MyType> instance()
 			{
 				static std::shared_ptr<MyType> instance = std::make_shared<MyType>();
@@ -67,9 +69,9 @@ public:
 			{
 				fflush(stderr);
 			}
-};
+		};
 
-typedef stderr_sink<std::mutex> stderr_sink_mt;
-typedef stderr_sink<details::null_mutex> stderr_sink_st;
-}
+		typedef stderr_sink<std::mutex> stderr_sink_mt;
+		typedef stderr_sink<details::null_mutex> stderr_sink_st;
+	}
 }

include/spdlog/sinks/wincolor_sink.h

+//
+// Copyright(c) 2016 spdlog
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+#pragma once
+
+#include <spdlog/sinks/base_sink.h>
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/common.h>
+
+#include <mutex>
+#include <string>
+#include <map>
+#include <wincon.h>
+
+namespace spdlog
+{
+	namespace sinks
+	{		
+		/*
+		 * Windows color console sink. Uses WriteConsoleA to write to the console with colors		
+		 */
+		template<class Mutex>
+		class wincolor_sink: public  base_sink<Mutex>
+		{
+		public:
+			const WORD BOLD = FOREGROUND_INTENSITY;
+			const WORD RED = FOREGROUND_RED;
+			const WORD CYAN = FOREGROUND_GREEN | FOREGROUND_BLUE;
+			const WORD WHITE = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
+			const WORD YELLOW = FOREGROUND_RED | FOREGROUND_GREEN;
+
+			wincolor_sink(HANDLE std_handle): out_handle_(std_handle)
+			{
+				colors_[level::trace] = CYAN;
+				colors_[level::debug] = CYAN;
+				colors_[level::info] = WHITE | BOLD;
+				colors_[level::warn] = YELLOW | BOLD;
+				colors_[level::err] = RED | BOLD; // red bold
+				colors_[level::critical] = BACKGROUND_RED | WHITE | BOLD; // white bold on red background
+				colors_[level::off] = 0;
+			}
+
+			virtual ~wincolor_sink()
+			{
+				flush();
+			}
+
+			wincolor_sink(const wincolor_sink& other) = delete;
+			wincolor_sink& operator=(const wincolor_sink& other) = delete;
+
+			virtual void _sink_it(const details::log_msg& msg) override
+			{
+				auto color = colors_[msg.level];
+				auto orig_attribs = set_console_attribs(color);
+				WriteConsoleA(out_handle_, msg.formatted.data(), msg.formatted.size(), nullptr, nullptr);
+				SetConsoleTextAttribute(out_handle_, orig_attribs); //reset to orig colors
+			}
+
+			virtual void flush() override
+			{
+				// windows console always flushed?
+			}
+
+			// change the  color for the given level
+			void set_color(level::level_enum level, WORD color)
+			{
+				std::lock_guard<Mutex> lock(_mutex);
+				colors_[level] = color;
+			}
+
+		private:
+			HANDLE out_handle_;
+			std::map<level::level_enum, WORD> colors_;
+
+			// set color and return the orig console attributes (for resetting later)
+			WORD set_console_attribs(WORD attribs)
+			{
+				CONSOLE_SCREEN_BUFFER_INFO orig_buffer_info;
+				GetConsoleScreenBufferInfo(out_handle_, &orig_buffer_info);
+				SetConsoleTextAttribute(out_handle_, attribs);
+				return  orig_buffer_info.wAttributes; //return orig attribs
+			}			
+		};
+
+		//
+		// windows color console to stdout
+		//
+		template<class Mutex>
+		class wincolor_stdout_sink: public wincolor_sink<Mutex>
+		{
+		public:
+			wincolor_stdout_sink():wincolor_sink(GetStdHandle(STD_OUTPUT_HANDLE))
+			{}			
+		};
+
+		typedef wincolor_stdout_sink<std::mutex> wincolor_stdout_sink_mt;
+		typedef wincolor_stdout_sink<details::null_mutex> wincolor_stdout_sink_st;
+
+		//
+		// windows color console to stderr
+		//
+		template<class Mutex>
+		class wincolor_stderr_sink: public wincolor_sink<Mutex>
+		{
+		public:
+			wincolor_stderr_sink():wincolor_sink(GetStdHandle(STD_ERROR_HANDLE))
+			{}		
+		};
+		
+		typedef wincolor_stderr_sink<std::mutex> wincolor_stderr_sink_mt;
+		typedef wincolor_stderr_sink<details::null_mutex> wincolor_stderr_sink_st;
+
+	}  
+}  
\ No newline at end of file

include/spdlog/spdlog.h

@@ -88,10 +88,17 @@ std::shared_ptr<logger> daily_logger_st(const std::string& logger_name, const fi
 //
 // Create and register stdout/stderr loggers
 //
-std::shared_ptr<logger> stdout_logger_mt(const std::string& logger_name, bool color = false);
-std::shared_ptr<logger> stdout_logger_st(const std::string& logger_name, bool color = false);
-std::shared_ptr<logger> stderr_logger_mt(const std::string& logger_name, bool color = false);
-std::shared_ptr<logger> stderr_logger_st(const std::string& logger_name, bool color = false);
+std::shared_ptr<logger> stdout_logger_mt(const std::string& logger_name);
+std::shared_ptr<logger> stdout_logger_st(const std::string& logger_name);
+std::shared_ptr<logger> stderr_logger_mt(const std::string& logger_name);
+std::shared_ptr<logger> stderr_logger_st(const std::string& logger_name);
+//
+// Create and register colored stdout/stderr loggers
+//
+std::shared_ptr<logger> stdout_color_mt(const std::string& logger_name);
+std::shared_ptr<logger> stdout_color_st(const std::string& logger_name);
+std::shared_ptr<logger> stderr_color_mt(const std::string& logger_name);
+std::shared_ptr<logger> stderr_color_st(const std::string& logger_name);
 
 
 //