Revamped some console log stuff.

* Added more colors!
 * VM's EE/IOP logs (the ones that come from the emulated games themselves) are colored accordingly: EE are faint cyan, IOP are faint yellow.  They're intentionally "hard to read" because 99% of the time they're meaningless trivia (but still cool since it's what the actual devs would have used for developing the games!).

Dev Notes:
 * Removed Console.Status (specify blue/green colors manually if you want them).
 * Renamed Console.Notice to Console.Warning.
 * I changed the overloads so that both char* and wxChar* versions work like printf now (no need to use wxsFormat when working with unicode strings).  I also removed wxString& versions of the overloads.  This should (I hope) also be an easier port to wx2.9 or 3.0, when that time comes.
 * Default log color is now black instead of gray; typically you'll want to manually specify Color_Gray when doing high volume logging (like the EErec's block tracking in debug builds).

git-svn-id: http://pcsx2.googlecode.com/svn/trunk@2091 96395faa-99c1-11dd-bbfe-3dabce05a288

common/include/Utilities/Console.h

@@ -23,13 +23,27 @@ enum ConsoleColors
 	Color_Current = -1,
 
 	Color_Black = 0,
-	Color_Red,
 	Color_Green,
-	Color_Yellow,
+	Color_Red,
 	Color_Blue,
 	Color_Magenta,
-	Color_Cyan,
+	Color_Orange,
-	Color_White,
+	Color_Gray,
+
+	Color_Cyan,			// faint visibility, intended for logging PS2/IOP output
+	Color_Yellow,		// faint visibility, intended for logging PS2/IOP output
+	Color_White,		// faint visibility, intended for logging PS2/IOP output
+
+	// Strong text *may* result in mis-aligned text in the console, depending on the
+	// font and the platform, so use these with caution.
+
+	Color_StrongBlack,
+	Color_StrongRed,	// intended for errors
+	Color_StrongGreen,	// intended for infrequent state information
+	Color_StrongBlue,	// intended for block headings
+	Color_StrongOrange,	// intended for warnings
+	
+	ConsoleColors_Count
 };
 
 // Use fastcall for the console; should be helpful in most cases
@@ -62,30 +76,21 @@ struct IConsoleWriter
 	// ----------------------------------------------------------------------------
 	// Public members; call these to print stuff to console!
 
+
 	void Write( ConsoleColors color, const char* fmt, ... ) const;
-	void Write( const char* fmt, ... ) const;
-	void Write( ConsoleColors color, const wxString& fmt ) const;
-	void Write( const wxString& fmt ) const;
-
 	void WriteLn( ConsoleColors color, const char* fmt, ... ) const;
+	void Write( const char* fmt, ... ) const;
 	void WriteLn( const char* fmt, ... ) const;
-	void WriteLn( ConsoleColors color, const wxString& fmt ) const;
-	void WriteLn( const wxString& fmt ) const;
-
 	void Error( const char* fmt, ... ) const;
-	void Notice( const char* fmt, ... ) const;
+	void Warning( const char* fmt, ... ) const;
-	void Status( const char* fmt, ... ) const;
 
-	void Error( const wxString& src ) const;
+	void Write( ConsoleColors color, const wxChar* fmt, ... ) const;
-	void Notice( const wxString& src ) const;
+	void WriteLn( ConsoleColors color, const wxChar* fmt, ... ) const;
-	void Status( const wxString& src ) const;
+	void Write( const wxChar* fmt, ... ) const;
+	void WriteLn( const wxChar* fmt, ... ) const;
+	void Error( const wxChar* fmt, ... ) const;
+	void Warning( const wxChar* fmt, ... ) const;
 
-	// ----------------------------------------------------------------------------
-	//  Private Members; for internal use only.
-
-	void _Write( const char* fmt, va_list args ) const;
-	void _WriteLn( const char* fmt, va_list args ) const;
-	void _WriteLn( ConsoleColors color, const char* fmt, va_list args ) const;
 };
 
 extern void Console_SetActiveHandler( const IConsoleWriter& writer, FILE* flushfp=NULL );

common/include/Utilities/SafeArray.h

@@ -73,13 +73,13 @@ class SafeArray
 public:
 	static const int DefaultChunkSize = 0x1000 * sizeof(T);
 
-public: 
+public:
-	const wxChar* Name;		// user-assigned block name
+	wxString	Name;			// user-assigned block name
-	int ChunkSize;
+	int			ChunkSize;
 
 protected:
-	T* m_ptr;
+	T*		m_ptr;
-	int m_size;	// size of the allocation of memory
+	int		m_size;				// size of the allocation of memory
 
 protected:
 	// Internal constructor for use by derived classes.  This allows a derived class to
@@ -232,13 +232,13 @@ public:
 	static const int DefaultChunkSize = 0x80 * sizeof(T);
 
 public: 
-	const wxChar* Name;		// user-assigned block name
+	wxString	Name;			// user-assigned block name
-	int ChunkSize;			// assigned DefaultChunkSize on init, reconfigurable at any time.
+	int			ChunkSize;		// assigned DefaultChunkSize on init, reconfigurable at any time.
 
 protected:
-	T* m_ptr;
+	T*		m_ptr;
-	int m_allocsize;	// size of the allocation of memory
+	int		m_allocsize;		// size of the allocation of memory
-	uint m_length;		// length of the array (active items, not buffer allocation)
+	uint	m_length;			// length of the array (active items, not buffer allocation)
 
 protected:
 	virtual T* _virtual_realloc( int newsize )
@@ -312,7 +312,7 @@ public:
 					wxsFormat(
 						L"Out-of-memory on SafeList block re-allocation.\n"
 						L"Name: %s, Old size: %d bytes, New size: %d bytes",
-						Name, m_allocsize, newalloc
+						Name.c_str(), m_allocsize, newalloc
 					),
 					
 					wxsFormat( _("Out of memory, trying to allocate %d bytes."), newalloc )

common/src/Utilities/Console.cpp

@@ -198,56 +198,144 @@ const IConsoleWriter ConsoleWriter_wxError =
 	ConsoleNull_ClearColor,
 };
 
+// Sanity check: truncate strings if they exceed 512k in length.  Anything like that
+// is either a bug or really horrible code that needs to be stopped before it causes
+// system deadlock.
+static const int MaxFormattedStringLength = 0x80000;
+
+template< typename CharType >
+class FormatBuffer : public MutexLock
+{
+public:
+	bool&				clearbit;
+	SafeArray<CharType>	buffer;
+	
+	FormatBuffer( bool& bit_to_clear_on_destruction ) :
+		clearbit( bit_to_clear_on_destruction )
+	,	buffer( 4096, wxsFormat( L"%s Format Buffer", (sizeof(CharType)==1) ? "Ascii" : "Unicode" ) )
+	{
+	}
+
+	virtual ~FormatBuffer() throw()
+	{
+		clearbit = true;
+		Wait();		// lock the mutex, just in case.
+	}
+	
+};
+
+static bool ascii_buffer_is_deleted = false;
+static bool unicode_buffer_is_deleted = false;
+
+static FormatBuffer<char>	ascii_buffer( ascii_buffer_is_deleted );
+static FormatBuffer<wxChar>	unicode_buffer( unicode_buffer_is_deleted );
+
+static void format_that_ascii_mess( SafeArray<char>& buffer, const char* fmt, va_list argptr )
+{
+	while( true )
+	{
+		int size = buffer.GetLength();
+		int len = vsnprintf(buffer.GetPtr(), size, fmt, argptr);
+
+		// some implementations of vsnprintf() don't NUL terminate
+		// the string if there is not enough space for it so
+		// always do it manually
+		buffer[size-1] = '\0';
+
+		if( size >= MaxFormattedStringLength ) break;
+
+		// vsnprintf() may return either -1 (traditional Unix behavior) or the
+		// total number of characters which would have been written if the
+		// buffer were large enough (newer standards such as Unix98)
+
+		if ( len < 0 )
+			len = size + (size/4);
+
+		if ( len < size ) break;
+		buffer.ExactAlloc( len + 1 );
+	};
+
+	// performing an assertion or log of a truncated string is unsafe, so let's not; even
+	// though it'd be kinda nice if we did.
+}
+
+static void format_that_unicode_mess( SafeArray<wxChar>& buffer, const wxChar* fmt, va_list argptr)
+{
+	while( true )
+	{
+		int size = buffer.GetLength();
+		int len = wxVsnprintf(buffer.GetPtr(), size, fmt, argptr);
+
+		// some implementations of vsnprintf() don't NUL terminate
+		// the string if there is not enough space for it so
+		// always do it manually
+		buffer[size-1] = L'\0';
+
+		if( size >= MaxFormattedStringLength ) break;
+
+		// vsnprintf() may return either -1 (traditional Unix behavior) or the
+		// total number of characters which would have been written if the
+		// buffer were large enough (newer standards such as Unix98)
+
+		if ( len < 0 )
+			len = size + (size/4);
+
+		if ( len < size ) break;
+		buffer.ExactAlloc( len + 1 );
+	};
+
+	// performing an assertion or log of a truncated string is unsafe, so let's not; even
+	// though it'd be kinda nice if we did.
+}
+
+static wxString ascii_format_string(const char* fmt, va_list argptr)
+{
+	if( ascii_buffer_is_deleted )
+	{
+		SafeArray<char>	localbuf( 4096, L"Temporary Ascii Formatting Buffer" );
+		format_that_ascii_mess( localbuf, fmt, argptr );
+		return fromUTF8( localbuf.GetPtr() );
+	}
+	else
+	{
+		ScopedLock locker( ascii_buffer );
+		format_that_ascii_mess( ascii_buffer.buffer, fmt, argptr );
+		return fromUTF8( ascii_buffer.buffer.GetPtr() );
+	}
+}
+
+
+static wxString unicode_format_string(const wxChar* fmt, va_list argptr)
+{
+	if( unicode_buffer_is_deleted )
+	{
+		SafeArray<wxChar> localbuf( 4096, L"Temporary Unicode Formatting Buffer" );
+		format_that_unicode_mess( localbuf, fmt, argptr );
+		return localbuf.GetPtr();
+	}
+	else
+	{
+		ScopedLock locker( unicode_buffer );
+		format_that_unicode_mess( unicode_buffer.buffer, fmt, argptr );
+		return unicode_buffer.buffer.GetPtr();
+	}
+}
+
 // =====================================================================================================
 //  IConsole Interfaces
 // =====================================================================================================
 // (all non-virtual members that do common work and then pass the result through DoWrite
 //  or DoWriteLn)
 
-// Writes a line of colored text to the console (no newline).
+// --------------------------------------------------------------------------------------
-// The console color is reset to default when the operation is complete.
+//  ASCII/UTF8 (char*)
-void IConsoleWriter::Write( ConsoleColors color, const wxString& fmt ) const
+// --------------------------------------------------------------------------------------
-{
-	SetColor( color );
-	Write( fmt );
-	ClearColor();
-}
-
-// Writes a line of colored text to the console, with automatic newline appendage.
-// The console color is reset to default when the operation is complete.
-void IConsoleWriter::WriteLn( ConsoleColors color, const wxString& fmt ) const
-{
-	SetColor( color );
-	WriteLn( fmt );
-	ClearColor();
-}
-
-void IConsoleWriter::_Write( const char* fmt, va_list args ) const
-{
-	std::string m_format_buffer;
-	vssprintf( m_format_buffer, fmt, args );
-	Write( fromUTF8( m_format_buffer.c_str() ) );
-}
-
-void IConsoleWriter::_WriteLn( const char* fmt, va_list args ) const
-{
-	std::string m_format_buffer;
-	vssprintf( m_format_buffer, fmt, args );
-	WriteLn( fromUTF8( m_format_buffer.c_str() ) );
-}
-
-void IConsoleWriter::_WriteLn( ConsoleColors color, const char* fmt, va_list args ) const
-{
-	SetColor( color );
-	_WriteLn( fmt, args );
-	ClearColor();
-}
 
 void IConsoleWriter::Write( const char* fmt, ... ) const
 {
 	va_list args;
 	va_start(args,fmt);
-	_Write( fmt, args );
+	DoWrite( ascii_format_string(fmt, args) );
 	va_end(args);
 }
 
@@ -256,7 +344,7 @@ void IConsoleWriter::Write( ConsoleColors color, const char* fmt, ... ) const
 	va_list args;
 	va_start(args,fmt);
 	SetColor( color );
-	_Write( fmt, args );
+	DoWrite( ascii_format_string(fmt, args) );
 	ClearColor();
 	va_end(args);
 }
@@ -265,7 +353,7 @@ void IConsoleWriter::WriteLn( const char* fmt, ... ) const
 {
 	va_list args;
 	va_start(args,fmt);
-	_WriteLn( fmt, args );
+	DoWriteLn( ascii_format_string(fmt, args) );
 	va_end(args);
 }
 
@@ -273,59 +361,93 @@ void IConsoleWriter::WriteLn( ConsoleColors color, const char* fmt, ... ) const
 {
 	va_list args;
 	va_start(args,fmt);
-	_WriteLn( color, fmt, args );
+	SetColor( color );
+	DoWriteLn( ascii_format_string(fmt, args) );
+	ClearColor();
 	va_end(args);
 }
 
-void IConsoleWriter::Write( const wxString& src ) const
-{
-	DoWrite( src );
-}
-
-void IConsoleWriter::WriteLn( const wxString& src ) const
-{
-	DoWriteLn( src );
-}
-
 void IConsoleWriter::Error( const char* fmt, ... ) const
 {
 	va_list args;
 	va_start(args,fmt);
-	_WriteLn( Color_Red, fmt, args );
+	SetColor( Color_StrongRed );
+	DoWriteLn( ascii_format_string(fmt, args) );
+	ClearColor();
 	va_end(args);
 }
 
-void IConsoleWriter::Notice( const char* fmt, ... ) const
+void IConsoleWriter::Warning( const char* fmt, ... ) const
 {
-	va_list list;
+	va_list args;
-	va_start(list,fmt);
+	va_start(args,fmt);
-	_WriteLn( Color_Yellow, fmt, list );
+	SetColor( Color_StrongOrange );
-	va_end(list);
+	DoWriteLn( ascii_format_string(fmt, args) );
+	ClearColor();
+	va_end(args);
 }
 
-void IConsoleWriter::Status( const char* fmt, ... ) const
+// --------------------------------------------------------------------------------------
+//  FmtWrite Variants - Unicode/UTF16 style
+// --------------------------------------------------------------------------------------
+
+void IConsoleWriter::Write( const wxChar* fmt, ... ) const
 {
-	va_list list;
+	va_list args;
-	va_start(list,fmt);
+	va_start(args,fmt);
-	_WriteLn( Color_Green, fmt, list );
+	DoWrite( unicode_format_string( fmt, args ) );
-	va_end(list);
+	va_end(args);
 }
 
-void IConsoleWriter::Error( const wxString& src ) const
+void IConsoleWriter::Write( ConsoleColors color, const wxChar* fmt, ... ) const
 {
-	WriteLn( Color_Red, src );
+	va_list args;
+	va_start(args,fmt);
+	SetColor( color );
+	DoWrite( unicode_format_string( fmt, args ) );
+	ClearColor();
+	va_end(args);
 }
 
-void IConsoleWriter::Notice( const wxString& src ) const
+void IConsoleWriter::WriteLn( const wxChar* fmt, ... ) const
 {
-	WriteLn( Color_Yellow, src );
+	va_list args;
+	va_start(args,fmt);
+	DoWriteLn( unicode_format_string( fmt, args ) );
+	va_end(args);
 }
 
-void IConsoleWriter::Status( const wxString& src ) const
+void IConsoleWriter::WriteLn( ConsoleColors color, const wxChar* fmt, ... ) const
 {
-	WriteLn( Color_Green, src );
+	va_list args;
+	va_start(args,fmt);
+	SetColor( color );
+	DoWriteLn( unicode_format_string( fmt, args ) );
+	ClearColor();
+	va_end(args);
 }
 
+void IConsoleWriter::Error( const wxChar* fmt, ... ) const
+{
+	va_list args;
+	va_start(args,fmt);
+	SetColor( Color_StrongRed );
+	DoWriteLn( unicode_format_string( fmt, args ) );
+	ClearColor();
+	va_end(args);
+}
+
+void IConsoleWriter::Warning( const wxChar* fmt, ... ) const
+{
+	va_list args;
+	va_start(args,fmt);
+	SetColor( Color_StrongOrange );
+	DoWriteLn( unicode_format_string( fmt, args ) );
+	ClearColor();
+	va_end(args);
+}
+
+
 // --------------------------------------------------------------------------------------
 //  Default Writer for C++ init / startup:
 // --------------------------------------------------------------------------------------

common/src/Utilities/Exceptions.cpp

@@ -51,10 +51,9 @@ DEVASSERT_INLINE void pxOnAssert( const wxChar* file, int line, const char* func
 	if( wxTheApp == NULL )
 	{
 		// Note: Format uses MSVC's syntax for output window hotlinking.
-		wxsFormat( L"%s(%d): Assertion failed in %s: %s\n",
+		wxLogError( wxsFormat( L"%s(%d): Assertion failed in %s: %s\n",
-			file, line, fromUTF8(func).c_str(), msg );
+			file, line, fromUTF8(func).c_str(), msg )
-
+		);
-		wxLogError( msg );
 	}
 	else
 	{

common/src/Utilities/ThreadTools.cpp

@@ -87,11 +87,11 @@ Threading::PersistentThread::~PersistentThread() throw()
 {
 	try
 	{
-		DevCon.WriteLn( L"(Thread Log) Executing destructor for " + m_name );
+		DbgCon.WriteLn( L"(Thread Log) Executing destructor for " + m_name );
 
 		if( m_running )
 		{
-			DevCon.WriteLn( L"\tWaiting for running thread to end...");
+			DevCon.WriteLn( L"(Thread Log) Waiting for running thread to end...");
 			m_lock_InThread.Wait();
 		}
 		Threading::Sleep( 1 );
@@ -108,8 +108,8 @@ Threading::PersistentThread::~PersistentThread() throw()
 		// so we can't allow for customized deadlock handlers, least not in any useful
 		// context.  So let's just log the condition and move on.
 
-		Console.Error( wxsFormat(L"\tThread destructor for '%s' timed out with error:\n\t",
+		Console.Error( L"(Thread Log) Thread destructor for '%s' timed out with error:\n\t",
-			m_name.c_str(), ex.FormatDiagnosticMessage().c_str() ) );
+			m_name.c_str(), ex.FormatDiagnosticMessage().c_str() );
 	}
 	DESTRUCTOR_CATCHALL
 }
@@ -121,8 +121,8 @@ void Threading::PersistentThread::FrankenMutex( MutexLock& mutex )
 		// Our lock is bupkis, which means  the previous thread probably deadlocked.
 		// Let's create a new mutex lock to replace it.
 
-		Console.Error( wxsFormat(
+		Console.Error( 
-			L"(Thread Log) Possible deadlock detected on restarted mutex belonging to '%s'.", m_name.c_str() )
+			L"(Thread Log) Possible deadlock detected on restarted mutex belonging to '%s'.", m_name.c_str()
 		);
 	}
 }
@@ -182,7 +182,7 @@ void Threading::PersistentThread::Cancel( bool isBlocking )
 
 		if( m_detached )
 		{
-			Console.Notice( "(Thread Warning) Ignoring attempted cancellation of detached thread." );
+			Console.Warning( "(Thread Warning) Ignoring attempted cancellation of detached thread." );
 			return;
 		}
 

common/src/x86emitter/cpudetect.cpp

@@ -97,7 +97,7 @@ static void SetSingleAffinity()
 
 	if( s_oldmask == ERROR_INVALID_PARAMETER )
 	{
-		Console.Notice(
+		Console.Warning(
 			"CpuDetect: SetThreadAffinityMask failed...\n"
 			"\tSystem Affinity : 0x%08x"
 			"\tProcess Affinity: 0x%08x"
@@ -353,7 +353,7 @@ void cpudetectInit()
 
 		if( sse3_result != !!x86caps.hasStreamingSIMD3Extensions )
 		{
-			Console.Notice( "SSE3 Detection Inconsistency: cpuid=%s, test_result=%s",
+			Console.Warning( "SSE3 Detection Inconsistency: cpuid=%s, test_result=%s",
 				bool_to_char( !!x86caps.hasStreamingSIMD3Extensions ), bool_to_char( sse3_result ) );
 
 			x86caps.hasStreamingSIMD3Extensions = sse3_result;
@@ -361,7 +361,7 @@ void cpudetectInit()
 
 		if( ssse3_result != !!x86caps.hasSupplementalStreamingSIMD3Extensions )
 		{
-			Console.Notice( "SSSE3 Detection Inconsistency: cpuid=%s, test_result=%s",
+			Console.Warning( "SSSE3 Detection Inconsistency: cpuid=%s, test_result=%s",
 				bool_to_char( !!x86caps.hasSupplementalStreamingSIMD3Extensions ), bool_to_char( ssse3_result ) );
 
 			x86caps.hasSupplementalStreamingSIMD3Extensions = ssse3_result;
@@ -369,7 +369,7 @@ void cpudetectInit()
 
 		if( sse41_result != !!x86caps.hasStreamingSIMD4Extensions )
 		{
-			Console.Notice( "SSE4 Detection Inconsistency: cpuid=%s, test_result=%s",
+			Console.Warning( "SSE4 Detection Inconsistency: cpuid=%s, test_result=%s",
 				bool_to_char( !!x86caps.hasStreamingSIMD4Extensions ), bool_to_char( sse41_result ) );
 
 			x86caps.hasStreamingSIMD4Extensions = sse41_result;
@@ -378,7 +378,7 @@ void cpudetectInit()
 	}
 	else
 	{
-		Console.Notice(
+		Console.Warning(
 			"Notice: Could not allocate memory for SSE3/4 detection.\n"
 			"\tRelying on CPUID results. [this is not an error]"
 		);

pcsx2/CDVD/CDVD.cpp

@@ -84,7 +84,7 @@ FILE *_cdvdOpenMechaVer()
 	fd = fopen(file, "r+b");
 	if (fd == NULL)
 	{
-		Console.Notice("MEC File Not Found , Creating Blank File");
+		Console.Warning("MEC File Not Found , Creating Blank File");
 		fd = fopen(file, "wb");
 		if (fd == NULL)
 		{
@@ -124,7 +124,7 @@ FILE *_cdvdOpenNVM()
 	fd = fopen(file, "r+b");
 	if (fd == NULL)
 	{
-		Console.Notice("NVM File Not Found , Creating Blank File");
+		Console.Warning("NVM File Not Found , Creating Blank File");
 		fd = fopen(file, "wb");
 		if (fd == NULL)
 		{
@@ -328,7 +328,7 @@ void cdvdReadKey(u8 arg0, u16 arg1, u32 arg2, u8* key) {
 	const wxCharBuffer crap( fname.ToAscii() );
 	const char* str = crap.data();
 	sprintf(exeName, "%c%c%c%c%c%c%c%c%c%c%c",str[8],str[9],str[10],str[11],str[12],str[13],str[14],str[15],str[16],str[17],str[18]);
-	DevCon.Notice("exeName = %s", &str[8]);
+	DevCon.Warning("exeName = %s", &str[8]);
 
 	// convert the number characters to a real 32bit number
 	numbers =	((((exeName[5] - '0'))*10000)	+
@@ -1048,14 +1048,14 @@ static void cdvdWrite04(u8 rt) { // NCOMMAND
 			// Seek to sector zero.  The cdvdStartSeek function will simulate
 			// spinup times if needed.
 
-			DevCon.Notice( "CdStandby : %d", rt );
+			DevCon.Warning( "CdStandby : %d", rt );
 			cdvd.Action = cdvdAction_Standby;
 			cdvd.ReadTime = cdvdBlockReadTime( MODE_DVDROM );
 			CDVD_INT( cdvdStartSeek( 0, MODE_DVDROM ) );
 		break;
 
 		case N_CD_STOP: // CdStop
-			DevCon.Notice( "CdStop : %d", rt );
+			DevCon.Warning( "CdStop : %d", rt );
 			cdvd.Action = cdvdAction_Stop;
 			CDVD_INT( PSXCLK / 6 );		// 166ms delay?
 		break;
@@ -1216,12 +1216,12 @@ static void cdvdWrite04(u8 rt) { // NCOMMAND
 		break;
 
 		case N_CD_CHG_SPDL_CTRL: // CdChgSpdlCtrl
-			Console.Notice("sceCdChgSpdlCtrl(%d)", cdvd.Param[0]);
+			Console.Warning("sceCdChgSpdlCtrl(%d)", cdvd.Param[0]);
 			cdvdSetIrq();
 		break;
 
 		default:
-			Console.Notice("NCMD Unknown %x", rt);
+			Console.Warning("NCMD Unknown %x", rt);
 			cdvdSetIrq();
 		break;
 	}
@@ -1250,7 +1250,7 @@ static __forceinline void cdvdWrite07(u8 rt)		// BREAK
 	// If we're already in a Ready state or already Breaking, then do nothing:
 	if ((cdvd.Ready != CDVD_NOTREADY) || (cdvd.Action == cdvdAction_Break)) return;
 
-	DbgCon.Notice("*PCSX2*: CDVD BREAK %x", rt);
+	DbgCon.WriteLn("*PCSX2*: CDVD BREAK %x", rt);
 
 	// Aborts any one of several CD commands:
 	// Pause, Seek, Read, Status, Standby, and Stop
@@ -1285,9 +1285,9 @@ static __forceinline void cdvdWrite14(u8 rt) { // PS1 MODE??
 	u32 cycle = psxRegs.cycle;
 
 	if (rt == 0xFE)
-		Console.Notice("*PCSX2*: go PS1 mode DISC SPEED = FAST");
+		Console.Warning("*PCSX2*: go PS1 mode DISC SPEED = FAST");
 	else
-		Console.Notice("*PCSX2*: go PS1 mode DISC SPEED = %dX", rt);
+		Console.Warning("*PCSX2*: go PS1 mode DISC SPEED = %dX", rt);
 
 	psxReset();
 	psxHu32(0x1f801450) = 0x8;
@@ -1934,7 +1934,7 @@ void cdvdWrite(u8 key, u8 rt)
 		case 0x18: cdvdWrite18(rt); break;
 		case 0x3A: cdvdWrite3A(rt); break;
 		default:
-			Console.Notice("IOP Unknown 8bit write to addr 0x1f4020%x = 0x%x", key, rt);
+			Console.Warning("IOP Unknown 8bit write to addr 0x1f4020%x = 0x%x", key, rt);
 			break;
 	}
 }

pcsx2/CDVD/CDVDaccess.cpp

@@ -159,15 +159,15 @@ static int FindDiskType(int mType)
 	switch(iCDType)
 	{
 		case CDVD_TYPE_DETCTCD:
-			Console.Status(" * CDVD Disk Open: CD, %d tracks (%d to %d):", tn.etrack-tn.strack+1,tn.strack,tn.etrack);
+			Console.WriteLn(" * CDVD Disk Open: CD, %d tracks (%d to %d):", tn.etrack-tn.strack+1,tn.strack,tn.etrack);
 			break;
 		
 		case CDVD_TYPE_DETCTDVDS:
-			Console.Status(" * CDVD Disk Open: DVD, Single layer or unknown:");
+			Console.WriteLn(" * CDVD Disk Open: DVD, Single layer or unknown:");
 			break;
 		
 		case CDVD_TYPE_DETCTDVDD:
-			Console.Status(" * CDVD Disk Open: DVD, Double layer:");
+			Console.WriteLn(" * CDVD Disk Open: DVD, Double layer:");
 			break;
 	}
 
@@ -188,12 +188,12 @@ static int FindDiskType(int mType)
 		if (td.type == CDVD_AUDIO_TRACK) 
 		{
 			audioTracks++;
-			Console.Status(" * * Track %d: Audio (%d sectors)", i,tlength);
+			Console.WriteLn(" * * Track %d: Audio (%d sectors)", i,tlength);
 		}
 		else 
 		{
 			dataTracks++;
-			Console.Status(" * * Track %d: Data (Mode %d) (%d sectors)", i,((td.type==CDVD_MODE1_TRACK)?1:2),tlength);
+			Console.WriteLn(" * * Track %d: Data (Mode %d) (%d sectors)", i,((td.type==CDVD_MODE1_TRACK)?1:2),tlength);
 		}
 	}
 
@@ -406,7 +406,7 @@ s32 DoCDVDreadTrack(u32 lsn, int mode)
 		break;
 	}
 
-	//DevCon.Notice("CDVD readTrack(lsn=%d,mode=%d)",params lsn, lastReadSize);
+	//DevCon.Warning("CDVD readTrack(lsn=%d,mode=%d)",params lsn, lastReadSize);
 	lastLSN = lsn;
 	return CDVD->readTrack(lsn,mode);
 }

pcsx2/CDVD/CDVDisoReader.cpp

@@ -128,7 +128,7 @@ static void FindLayer1Start()
 		int off = iso->blockofs;
 		u8 tempbuffer[CD_FRAMESIZE_RAW];
 
-		Console.Status("CDVDiso: searching for layer1...");
+		Console.WriteLn("CDVDiso: searching for layer1...");
 		//tempbuffer = (u8*)malloc(CD_FRAMESIZE_RAW);
 		for (layer1start = (iso->blocks / 2 - 0x10) & ~0xf; layer1start < 0x200010; layer1start += 16)
 		{
@@ -146,12 +146,12 @@ static void FindLayer1Start()
 
 		if(layer1start == 0x200010)
 		{
-			Console.Status("\tCouldn't find second layer on dual layer... ignoring");
+			Console.WriteLn("\tCouldn't find second layer on dual layer... ignoring");
 			layer1start=-2;
 		}
 
 		if(layer1start>=0)
-			Console.Status("\tfound at 0x%8.8x", layer1start);
+			Console.WriteLn("\tfound at 0x%8.8x", layer1start);
 	}
 }
 

pcsx2/CDVD/IsoFStools.cpp

@@ -209,7 +209,7 @@ int IsoFS_getVolumeDescriptor(void)
 	else if (CDVolDesc.filesystemType == 2)
 		DbgCon.WriteLn( Color_Green, "CD FileSystem is Joliet");
 	else 
-		DbgCon.Notice("Could not detect CD FileSystem type");
+		DbgCon.Warning("Could not detect CD FileSystem type");
 
 	//	CdStop();
 
@@ -333,7 +333,7 @@ int IsoFS_findFile(const char* fname, TocEntry* tocEntry){
 		// If we havent found the directory name we wanted then fail
 		if (found_dir != TRUE)
 		{
-			Console.Notice( "IsoFS_findfile: could not find dir" );
+			Console.Warning( "IsoFS_findfile: could not find dir" );
 			return -1;
 		}
 
@@ -412,7 +412,7 @@ int IsoFS_findFile(const char* fname, TocEntry* tocEntry){
 		}
 	}
 
-	DbgCon.Notice("IsoFS_findfile: could not find file");
+	DbgCon.Warning("IsoFS_findfile: could not find file");
 
 	return FALSE;
 }

pcsx2/COP0.cpp

@@ -210,10 +210,10 @@ static __forceinline bool PERF_ShouldCountEvent( uint evt )
 void COP0_DiagnosticPCCR()
 {
 	if( cpuRegs.PERF.n.pccr.b.Event0 >= 7 && cpuRegs.PERF.n.pccr.b.Event0 <= 10 )
-		Console.Notice( "PERF/PCR0 Unsupported Update Event Mode = 0x%x", cpuRegs.PERF.n.pccr.b.Event0 );
+		Console.Warning( "PERF/PCR0 Unsupported Update Event Mode = 0x%x", cpuRegs.PERF.n.pccr.b.Event0 );
 
 	if( cpuRegs.PERF.n.pccr.b.Event1 >= 7 && cpuRegs.PERF.n.pccr.b.Event1 <= 10 )
-		Console.Notice( "PERF/PCR1 Unsupported Update Event Mode = 0x%x", cpuRegs.PERF.n.pccr.b.Event1 );
+		Console.Warning( "PERF/PCR1 Unsupported Update Event Mode = 0x%x", cpuRegs.PERF.n.pccr.b.Event1 );
 }
 extern int branch;
 __forceinline void COP0_UpdatePCCR()

pcsx2/Common.h

@@ -36,9 +36,10 @@
 #include "Elfheader.h"
 #include "Patch.h"
 
+static const ConsoleColors ConColor_IOP = Color_Yellow;
+static const ConsoleColors ConColor_EE = Color_Cyan;
 
 // Some homeless externs.  This is as good a spot as any for now...
 
-
 extern void SetCPUState(u32 sseMXCSR, u32 sseVUMXCSR);
 extern u32  g_sseVUMXCSR, g_sseMXCSR;

pcsx2/Counters.cpp

@@ -256,7 +256,7 @@ u32 UpdateVSyncRate()
 		{
 			m_iTicks = ticks;
 			gsOnModeChanged( vSyncInfo.Framerate, m_iTicks );
-			Console.Status( limiterMsg, EmuConfig.Video.FpsLimit, 0 );
+			Console.WriteLn( limiterMsg, EmuConfig.Video.FpsLimit, 0 );
 		}
 	}
 	else
@@ -266,7 +266,7 @@ u32 UpdateVSyncRate()
 		{
 			m_iTicks = ticks;
 			gsOnModeChanged( vSyncInfo.Framerate, m_iTicks );
-			Console.Status( limiterMsg, vSyncInfo.Framerate/50, (vSyncInfo.Framerate*2)%100 );
+			Console.WriteLn( limiterMsg, vSyncInfo.Framerate/50, (vSyncInfo.Framerate*2)%100 );
 		}
 	}
 

pcsx2/Dump.cpp

@@ -207,7 +207,7 @@ void iDumpBlock( int startpc, u8 * ptr )
 	u8 fpuused[33];
 	int numused, fpunumused;
 
-	Console.Status( "dump1 %x:%x, %x", startpc, pc, cpuRegs.cycle );
+	Console.WriteLn( "dump1 %x:%x, %x", startpc, pc, cpuRegs.cycle );
 
 	g_Conf->Folders.Logs.Mkdir();
 	AsciiFile eff(

pcsx2/Elfheader.cpp

@@ -389,7 +389,7 @@ struct ElfObject
 							size = proghead[ i ].p_filesz;
 
 						if( proghead[ i ].p_vaddr != proghead[ i ].p_paddr )
-							Console.Notice( "ElfProgram different load addrs: paddr=0x%8.8x, vaddr=0x%8.8x",
+							Console.Warning( "ElfProgram different load addrs: paddr=0x%8.8x, vaddr=0x%8.8x",
 								proghead[ i ].p_paddr, proghead[ i ].p_vaddr);
 
 						// used to be paddr
@@ -515,14 +515,14 @@ u32 loadElfCRC( const char* filename )
 
 	IsoFS_init( );
 	
-	Console.Status("loadElfCRC: %s", filename);
+	Console.WriteLn("loadElfCRC: %s", filename);
 	
 	int mylen = strlen( "cdromN:" );
 	if ( IsoFS_findFile( filename + mylen, &toc ) == -1 ) return 0;
 
-	DevCon.Status( "loadElfFile: %d bytes", toc.fileSize );
+	DevCon.WriteLn( "loadElfFile: %d bytes", toc.fileSize );
 	u32 crcval = ElfObject( wxString::FromAscii( filename ), toc.fileSize ).GetCRC();
-	Console.Status( "loadElfFile: %s; CRC = %8.8X", filename, crcval );
+	Console.WriteLn( "loadElfFile: %s; CRC = %8.8X", filename, crcval );
 
 	return crcval;
 }
@@ -542,7 +542,7 @@ void loadElfFile(const wxString& filename)
 	if( filename.IsEmpty() ) return;
 	
 	s64 elfsize;
-	Console.Status( wxsFormat( L"loadElfFile: %s", filename.c_str() ) );
+	Console.WriteLn( L"loadElfFile: %s", filename.c_str() );
 
 	const wxCharBuffer buffer( filename.ToAscii() );
 	const char* fnptr = buffer.data();
@@ -567,7 +567,7 @@ void loadElfFile(const wxString& filename)
 	if( elfsize > 0xfffffff )
 		throw Exception::BadStream( filename, wxLt("Illegal ELF file size, over 2GB!") );
 
-	Console.Status( wxsFormat(L"loadElfFile: %d", wxULongLong(elfsize).GetLo() ) );
+	Console.WriteLn( L"loadElfFile: %d", wxULongLong(elfsize).GetLo() );
 	if( elfsize == 0 )
 		throw Exception::BadStream( filename, wxLt("Unexpected end of ELF file: ") );
 
@@ -599,12 +599,12 @@ void loadElfFile(const wxString& filename)
 		if( memcmp( "rom0:OSDSYS", (char*)PSM( i ), 11 ) == 0 )
 		{
 			strcpy( (char*)PSM( i ), fnptr );
-			DevCon.Status( "loadElfFile: addr %x \"%s\" -> \"%s\"", i, "rom0:OSDSYS", fnptr );
+			DevCon.WriteLn( "loadElfFile: addr %x \"%s\" -> \"%s\"", i, "rom0:OSDSYS", fnptr );
 		}
 	}
 
 	ElfCRC = elfobj.GetCRC();
-	Console.Status( wxsFormat( L"loadElfFile: %s; CRC = %8.8X", filename.c_str(), ElfCRC ) );
+	Console.WriteLn( L"loadElfFile: %s; CRC = %8.8X", filename.c_str(), ElfCRC );
 	ElfApplyPatches();
 	mtgsThread.SendGameCRC( ElfCRC );
 	
@@ -626,7 +626,7 @@ int GetPS2ElfName( wxString& name )
 
 	// check if the file exists
 	if (IsoFS_findFile("SYSTEM.CNF;1", &tocEntry) != TRUE){
-		Console.Status("GetElfName: SYSTEM.CNF not found; invalid cd image or no disc present.");
+		Console.Warning("GetElfName: SYSTEM.CNF not found; invalid cd image or no disc present.");
 		return 0;//could not find; not a PS/PS2 cdvd
 	}
 

pcsx2/FPU.cpp

@@ -78,7 +78,7 @@
 // If we have an infinity value, then Overflow has occured.
 #define checkOverflow(xReg, cFlagsToSet, shouldReturn) {  \
 	if ( ( xReg & ~0x80000000 ) == PosInfinity ) {  \
-		/*Console.Notice( "FPU OVERFLOW!: Changing to +/-Fmax!!!!!!!!!!!!\n" );*/  \
+		/*Console.Warning( "FPU OVERFLOW!: Changing to +/-Fmax!!!!!!!!!!!!\n" );*/  \
 		xReg = ( xReg & 0x80000000 ) | posFmax;  \
 		_ContVal_ |= cFlagsToSet;  \
 		if ( shouldReturn ) { return; }  \
@@ -88,7 +88,7 @@
 // If we have a denormal value, then Underflow has occured.
 #define checkUnderflow(xReg, cFlagsToSet, shouldReturn) {  \
 	if ( ( ( xReg & 0x7F800000 ) == 0 ) && ( ( xReg & 0x007FFFFF ) != 0 ) ) {  \
-		/*Console.Notice( "FPU UNDERFLOW!: Changing to +/-0!!!!!!!!!!!!\n" );*/  \
+		/*Console.Warning( "FPU UNDERFLOW!: Changing to +/-0!!!!!!!!!!!!\n" );*/  \
 		xReg &= 0x80000000;  \
 		_ContVal_ |= cFlagsToSet;  \
 		if ( shouldReturn ) { return; }  \

pcsx2/FiFo.cpp

@@ -43,7 +43,7 @@
 
 void __fastcall ReadFIFO_page_4(u32 mem, u64 *out)
 {
-	jASSUME( (mem >= VIF0_FIFO) && (mem < VIF1_FIFO) );
+	pxAssert( (mem >= VIF0_FIFO) && (mem < VIF1_FIFO) );
 
 	VIF_LOG("ReadFIFO/VIF0 0x%08X", mem);
 	
@@ -53,12 +53,12 @@ void __fastcall ReadFIFO_page_4(u32 mem, u64 *out)
 
 void __fastcall ReadFIFO_page_5(u32 mem, u64 *out)
 {
-	jASSUME( (mem >= VIF1_FIFO) && (mem < GIF_FIFO) );
+	pxAssert( (mem >= VIF1_FIFO) && (mem < GIF_FIFO) );
 
 	VIF_LOG("ReadFIFO/VIF1, addr=0x%08X", mem);
 
 	if (vif1Regs->stat.test(VIF1_STAT_INT | VIF1_STAT_VSS | VIF1_STAT_VIS | VIF1_STAT_VFS) )
-		DevCon.Notice( "Reading from vif1 fifo when stalled" );
+		DevCon.Warning( "Reading from vif1 fifo when stalled" );
 
 	if (vif1Regs->stat.FDR)
 	{
@@ -72,9 +72,9 @@ void __fastcall ReadFIFO_page_5(u32 mem, u64 *out)
 
 void __fastcall ReadFIFO_page_6(u32 mem, u64 *out)
 {
-	jASSUME( (mem >= GIF_FIFO) && (mem < IPUout_FIFO) );
+	pxAssert( (mem >= GIF_FIFO) && (mem < IPUout_FIFO) );
 
-	DevCon.Notice( "ReadFIFO/GIF, addr=0x%x", mem );
+	DevCon.Warning( "ReadFIFO/GIF, addr=0x%x", mem );
 
 	out[0] = psHu64(GIF_FIFO);
 	out[1] = psHu64(GIF_FIFO + 8);
@@ -82,7 +82,7 @@ void __fastcall ReadFIFO_page_6(u32 mem, u64 *out)
 
 void __fastcall ReadFIFO_page_7(u32 mem, u64 *out)
 {
-	jASSUME( (mem >= IPUout_FIFO) && (mem < D0_CHCR) );
+	pxAssert( (mem >= IPUout_FIFO) && (mem < D0_CHCR) );
 
 	// All addresses in this page map to 0x7000 and 0x7010:
 	mem &= 0x10;
@@ -107,7 +107,7 @@ void __fastcall ReadFIFO_page_7(u32 mem, u64 *out)
 
 void __fastcall WriteFIFO_page_4(u32 mem, const mem128_t *value)
 {
-	jASSUME( (mem >= VIF0_FIFO) && (mem < VIF1_FIFO) );
+	pxAssert( (mem >= VIF0_FIFO) && (mem < VIF1_FIFO) );
 
 	VIF_LOG("WriteFIFO/VIF0, addr=0x%08X", mem);
 
@@ -121,7 +121,7 @@ void __fastcall WriteFIFO_page_4(u32 mem, const mem128_t *value)
 
 void __fastcall WriteFIFO_page_5(u32 mem, const mem128_t *value)
 {
-	jASSUME( (mem >= VIF1_FIFO) && (mem < GIF_FIFO) );
+	pxAssert( (mem >= VIF1_FIFO) && (mem < GIF_FIFO) );
 
 	VIF_LOG("WriteFIFO/VIF1, addr=0x%08X", mem);
 
@@ -129,9 +129,9 @@ void __fastcall WriteFIFO_page_5(u32 mem, const mem128_t *value)
 	psHu64(VIF1_FIFO + 8) = value[1];
 
 	if (vif1Regs->stat.FDR)
-		DevCon.Notice("writing to fifo when fdr is set!");
+		DevCon.Warning("writing to fifo when fdr is set!");
 	if (vif1Regs->stat.test(VIF1_STAT_INT | VIF1_STAT_VSS | VIF1_STAT_VIS | VIF1_STAT_VFS) )
-		DevCon.Notice("writing to vif1 fifo when stalled");
+		DevCon.Warning("writing to vif1 fifo when stalled");
 
 	vif1ch->qwc += 1;
 	int ret = VIF1transfer((u32*)value, 4, 0);
@@ -143,7 +143,7 @@ __aligned16 u32 nloop0_packet[4] = {0x8000, 0, 0, 0};
 
 void __fastcall WriteFIFO_page_6(u32 mem, const mem128_t *value)
 {
-	jASSUME( (mem >= GIF_FIFO) && (mem < IPUout_FIFO) );
+	pxAssert( (mem >= GIF_FIFO) && (mem < IPUout_FIFO) );
 	GIF_LOG("WriteFIFO/GIF, addr=0x%08X", mem);
 
 	psHu64(GIF_FIFO) = value[0];
@@ -160,7 +160,7 @@ void __fastcall WriteFIFO_page_6(u32 mem, const mem128_t *value)
 
 void __fastcall WriteFIFO_page_7(u32 mem, const mem128_t *value)
 {
-	jASSUME( (mem >= IPUout_FIFO) && (mem < D0_CHCR) );
+	pxAssert( (mem >= IPUout_FIFO) && (mem < D0_CHCR) );
 
 	// All addresses in this page map to 0x7000 and 0x7010:
 	mem &= 0x10;
@@ -170,7 +170,7 @@ void __fastcall WriteFIFO_page_7(u32 mem, const mem128_t *value)
 	if( mem == 0 )
 	{
 		// Should this raise a PS2 exception or just ignore silently?
-		Console.Notice( "WriteFIFO/IPUout (ignored)" );
+		Console.Warning( "WriteFIFO/IPUout (ignored)" );
 	}
 	else
 	{

pcsx2/GSState.cpp

@@ -73,7 +73,7 @@ void SaveGSState(const wxString& file)
 	if( g_SaveGSStream ) return;
 
 	Console.WriteLn( "Saving GS State..." );
-	Console.WriteLn( wxsFormat( L"\t%s", file.c_str() ) );
+	Console.WriteLn( L"\t%s", file.c_str() );
 
 	SafeArray<u8> buf;
 	g_fGSSave = new memSavingState( buf );
@@ -88,7 +88,7 @@ void LoadGSState(const wxString& file)
 {
 	int ret;
 
-	Console.Status( "Loading GS State..." );
+	Console.WriteLn( "Loading GS State..." );
 
 	wxString src( file );
 

pcsx2/Gif.cpp

@@ -73,7 +73,7 @@ __forceinline void gsInterrupt()
 	{
 		if (!dmacRegs->ctrl.DMAE) 
 		{
-			Console.Notice("gs dma masked, re-scheduling...");
+			Console.Warning("gs dma masked, re-scheduling...");
 			// re-raise the int shortly in the future
 			CPU_INT( 2, 64 );
 			return;
@@ -124,7 +124,7 @@ int  _GIFchain()
 		//must increment madr and clear qwc, else it loops
 		gif->madr += gif->qwc * 16;
 		gif->qwc = 0;
-		Console.Notice( "Hackfix - NULL GIFchain" );
+		Console.Warning( "Hackfix - NULL GIFchain" );
 		return -1;
 	}
 

pcsx2/Hw.cpp

@@ -75,7 +75,7 @@ __forceinline void intcInterrupt()
 	if ((cpuRegs.CP0.n.Status.val & 0x400) != 0x400) return;
 
 	if ((psHu32(INTC_STAT)) == 0) {
-		DevCon.Notice("*PCSX2*: intcInterrupt already cleared");
+		DevCon.Warning("*PCSX2*: intcInterrupt already cleared");
         return;
 	}
 	if ((psHu32(INTC_STAT) & psHu32(INTC_MASK)) == 0) return;
@@ -197,7 +197,7 @@ bool hwDmacSrcChainWithStack(DMACh *dma, int id) {
                     break;
                     
                 default:
-                    Console.Notice("Call Stack Overflow (report if it fixes/breaks anything)");
+                    Console.Warning("Call Stack Overflow (report if it fixes/breaks anything)");
                     return true;
 			}
 			

pcsx2/HwRead.cpp

@@ -55,7 +55,7 @@ __forceinline mem8_t hwRead8(u32 mem)
 	u8 ret;
 
 	if( mem >= IPU_CMD && mem < D0_CHCR )
-		DevCon.Notice("Unexpected hwRead8 from 0x%x", mem);
+		DevCon.Warning("Unexpected hwRead8 from 0x%x", mem);
 
 	switch (mem)
 	{
@@ -128,7 +128,7 @@ __forceinline mem16_t hwRead16(u32 mem)
 	u16 ret;
 
 	if( mem >= IPU_CMD && mem < D0_CHCR )
-		Console.Notice("Unexpected hwRead16 from 0x%x", mem);
+		Console.Warning("Unexpected hwRead16 from 0x%x", mem);
 
 	switch (mem)
 	{

pcsx2/HwWrite.cpp

@@ -147,7 +147,7 @@ void hwWrite8(u32 mem, u8 value)
 	}
 
 	if( mem >= IPU_CMD && mem < D0_CHCR )
-		DevCon.Notice( "hwWrite8 to 0x%x = 0x%x", mem, value );
+		DevCon.Warning( "hwWrite8 to 0x%x = 0x%x", mem, value );
 
 	switch (mem) {
 		case RCNT0_COUNT: rcntWcount(0, value); break;
@@ -180,7 +180,7 @@ void hwWrite8(u32 mem, u8 value)
 			     ( value == '\n' && sio_count != 0 ))
 			{
 				sio_buffer[sio_count] = 0;
-				Console.WriteLn( Color_Cyan, sio_buffer );
+				Console.WriteLn( ConColor_EE, sio_buffer );
 				sio_count = 0;
 			}
 			else if( value != '\n' )
@@ -197,7 +197,7 @@ void hwWrite8(u32 mem, u8 value)
 			DMA_LOG("VIF0dma EXECUTE, value=0x%x", value);
 			if ((value & 0x1) && !dmacRegs->ctrl.DMAE) 
 			{
-				DevCon.Notice("8 bit VIF0 DMA Start while DMAC Disabled\n");
+				DevCon.Warning("8 bit VIF0 DMA Start while DMAC Disabled\n");
 				QueuedDMA |= 0x1;
 			}
 			DmaExec8(dmaVIF0, mem, value);
@@ -207,7 +207,7 @@ void hwWrite8(u32 mem, u8 value)
 			DMA_LOG("VIF1dma EXECUTE, value=0x%x", value);
 			if ((value & 0x1) && !dmacRegs->ctrl.DMAE) 
 			{
-				DevCon.Notice("8 bit VIF1 DMA Start while DMAC Disabled\n");
+				DevCon.Warning("8 bit VIF1 DMA Start while DMAC Disabled\n");
 				QueuedDMA |= 0x2;
 			}
 			if(value & 0x1) vif1.done = false;  //This must be done here! some games (ala Crash of the Titans) pause the dma to start MFIFO
@@ -218,7 +218,7 @@ void hwWrite8(u32 mem, u8 value)
 			DMA_LOG("GSdma EXECUTE, value=0x%x", value);
 			if ((value & 0x1) && !dmacRegs->ctrl.DMAE) 
 			{
-				DevCon.Notice("8 bit GIF DMA Start while DMAC Disabled\n");
+				DevCon.Warning("8 bit GIF DMA Start while DMAC Disabled\n");
 				QueuedDMA |= 0x4;
 			}
 			DmaExec8(dmaGIF, mem, value);
@@ -228,7 +228,7 @@ void hwWrite8(u32 mem, u8 value)
 			DMA_LOG("IPU0dma EXECUTE, value=0x%x", value);
 			if ((value & 0x1) && !dmacRegs->ctrl.DMAE) 
 			{
-				DevCon.Notice("8 bit IPU0 DMA Start while DMAC Disabled\n");
+				DevCon.Warning("8 bit IPU0 DMA Start while DMAC Disabled\n");
 				QueuedDMA |= 0x8;
 			}
 			DmaExec8(dmaIPU0, mem, value);
@@ -238,7 +238,7 @@ void hwWrite8(u32 mem, u8 value)
 			DMA_LOG("IPU1dma EXECUTE, value=0x%x", value);
 			if ((value & 0x1) && !dmacRegs->ctrl.DMAE) 
 			{
-				DevCon.Notice("8 bit IPU1 DMA Start while DMAC Disabled\n");
+				DevCon.Warning("8 bit IPU1 DMA Start while DMAC Disabled\n");
 				QueuedDMA |= 0x10;
 			}
 			DmaExec8(dmaIPU1, mem, value);
@@ -249,7 +249,7 @@ void hwWrite8(u32 mem, u8 value)
 //			if (value == 0) psxSu32(0x30) = 0x40000;
 			if ((value & 0x1) && !dmacRegs->ctrl.DMAE) 
 			{
-				DevCon.Notice("8 bit SIF0 DMA Start while DMAC Disabled\n");
+				DevCon.Warning("8 bit SIF0 DMA Start while DMAC Disabled\n");
 				QueuedDMA |= 0x20;
 			}
 			DmaExec8(dmaSIF0, mem, value);
@@ -259,7 +259,7 @@ void hwWrite8(u32 mem, u8 value)
 			DMA_LOG("SIF1dma EXECUTE, value=0x%x", value);
 			if ((value & 0x1) && !dmacRegs->ctrl.DMAE) 
 			{
-				DevCon.Notice("8 bit SIF1 DMA Start while DMAC Disabled\n");
+				DevCon.Warning("8 bit SIF1 DMA Start while DMAC Disabled\n");
 				QueuedDMA |= 0x40;
 			}
 			DmaExec8(dmaSIF1, mem, value);
@@ -269,7 +269,7 @@ void hwWrite8(u32 mem, u8 value)
 			DMA_LOG("SIF2dma EXECUTE, value=0x%x", value);
 			if ((value & 0x1) && !dmacRegs->ctrl.DMAE) 
 			{
-				DevCon.Notice("8 bit SIF2 DMA Start while DMAC Disabled\n");
+				DevCon.Warning("8 bit SIF2 DMA Start while DMAC Disabled\n");
 				QueuedDMA |= 0x80;
 			}
 			DmaExec8(dmaSIF2, mem, value);
@@ -279,7 +279,7 @@ void hwWrite8(u32 mem, u8 value)
 			DMA_LOG("fromSPRdma8 EXECUTE, value=0x%x", value);
 			if ((value & 0x1) && !dmacRegs->ctrl.DMAE) 
 			{
-				DevCon.Notice("8 bit SPR0 DMA Start while DMAC Disabled\n");
+				DevCon.Warning("8 bit SPR0 DMA Start while DMAC Disabled\n");
 				QueuedDMA |= 0x100;
 			}
 			DmaExec8(dmaSPR0, mem, value);
@@ -289,7 +289,7 @@ void hwWrite8(u32 mem, u8 value)
 			DMA_LOG("toSPRdma8 EXECUTE, value=0x%x", value);
 			if ((value & 0x1) && !dmacRegs->ctrl.DMAE) 
 			{
-				DevCon.Notice("8 bit SPR1 DMA Start while DMAC Disabled\n");
+				DevCon.Warning("8 bit SPR1 DMA Start while DMAC Disabled\n");
 				QueuedDMA |= 0x200;
 			}
 			DmaExec8(dmaSPR1, mem, value);
@@ -348,7 +348,7 @@ void hwWrite8(u32 mem, u8 value)
 __forceinline void hwWrite16(u32 mem, u16 value)
 {
 	if( mem >= IPU_CMD && mem < D0_CHCR )
-		Console.Notice( "hwWrite16 to %x", mem );
+		Console.Warning( "hwWrite16 to %x", mem );
 
 	switch(mem)
 	{
@@ -374,7 +374,7 @@ __forceinline void hwWrite16(u32 mem, u16 value)
 			DMA_LOG("VIF0dma %lx", value);
 			if ((value & 0x100) && !dmacRegs->ctrl.DMAE) 
 			{
-				DevCon.Notice("16 bit VIF0 DMA Start while DMAC Disabled\n");
+				DevCon.Warning("16 bit VIF0 DMA Start while DMAC Disabled\n");
 				QueuedDMA |= 0x1;
 			}
 			DmaExec16(dmaVIF0, mem, value);
@@ -384,7 +384,7 @@ __forceinline void hwWrite16(u32 mem, u16 value)
 			DMA_LOG("VIF1dma CHCR %lx", value);
 			if ((value & 0x100) && !dmacRegs->ctrl.DMAE) 
 			{
-				DevCon.Notice("16 bit VIF1 DMA Start while DMAC Disabled\n");
+				DevCon.Warning("16 bit VIF1 DMA Start while DMAC Disabled\n");
 				QueuedDMA |= 0x2;
 			}
 			if(value & 0x100) vif1.done = false;  //This must be done here! some games (ala Crash of the Titans) pause the dma to start MFIFO
@@ -428,7 +428,7 @@ __forceinline void hwWrite16(u32 mem, u16 value)
 			DMA_LOG("0x%8.8x hwWrite32: GSdma %lx", cpuRegs.cycle, value);
 			if ((value & 0x100) && !dmacRegs->ctrl.DMAE) 
 			{
-				DevCon.Notice("16 bit GIF DMA Start while DMAC Disabled\n");
+				DevCon.Warning("16 bit GIF DMA Start while DMAC Disabled\n");
 				QueuedDMA |= 0x4;
 			}
 			DmaExec16(dmaGIF, mem, value);
@@ -470,7 +470,7 @@ __forceinline void hwWrite16(u32 mem, u16 value)
 			DMA_LOG("IPU0dma %lx", value);
 			if ((value & 0x100) && !dmacRegs->ctrl.DMAE) 
 			{
-				DevCon.Notice("16 bit IPU0 DMA Start while DMAC Disabled\n");
+				DevCon.Warning("16 bit IPU0 DMA Start while DMAC Disabled\n");
 				QueuedDMA |= 0x8;
 			}
 			DmaExec16(dmaIPU0, mem, value);
@@ -502,7 +502,7 @@ __forceinline void hwWrite16(u32 mem, u16 value)
 			DMA_LOG("IPU1dma %lx", value);
 			if ((value & 0x100) && !dmacRegs->ctrl.DMAE) 
 			{
-				DevCon.Notice("16 bit IPU1 DMA Start while DMAC Disabled\n");
+				DevCon.Warning("16 bit IPU1 DMA Start while DMAC Disabled\n");
 				QueuedDMA |= 0x10;
 			}
 			DmaExec16(dmaIPU1, mem, value);
@@ -534,7 +534,7 @@ __forceinline void hwWrite16(u32 mem, u16 value)
 //			if (value == 0) psxSu32(0x30) = 0x40000;
 			if ((value & 0x100) && !dmacRegs->ctrl.DMAE) 
 			{
-				DevCon.Notice("16 bit SIF0 DMA Start while DMAC Disabled\n");
+				DevCon.Warning("16 bit SIF0 DMA Start while DMAC Disabled\n");
 				QueuedDMA |= 0x20;
 			}
 			DmaExec16(dmaSIF0, mem, value);
@@ -548,7 +548,7 @@ __forceinline void hwWrite16(u32 mem, u16 value)
 			DMA_LOG("SIF1dma %lx", value);
 			if ((value & 0x100) && !dmacRegs->ctrl.DMAE) 
 			{
-				DevCon.Notice("16 bit SIF1 DMA Start while DMAC Disabled\n");
+				DevCon.Warning("16 bit SIF1 DMA Start while DMAC Disabled\n");
 				QueuedDMA |= 0x40;
 			}
 			DmaExec16(dmaSIF1, mem, value);
@@ -580,7 +580,7 @@ __forceinline void hwWrite16(u32 mem, u16 value)
 			DMA_LOG("SIF2dma %lx", value);
 			if ((value & 0x100) && !dmacRegs->ctrl.DMAE) 
 			{
-				DevCon.Notice("16 bit SIF2 DMA Start while DMAC Disabled\n");
+				DevCon.Warning("16 bit SIF2 DMA Start while DMAC Disabled\n");
 				QueuedDMA |= 0x80;
 			}
 			DmaExec16(dmaSIF2, mem, value);
@@ -594,7 +594,7 @@ __forceinline void hwWrite16(u32 mem, u16 value)
 			DMA_LOG("fromSPRdma %lx", value);
 			if ((value & 0x100) && !dmacRegs->ctrl.DMAE) 
 			{
-				DevCon.Notice("16 bit SPR0 DMA Start while DMAC Disabled\n");
+				DevCon.Warning("16 bit SPR0 DMA Start while DMAC Disabled\n");
 				QueuedDMA |= 0x100;
 			}
 			DmaExec16(dmaSPR0, mem, value);
@@ -604,7 +604,7 @@ __forceinline void hwWrite16(u32 mem, u16 value)
 			DMA_LOG("toSPRdma %lx", value);
 			if ((value & 0x100) && !dmacRegs->ctrl.DMAE) 
 			{
-				DevCon.Notice("16 bit SPR1 DMA Start while DMAC Disabled\n");
+				DevCon.Warning("16 bit SPR1 DMA Start while DMAC Disabled\n");
 				QueuedDMA |= 0x200;
 			}
 			DmaExec16(dmaSPR1, mem, value);
@@ -743,7 +743,7 @@ void __fastcall hwWrite32_page_03( u32 mem, u32 value )
 		break;
 
 		case GIF_STAT: // stat is readonly
-			DevCon.Notice("*PCSX2* GIFSTAT write value = 0x%x (readonly, ignored)", value);
+			DevCon.Warning("*PCSX2* GIFSTAT write value = 0x%x (readonly, ignored)", value);
 		break;
 
 		default:
@@ -762,7 +762,7 @@ void __fastcall hwWrite32_page_0B( u32 mem, u32 value )
 			DMA_LOG("IPU0dma EXECUTE, value=0x%x\n", value);
 			if ((value & 0x100) && !dmacRegs->ctrl.DMAE) 
 			{
-				DevCon.Notice("32 bit IPU0 DMA Start while DMAC Disabled\n");
+				DevCon.Warning("32 bit IPU0 DMA Start while DMAC Disabled\n");
 				QueuedDMA |= 0x8;
 			}
 			DmaExec(dmaIPU0, mem, value);
@@ -779,7 +779,7 @@ void __fastcall hwWrite32_page_0B( u32 mem, u32 value )
 			DMA_LOG("IPU1dma EXECUTE, value=0x%x\n", value);
 			if ((value & 0x100) && !dmacRegs->ctrl.DMAE) 
 			{
-				DevCon.Notice("32 bit IPU1 DMA Start while DMAC Disabled\n");
+				DevCon.Warning("32 bit IPU1 DMA Start while DMAC Disabled\n");
 				QueuedDMA |= 0x10;
 			}
 			DmaExec(dmaIPU1, mem, value);
@@ -930,7 +930,7 @@ void __fastcall hwWrite32_generic( u32 mem, u32 value )
 		
 			if ((value & 0x100) && !dmacRegs->ctrl.DMAE) 
 			{
-				DevCon.Notice("32 bit VIF0 DMA Start while DMAC Disabled\n");
+				DevCon.Warning("32 bit VIF0 DMA Start while DMAC Disabled\n");
 				QueuedDMA |= 0x1;
 			}
 			
@@ -943,7 +943,7 @@ void __fastcall hwWrite32_generic( u32 mem, u32 value )
 		
 			if ((value & 0x100) && !dmacRegs->ctrl.DMAE) 
 			{
-				DevCon.Notice("32 bit VIF1 DMA Start while DMAC Disabled\n");
+				DevCon.Warning("32 bit VIF1 DMA Start while DMAC Disabled\n");
 				QueuedDMA |= 0x2;
 			}
 			
@@ -967,7 +967,7 @@ void __fastcall hwWrite32_generic( u32 mem, u32 value )
 			DMA_LOG("GIFdma EXECUTE, value=0x%x", value);
 			if ((value & 0x100) && !dmacRegs->ctrl.DMAE) 
 			{
-				DevCon.Notice("32 bit GIF DMA Start while DMAC Disabled\n");
+				DevCon.Warning("32 bit GIF DMA Start while DMAC Disabled\n");
 				QueuedDMA |= 0x4;
 			}
 			DmaExec(dmaGIF, mem, value);
@@ -986,7 +986,7 @@ void __fastcall hwWrite32_generic( u32 mem, u32 value )
 			//if (value == 0) psxSu32(0x30) = 0x40000;
 			if ((value & 0x100) && !dmacRegs->ctrl.DMAE) 
 			{
-				DevCon.Notice("32 bit SIF0 DMA Start while DMAC Disabled\n");
+				DevCon.Warning("32 bit SIF0 DMA Start while DMAC Disabled\n");
 				QueuedDMA |= 0x20;
 			}
 			DmaExec(dmaSIF0, mem, value);
@@ -996,7 +996,7 @@ void __fastcall hwWrite32_generic( u32 mem, u32 value )
 			DMA_LOG("SIF1dma EXECUTE, value=0x%x", value);
 			if ((value & 0x100) && !dmacRegs->ctrl.DMAE) 
 			{
-				DevCon.Notice("32 bit SIF1 DMA Start while DMAC Disabled\n");
+				DevCon.Warning("32 bit SIF1 DMA Start while DMAC Disabled\n");
 				QueuedDMA |= 0x40;
 			}
 			DmaExec(dmaSIF1, mem, value);
@@ -1011,7 +1011,7 @@ void __fastcall hwWrite32_generic( u32 mem, u32 value )
 			DMA_LOG("SIF2dma EXECUTE, value=0x%x", value);
 			if ((value & 0x100) && !dmacRegs->ctrl.DMAE) 
 			{
-				DevCon.Notice("32 bit SIF2 DMA Start while DMAC Disabled\n");
+				DevCon.Warning("32 bit SIF2 DMA Start while DMAC Disabled\n");
 				QueuedDMA |= 0x80;
 			}
 			DmaExec(dmaSIF2, mem, value);
@@ -1021,7 +1021,7 @@ void __fastcall hwWrite32_generic( u32 mem, u32 value )
 			DMA_LOG("SPR0dma EXECUTE (fromSPR), value=0x%x", value);
 			if ((value & 0x100) && !dmacRegs->ctrl.DMAE) 
 			{
-				DevCon.Notice("32 bit SPR0 DMA Start while DMAC Disabled\n");
+				DevCon.Warning("32 bit SPR0 DMA Start while DMAC Disabled\n");
 				QueuedDMA |= 0x100;
 			}
 			DmaExec(dmaSPR0, mem, value);
@@ -1031,7 +1031,7 @@ void __fastcall hwWrite32_generic( u32 mem, u32 value )
 			DMA_LOG("SPR1dma EXECUTE (toSPR), value=0x%x", value);
 			if ((value & 0x100) && !dmacRegs->ctrl.DMAE) 
 			{
-				DevCon.Notice("32 bit SPR1 DMA Start while DMAC Disabled\n");
+				DevCon.Warning("32 bit SPR1 DMA Start while DMAC Disabled\n");
 				QueuedDMA |= 0x200;
 			}
 			DmaExec(dmaSPR1, mem, value);
@@ -1081,7 +1081,7 @@ void __fastcall hwWrite64_page_03( u32 mem, const mem64_t* srcval )
 	switch (mem)
 	{
 		case GIF_CTRL:
-			DevCon.Status("GIF_CTRL write 64", value);
+			DevCon.WriteLn("GIF_CTRL write 64", value);
 			psHu32(mem) = value & 0x8;
 			if(value & 0x1)
 				gsGIFReset();
@@ -1099,7 +1099,7 @@ void __fastcall hwWrite64_page_03( u32 mem, const mem64_t* srcval )
 			// set/clear bits 0 and 2 as per the GIF_MODE value.
 			const u32 bitmask = GIF_MODE_M3R | GIF_MODE_IMT;
 			
-			Console.Status("GIFMODE64 %x", value);
+			Console.WriteLn("GIFMODE64 %x", value);
 
 			psHu64(GIF_MODE) = value;
 			psHu32(GIF_STAT) &= ~bitmask;

pcsx2/IPU/IPU.cpp

@@ -282,11 +282,11 @@ __forceinline u64 ipuRead64(u32 mem)
 			break;
 
 		ipucase(IPU_CTRL):
-			DevCon.Notice("reading 64bit IPU ctrl");
+			DevCon.Warning("reading 64bit IPU ctrl");
 			break;
 
 		ipucase(IPU_BP):
-			DevCon.Notice("reading 64bit IPU top");
+			DevCon.Warning("reading 64bit IPU top");
 			break;
 
 		ipucase(IPU_TOP): // IPU_TOP

pcsx2/IopBios.cpp

@@ -175,12 +175,8 @@ void bios_write()  // 0x35/0x03
 	{
 		const char *ptr = Ra1;
 
-		// fixme: This should use %s with a length parameter (but I forget the exact syntax
+		// fixme: This should use %s with a length parameter (but I forget the exact syntax)
-		while (a2 > 0) 
+		Console.Write( ConColor_IOP, "%.*s", a2, ptr);
-		{
-			Console.Write("%c", *ptr++);
-			a2--;
-		}
 	}
 	else
 	{
@@ -291,19 +287,19 @@ _start:
 	// Note: Use Read to obtain a write pointer here, since we're just writing back the 
 	// temp buffer we saved earlier.
 	memcpy( (void*)iopVirtMemR<void>(sp), save, 4*4);
-	Console.Write( Color_Cyan, "%s", tmp);
+	Console.Write( ConColor_IOP, tmp);
 	pc0 = ra;
 }
 
 void bios_putchar ()  // 3d
 {
-    Console.Write( Color_Cyan, "%c", a0 );
+    Console.Write( ConColor_IOP, "%c", a0 );
     pc0 = ra;
 }
 
 void bios_puts ()  // 3e/3f
 {
-    Console.Write( Color_Cyan, Ra0 );
+    Console.Write( ConColor_IOP, Ra0 );
     pc0 = ra;
 }
 

pcsx2/IopDma.cpp

@@ -31,7 +31,7 @@ static void __fastcall psxDmaGeneric(u32 madr, u32 bcr, u32 chcr, u32 spuCore, _
 	const char dmaNum = spuCore ? '7' : '4';
 
 	/*if (chcr & 0x400) DevCon.Status("SPU 2 DMA %c linked list chain mode! chcr = %x madr = %x bcr = %x\n", dmaNum, chcr, madr, bcr);
-	if (chcr & 0x40000000) DevCon.Notice("SPU 2 DMA %c Unusual bit set on 'to' direction chcr = %x madr = %x bcr = %x\n", dmaNum, chcr, madr, bcr);
+	if (chcr & 0x40000000) DevCon.Warning("SPU 2 DMA %c Unusual bit set on 'to' direction chcr = %x madr = %x bcr = %x\n", dmaNum, chcr, madr, bcr);
 	if ((chcr & 0x1) == 0) DevCon.Status("SPU 2 DMA %c loading from spu2 memory chcr = %x madr = %x bcr = %x\n", dmaNum, chcr, madr, bcr);*/
 
 	const int size = (bcr >> 16) * (bcr & 0xFFFF);
@@ -53,7 +53,7 @@ static void __fastcall psxDmaGeneric(u32 madr, u32 bcr, u32 chcr, u32 spuCore, _
 
 		if((g_psxNextBranchCycle - psxNextsCounter) > (u32)psxNextCounter)
 		{
-			//DevCon.Notice("SPU2async Setting new counter branch, old %x new %x ((%x - %x = %x) > %x delta)", g_psxNextBranchCycle, psxNextsCounter + psxNextCounter, g_psxNextBranchCycle, psxNextsCounter, (g_psxNextBranchCycle - psxNextsCounter), psxNextCounter);
+			//DevCon.Warning("SPU2async Setting new counter branch, old %x new %x ((%x - %x = %x) > %x delta)", g_psxNextBranchCycle, psxNextsCounter + psxNextCounter, g_psxNextBranchCycle, psxNextsCounter, (g_psxNextBranchCycle - psxNextsCounter), psxNextCounter);
 			g_psxNextBranchCycle = psxNextsCounter + psxNextCounter;
 		}
 	}

pcsx2/IopHw.cpp

@@ -69,7 +69,7 @@ u8 psxHwRead8(u32 add) {
 		case IOP_T5_COUNT:
 		case IOP_T5_MODE:
 		case IOP_T5_TARGET:
-			DevCon.Notice( "IOP Counter Read8 from addr0x%x = 0x%x", add, psxHu8(add) );
+			DevCon.Warning( "IOP Counter Read8 from addr0x%x = 0x%x", add, psxHu8(add) );
 			return psxHu8(add);
 #endif
 
@@ -649,7 +649,7 @@ void psxHwWrite8(u32 add, u8 value) {
 		case IOP_T5_COUNT:
 		case IOP_T5_MODE:
 		case IOP_T5_TARGET:
-			DevCon.Notice( "IOP Counter Write8 to addr 0x%x = 0x%x", add, value );
+			DevCon.Warning( "IOP Counter Write8 to addr 0x%x = 0x%x", add, value );
 			psxHu8(add) = value;
 		return;
 
@@ -673,7 +673,7 @@ void psxHwWrite8(u32 add, u8 value) {
 				( value == '\n' && g_pbufi != 0 ) )
 			{
 				g_pbuf[g_pbufi] = 0;
-				DevCon.WriteLn( Color_Cyan, "%s", g_pbuf );
+				Console.WriteLn( ConColor_IOP, g_pbuf );
 				g_pbufi = 0;
 			}
 			else if( value != '\n' )
@@ -1236,7 +1236,7 @@ void psxHwWrite32(u32 add, u32 value) {
 //------------------------------------------------------------------
 		case 0x1f8014c0:
 			PSXHW_LOG("RTC_HOLDMODE 32bit write %lx", value);
-			Console.Notice("** RTC_HOLDMODE 32bit write %lx", value);
+			Console.Warning("** RTC_HOLDMODE 32bit write %lx", value);
 			break;
 
 		case 0x1f801450:

pcsx2/IopMem.cpp

@@ -57,7 +57,7 @@ void psxMemReset()
 	jASSUME( psxMemWLUT != NULL );
 	jASSUME( m_psxAllMem != NULL );
 
-	DbgCon.Status( "psxMemReset > Resetting core memory!" );
+	DbgCon.WriteLn( "IOP Resetting physical ram..." );
 
 	memzero_ptr<0x2000 * sizeof(uptr) * 2>( psxMemWLUT );	// clears both allocations, RLUT and WLUT
 	memzero_ptr<m_psxMemSize>( m_psxAllMem );

pcsx2/IopSio2.cpp

@@ -52,7 +52,7 @@ only recv2 & dataout influences padman
 
 
 void sio2Reset() {
-	DevCon.Status( "Sio2 Reset" );
+	DevCon.WriteLn( "Sio2 Reset" );
 	memzero(sio2);
 	sio2.packet.recvVal1 = 0x1D100; // Nothing is connected at start
 }
@@ -155,7 +155,7 @@ void sio2_serialIn(u8 value){
 	sioWrite8(value);
 	
 	if (sio2.packet.sendSize > BUFSIZE) {//asadr
-		Console.Notice("*PCSX2*: sendSize >= %d", BUFSIZE);
+		Console.Warning("*PCSX2*: sendSize >= %d", BUFSIZE);
 	} else {
 		sio2.buf[sio2.packet.sendSize] = sioRead8();
 		sio2.packet.sendSize++;

pcsx2/MTGS.cpp

@@ -466,7 +466,7 @@ void mtgsThreadObject::SetEvent()
 
 void mtgsThreadObject::PrepEventWait()
 {
-	//Console.Notice( "MTGS Stall!  EE waits for nothing! ... except your GPU sometimes." );
+	//Console.Warning( "MTGS Stall!  EE waits for nothing! ... except your GPU sometimes." );
 	SetEvent();
 	Timeslice();
 }
@@ -591,15 +591,15 @@ int mtgsThreadObject::PrepDataPacket( GIF_PATH pathidx, const u8* srcdata, u32 s
 				{
 					total_bucket+=ringtx_inf[i][j];
 					bucket_subitems++;
-					Console.Notice("GSRingBufCopy :tx [%d,%d] algn %d : count= %d [%.2f%%]",1<<i,(1<<(i+1))-16,1<<j,ringtx_inf[i][j],ringtx_inf[i][j]/(float)ringtx_c*100);
+					Console.Warning("GSRingBufCopy :tx [%d,%d] algn %d : count= %d [%.2f%%]",1<<i,(1<<(i+1))-16,1<<j,ringtx_inf[i][j],ringtx_inf[i][j]/(float)ringtx_c*100);
 					ringtx_inf[i][j]=0;
 				}
 			}
 			if (total_bucket)
-				Console.Notice("GSRingBufCopy :tx [%d,%d] total : count= %d [%.2f%%] [%.2f%%]",1<<i,(1<<(i+1))-16,total_bucket,total_bucket/(float)ringtx_c*100,ringtx_inf_s[i]/(float)ringtx_s*100);
+				Console.Warning("GSRingBufCopy :tx [%d,%d] total : count= %d [%.2f%%] [%.2f%%]",1<<i,(1<<(i+1))-16,total_bucket,total_bucket/(float)ringtx_c*100,ringtx_inf_s[i]/(float)ringtx_s*100);
 			ringtx_inf_s[i]=0;
 		}
-		Console.Notice("GSRingBufCopy :tx ulg count =%d [%.2f%%]",ringtx_s_ulg,ringtx_s_ulg/(float)ringtx_s*100);
+		Console.Warning("GSRingBufCopy :tx ulg count =%d [%.2f%%]",ringtx_s_ulg,ringtx_s_ulg/(float)ringtx_s*100);
 		ringtx_s_ulg=0;
 		ringtx_c=0;
 		ringtx_s=0;

pcsx2/Memory.cpp

@@ -870,10 +870,10 @@ void mmap_MarkCountedRamPage( u32 paddr )
 	if( m_PageProtectInfo[rampage].Mode == ProtMode_Write )
 		return;		// skip town if we're already protected.
 
-	if( m_PageProtectInfo[rampage].Mode == ProtMode_Manual )
+	DbgCon.WriteLn( Color_Gray, (m_PageProtectInfo[rampage].Mode == ProtMode_Manual) ?
-		DbgCon.WriteLn( "dyna_page_reset @ 0x%05x", paddr>>12 );
+		"dyna_page_reset @ 0x%05x" : "Write-protected page @ 0x%05x",
-	else
+		paddr>>12
-		DbgCon.WriteLn( "Write-protected page @ 0x%05x", paddr>>12 );
+	);
 
 	m_PageProtectInfo[rampage].Mode = ProtMode_Write;
 	HostSys::MemProtect( &psM[rampage<<12], 1, Protect_ReadOnly );

pcsx2/PluginManager.cpp

@@ -662,13 +662,13 @@ static void PS2E_CALLBACK pcsx2_OSD_WriteLn( int icon, const char* msg )
 
 PluginManager::PluginManager( const wxString (&folders)[PluginId_Count] )
 {
-	Console.Status( "Loading plugins..." );
+	Console.WriteLn( Color_StrongBlue, "Loading plugins..." );
 
 	const PluginInfo* pi = tbl_PluginInfo; do
 	{
 		const PluginsEnum_t pid = pi->id;
 
-		Console.WriteLn( "\tBinding %s\t: %s ", tbl_PluginInfo[pid].shortname, folders[pid].ToUTF8().data() );
+		Console.WriteLn( L"\tBinding %s\t: %s ", tbl_PluginInfo[pid].GetShortname().c_str(), folders[pid].c_str() );
 
 		if( folders[pid].IsEmpty() )
 			throw Exception::InvalidArgument( "Empty plugin filename." );
@@ -707,7 +707,7 @@ PluginManager::PluginManager( const wxString (&folders)[PluginId_Count] )
 	PADinit = (_PADinit)m_info[PluginId_PAD].CommonBindings.Init;
 	m_info[PluginId_PAD].CommonBindings.Init = _hack_PADinit;
 
-	Console.Status( "Plugins loaded successfully.\n" );
+	Console.WriteLn( Color_StrongBlue, "Plugins loaded successfully.\n" );
 
 	// HACK!  Manually bind the Internal MemoryCard plugin for now, until
 	// we get things more completed in the new plugin api.
@@ -906,7 +906,7 @@ void PluginManager::Open( PluginsEnum_t pid )
 
 void PluginManager::Open()
 {
-	Console.Status( "Opening plugins..." );
+	Console.WriteLn( Color_StrongBlue, "Opening plugins..." );
 
 	const PluginInfo* pi = tbl_PluginInfo; do {
 		Open( pi->id );
@@ -918,13 +918,13 @@ void PluginManager::Open()
 
 	if (GSopen2) mtgsThread.WaitForOpen();
 
-	Console.Status( "Plugins opened successfully." );
+	Console.WriteLn( Color_StrongBlue, "Plugins opened successfully." );
 }
 
 void PluginManager::Close( PluginsEnum_t pid )
 {
 	if( !m_info[pid].IsOpened ) return;
-	Console.Status( "\tClosing %s", tbl_PluginInfo[pid].shortname );
+	Console.WriteLn( "\tClosing %s", tbl_PluginInfo[pid].shortname );
 
 	if( pid == PluginId_GS )
 	{
@@ -942,7 +942,7 @@ void PluginManager::Close( PluginsEnum_t pid )
 
 void PluginManager::Close( bool closegs )
 {
-	DbgCon.Status( "Closing plugins..." );
+	DbgCon.WriteLn( Color_StrongBlue, "Closing plugins..." );
 
 	// Close plugins in reverse order of the initialization procedure.
 
@@ -952,7 +952,7 @@ void PluginManager::Close( bool closegs )
 			Close( tbl_PluginInfo[i].id );
 	}
 
-	DbgCon.Status( "Plugins closed successfully." );
+	DbgCon.WriteLn( Color_StrongBlue, "Plugins closed successfully." );
 }
 
 // Initializes all plugins.  Plugin initialization should be done once for every new emulation
@@ -973,7 +973,7 @@ void PluginManager::Init()
 		if( m_info[pid].IsInitialized ) continue;
 		if( !printlog )
 		{
-			Console.Status( "Initializing plugins..." );
+			Console.WriteLn( Color_StrongBlue, "Initializing plugins..." );
 			printlog = true;
 		}
 		Console.WriteLn( "\tInit %s", tbl_PluginInfo[pid].shortname );
@@ -993,7 +993,7 @@ void PluginManager::Init()
 	}
 
 	if( printlog )
-		Console.Status( "Plugins initialized successfully.\n" );
+		Console.WriteLn( Color_StrongBlue, "Plugins initialized successfully.\n" );
 }
 
 // Shuts down all plugins.  Plugins are closed first, if necessary.
@@ -1007,7 +1007,7 @@ void PluginManager::Shutdown()
 	mtgsThread.Cancel();	// cancel it for speedier shutdown!
 
 	Close();
-	DbgCon.Status( "Shutting down plugins..." );
+	DbgCon.WriteLn( Color_StrongGreen, "Shutting down plugins..." );
 
 	// Shutdown plugins in reverse order (probably doesn't matter...
 	//  ... but what the heck, right?)
@@ -1029,7 +1029,7 @@ void PluginManager::Shutdown()
 		SysPlugins.Mcd = NULL;
 	}
 
-	DbgCon.Status( "Plugins shutdown successfully." );
+	DbgCon.WriteLn( Color_StrongGreen, "Plugins shutdown successfully." );
 }
 
 // For internal use only, unless you're the MTGS.  Then it's for you too!
@@ -1072,7 +1072,7 @@ void PluginManager::Freeze( PluginsEnum_t pid, SaveStateBase& state )
 		// no state data to read, but the plugin expects some state data.
 		// Issue a warning to console...
 		if( fP.size != 0 )
-			Console.Notice( "\tWarning: No data for this plugin was found. Plugin status may be unpredictable." );
+			Console.Warning( "\tWarning: No data for this plugin was found. Plugin status may be unpredictable." );
 		return;
 
 		// Note: Size mismatch check could also be done here on loading, but

pcsx2/R3000AInterpreter.cpp

@@ -258,15 +258,15 @@ void zeroEx()
 	}
 
 	if (!strncmp(lib, "loadcore", 8) && code == 6) {
-		DevCon.WriteLn("loadcore RegisterLibraryEntries (%x): %8.8s", psxRegs.pc, iopVirtMemR<char>(psxRegs.GPR.n.a0+12));
+		DevCon.WriteLn( Color_Gray, "loadcore RegisterLibraryEntries (%x): %8.8s", psxRegs.pc, iopVirtMemR<char>(psxRegs.GPR.n.a0+12));
 	}
 
 	if (!strncmp(lib, "intrman", 7) && code == 4) {
-		DevCon.WriteLn("intrman RegisterIntrHandler (%x): intr %s, handler %x", psxRegs.pc, intrname[psxRegs.GPR.n.a0], psxRegs.GPR.n.a2);
+		DevCon.WriteLn( Color_Gray, "intrman RegisterIntrHandler (%x): intr %s, handler %x", psxRegs.pc, intrname[psxRegs.GPR.n.a0], psxRegs.GPR.n.a2);
 	}
 
 	if (!strncmp(lib, "sifcmd", 6) && code == 17) {
-		DevCon.WriteLn("sifcmd sceSifRegisterRpc (%x): rpc_id %x", psxRegs.pc, psxRegs.GPR.n.a1);
+		DevCon.WriteLn( Color_Gray, "sifcmd sceSifRegisterRpc (%x): rpc_id %x", psxRegs.pc, psxRegs.GPR.n.a1);
 	}
 
 	if (!strncmp(lib, "sysclib", 8))

pcsx2/R3000AOpcodeTables.cpp

@@ -300,7 +300,7 @@ void psxCTC0() { _rFs_ = _u32(_rRt_); }
 * Format:  ?                                             *
 *********************************************************/
 void psxNULL() { 
-Console.Notice("psx: Unimplemented op %x", psxRegs.code);
+Console.Warning("psx: Unimplemented op %x", psxRegs.code);
 }
 
 void psxSPECIAL() {

pcsx2/R5900.cpp

@@ -124,7 +124,7 @@ __releaseinline void cpuException(u32 code, u32 bd)
 		{
 			//Reset / NMI
 			cpuRegs.pc = 0xBFC00000;
-			Console.Notice("Reset request");
+			Console.Warning("Reset request");
 			UpdateCP0Status();
 			return;
 		} 
@@ -141,7 +141,7 @@ __releaseinline void cpuException(u32 code, u32 bd)
 		cpuRegs.CP0.n.Status.b.EXL = 1;
 		if (bd) 
 		{
-			Console.Notice("branch delay!!");
+			Console.Warning("branch delay!!");
 			cpuRegs.CP0.n.EPC = cpuRegs.pc - 4;
 			cpuRegs.CP0.n.Cause |= 0x80000000;
 		} 
@@ -154,7 +154,7 @@ __releaseinline void cpuException(u32 code, u32 bd)
 	else 
 	{
 		offset = 0x180; //Override the cause		
-		if (errLevel2) Console.Notice("cpuException: Status.EXL = 1 cause %x", code);
+		if (errLevel2) Console.Warning("cpuException: Status.EXL = 1 cause %x", code);
 	}
 	
 	if (checkStatus)
@@ -170,7 +170,7 @@ void cpuTlbMiss(u32 addr, u32 bd, u32 excode)
 	Console.Error("cpuTlbMiss pc:%x, cycl:%x, addr: %x, status=%x, code=%x",
 		cpuRegs.pc, cpuRegs.cycle, addr, cpuRegs.CP0.n.Status.val, excode);
 		
-	if (bd) Console.Notice("branch delay!!");
+	if (bd) Console.Warning("branch delay!!");
 
 	pxFail( "TLB Miss handler is uninished code." ); // temporary
 
@@ -325,7 +325,7 @@ static __forceinline void _cpuTestTIMR()
 	if ( (cpuRegs.CP0.n.Status.val & 0x8000) &&
 		cpuRegs.CP0.n.Count >= cpuRegs.CP0.n.Compare && cpuRegs.CP0.n.Count < cpuRegs.CP0.n.Compare+1000 )
 	{
-		Console.Status("timr intr: %x, %x", cpuRegs.CP0.n.Count, cpuRegs.CP0.n.Compare);
+		Console.WriteLn( Color_Magenta, "timr intr: %x, %x", cpuRegs.CP0.n.Count, cpuRegs.CP0.n.Compare);
 		cpuException(0x808000, cpuRegs.branch);
 	}
 }
@@ -426,7 +426,7 @@ __forceinline void _cpuBranchTest_Shared()
 			int cycleCount = std::min( EEsCycle, (s32)(eeWaitCycles>>4) );
 			int cyclesRun = cycleCount - psxCpu->ExecuteBlock( cycleCount );
 			EEsCycle -= cyclesRun;
-			//Console.Notice( "IOP Exception-Pending Execution -- EEsCycle: %d", EEsCycle );
+			//Console.Warning( "IOP Exception-Pending Execution -- EEsCycle: %d", EEsCycle );
 		}
 		else*/
 		{
@@ -462,7 +462,7 @@ __forceinline void _cpuBranchTest_Shared()
 		// IOP extra timeslices in short order.
 
 		cpuSetNextBranchDelta( 48 );
-		//Console.Notice( "EE ahead of the IOP -- Rapid Branch!  %d", EEsCycle );
+		//Console.Warning( "EE ahead of the IOP -- Rapid Branch!  %d", EEsCycle );
 	}
 
 	// The IOP could be running ahead/behind of us, so adjust the iop's next branch by its
@@ -562,7 +562,7 @@ void cpuExecuteBios()
 	// Set the video mode to user's default request:
 	gsSetRegionMode( (GS_RegionMode)EmuConfig.Video.DefaultRegionMode );
 
-	Console.Status( "Executing Bios Stub..." );
+	Console.WriteLn( "Executing Bios Stub..." );
 
 	g_ExecBiosHack = true;
 	while(	cpuRegs.pc != 0x00200008 &&
@@ -592,7 +592,7 @@ void cpuExecuteBios()
 	// with new faster versions:
 	Cpu->Reset();
 
-	Console.Notice("Execute Bios Stub Complete");
+	Console.Warning("Execute Bios Stub Complete");
 	//GSprintf(5, "PCSX2 " PCSX2_VERSION "\nExecuteBios Complete\n");
 }
 

pcsx2/R5900OpcodeImpl.cpp

@@ -136,9 +136,9 @@ void Unknown() {
 	CPU_LOG("%8.8lx: Unknown opcode called", cpuRegs.pc);
 }
 
-void MMI_Unknown() { Console.Notice("Unknown MMI opcode called"); }
+void MMI_Unknown() { Console.Warning("Unknown MMI opcode called"); }
-void COP0_Unknown() { Console.Notice("Unknown COP0 opcode called"); }
+void COP0_Unknown() { Console.Warning("Unknown COP0 opcode called"); }
-void COP1_Unknown() { Console.Notice("Unknown FPU/COP1 opcode called"); }
+void COP1_Unknown() { Console.Warning("Unknown FPU/COP1 opcode called"); }
 
 
 
@@ -761,7 +761,7 @@ int __Deci2Call(int call, u32 *addr)
 			else
 			{
 				deci2handler = NULL;
-				DevCon.Notice( "Deci2Call.Open > NULL address ignored." );
+				DevCon.Warning( "Deci2Call.Open > NULL address ignored." );
 			}
 			return 1;
 
@@ -790,7 +790,7 @@ int __Deci2Call(int call, u32 *addr)
 					pdeciaddr += (deci2addr[4]+0xc)%16;
 				memcpy(deci2buffer, pdeciaddr, deci2addr[1]-0xc);
 				deci2buffer[deci2addr[1]-0xc>=255?255:deci2addr[1]-0xc]='\0';
-				Console.Write( Color_Cyan, deci2buffer );
+				Console.Write( ConColor_EE, deci2buffer );
 			}
 			deci2addr[3] = 0;
 			return 1;
@@ -809,7 +809,7 @@ int __Deci2Call(int call, u32 *addr)
 
 		case 0x10://kputs
 			if( addr != NULL )
-				Console.Write( Color_Cyan, "%s", PSM(*addr));
+				Console.Write( ConColor_EE, (char*)PSM(*addr) );
 			return 1;
 	}
 
@@ -831,7 +831,7 @@ void SYSCALL()
 	if (call == 0x7c)
 	{
 		if(cpuRegs.GPR.n.a0.UL[0] == 0x10)
-			Console.Write( Color_Cyan, (char*)PSM(memRead32(cpuRegs.GPR.n.a1.UL[0])) );
+			Console.Write( ConColor_EE, (char*)PSM(memRead32(cpuRegs.GPR.n.a1.UL[0])) );
 		else
 			__Deci2Call( cpuRegs.GPR.n.a0.UL[0], (u32*)PSM(cpuRegs.GPR.n.a1.UL[0]) );
 	}

pcsx2/RecoverySystem.cpp

@@ -330,7 +330,7 @@ void OnFinished_ZipToDisk( const wxCommandEvent& evt )
 
 	if( zip_dest_filename.IsEmpty() )
 	{
-		Console.Notice( "Cannot save state to disk: empty filename specified." );
+		Console.Warning( "Cannot save state to disk: empty filename specified." );
 		return;
 	}
 		
@@ -358,7 +358,7 @@ void StateCopy_SaveToFile( const wxString& file )
 	if( state_buffer_lock.IsLocked() ) return;
 	zip_dest_filename = file;
 	(new StateThread_Freeze( OnFinished_ZipToDisk ))->Start();
-	Console.Status( wxsFormat( L"Saving savestate to file: %s", zip_dest_filename.c_str() ) );
+	Console.WriteLn( Color_StrongGreen, L"Saving savestate to file: %s", zip_dest_filename.c_str() );
 }
 
 void StateCopy_LoadFromFile( const wxString& file )
@@ -378,8 +378,8 @@ void StateCopy_SaveToSlot( uint num )
 
 	zip_dest_filename = SaveStateBase::GetFilename( num );
 	(new StateThread_Freeze( OnFinished_ZipToDisk ))->Start();
-	Console.Status( "Saving savestate to slot %d...", num );
+	Console.WriteLn( Color_StrongGreen, "Saving savestate to slot %d...", num );
-	Console.Status( wxsFormat(L"\tfilename: %s", zip_dest_filename.c_str()) );
+	Console.WriteLn( Color_StrongGreen, L"\tfilename: %s", zip_dest_filename.c_str() );
 }
 
 void StateCopy_LoadFromSlot( uint slot )
@@ -389,12 +389,12 @@ void StateCopy_LoadFromSlot( uint slot )
 
 	if( !wxFileExists( file ) )
 	{
-		Console.Notice( "Savestate slot %d is empty.", slot );
+		Console.Warning( "Savestate slot %d is empty.", slot );
 		return;
 	}
 
-	Console.Status( "Loading savestate from slot %d...", slot );
+	Console.WriteLn( Color_StrongGreen, "Loading savestate from slot %d...", slot );
-	Console.Status( wxsFormat(L"\tfilename: %s", file.c_str()) );
+	Console.WriteLn( Color_StrongGreen, L"\tfilename: %s", file.c_str() );
 
 	CoreThread.Pause();
 	(new StateThread_UnzipFromDisk( OnFinished_Restore, file ))->Start();

pcsx2/SPR.cpp

@@ -38,12 +38,12 @@ static void TestClearVUs(u32 madr, u32 size)
 	{
 		if (madr < 0x11004000)
 		{
-			DbgCon.Notice("scratch pad clearing vu0");
+			DbgCon.Warning("scratch pad clearing vu0");
 			CpuVU0.Clear(madr&0xfff, size);
 		}
 		else if (madr >= 0x11008000 && madr < 0x1100c000)
 		{
-			DbgCon.Notice("scratch pad clearing vu1");
+			DbgCon.Warning("scratch pad clearing vu1");
 			CpuVU1.Clear(madr&0x3fff, size);
 		}
 	}

pcsx2/SaveState.cpp

@@ -325,7 +325,7 @@ bool SaveStateBase::FreezeSection()
 			Freeze( size );
 			m_tagspace[sizeof(m_tagspace)-1] = 0;
 
-			Console.Notice(
+			Console.Warning(
 				"Warning: Unknown tag encountered while loading savestate; going to ignore it!\n"
 				"\tTagname: %s, Size: %d", m_tagspace, size
 			);

pcsx2/Sio.cpp

@@ -382,7 +382,7 @@ void SIO_CommandWrite(u8 value,int way) {
 					sio.buf[2]='+';
 					sio.buf[3]=sio.terminator;
 					//if (sio.k != 0 || (sio.sector & 0xf) != 0)
-					//	Console.Notice("saving : odd position for erase.");
+					//	Console.Warning("saving : odd position for erase.");
 
 					_EraseMCDBlock((512+16)*(sio.sector&~0xf));
 

pcsx2/System.cpp

@@ -45,18 +45,19 @@ SessionOverrideFlags	g_Session = {false};
 // This function should be called once during program execution.
 void SysDetect()
 {
-	Console.Notice("PCSX2 %d.%d.%d.r%d %s - compiled on " __DATE__, PCSX2_VersionHi, PCSX2_VersionMid, PCSX2_VersionLo,
+	Console.WriteLn( Color_StrongGreen, "PCSX2 %d.%d.%d.r%d %s - compiled on " __DATE__, PCSX2_VersionHi, PCSX2_VersionMid, PCSX2_VersionLo,
 		SVN_REV, SVN_MODS ? "(modded)" : ""
 	);
 
-	Console.Notice("Savestate version: %x", g_SaveVersion);
+	Console.WriteLn( "Savestate version: 0x%x", g_SaveVersion);
+	Console.Newline();
 
 	cpudetectInit();
 
-	Console.SetColor( Color_Black );
+	//Console.SetColor( Color_Gray );
 
-	Console.WriteLn( "x86Init:" );
+	Console.WriteLn( Color_StrongBlack, "x86-32 Init:" );
-	Console.WriteLn( wxsFormat(
+	Console.WriteLn(
 		L"\tCPU vendor name  =  %s\n"
 		L"\tFamilyID         =  %x\n"
 		L"\tx86Family        =  %s\n"
@@ -65,14 +66,14 @@ void SysDetect()
 		L"\tx86PType         =  %s\n"
 		L"\tx86Flags         =  %8.8x %8.8x\n"
 		L"\tx86EFlags        =  %8.8x\n",
-			wxString::FromAscii( x86caps.VendorName ).c_str(), x86caps.StepID,
+			fromUTF8( x86caps.VendorName ).c_str(), x86caps.StepID,
-			wxString::FromAscii( x86caps.FamilyName ).Trim().Trim(false).c_str(),
+			fromUTF8( x86caps.FamilyName ).Trim().Trim(false).c_str(),
 			x86caps.Speed / 1000, x86caps.Speed%1000,
 			x86caps.PhysicalCores, x86caps.LogicalCores,
-			wxString::FromAscii( x86caps.TypeName ).c_str(),
+			fromUTF8( x86caps.TypeName ).c_str(),
 			x86caps.Flags, x86caps.Flags2,
 			x86caps.EFlags
-	) );
+	);
 
 	wxArrayString features[2];	// 2 lines, for readability!
 
@@ -93,11 +94,12 @@ void SysDetect()
 	JoinString( result[0], features[0], L".. " );
 	JoinString( result[1], features[1], L".. " );
 
-	Console.WriteLn( L"Features Detected:\n\t" + result[0] + (result[1].IsEmpty() ? L"" : (L"\n\t" + result[1])) + L"\n" );
+	Console.ClearColor();
+
+	Console.WriteLn( Color_StrongBlack,	L"x86 Features Detected:" );
+	Console.WriteLn( L"\t" + result[0] + (result[1].IsEmpty() ? L"" : (L"\n\t" + result[1])) + L"\n" );
 
 	//if ( x86caps.VendorName[0] == 'A' ) //AMD cpu
-
-	Console.ClearColor();
 }
 
 // returns the translated error message for the Virtual Machine failing to allocate!
@@ -113,7 +115,7 @@ SysCoreAllocations::SysCoreAllocations()
 {
 	InstallSignalHandler();
 
-	Console.Status( "Initializing PS2 virtual machine..." );
+	Console.WriteLn( "Initializing PS2 virtual machine..." );
 
 	RecSuccess_EE		= false;
 	RecSuccess_IOP		= false;
@@ -151,7 +153,7 @@ SysCoreAllocations::SysCoreAllocations()
 		);
 	}
 
-	Console.Status( "Allocating memory for recompilers..." );
+	Console.WriteLn( "Allocating memory for recompilers..." );
 
 	try
 	{
@@ -265,7 +267,7 @@ u8 *SysMmapEx(uptr base, u32 size, uptr bounds, const char *caller)
 
 	if( (Mem == NULL) || (bounds != 0 && (((uptr)Mem + size) > bounds)) )
 	{
-		DevCon.Notice( "First try failed allocating %s at address 0x%x", caller, base );
+		DevCon.Warning( "First try failed allocating %s at address 0x%x", caller, base );
 
 		// memory allocation *must* have the top bit clear, so let's try again
 		// with NULL (let the OS pick something for us).
@@ -275,7 +277,7 @@ u8 *SysMmapEx(uptr base, u32 size, uptr bounds, const char *caller)
 		Mem = (u8*)HostSys::Mmap( NULL, size );
 		if( bounds != 0 && (((uptr)Mem + size) > bounds) )
 		{
-			DevCon.Error( "Fatal Error:\n\tSecond try failed allocating %s, block ptr 0x%x does not meet required criteria.", caller, Mem );
+			DevCon.Warning( "Fatal Error:\n\tSecond try failed allocating %s, block ptr 0x%x does not meet required criteria.", caller, Mem );
 			SafeSysMunmap( Mem, size );
 
 			// returns NULL, caller should throw an exception.

pcsx2/VU0.cpp

@@ -75,7 +75,7 @@ __forceinline void _vu0run(bool breakOnMbit) {
 	do {
 		// knockout kings 2002 loops here with sVU
 		if (breakOnMbit && (VU0.cycle-startcycle > 0x1000)) {
-			Console.Notice("VU0 perma-stall, breaking execution...");
+			Console.Warning("VU0 perma-stall, breaking execution...");
 			break; // mVU will never get here (it handles mBit internally)
 		}
 		CpuVU0.ExecuteBlock();
@@ -354,7 +354,7 @@ void vu0Finish()
 		if(VU0.VI[REG_VPU_STAT].UL & 0x1) {
 			VU0.VI[REG_VPU_STAT].UL &= ~1;
 			// this log tends to spam a lot (MGS3)
-			//Console.Notice("vu0Finish > stall aborted by force.");
+			//Console.Warning("vu0Finish > stall aborted by force.");
 		}
 	}
 }

pcsx2/VU0micro.cpp

@@ -54,7 +54,7 @@ void __fastcall vu0ExecMicro(u32 addr) {
 	VUM_LOG("vu0ExecMicro %x", addr);
 	
 	if(VU0.VI[REG_VPU_STAT].UL & 0x1) {
-		DevCon.Notice("vu0ExecMicro > Stalling for previous microprogram to finish");
+		DevCon.Warning("vu0ExecMicro > Stalling for previous microprogram to finish");
 		vu0Finish();
 	}
 	VU0.VI[REG_VPU_STAT].UL|= 0x1;

pcsx2/VU0microInterp.cpp

@@ -106,7 +106,7 @@ static void _vu0Exec(VURegs* VU)
 		vfreg = 0; vireg = 0;
 		if (uregs.VFwrite) {
 			if (lregs.VFwrite == uregs.VFwrite) {
-//				Console.Notice("*PCSX2*: Warning, VF write to the same reg in both lower/upper cycle");
+//				Console.Warning("*PCSX2*: Warning, VF write to the same reg in both lower/upper cycle");
 				discard = 1;
 			}
 			if (lregs.VFread0 == uregs.VFwrite ||
@@ -118,7 +118,7 @@ static void _vu0Exec(VURegs* VU)
 		}
 		if (uregs.VIread & (1 << REG_CLIP_FLAG)) {
 			if (lregs.VIwrite & (1 << REG_CLIP_FLAG)) {
-				Console.Notice("*PCSX2*: Warning, VI write to the same reg in both lower/upper cycle");
+				Console.Warning("*PCSX2*: Warning, VI write to the same reg in both lower/upper cycle");
 				discard = 1;
 			}
 			if (lregs.VIread & (1 << REG_CLIP_FLAG)) {
@@ -176,7 +176,7 @@ void vu0Exec(VURegs* VU)
 {
 	if (VU->VI[REG_TPC].UL >= VU->maxmicro) { 
 #ifdef CPU_LOG
-		Console.Notice("VU0 memory overflow!!: %x", VU->VI[REG_TPC].UL);
+		Console.Warning("VU0 memory overflow!!: %x", VU->VI[REG_TPC].UL);
 #endif
 		VU0.VI[REG_VPU_STAT].UL&= ~0x1; 
 	} else { 

pcsx2/VU1microInterp.cpp

@@ -102,7 +102,7 @@ static void _vu1Exec(VURegs* VU)
 		vfreg = 0; vireg = 0;
 		if (uregs.VFwrite) {
 			if (lregs.VFwrite == uregs.VFwrite) {
-//				Console.Notice("*PCSX2*: Warning, VF write to the same reg in both lower/upper cycle");
+//				Console.Warning("*PCSX2*: Warning, VF write to the same reg in both lower/upper cycle");
 				discard = 1;
 			}
 			if (lregs.VFread0 == uregs.VFwrite ||
@@ -114,7 +114,7 @@ static void _vu1Exec(VURegs* VU)
 		}
 		if (uregs.VIread & (1 << REG_CLIP_FLAG)) {
 			if (lregs.VIwrite & (1 << REG_CLIP_FLAG)) {
-				Console.Notice("*PCSX2*: Warning, VI write to the same reg in both lower/upper cycle");
+				Console.Warning("*PCSX2*: Warning, VI write to the same reg in both lower/upper cycle");
 				discard = 1;
 			}
 			if (lregs.VIread & (1 << REG_CLIP_FLAG)) {

pcsx2/VUops.cpp

@@ -2064,10 +2064,10 @@ void _vuXGKICK(VURegs * VU)
 	
 	if((size << 4) > (u32)(0x4000-((VU->VI[_Is_].US[0]*16) & 0x3fff)))
 	{
-		//DevCon.Notice("addr + Size = 0x%x, transferring %x then doing %x", ((VU->VI[_Is_].US[0]*16) & 0x3fff) + (size << 4), (0x4000-((VU->VI[_Is_].US[0]*16) & 0x3fff)) >> 4, size - (0x4000-((VU->VI[_Is_].US[0]*16) & 0x3fff) >> 4));
+		//DevCon.Warning("addr + Size = 0x%x, transferring %x then doing %x", ((VU->VI[_Is_].US[0]*16) & 0x3fff) + (size << 4), (0x4000-((VU->VI[_Is_].US[0]*16) & 0x3fff)) >> 4, size - (0x4000-((VU->VI[_Is_].US[0]*16) & 0x3fff) >> 4));
 		memcpy_aligned(pmem, (u8*)VU->Mem+((VU->VI[_Is_].US[0]*16) & 0x3fff), 0x4000-((VU->VI[_Is_].US[0]*16) & 0x3fff));
 		size -= (0x4000-((VU->VI[_Is_].US[0]*16) & 0x3fff)) >> 4;
-		//DevCon.Notice("Size left %x", size);
+		//DevCon.Warning("Size left %x", size);
 		pmem += 0x4000-((VU->VI[_Is_].US[0]*16) & 0x3fff);
 		memcpy_aligned(pmem, (u8*)VU->Mem, size<<4);
 	}

pcsx2/Vif0Dma.cpp

@@ -197,7 +197,7 @@ static int __fastcall Vif0TransMPG(u32 *data)  // MPG
 {
 	if (vif0.vifpacketsize < vif0.tag.size)
 	{
-		if((vif0.tag.addr + vif0.vifpacketsize) > 0x1000) DevCon.Notice("Vif0 MPG Split Overflow");
+		if((vif0.tag.addr + vif0.vifpacketsize) > 0x1000) DevCon.Warning("Vif0 MPG Split Overflow");
 
 		vif0mpgTransfer(vif0.tag.addr, data, vif0.vifpacketsize);
 		vif0.tag.addr += vif0.vifpacketsize << 2;
@@ -209,7 +209,7 @@ static int __fastcall Vif0TransMPG(u32 *data)  // MPG
 	{
 		int ret;
 
-		if((vif0.tag.addr + vif0.tag.size) > 0x1000) DevCon.Notice("Vif0 MPG Overflow");
+		if((vif0.tag.addr + vif0.tag.size) > 0x1000) DevCon.Warning("Vif0 MPG Overflow");
 
 		vif0mpgTransfer(vif0.tag.addr, data, vif0.tag.size);
 		ret = vif0.tag.size;

pcsx2/Vif1Dma.cpp

@@ -211,7 +211,7 @@ static int __fastcall Vif1TransMPG(u32 *data)
 {
 	if (vif1.vifpacketsize < vif1.tag.size)
 	{
-		if((vif1.tag.addr + vif1.vifpacketsize) > 0x4000) DevCon.Notice("Vif1 MPG Split Overflow");
+		if((vif1.tag.addr + vif1.vifpacketsize) > 0x4000) DevCon.Warning("Vif1 MPG Split Overflow");
 		vif1mpgTransfer(vif1.tag.addr, data, vif1.vifpacketsize);
 		vif1.tag.addr += vif1.vifpacketsize << 2;
 		vif1.tag.size -= vif1.vifpacketsize;
@@ -220,7 +220,7 @@ static int __fastcall Vif1TransMPG(u32 *data)
 	else
 	{
 		int ret;
-		if((vif1.tag.addr + vif1.tag.size) > 0x4000) DevCon.Notice("Vif1 MPG Overflow");
+		if((vif1.tag.addr + vif1.tag.size) > 0x4000) DevCon.Warning("Vif1 MPG Overflow");
 		vif1mpgTransfer(vif1.tag.addr, data, vif1.tag.size);
 		ret = vif1.tag.size;
 		vif1.tag.size = 0;

pcsx2/VifDma.cpp

@@ -333,7 +333,7 @@ template<const u32 VIFdmanum> u32 VIFalign(u32 *data, vifCode *v, u32 size)
 		}
 		else
 		{
-			DevCon.Notice("Offset = %x", vifRegs->offset);
+			DevCon.Warning("Offset = %x", vifRegs->offset);
 			vif->tag.addr += unpacksize * 4;
 			return size>>2;
 		}
@@ -440,7 +440,7 @@ template<const u32 VIFdmanum> u32 VIFalign(u32 *data, vifCode *v, u32 size)
 			/* unpack one qword */
 			if(vif->tag.addr + ((size / ft->dsize) * 4)  >= (u32)vif_size(VIFdmanum))
 			{
-				//DevCon.Notice("Overflow");
+				//DevCon.Warning("Overflow");
 				vif->tag.addr &= (u32)(vif_size(VIFdmanum) - 1);
 				dest = (u32*)(VU->Mem + v->addr);
 			}
@@ -532,7 +532,7 @@ template<const u32 VIFdmanum> void VIFunpack(u32 *data, vifCode *v, u32 size)
 	{
 		if (v->addr >= memlimit)
 		{
-			//DevCon.Notice("Overflown at the start");
+			//DevCon.Warning("Overflown at the start");
 			v->addr &= (memlimit - 1);
 			dest = (u32*)(VU->Mem + v->addr);
 		}
@@ -557,7 +557,7 @@ template<const u32 VIFdmanum> void VIFunpack(u32 *data, vifCode *v, u32 size)
 			}
 			else
 			{
-				//DevCon.Notice("VIF%x Unpack ending %x > %x", VIFdmanum, tempsize, VIFdmanum ? 0x4000 : 0x1000);
+				//DevCon.Warning("VIF%x Unpack ending %x > %x", VIFdmanum, tempsize, VIFdmanum ? 0x4000 : 0x1000);
 				tempsize = size;
 				size = 0;
 			}
@@ -679,7 +679,7 @@ template<const u32 VIFdmanum> void VIFunpack(u32 *data, vifCode *v, u32 size)
 			int incdest = ((vifRegs->cycle.cl - vifRegs->cycle.wl) << 2) + 4;
 			size = 0;
 			int addrstart = v->addr;
-			if((tempsize >> 2) != vif->tag.size) DevCon.Notice("split when size != tagsize");
+			if((tempsize >> 2) != vif->tag.size) DevCon.Warning("split when size != tagsize");
 
 			VIFUNPACK_LOG("sorting tempsize :p, size %d, vifnum %d, addr %x", tempsize, vifRegs->num, vif->tag.addr);
 
@@ -687,7 +687,7 @@ template<const u32 VIFdmanum> void VIFunpack(u32 *data, vifCode *v, u32 size)
 			{
 				if(v->addr >= memlimit)
 				{
-					DevCon.Notice("Mem limit overflow");
+					DevCon.Warning("Mem limit overflow");
 					v->addr &= (memlimit - 1);
 					dest = (u32*)(VU->Mem + v->addr);
 				}
@@ -756,9 +756,9 @@ template<const u32 VIFdmanum> void VIFunpack(u32 *data, vifCode *v, u32 size)
 
 		if(vifRegs->cycle.cl > 0) // Quicker and avoids zero division :P
 			if((u32)(((size / ft->gsize) / vifRegs->cycle.cl) * vifRegs->cycle.wl) < vifRegs->num)
-			DevCon.Notice("Filling write warning! %x < %x and CL = %x WL = %x", (size / ft->gsize), vifRegs->num, vifRegs->cycle.cl, vifRegs->cycle.wl);
+			DevCon.Warning("Filling write warning! %x < %x and CL = %x WL = %x", (size / ft->gsize), vifRegs->num, vifRegs->cycle.cl, vifRegs->cycle.wl);
 
-		//DevCon.Notice("filling write %d cl %d, wl %d mask %x mode %x unpacktype %x addr %x", vifRegs->num, vifRegs->cycle.cl, vifRegs->cycle.wl, vifRegs->mask, vifRegs->mode, unpackType, vif->tag.addr);
+		//DevCon.Warning("filling write %d cl %d, wl %d mask %x mode %x unpacktype %x addr %x", vifRegs->num, vifRegs->cycle.cl, vifRegs->cycle.wl, vifRegs->mask, vifRegs->mode, unpackType, vif->tag.addr);
 		while (vifRegs->num > 0)
 		{
 			if (vif->cl == vifRegs->cycle.wl)

pcsx2/gui/AppConfig.cpp

@@ -535,7 +535,7 @@ void RelocateLogfile()
 
 	if( (emuLog != NULL) && (emuLogName != newlogname) )
 	{
-		Console.Status( wxsFormat(L"\nRelocating Logfile...\n\tFrom: %s\n\tTo  : %s\n", emuLogName.c_str(), newlogname.c_str()) );
+		Console.WriteLn( L"\nRelocating Logfile...\n\tFrom: %s\n\tTo  : %s\n", emuLogName.c_str(), newlogname.c_str() );
 		wxGetApp().DisableDiskLogging();
 
 		fclose( emuLog );

pcsx2/gui/AppCoreThread.cpp

@@ -77,7 +77,7 @@ void AppCoreThread::Resume()
 				sApp.SysExecute();
 			}
 			else
-				Console.Status( "SysResume: Multiple resume retries failed.  Giving up..." );
+				Console.WriteLn( Color_Orange, "SysResume: Multiple resume retries failed.  Giving up..." );
 		}
 	}
 	

pcsx2/gui/AppInit.cpp

@@ -68,7 +68,7 @@ void Pcsx2App::ReadUserModeSettings()
 	wxDirName usrlocaldir( wxStandardPaths::Get().GetUserLocalDataDir() );
 	if( !usrlocaldir.Exists() )
 	{
-		Console.Status( L"Creating UserLocalData folder: " + usrlocaldir.ToString() );
+		Console.WriteLn( L"Creating UserLocalData folder: " + usrlocaldir.ToString() );
 		usrlocaldir.Mkdir();
 	}
 
@@ -199,7 +199,7 @@ bool Pcsx2App::OnCmdLineParsed( wxCmdLineParser& parser )
 		OverrideOptions.Filenames.Plugins[pi->id] = dest;
 
 		if( wxFileExists( dest ) )
-			Console.Notice( pi->GetShortname() + L" override: " + dest );
+			Console.Warning( pi->GetShortname() + L" override: " + dest );
 		else
 		{
 			bool result = Msgbox::OkCancel(
@@ -335,7 +335,7 @@ bool Pcsx2App::OnInit()
 	// ----------------------------------------------------------------------------
 	catch( Exception::StartupAborted& ex )
 	{
-		Console.Notice( ex.FormatDiagnosticMessage() );
+		Console.Warning( ex.FormatDiagnosticMessage() );
 		CleanupMess();
 		return false;
 	}

pcsx2/gui/AppMain.cpp

@@ -224,13 +224,13 @@ void Pcsx2App::HandleEvent(wxEvtHandler *handler, wxEventFunction func, wxEvent&
 	// ----------------------------------------------------------------------------
 	catch( Exception::CancelEvent& ex )
 	{
-		Console.Notice( ex.FormatDiagnosticMessage() );
+		Console.Warning( ex.FormatDiagnosticMessage() );
 	}
 	// ----------------------------------------------------------------------------
 	catch( Exception::BadSavedState& ex)
 	{
 		// Saved state load failed.
-		Console.Notice( ex.FormatDiagnosticMessage() );
+		Console.Warning( ex.FormatDiagnosticMessage() );
 		CoreThread.Resume();
 	}
 	// ----------------------------------------------------------------------------
@@ -524,7 +524,7 @@ __forceinline bool SysHasValidState()
 void SysStatus( const wxString& text )
 {
 	// mirror output to the console!
-	Console.Status( text.c_str() );
+	Console.WriteLn( text.c_str() );
 	sMainFrame.SetStatusText( text );
 }
 

pcsx2/gui/ConsoleLogger.cpp

@@ -96,7 +96,7 @@ void pxLogConsole::DoLog( wxLogLevel level, const wxChar *szString, time_t t )
 		break;
 
 		case wxLOG_Warning:
-			Console.Notice( wxString(L"wx > ") + szString );
+			Console.Warning( wxString(L"wx > ") + szString );
 		break;
     }
 }
@@ -111,8 +111,8 @@ void ConsoleTestThread::ExecuteTaskInThread()
 	{
 		// Two lines, both formatted, and varied colors.  This makes for a fairly realistic
 		// worst case scenario (without being entirely unrealistic).
-		Console.WriteLn( wxsFormat( L"This is a threaded logging test. Something bad could happen... %d", ++numtrack ) );
+		Console.WriteLn( L"This is a threaded logging test. Something bad could happen... %d", ++numtrack );
-		Console.Status( wxsFormat( L"Testing high stress loads %s", L"(multi-color)" ) );
+		Console.Warning( L"Testing high stress loads %s", L"(multi-color)" );
 		Yield( 0 );
 	}
 }
@@ -165,7 +165,7 @@ static bool OpenLogFile(wxFile& file, wxString& filename, wxWindow *parent)
 //   (actual font used is the system-selected fixed-width font)
 //
 ConsoleLogFrame::ColorArray::ColorArray( int fontsize ) :
-	m_table( 8 )
+	m_table( ConsoleColors_Count )
 {
 	Create( fontsize );
 }
@@ -177,18 +177,27 @@ ConsoleLogFrame::ColorArray::~ColorArray()
 
 void ConsoleLogFrame::ColorArray::Create( int fontsize )
 {
-	wxFont fixed( fontsize, wxMODERN, wxNORMAL, wxNORMAL );
+	const wxFont fixed( fontsize, wxMODERN, wxNORMAL, wxNORMAL );
-	wxFont fixedB( fontsize, wxMODERN, wxNORMAL, wxBOLD );
+	const wxFont fixedB( fontsize, wxMODERN, wxNORMAL, wxBOLD );
 
 	// Standard R, G, B format:
 	new (&m_table[Color_Black])		wxTextAttr( wxColor(   0,   0,   0 ), wxNullColour, fixed );
-	new (&m_table[Color_Red])		wxTextAttr( wxColor( 128,   0,   0 ), wxNullColour, fixedB );
+	new (&m_table[Color_Red])		wxTextAttr( wxColor( 128,   0,   0 ), wxNullColour, fixed );
 	new (&m_table[Color_Green])		wxTextAttr( wxColor(   0, 128,   0 ), wxNullColour, fixed );
 	new (&m_table[Color_Blue])		wxTextAttr( wxColor(   0,   0, 128 ), wxNullColour, fixed );
-	new (&m_table[Color_Yellow])	wxTextAttr( wxColor( 160, 160,   0 ), wxNullColour, fixedB );
-	new (&m_table[Color_Cyan])		wxTextAttr( wxColor(   0, 140, 140 ), wxNullColour, fixed );
 	new (&m_table[Color_Magenta])	wxTextAttr( wxColor( 160,   0, 160 ), wxNullColour, fixed );
-	new (&m_table[Color_White])		wxTextAttr( wxColor( 128, 128, 128 ), wxNullColour, fixed );
+	new (&m_table[Color_Orange])	wxTextAttr( wxColor( 160, 120,   0 ), wxNullColour, fixed );
+	new (&m_table[Color_Gray])		wxTextAttr( wxColor( 108, 108, 108 ), wxNullColour, fixed );
+
+	new (&m_table[Color_Cyan])		wxTextAttr( wxColor( 128, 180, 180 ), wxNullColour, fixed );
+	new (&m_table[Color_Yellow])	wxTextAttr( wxColor( 180, 180, 128 ), wxNullColour, fixed );
+	new (&m_table[Color_White])		wxTextAttr( wxColor( 160, 160, 160 ), wxNullColour, fixed );
+
+	new (&m_table[Color_StrongBlack])	wxTextAttr( wxColor(   0,   0,   0 ), wxNullColour, fixedB );
+	new (&m_table[Color_StrongRed])		wxTextAttr( wxColor( 128,   0,   0 ), wxNullColour, fixedB );
+	new (&m_table[Color_StrongGreen])	wxTextAttr( wxColor(   0, 128,   0 ), wxNullColour, fixedB );
+	new (&m_table[Color_StrongBlue])	wxTextAttr( wxColor(   0,   0, 128 ), wxNullColour, fixedB );
+	new (&m_table[Color_StrongOrange])	wxTextAttr( wxColor( 160, 120,   0 ), wxNullColour, fixedB );
 }
 
 void ConsoleLogFrame::ColorArray::Cleanup()
@@ -213,7 +222,7 @@ void ConsoleLogFrame::ColorArray::SetFont( int fontsize )
 	Create( fontsize );
 }
 
-static const ConsoleColors DefaultConsoleColor = Color_White;
+static const ConsoleColors DefaultConsoleColor = Color_Black;
 
 enum MenuIDs_t
 {

pcsx2/gui/GlobalCommands.cpp

@@ -151,7 +151,7 @@ namespace Implementations
 	{
 #ifdef PCSX2_DEVBUILD
 		iDumpRegisters(cpuRegs.pc, 0);
-		Console.Notice("hardware registers dumped EE:%x, IOP:%x\n", cpuRegs.pc, psxRegs.pc);
+		Console.Warning("hardware registers dumped EE:%x, IOP:%x\n", cpuRegs.pc, psxRegs.pc);
 #endif
 	}
 }
@@ -261,10 +261,10 @@ void AcceleratorDictionary::Map( const KeyAcceleratorCode& acode, const char *se
 
 	if( result != NULL )
 	{
-		Console.Notice( wxsFormat(
+		Console.Warning(
 			L"Kbd Accelerator '%s' is mapped multiple times.\n"
 			L"\t'Command %s' is being replaced by '%s'",
-			acode.ToString().c_str(), fromUTF8( result->Id ).c_str(), searchfor )
+			acode.ToString().c_str(), fromUTF8( result->Id ).c_str(), searchfor
 		);
 	}
 
@@ -272,8 +272,8 @@ void AcceleratorDictionary::Map( const KeyAcceleratorCode& acode, const char *se
 
 	if( result == NULL )
 	{
-		Console.Notice( wxsFormat( L"Kbd Accelerator '%s' is mapped to unknown command '%s'",
+		Console.Warning( L"Kbd Accelerator '%s' is mapped to unknown command '%s'",
-			acode.ToString().c_str(), fromUTF8( searchfor ).c_str() )
+			acode.ToString().c_str(), fromUTF8( searchfor ).c_str()
 		);
 	}
 	else

pcsx2/gui/IniInterface.cpp

@@ -174,9 +174,9 @@ void IniLoader::_EnumEntry( const wxString& var, int& value, const wxChar* const
 
 	if( enumArray[i] == NULL )
 	{
-		Console.Notice( wxsFormat( L"Loadini Warning: Unrecognized value '%s' on key '%s'\n\tUsing the default setting of '%s'.",
+		Console.Warning( L"Loadini Warning: Unrecognized value '%s' on key '%s'\n\tUsing the default setting of '%s'.",
 			retval.c_str(), var.c_str(), enumArray[defvalue]
-		) );
+		);
 		value = defvalue;
 	}
 	else
@@ -258,11 +258,11 @@ void IniSaver::_EnumEntry( const wxString& var, int& value, const wxChar* const*
 	const int cnt = _calcEnumLength( enumArray );
 	if( value >= cnt )
 	{
-		Console.Notice( wxsFormat(
+		Console.Warning( 
 			L"Settings Warning: An illegal enumerated index was detected when saving '%s'\n"
 			L"\tIllegal Value: %d\n"
 			L"\tUsing Default: %d (%s)\n",
-			var.c_str(), value, defvalue, enumArray[defvalue] )
+			var.c_str(), value, defvalue, enumArray[defvalue]
 		);
 
 		// Cause a debug assertion, since this is a fully recoverable error.

pcsx2/gui/MainFrame.cpp

@@ -158,7 +158,7 @@ void MainEmuFrame::OnMoveAround( wxMoveEvent& evt )
 	// while the logger spams itself)
 	// ... makes for a good test of the message pump's responsiveness.
 	if( EnableThreadedLoggingTest )
-		Console.Notice( "Threaded Logging Test!  (a window move event)" );
+		Console.Warning( "Threaded Logging Test!  (a window move event)" );
 
 	// evt.GetPosition() returns the client area position, not the window frame position.
 	// So read the window's screen-relative position directly.

pcsx2/gui/MemoryCardFile.cpp

@@ -191,7 +191,7 @@ s32 FileMemoryCard::Save( uint port, uint slot, const u8 *src, u32 adr, int size
 	for (int i=0; i<size; i++)
 	{
 		if ((m_currentdata[i] & src[i]) != src[i])
-			Console.Notice("MemoryCard: (warning) writing to uncleared data.");
+			Console.Warning("MemoryCard: (warning) writing to uncleared data.");
 		m_currentdata[i] &= src[i];
 	}
 

pcsx2/gui/Panels/PluginSelectorPanel.cpp

@@ -109,7 +109,7 @@ public:
 			if ( ((version >> 16)&0xff) == tbl_PluginInfo[pluginTypeIndex].version )
 				return true;
 
-			Console.Notice("%s Plugin %s:  Version %x != %x", info.shortname, m_plugpath.c_str(), 0xff&(version >> 16), info.version);
+			Console.Warning("%s Plugin %s:  Version %x != %x", info.shortname, m_plugpath.c_str(), 0xff&(version >> 16), info.version);
 		}
 		return false;
 	}
@@ -551,7 +551,7 @@ Panels::PluginSelectorPanel::EnumThread::EnumThread( PluginSelectorPanel& master
 
 void Panels::PluginSelectorPanel::EnumThread::DoNextPlugin( int curidx )
 {
-	DbgCon.WriteLn( L"Enumerating Plugin: " + m_master.GetFilename( curidx ) );
+	DbgCon.WriteLn( L"\tEnumerating Plugin: " + m_master.GetFilename( curidx ) );
 
 	try
 	{
@@ -574,7 +574,7 @@ void Panels::PluginSelectorPanel::EnumThread::DoNextPlugin( int curidx )
 	}
 	catch( Exception::BadStream& ex )
 	{
-		Console.Status( ex.FormatDiagnosticMessage() );
+		Console.Warning( ex.FormatDiagnosticMessage() );
 	}
 
 	wxCommandEvent yay( pxEVT_EnumeratedNext );
@@ -585,7 +585,7 @@ void Panels::PluginSelectorPanel::EnumThread::DoNextPlugin( int curidx )
 
 void Panels::PluginSelectorPanel::EnumThread::ExecuteTaskInThread()
 {
-	DevCon.Status( "Plugin Enumeration Thread started..." );
+	DevCon.WriteLn( "Plugin Enumeration Thread started..." );
 
 	wxGetApp().Ping();		// gives the gui thread some time to refresh
 	Yield( 3 );
@@ -602,5 +602,5 @@ void Panels::PluginSelectorPanel::EnumThread::ExecuteTaskInThread()
 	done.SetClientData( this );
 	m_master.GetEventHandler()->AddPendingEvent( done );
 
-	DevCon.Status( "Plugin Enumeration Thread complete!" );
+	DevCon.WriteLn( "Plugin Enumeration Thread complete!" );
 }

pcsx2/gui/Saveslots.cpp

@@ -57,7 +57,7 @@ void States_DefrostCurrentSlot()
 
 static void OnSlotChanged()
 {
-	Console.Notice( " > Selected savestate slot %d", StatesC);
+	Console.Warning( " > Selected savestate slot %d", StatesC);
 
 	if( GSchangeSaveState != NULL )
 		GSchangeSaveState(StatesC, SaveStateBase::GetFilename(StatesC).mb_str());

pcsx2/gui/i18n.cpp

@@ -140,8 +140,8 @@ const wxChar* __fastcall pxGetTranslation( const wxChar* message )
 	{
 		if( wxStrlen( message ) > 96 )
 		{
-			Console.Notice( "pxGetTranslation: Long message detected, maybe use pxE() instead?" );
+			Console.Warning( "pxGetTranslation: Long message detected, maybe use pxE() instead?" );
-			Console.Status( wxsFormat( L"\tMessage: %s", message ) );
+			Console.WriteLn( Color_Green, L"\tMessage: %s", message );
 		}
 	}
 	return wxGetTranslation( message );
@@ -152,7 +152,7 @@ bool i18n_SetLanguage( int wxLangId )
 {
 	if( !wxLocale::IsAvailable( wxLangId ) )
 	{
-		Console.Notice( "Invalid Language Identifier (wxID=%d).", wxLangId );
+		Console.Warning( "Invalid Language Identifier (wxID=%d).", wxLangId );
 		return false;
 	}
 
@@ -160,8 +160,8 @@ bool i18n_SetLanguage( int wxLangId )
 
 	if( !locale->IsOk() )
 	{
-		Console.Notice( wxsFormat( L"SetLanguage: '%s' [%s] is not supported by the operating system",
+		Console.Warning( L"SetLanguage: '%s' [%s] is not supported by the operating system",
-			wxLocale::GetLanguageName( locale->GetLanguage() ).c_str(), locale->GetCanonicalName().c_str() )
+			wxLocale::GetLanguageName( locale->GetLanguage() ).c_str(), locale->GetCanonicalName().c_str()
 		);
 
 		safe_delete( locale );
@@ -170,8 +170,8 @@ bool i18n_SetLanguage( int wxLangId )
 
 	if( !IsEnglish(wxLangId) && !locale->AddCatalog( L"pcsx2main" ) )
 	{
-		Console.Notice( wxsFormat( L"SetLanguage: Cannot find pcsx2main.mo file for language '%s' [%s]",
+		Console.Warning( L"SetLanguage: Cannot find pcsx2main.mo file for language '%s' [%s]",
-			wxLocale::GetLanguageName( locale->GetLanguage() ).c_str(), locale->GetCanonicalName().c_str() )
+			wxLocale::GetLanguageName( locale->GetLanguage() ).c_str(), locale->GetCanonicalName().c_str()
 		);
 		safe_delete( locale );
 		return false;

pcsx2/ps2/BiosTools.cpp

@@ -122,7 +122,7 @@ static void loadBiosRom( const wxChar *ext, u8 *dest, s64 maxSize )
 		Bios1 = Path::ReplaceExtension( Bios, ext );
 		if( (filesize=Path::GetFileSize( Bios1 ) ) <= 0 )
 		{
-			Console.Notice( "Load Bios Warning: %s not found (this is not an error!)", wxString(ext).ToAscii().data() );
+			Console.Warning( "Load Bios Warning: %s not found (this is not an error!)", wxString(ext).ToAscii().data() );
 			return;
 		}
 	}
@@ -167,7 +167,7 @@ void LoadBIOS()
 	}
 
 	BiosVersion = GetBiosVersion();
-	Console.Status("Bios Version %d.%d", BiosVersion >> 8, BiosVersion & 0xff);
+	Console.WriteLn("Bios Version %d.%d", BiosVersion >> 8, BiosVersion & 0xff);
 
 	//injectIRX("host.irx");	//not fully tested; still buggy
 

pcsx2/ps2/GIFpath.cpp

@@ -196,7 +196,7 @@ static void __fastcall RegHandlerUNMAPPED(const u32* data)
 	//   silently ignored.
 	
 	if( regidx != 0x7f && regidx != 0xee )
-		Console.Notice( "Ignoring Unmapped GIFtag Register, Index = %02x", regidx );
+		Console.Warning( "Ignoring Unmapped GIFtag Register, Index = %02x", regidx );
 }
 
 #define INSERT_UNMAPPED_4	RegHandlerUNMAPPED, RegHandlerUNMAPPED, RegHandlerUNMAPPED, RegHandlerUNMAPPED,

pcsx2/ps2/Iop/IopHwRead.cpp

@@ -48,12 +48,12 @@ mem8_t __fastcall iopHwRead8_Page1( u32 addr )
 		default:
 			if( masked_addr >= 0x100 && masked_addr < 0x130 )
 			{
-				DevCon.Notice( "HwRead8 from Counter16 [ignored], addr 0x%08x = 0x%02x", addr, psxHu8(addr) );
+				DevCon.Warning( "HwRead8 from Counter16 [ignored], addr 0x%08x = 0x%02x", addr, psxHu8(addr) );
 				ret = psxHu8( addr );
 			}
 			else if( masked_addr >= 0x480 && masked_addr < 0x4a0 )
 			{
-				DevCon.Notice( "HwRead8 from Counter32 [ignored], addr 0x%08x = 0x%02x", addr, psxHu8(addr) );
+				DevCon.Warning( "HwRead8 from Counter32 [ignored], addr 0x%08x = 0x%02x", addr, psxHu8(addr) );
 				ret = psxHu8( addr );
 			}
 			else if( (masked_addr >= pgmsk(HW_USB_START)) && (masked_addr < pgmsk(HW_USB_END)) )
@@ -213,7 +213,7 @@ static __forceinline T _HwRead_16or32_Page1( u32 addr )
 			ret = SPU2read( addr );
 		else
 		{
-			DevCon.Notice( "HwRead32 from SPU2? (addr=0x%08X) .. What manner of trickery is this?!", addr );
+			DevCon.Warning( "HwRead32 from SPU2? (addr=0x%08X) .. What manner of trickery is this?!", addr );
 			ret = psxHu32(addr);
 		}
 	}

pcsx2/ps2/Iop/IopHwWrite.cpp

@@ -60,7 +60,7 @@ mem32_t __fastcall iopHwRead32_generic( u32 addr )	{ return _generic_read<mem32_
 void __fastcall iopHwWrite8_Page1( u32 addr, mem8_t val )
 {
 	// all addresses are assumed to be prefixed with 0x1f801xxx:
-	jASSUME( (addr >> 12) == 0x1f801 );
+	pxAssert( (addr >> 12) == 0x1f801 );
 
 	u32 masked_addr = pgmsk( addr );
 
@@ -81,12 +81,12 @@ void __fastcall iopHwWrite8_Page1( u32 addr, mem8_t val )
 		default:
 			if( masked_addr >= 0x100 && masked_addr < 0x130 )
 			{
-				DevCon.Notice( "HwWrite8 to Counter16 [ignored], addr 0x%08x = 0x%02x", addr, psxHu8(addr) );
+				DevCon.Warning( "HwWrite8 to Counter16 [ignored], addr 0x%08x = 0x%02x", addr, psxHu8(addr) );
 				psxHu8( addr ) = val;
 			}
 			else if( masked_addr >= 0x480 && masked_addr < 0x4a0 )
 			{
-				DevCon.Notice( "HwWrite8 to Counter32 [ignored], addr 0x%08x = 0x%02x", addr, psxHu8(addr) );
+				DevCon.Warning( "HwWrite8 to Counter32 [ignored], addr 0x%08x = 0x%02x", addr, psxHu8(addr) );
 				psxHu8( addr ) = val;
 			}
 			else if( masked_addr >= pgmsk(HW_USB_START) && masked_addr < pgmsk(HW_USB_END) )
@@ -109,7 +109,7 @@ static int g_pbufi;
 void __fastcall iopHwWrite8_Page3( u32 addr, mem8_t val )
 {
 	// all addresses are assumed to be prefixed with 0x1f803xxx:
-	jASSUME( (addr >> 12) == 0x1f803 );
+	pxAssert( (addr >> 12) == 0x1f803 );
 
 	if( addr == 0x1f80380c )	// STDOUT
 	{
@@ -119,7 +119,7 @@ void __fastcall iopHwWrite8_Page3( u32 addr, mem8_t val )
 			( val == '\n' && g_pbufi != 0 ) )
 		{
 			g_pbuf[g_pbufi] = 0;
-			DevCon.WriteLn( Color_Cyan, g_pbuf );
+			Console.WriteLn( ConColor_IOP, g_pbuf );
 			g_pbufi = 0;
 		}
 		else if( val != '\n' )
@@ -135,7 +135,7 @@ void __fastcall iopHwWrite8_Page3( u32 addr, mem8_t val )
 void __fastcall iopHwWrite8_Page8( u32 addr, mem8_t val )
 {
 	// all addresses are assumed to be prefixed with 0x1f808xxx:
-	jASSUME( (addr >> 12) == 0x1f808 );
+	pxAssert( (addr >> 12) == 0x1f808 );
 
 	if( addr == HW_SIO2_DATAIN )	// sio2 serial data feed input
 		sio2_serialIn( val );
@@ -153,10 +153,10 @@ template< typename T >
 static __forceinline void _HwWrite_16or32_Page1( u32 addr, T val )
 {
 	// all addresses are assumed to be prefixed with 0x1f801xxx:
-	jASSUME( (addr >> 12) == 0x1f801 );
+	pxAssert( (addr >> 12) == 0x1f801 );
 
 	// all addresses should be aligned to the data operand size:
-	jASSUME(
+	pxAssert(
 		( sizeof(T) == 2 && (addr & 1) == 0 ) ||
 		( sizeof(T) == 4 && (addr & 3) == 0 )
 	);
@@ -237,7 +237,7 @@ static __forceinline void _HwWrite_16or32_Page1( u32 addr, T val )
 			SPU2write( addr, val );
 		else
 		{
-			DevCon.Notice( "HwWrite32 to SPU2? (addr=0x%08X) .. What manner of trickery is this?!", addr );
+			DevCon.Warning( "HwWrite32 to SPU2? (addr=0x%08X) .. What manner of trickery is this?!", addr );
 			//psxHu(addr) = val;
 		}
 	}
@@ -466,7 +466,7 @@ void __fastcall iopHwWrite16_Page1( u32 addr, mem16_t val )
 void __fastcall iopHwWrite16_Page3( u32 addr, mem16_t val )
 {
 	// all addresses are assumed to be prefixed with 0x1f803xxx:
-	jASSUME( (addr >> 12) == 0x1f803 );
+	pxAssert( (addr >> 12) == 0x1f803 );
 	psxHu16(addr) = val;
 	PSXHW_LOG( "HwWrite16 to %s, addr 0x%08x = 0x%04x", _log_GetIopHwName<mem16_t>( addr ), addr, val );
 }
@@ -474,7 +474,7 @@ void __fastcall iopHwWrite16_Page3( u32 addr, mem16_t val )
 void __fastcall iopHwWrite16_Page8( u32 addr, mem16_t val )
 {
 	// all addresses are assumed to be prefixed with 0x1f808xxx:
-	jASSUME( (addr >> 12) == 0x1f808 );
+	pxAssert( (addr >> 12) == 0x1f808 );
 	psxHu16(addr) = val;
 	PSXHW_LOG( "HwWrite16 to %s, addr 0x%08x = 0x%04x", _log_GetIopHwName<mem16_t>( addr ), addr, val );
 }
@@ -489,7 +489,7 @@ void __fastcall iopHwWrite32_Page1( u32 addr, mem32_t val )
 void __fastcall iopHwWrite32_Page3( u32 addr, mem32_t val )
 {
 	// all addresses are assumed to be prefixed with 0x1f803xxx:
-	jASSUME( (addr >> 12) == 0x1f803 );
+	pxAssert( (addr >> 12) == 0x1f803 );
 	psxHu16(addr) = val;
 	PSXHW_LOG( "HwWrite32 to %s, addr 0x%08x = 0x%04x", _log_GetIopHwName<mem32_t>( addr ), addr, val );
 }
@@ -497,7 +497,7 @@ void __fastcall iopHwWrite32_Page3( u32 addr, mem32_t val )
 void __fastcall iopHwWrite32_Page8( u32 addr, mem32_t val )
 {
 	// all addresses are assumed to be prefixed with 0x1f808xxx:
-	jASSUME( (addr >> 12) == 0x1f808 );
+	pxAssert( (addr >> 12) == 0x1f808 );
 
 	u32 masked_addr = addr & 0x0fff;
 

pcsx2/windows/SamplProf.cpp

@@ -231,7 +231,7 @@ int __stdcall ProfilerThread(void* nada)
 				rv += lst[i].ToString(tick_count);
 			}
 
-			Console.WriteLn("+Sampling Profiler Results-\n%s\n+>", rv.ToAscii().data() );
+			Console.WriteLn( L"+Sampling Profiler Results-\n%s\n+>", rv.c_str() );
 
 			tick_count=0;
 

pcsx2/windows/WinCompressNTFS.cpp

@@ -98,7 +98,7 @@ bool StreamException_LogFromErrno( const wxString& streamname, const wxChar* act
 	}
 	catch( Exception::Stream& ex )
 	{
-		Console.Notice( wxsFormat( L"%s: %s", action, ex.FormatDiagnosticMessage().c_str() ) );
+		Console.Warning( L"%s: %s", action, ex.FormatDiagnosticMessage().c_str() );
 		return true;
 	}
 	return false;
@@ -113,7 +113,7 @@ bool StreamException_LogLastError( const wxString& streamname, const wxChar* act
 	}
 	catch( Exception::Stream& ex )
 	{
-		Console.Notice( wxsFormat( L"%s: %s", action, ex.FormatDiagnosticMessage().c_str() ) );
+		Console.Warning( L"%s: %s", action, ex.FormatDiagnosticMessage().c_str() );
 		return true;
 	}
 	return false;

pcsx2/x86/iFPU.cpp

@@ -685,7 +685,7 @@ int recCommutativeOp(int info, int regd, int op)
 			}
 			break;
 		default:
-			Console.Status("FPU: recCommutativeOp case 4");
+			Console.WriteLn(Color_Magenta, "FPU: recCommutativeOp case 4");
 			SSE_MOVSS_M32_to_XMM(regd, (uptr)&fpuRegs.fpr[_Fs_]);
 			SSE_MOVSS_M32_to_XMM(t0reg, (uptr)&fpuRegs.fpr[_Ft_]);
 			if (CHECK_FPU_EXTRA_OVERFLOW || (op >= 2)) { fpuFloat2(regd); fpuFloat2(t0reg); }
@@ -801,7 +801,7 @@ void recC_EQ_xmm(int info)
 			SSE_UCOMISS_XMM_to_XMM(EEREC_S, EEREC_T); 
 			break;
 		default: 
-			Console.Status("recC_EQ_xmm: Default");
+			Console.WriteLn(Color_Magenta, "recC_EQ_xmm: Default");
 			tempReg = _allocX86reg(-1, X86TYPE_TEMP, 0, 0);
 			if (tempReg < 0) {Console.Error("FPU: DIV Allocation Error!"); tempReg = EAX;}
 			MOV32MtoR(tempReg, (uptr)&fpuRegs.fpr[_Fs_]);
@@ -881,7 +881,7 @@ void recC_LE_xmm(int info )
 			SSE_UCOMISS_XMM_to_XMM(EEREC_S, EEREC_T); 
 			break;
 		default: // Untested and incorrect, but this case is never reached AFAIK (cottonvibes)
-			Console.Status("recC_LE_xmm: Default");
+			Console.WriteLn(Color_Magenta, "recC_LE_xmm: Default");
 			tempReg = _allocX86reg(-1, X86TYPE_TEMP, 0, 0);
 			if (tempReg < 0) {Console.Error("FPU: DIV Allocation Error!"); tempReg = EAX;}
 			MOV32MtoR(tempReg, (uptr)&fpuRegs.fpr[_Fs_]);
@@ -957,7 +957,7 @@ void recC_LT_xmm(int info)
 			SSE_UCOMISS_XMM_to_XMM(EEREC_S, EEREC_T); 
 			break;
 		default:
-			Console.Status("recC_LT_xmm: Default");
+			Console.WriteLn(Color_Magenta, "recC_LT_xmm: Default");
 			tempReg = _allocX86reg(-1, X86TYPE_TEMP, 0, 0);
 			if (tempReg < 0) {Console.Error("FPU: DIV Allocation Error!"); tempReg = EAX;}
 			MOV32MtoR(tempReg, (uptr)&fpuRegs.fpr[_Fs_]);
@@ -1629,7 +1629,7 @@ void recSUBop(int info, int regd)
 			}
 			break;
 		default:
-			Console.Notice("FPU: SUB case 4");
+			Console.Warning("FPU: SUB case 4");
 			SSE_MOVSS_M32_to_XMM(t0reg, (uptr)&fpuRegs.fpr[_Ft_]);
 			SSE_MOVSS_M32_to_XMM(regd, (uptr)&fpuRegs.fpr[_Fs_]);
 			recSUBhelper(regd, t0reg);

pcsx2/x86/iR3000A.cpp

@@ -788,7 +788,7 @@ void recResetIOP()
 	pxAssert( recMem != NULL );
 	pxAssert( m_recBlockAlloc != NULL );
 
-	DevCon.Status( "iR3000A Resetting recompiler memory and structures" );
+	DevCon.WriteLn( "iR3000A Recompiler reset." );
 
 	memset_8<0xcc,RECMEM_SIZE>( recMem );	// 0xcc is INT3
 	iopClearRecLUT((BASEBLOCK*)m_recBlockAlloc,

pcsx2/x86/iVU1micro.cpp

@@ -149,14 +149,14 @@ namespace VU1micro
 			char str2[150];
 			SysPrintf("\n\n");
 			SysPrintf("-----------------------------------------------\n");
-			Console.Notice("Problem Occurred!");
+			Console.Warning("Problem Occurred!");
 			SysPrintf("-----------------------------------------------\n");
 			SysPrintf("runCount = %d\n", runCount);
 			SysPrintf("StartPC [%04x]\n", ((VURegs*)backVUregs)->VI[REG_TPC].UL);
 			SysPrintf("-----------------------------------------------\n\n");
 
 			SysPrintf("-----------------------------------------------\n");
-			Console.Notice("Super VU / Micro VU");
+			Console.Warning("Super VU / Micro VU");
 			SysPrintf("-----------------------------------------------\n");
 
 			for (int i = 0; i < 32; i++) {

pcsx2/x86/ix86-32/iR5900-32.cpp

@@ -263,7 +263,7 @@ u32* recGetImm64(u32 hi, u32 lo)
 
 	if (recConstBufPtr >= recConstBuf + RECCONSTBUF_SIZE)
 	{
-		Console.Status( "EErec const buffer filled; Resetting..." );
+		Console.WriteLn( "EErec const buffer filled; Resetting..." );
 		throw Exception::ForceDispatcherReg();
 
 		/*for (u32 *p = recConstBuf; p < recConstBuf + RECCONSTBUF_SIZE; p += 2)
@@ -284,7 +284,7 @@ u32* recGetImm64(u32 hi, u32 lo)
 	imm64[0] = lo;
 	imm64[1] = hi;
 
-	//Console.Notice("Consts allocated: %d of %u", (recConstBufPtr - recConstBuf) / 2, count);
+	//Console.Warning("Consts allocated: %d of %u", (recConstBufPtr - recConstBuf) / 2, count);
 
 	return imm64;
 }
@@ -569,7 +569,7 @@ static bool eeRecIsReset = false;
 ////////////////////////////////////////////////////
 void recResetEE( void )
 {
-	Console.Status( "Issuing EE/iR5900-32 Recompiler Reset [mem/structure cleanup]" );
+	Console.WriteLn( Color_StrongBlack, "Issuing EE/iR5900-32 Recompiler Reset" );
 
 	maxrecmem = 0;
 
@@ -1206,7 +1206,7 @@ void recompileNextInstruction(int delayslot)
 			case 1:
 				switch(_Rt_) {
 					case 0: case 1: case 2: case 3: case 0x10: case 0x11: case 0x12: case 0x13:
-						Console.Notice("branch %x in delay slot!", cpuRegs.code);
+						Console.Warning("branch %x in delay slot!", cpuRegs.code);
 						_clearNeededX86regs();
 						_clearNeededMMXregs();
 						_clearNeededXMMregs();
@@ -1215,7 +1215,7 @@ void recompileNextInstruction(int delayslot)
 				break;
 
 			case 2: case 3: case 4: case 5: case 6: case 7: case 0x14: case 0x15: case 0x16: case 0x17:
-				Console.Notice("branch %x in delay slot!", cpuRegs.code);
+				Console.Warning("branch %x in delay slot!", cpuRegs.code);
 				_clearNeededX86regs();
 				_clearNeededMMXregs();
 				_clearNeededXMMregs();
@@ -1281,7 +1281,7 @@ static u32 s_recblocks[] = {0};
 // Called when a block under manual protection fails it's pre-execution integrity check.
 void __fastcall dyna_block_discard(u32 start,u32 sz)
 {
-	DevCon.WriteLn("dyna_block_discard .. start=0x%08X  size=%d", start, sz*4);
+	DevCon.WriteLn("Discarding Manual Block @ 0x%08X  [size=%d]", start, sz*4);
 	recClear(start, sz);
 
 	// Stack trick: This function was invoked via a direct jmp, so manually pop the
@@ -1393,7 +1393,7 @@ static void __fastcall recRecompile( const u32 startpc )
 				willbranch3 = 1;
 				s_nEndBlock = i;
 
-				//DevCon.Notice( "Pagesplit @ %08X : size=%d insts", startpc, (i-startpc) / 4 );
+				//DevCon.Warning( "Pagesplit @ %08X : size=%d insts", startpc, (i-startpc) / 4 );
 				break;
 			}
 
@@ -1620,7 +1620,7 @@ StartRecomp:
 			}
 			else
 			{
-				DbgCon.Notice( "Uncounted Manual block @ %08X : size=%3d page/offs=%05X/%03X  inpgsz=%d",
+				DbgCon.WriteLn( "Uncounted Manual block @ 0x%08X : size=%3d page/offs=%05X/%03X  inpgsz=%d",
 					startpc, sz, inpage_ptr>>12, inpage_ptr&0xfff, pgsz, inpage_sz );
 			}
 

pcsx2/x86/microVU.cpp

@@ -211,7 +211,7 @@ microVUf(int) mVUfindLeastUsedProg() {
 			mVU->prog.prog[i].isOld  = 0;
 			mVU->prog.prog[i].used	 = 1;
 			mVUsortProg(mVU, i);
-			Console.Notice("microVU%d: Cached MicroPrograms = [%03d] [%03d]", vuIndex, i+1, mVU->prog.total+1);
+			Console.Warning("microVU%d: Cached MicroPrograms = [%03d] [%03d]", vuIndex, i+1, mVU->prog.total+1);
 			return i;
 		}
 	}
@@ -228,7 +228,7 @@ microVUf(int) mVUfindLeastUsedProg() {
 	mVU->prog.prog[pIdx].isOld	= 0;
 	mVU->prog.prog[pIdx].used	= 1;
 	mVUsortProg(mVU, pIdx);
-	Console.Notice("microVU%d: Cached MicroPrograms = [%03d] [%03d]", vuIndex, pIdx+1, mVU->prog.total+1);
+	Console.Warning("microVU%d: Cached MicroPrograms = [%03d] [%03d]", vuIndex, pIdx+1, mVU->prog.total+1);
 	return pIdx;
 }
 
@@ -244,7 +244,7 @@ microVUt(void) mVUvsyncUpdate(mV) {
 			mVU->prog.total--;
 			if (!mVU->index) mVUclearProg<0>(i);
 			else			 mVUclearProg<1>(i);
-			DevCon.Status("microVU%d: Killing Dead Program [%03d]", mVU->index, i+1);
+			DevCon.WriteLn("microVU%d: Killing Dead Program [%03d]", mVU->index, i+1);
 		}
 		else if (((mVU->prog.curFrame - mVU->prog.prog[i].frame) >= (30  *  1)) && !mVU->prog.prog[i].isOld) {
 			mVU->prog.prog[i].isOld = 1;

pcsx2/x86/microVU.h

@@ -93,7 +93,7 @@ public:
 		if (listI < 7) return;
 		microBlockLink* linkI = &blockList;
 		for (int i = 0; i <= listI; i++) {
-			DevCon.Status("[%04x][Block #%d][q=%02d][p=%02d][xgkick=%d][vi15=%08x][viBackup=%02d][flags=%02x][exactMatch=%x]",
+			DevCon.WriteLn( Color_Green, "[%04x][Block #%d][q=%02d][p=%02d][xgkick=%d][vi15=%08x][viBackup=%02d][flags=%02x][exactMatch=%x]",
 			pc, i, linkI->block->pState.q, linkI->block->pState.p, linkI->block->pState.xgkick, linkI->block->pState.vi15,
 			linkI->block->pState.viBackUp, linkI->block->pState.flags, linkI->block->pState.needExactMatch);
 			linkI = linkI->next;

pcsx2/x86/microVU_Analyze.inl

@@ -380,7 +380,7 @@ microVUt(void) analyzeBranchVI(mV, int xReg, bool &infoVar) {
 			infoVar = 1;
 		}
 		iPC = bPC;
-		DevCon.Status("microVU%d: Branch VI-Delay (%d) [%04x]", getIndex, i, xPC);
+		Console.WriteLn( Color_Green, "microVU%d: Branch VI-Delay (%d) [%04x]", getIndex, i, xPC);
 	}
 	else iPC = bPC;
 }
@@ -394,7 +394,7 @@ microVUt(int) mVUbranchCheck(mV) {
 		incPC(2);
 		mVUlow.evilBranch = 1;
 		mVUregs.blockType = 2;
-		DevCon.Status("microVU%d Warning: Branch in Branch delay slot! [%04x]", mVU->index, xPC);
+		Console.Warning("microVU%d Warning: Branch in Branch delay slot! [%04x]", mVU->index, xPC);
 		return 1;
 	}
 	incPC(2);

pcsx2/x86/microVU_Compile.inl

@@ -65,7 +65,7 @@ microVUt(void) mVUsetupRange(mV, s32 pc, bool isStartPC) {
 			mVUcurProg.ranges.total = 0;
 			mVUrange[0] = 0;
 			mVUrange[1] = mVU->microMemSize - 8;
-			DevCon.Status("microVU%d: Prog Range List Full", mVU->index);
+			DevCon.WriteLn( Color_StrongBlack, "microVU%d: Prog Range List Full", mVU->index);
 		}
 	}
 	else {
@@ -89,7 +89,7 @@ microVUt(void) mVUsetupRange(mV, s32 pc, bool isStartPC) {
 			}
 		}
 		else {
-			DevCon.Status("microVU%d: Prog Range Wrap [%04x] [%d]", mVU->index, mVUrange[0], mVUrange[1]);
+			DevCon.WriteLn("microVU%d: Prog Range Wrap [%04x] [%d]", mVU->index, mVUrange[0], mVUrange[1]);
 			mVUrange[1] = mVU->microMemSize - 8;
 			if (mVUcurProg.ranges.total < mVUcurProg.ranges.max) {
 				mVUcurProg.ranges.total++;
@@ -100,16 +100,16 @@ microVUt(void) mVUsetupRange(mV, s32 pc, bool isStartPC) {
 				mVUcurProg.ranges.total = 0;
 				mVUrange[0] = 0;
 				mVUrange[1] = mVU->microMemSize - 8;
-				DevCon.Status("microVU%d: Prog Range List Full", mVU->index);
+				DevCon.WriteLn( Color_StrongBlack, "microVU%d: Prog Range List Full", mVU->index);
 			}
 		}
 	}
 }
 
 microVUt(void) startLoop(mV) {
-	if (curI & _Mbit_)	{ Console.Status("microVU%d: M-bit set!", getIndex); }
+	if (curI & _Mbit_)	{ Console.WriteLn(Color_Green, "microVU%d: M-bit set!", getIndex); }
-	if (curI & _Dbit_)	{ DevCon.Status ("microVU%d: D-bit set!", getIndex); }
+	if (curI & _Dbit_)	{ DevCon.WriteLn (Color_Green, "microVU%d: D-bit set!", getIndex); }
-	if (curI & _Tbit_)	{ DevCon.Status ("microVU%d: T-bit set!", getIndex); }
+	if (curI & _Tbit_)	{ DevCon.WriteLn (Color_Green, "microVU%d: T-bit set!", getIndex); }
 	memset(&mVUinfo,	 0, sizeof(mVUinfo));
 	memset(&mVUregsTemp, 0, sizeof(mVUregsTemp));
 }
@@ -121,7 +121,7 @@ microVUt(void) doIbit(mV) {
 		mVU->regAlloc->clearRegVF(33);
 
 		if (CHECK_VU_OVERFLOW && ((curI & 0x7fffffff) >= 0x7f800000)) {
-			Console.Status("microVU%d: Clamping I Reg", mVU->index);
+			Console.WriteLn(Color_Green,"microVU%d: Clamping I Reg", mVU->index);
 			tempI = (0x80000000 & curI) | 0x7f7fffff; // Clamp I Reg
 		}
 		else tempI = curI;
@@ -133,7 +133,7 @@ microVUt(void) doIbit(mV) {
 
 microVUt(void) doSwapOp(mV) { 
 	if (mVUinfo.backupVF && !mVUlow.noWriteVF) {
-		DevCon.Status("microVU%d: Backing Up VF Reg [%04x]", getIndex, xPC);
+		DevCon.WriteLn(Color_Green, "microVU%d: Backing Up VF Reg [%04x]", getIndex, xPC);
 		int t1 = mVU->regAlloc->allocReg(mVUlow.VF_write.reg);
 		int t2 = mVU->regAlloc->allocReg();
 		SSE_MOVAPS_XMM_to_XMM(t2, t1);
@@ -182,7 +182,7 @@ microVUt(void) eBitWarning(mV) {
 	if (mVUpBlock->pState.blockType == 2) Console.Error("microVU%d Warning: Branch, Branch, Branch! [%04x]", mVU->index, xPC);
 	incPC(2);
 	if (curI & _Ebit_) {
-		DevCon.Status("microVU%d: E-bit in Branch delay slot! [%04x]", mVU->index, xPC);
+		DevCon.Warning("microVU%d: E-bit in Branch delay slot! [%04x]", mVU->index, xPC);
 		mVUregs.blockType = 1;
 	}
 	incPC(-2);

pcsx2/x86/microVU_Flags.inl

@@ -50,7 +50,7 @@ microVUt(void) mVUstatusFlagOp(mV) {
 		}
 	}
 	iPC = curPC;
-	DevCon.Status("microVU%d: FSSET Optimization", getIndex);
+	DevCon.WriteLn(Color_Green, "microVU%d: FSSET Optimization", getIndex);
 }
 
 int findFlagInst(int* fFlag, int cycles) {

pcsx2/x86/microVU_Misc.h

@@ -273,7 +273,7 @@ typedef u32 (__fastcall *mVUCall)(void*, void*);
 #define mVUcacheCheck(ptr, start, limit) {														  \
 	uptr diff = ptr - start;																	  \
 	if (diff >= limit) {																		  \
-		Console.Status("microVU%d: Program cache limit reached. Size = 0x%x", mVU->index, diff); \
+		Console.WriteLn("microVU%d: Program cache limit reached. Size = 0x%x", mVU->index, diff); \
 		mVUreset(mVU);																			  \
 	}																							  \
 }

pcsx2/x86/sVU_Lower.cpp

@@ -1593,7 +1593,7 @@ void recVUMI_ESADD( VURegs *VU, int info)
 	//Console.WriteLn("VU: ESADD");
 	pxAssert( VU == &VU1 );
 	if( EEREC_TEMP == EEREC_D ) { // special code to reset P ( FixMe: don't know if this is still needed! (cottonvibes) )
-		Console.Notice("ESADD: Resetting P reg!!!\n");
+		Console.Warning("ESADD: Resetting P reg!!!\n");
 		MOV32ItoM(VU_VI_ADDR(REG_P, 0), 0);
 		return;
 	}
@@ -1981,10 +1981,10 @@ void __fastcall VU1XGKICK_MTGSTransfer(u32 *pMem, u32 addr)
 	
 	if((size << 4) > (0x4000-(addr&0x3fff))) 
 	{
-		//DevCon.Notice("addr + Size = 0x%x, transferring %x then doing %x", (addr&0x3fff) + (size << 4), (0x4000-(addr&0x3fff)) >> 4, size - ((0x4000-(addr&0x3fff)) >> 4));
+		//DevCon.Warning("addr + Size = 0x%x, transferring %x then doing %x", (addr&0x3fff) + (size << 4), (0x4000-(addr&0x3fff)) >> 4, size - ((0x4000-(addr&0x3fff)) >> 4));
 		memcpy_aligned(pmem, (u8*)pMem+addr, 0x4000-(addr&0x3fff));
 		size -= (0x4000-(addr&0x3fff)) >> 4;
-		//DevCon.Notice("Size left %x", size);
+		//DevCon.Warning("Size left %x", size);
 		pmem += 0x4000-(addr&0x3fff);
 		memcpy_aligned(pmem, (u8*)pMem, size<<4);
 	}

pcsx2/x86/sVU_Micro.cpp

@@ -1727,9 +1727,9 @@ void testPrintOverflow() {
 	tempRegX[2] &= 0xff800000;
 	tempRegX[3] &= 0xff800000;
 	if ( (tempRegX[0] == 0x7f800000) || (tempRegX[1] == 0x7f800000) || (tempRegX[2] == 0x7f800000) || (tempRegX[3] == 0x7f800000) )
-		Console.Notice( "VU OVERFLOW!: Changing to +Fmax!!!!!!!!!!!!" );
+		Console.Warning( "VU OVERFLOW!: Changing to +Fmax!!!!!!!!!!!!" );
 	if ( (tempRegX[0] == 0xff800000) || (tempRegX[1] == 0xff800000) || (tempRegX[2] == 0xff800000) || (tempRegX[3] == 0xff800000) )
-		Console.Notice( "VU OVERFLOW!: Changing to -Fmax!!!!!!!!!!!!" );
+		Console.Warning( "VU OVERFLOW!: Changing to -Fmax!!!!!!!!!!!!" );
 }
 
 // Outputs to the console when overflow has occured.

pcsx2/x86/sVU_zerorec.cpp

@@ -343,7 +343,7 @@ void SuperVUAlloc(int vuindex)
 {
 	// The old -1 crap has been depreciated on this function.  Please
 	// specify either 0 or 1, thanks.
-	jASSUME(vuindex >= 0);
+	pxAssert(vuindex >= 0);
 
 	// upper 4 bits must be zero!
 	if (s_recVUMem == NULL)
@@ -357,6 +357,8 @@ void SuperVUAlloc(int vuindex)
 			throw Exception::OutOfMemory(
 				// untranslated diagnostic msg, use exception's default for translation
 				wxsFormat( L"SuperVU failed to allocate recompiler memory (addr: 0x%x)", (u32)s_recVUMem ),
+				
+				// Translated message
 				_("An out of memory error occured while attempting to reserve memory for the core recompilers.")
 			);
 		}
@@ -368,7 +370,7 @@ void SuperVUAlloc(int vuindex)
 
 	if (vuindex >= 0)
 	{
-		jASSUME(s_recVUMem != NULL);
+		pxAssert(s_recVUMem != NULL);
 
 		if (recVUHeaders[vuindex] == NULL)
 			recVUHeaders[vuindex] = new VuFunctionHeader* [s_MemSize[vuindex] / 8];
@@ -449,7 +451,7 @@ void SuperVUReset(int vuindex)
 
 	if (vuindex < 0)
 	{
-		DbgCon.Status("SuperVU reset > Resetting recompiler memory and structures.");
+		DbgCon.WriteLn("SuperVU: Resetting recompiler memory and structures.");
 
 		// Does this cause problems on VU recompiler resets?  It could, if the VU works like
 		// the EE used to, and actually tries to re-enter the recBlock after issuing a clear. (air)
@@ -461,7 +463,7 @@ void SuperVUReset(int vuindex)
 	}
 	else
 	{
-		DbgCon.Status("SuperVU reset [VU%d] > Resetting the recs and junk", vuindex);
+		DbgCon.WriteLn("SuperVU [VU%d]: Resetting the recs and junk", vuindex);
 		list<VuFunctionHeader*>::iterator it;
 		if (recVUHeaders[vuindex]) memset(recVUHeaders[vuindex], 0, sizeof(VuFunctionHeader*) * (s_MemSize[vuindex] / 8));
 		if (recVUBlocks[vuindex]) memset(recVUBlocks[vuindex], 0, sizeof(VuBlockHeader) * (s_MemSize[vuindex] / 8));
@@ -502,7 +504,7 @@ void __fastcall SuperVUClear(u32 startpc, u32 size, int vuindex)
 			if (plist->size() > 30)
 			{
 				// list is too big, delete
-				//Console.Notice("Performance warning: deleting cached VU program!");
+				//Console.Warning("Performance warning: deleting cached VU program!");
 				delete plist->front();
 				plist->pop_front();
 			}
@@ -3785,7 +3787,7 @@ void VuInstruction::Recompile(list<VuInstruction>::iterator& itinst, u32 vuxyz)
 #ifdef PCSX2_DEVBUILD
 		if (regs[1].VIread & regs[0].VIwrite & ~((1 << REG_Q) | (1 << REG_P) | (1 << REG_VF0_FLAG) | (1 << REG_ACC_FLAG)))
 		{
-			Console.Notice("*PCSX2*: Warning, VI write to the same reg %x in both lower/upper cycle %x", regs[1].VIread & regs[0].VIwrite, s_pCurBlock->startpc);
+			Console.Warning("*PCSX2*: Warning, VI write to the same reg %x in both lower/upper cycle %x", regs[1].VIread & regs[0].VIwrite, s_pCurBlock->startpc);
 		}
 #endif
 
@@ -4596,5 +4598,5 @@ void recVULowerOP_T3_11(VURegs* VU, s32 info)
 
 void recVUunknown(VURegs* VU, s32 info)
 {
-	Console.Notice("Unknown SVU micromode opcode called");
+	Console.Warning("Unknown SVU micromode opcode called");
 }