libretro/pcsx2
1
0
Fork 0
mirror of https://github.com/libretro/pcsx2.git synced 2024-12-21 01:08:14 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Brand new approach to console logging, should be a lot more efficient, and is relatively deadlock-free. Also fixes most of the scrolling issues from prev versions.

Browse Source 
git-svn-id: http://pcsx2.googlecode.com/svn/trunk@2044 96395faa-99c1-11dd-bbfe-3dabce05a288
This commit is contained in:
Jake.Stine 2009-10-20 19:34:57 +00:00
parent f8783a77ab
commit 43bac9c6a9
6 changed files with 286 additions and 195 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
common/include/Utilities/Console.h
View File

@ -20,6 +20,8 @@
enum ConsoleColors
{
Color_Current = -1,
Color_Black = 0,
Color_Red,
Color_Green,
@ -27,7 +29,7 @@ enum ConsoleColors
Color_Blue,
Color_Magenta,
Color_Cyan,
Color_White
Color_White,
};
// Use fastcall for the console; should be helpful in most cases

99
common/src/Utilities/Windows/WinThreads.cpp
View File

@ -22,61 +22,58 @@
#include "implement.h" // win32 pthreads implementations.
#endif
namespace Threading
void Threading::CountLogicalCores( int LogicalCoresPerPhysicalCPU, int PhysicalCoresPerPhysicalCPU )
{
void CountLogicalCores( int LogicalCoresPerPhysicalCPU, int PhysicalCoresPerPhysicalCPU )
DWORD vProcessCPUs;
DWORD vSystemCPUs;
x86caps.LogicalCores = 1;
if( !GetProcessAffinityMask (GetCurrentProcess (),
&vProcessCPUs, &vSystemCPUs) ) return;
int CPUs = 0;
DWORD bit;
for (bit = 1; bit != 0; bit <<= 1)
{
DWORD vProcessCPUs;
DWORD vSystemCPUs;
x86caps.LogicalCores = 1;
if( !GetProcessAffinityMask (GetCurrentProcess (),
&vProcessCPUs, &vSystemCPUs) ) return;
int CPUs = 0;
DWORD bit;
for (bit = 1; bit != 0; bit <<= 1)
{
if (vSystemCPUs & bit)
CPUs++;
}
x86caps.LogicalCores = CPUs;
if( LogicalCoresPerPhysicalCPU > CPUs) // for 1-socket HTT-disabled machines
LogicalCoresPerPhysicalCPU = CPUs;
x86caps.PhysicalCores = ( CPUs / LogicalCoresPerPhysicalCPU ) * PhysicalCoresPerPhysicalCPU;
//ptw32_smp_system = ( x86caps.LogicalCores > 1 ) ? TRUE : FALSE;
if (vSystemCPUs & bit)
CPUs++;
}
__forceinline void Sleep( int ms )
{
::Sleep( ms );
}
x86caps.LogicalCores = CPUs;
if( LogicalCoresPerPhysicalCPU > CPUs) // for 1-socket HTT-disabled machines
LogicalCoresPerPhysicalCPU = CPUs;
// For use in spin/wait loops, Acts as a hint to Intel CPUs and should, in theory
// improve performance and reduce cpu power consumption.
__forceinline void SpinWait()
{
__asm pause;
}
__forceinline void EnableHiresScheduler()
{
// This improves accuracy of Sleep() by some amount, and only adds a negligable amount of
// overhead on modern CPUs. Typically desktops are already set pretty low, but laptops in
// particular may have a scheduler Period of 15 or 20ms to extend battery life.
// (note: this same trick is used by most multimedia software and games)
timeBeginPeriod( 1 );
}
__forceinline void DisableHiresScheduler()
{
timeEndPeriod( 1 );
}
x86caps.PhysicalCores = ( CPUs / LogicalCoresPerPhysicalCPU ) * PhysicalCoresPerPhysicalCPU;
//ptw32_smp_system = ( x86caps.LogicalCores > 1 ) ? TRUE : FALSE;
}
__forceinline void Threading::Sleep( int ms )
{
::Sleep( ms );
}
// For use in spin/wait loops, Acts as a hint to Intel CPUs and should, in theory
// improve performance and reduce cpu power consumption.
__forceinline void Threading::SpinWait()
{
__asm pause;
}
__forceinline void Threading::EnableHiresScheduler()
{
// This improves accuracy of Sleep() by some amount, and only adds a negligable amount of
// overhead on modern CPUs. Typically desktops are already set pretty low, but laptops in
// particular may have a scheduler Period of 15 or 20ms to extend battery life.
// (note: this same trick is used by most multimedia software and games)
timeBeginPeriod( 1 );
}
__forceinline void Threading::DisableHiresScheduler()
{
timeEndPeriod( 1 );
}

13
pcsx2/System/SysThreads.cpp
View File

@ -128,7 +128,18 @@ bool SysThreadBase::Suspend( bool isBlocking )
m_sem_event.Post();
}
if( isBlocking ) m_RunningLock.Wait();
if( isBlocking )
{
if( !m_RunningLock.Wait( wxTimeSpan( 0,0,3,0 ) ) )
{
// [TODO] : Implement proper deadlock handler here that lets the user continue
// to wait, or issue a cancel to the thread.
throw Exception::ThreadTimedOut( L"Possible deadlock while suspending the " + m_name,
m_name + L" is not responding to suspend requests. It may be deadlocked or just running *really* slow."
);
}
}
return retval;
}

1
pcsx2/gui/App.h
View File

@ -403,7 +403,6 @@ public:
// Console / Program Logging Helpers
// ----------------------------------------------------------------------------
ConsoleLogFrame* GetProgramLog();
void ProgramLog_CountMsg();
void ProgramLog_PostEvent( wxEvent& evt );
void EnableAllLogging() const;
void DisableWindowLogging() const;

293
pcsx2/gui/ConsoleLogger.cpp
View File

@ -27,14 +27,14 @@ BEGIN_DECLARE_EVENT_TYPES()
DECLARE_EVENT_TYPE(wxEVT_LOG_Write, -1)
DECLARE_EVENT_TYPE(wxEVT_LOG_Newline, -1)
DECLARE_EVENT_TYPE(wxEVT_SetTitleText, -1)
DECLARE_EVENT_TYPE(wxEVT_SemaphoreWait, -1)
DECLARE_EVENT_TYPE(wxEVT_FlushQueue, -1)
END_DECLARE_EVENT_TYPES()
DEFINE_EVENT_TYPE(wxEVT_LOG_Write)
DEFINE_EVENT_TYPE(wxEVT_LOG_Newline)
DEFINE_EVENT_TYPE(wxEVT_SetTitleText)
DEFINE_EVENT_TYPE(wxEVT_DockConsole)
DEFINE_EVENT_TYPE(wxEVT_SemaphoreWait)
DEFINE_EVENT_TYPE(wxEVT_FlushQueue)
// C++ requires abstract destructors to exist, even thought hey're abstract.
PipeRedirectionBase::~PipeRedirectionBase() throw() {}
@ -226,12 +226,23 @@ ConsoleLogFrame::ConsoleLogFrame( MainEmuFrame *parent, const wxString& title, A
, m_TextCtrl( *new wxTextCtrl(this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize,
wxTE_MULTILINE | wxHSCROLL | wxTE_READONLY | wxTE_RICH2 ) )
, m_ColorTable( options.FontSize )
, m_curcolor( DefaultConsoleColor )
, m_msgcounter( 0 )
, m_pendingFlushes( 0 )
, m_WaitingThreadsForFlush( 0 )
, m_ThawThrottle( 0 )
, m_ThawNeeded( false )
, m_ThawPending( false )
, m_QueueColorSection( L"ConsoleLog::QueueColorSection" )
, m_QueueBuffer( L"ConsoleLog::QueueBuffer" )
, m_CurQueuePos( false )
, m_threadlogger( EnableThreadedLoggingTest ? new ConsoleTestThread() : NULL )
{
m_TextCtrl.SetBackgroundColour( wxColor( 230, 235, 242 ) );
m_TextCtrl.SetDefaultStyle( m_ColorTable[DefaultConsoleColor] );
// create Log menu (contains most options)
wxMenuBar *pMenuBar = new wxMenuBar();
wxMenu& menuLog = *new wxMenu();
@ -263,7 +274,6 @@ ConsoleLogFrame::ConsoleLogFrame( MainEmuFrame *parent, const wxString& title, A
// status bar for menu prompts
CreateStatusBar();
ClearColor();
SetSize( wxRect( options.DisplayPosition, options.DisplaySize ) );
Show( options.Visible );
@ -281,11 +291,10 @@ ConsoleLogFrame::ConsoleLogFrame( MainEmuFrame *parent, const wxString& title, A
Connect( wxEVT_MOVE, wxMoveEventHandler(ConsoleLogFrame::OnMoveAround) );
Connect( wxEVT_SIZE, wxSizeEventHandler(ConsoleLogFrame::OnResize) );
Connect( wxEVT_LOG_Write, wxCommandEventHandler(ConsoleLogFrame::OnWrite) );
Connect( wxEVT_LOG_Newline, wxCommandEventHandler(ConsoleLogFrame::OnNewline) );
Connect( wxEVT_SetTitleText, wxCommandEventHandler(ConsoleLogFrame::OnSetTitle) );
Connect( wxEVT_DockConsole, wxCommandEventHandler(ConsoleLogFrame::OnDockedMove) );
Connect( wxEVT_SemaphoreWait, wxCommandEventHandler(ConsoleLogFrame::OnSemaphoreWait) );
Connect( wxEVT_FlushQueue, wxCommandEventHandler(ConsoleLogFrame::OnFlushEvent) );
if( m_threadlogger != NULL )
m_threadlogger->Start();
@ -297,51 +306,74 @@ ConsoleLogFrame::~ConsoleLogFrame()
wxGetApp().OnProgramLogClosed();
}
void ConsoleLogFrame::SetColor( ConsoleColors color )
{
if( color != m_curcolor )
m_TextCtrl.SetDefaultStyle( m_ColorTable[m_curcolor=color] );
}
void ConsoleLogFrame::ClearColor()
{
if( DefaultConsoleColor != m_curcolor )
m_TextCtrl.SetDefaultStyle( m_ColorTable[m_curcolor=DefaultConsoleColor] );
}
void ConsoleLogFrame::Write( const wxString& text )
{
// remove selection (WriteText is in fact ReplaceSelection)
// TODO : Optimize this to only replace selection if some selection
// messages have been received since the last write.
#ifdef __WXMSW__
wxTextPos nLen = m_TextCtrl.GetLastPosition();
m_TextCtrl.SetSelection(nLen, nLen);
#endif
m_TextCtrl.AppendText( text );
// cap at 256k for now...
// fixme - 256k runs well on win32 but appears to be very sluggish on linux. Might
// need platform dependent defaults here. - air
if( m_TextCtrl.GetLastPosition() > 0x40000 )
{
m_TextCtrl.Remove( 0, 0x10000 );
}
}
int m_pendingFlushes = 0;
// Implementation note: Calls SetColor and Write( text ). Override those virtuals
// and this one will magically follow suite. :)
void ConsoleLogFrame::Write( ConsoleColors color, const wxString& text )
{
SetColor( color );
Write( text );
//#ifdef PCSX2_SEH
pthread_testcancel();
//#endif
ScopedLock lock( m_QueueLock );
if( m_QueueColorSection.GetLength() == 0 )
{
pxAssertMsg( m_CurQueuePos == 0, "Queue's character position didn't get reset in sync with it's ColorSection table." );
}
if( (m_QueueColorSection.GetLength() == 0) || ((color != Color_Current) && (m_QueueColorSection.GetLast().color != color)) )
{
++m_CurQueuePos; // Don't overwrite the NULL;
m_QueueColorSection.Add( ColorSection(color, m_CurQueuePos) );
}
int endpos = m_CurQueuePos + text.Length();
m_QueueBuffer.MakeRoomFor( endpos + 1 ); // and the null!!
memcpy_fast( &m_QueueBuffer[m_CurQueuePos], text.c_str(), sizeof(wxChar) * text.Length() );
m_CurQueuePos = endpos;
// this NULL may be overwritten if the next message sent doesn't perform a color change.
m_QueueBuffer[m_CurQueuePos] = 0;
// Idle events don't always pass (wx blocks them when moving windows or using menus, for
// example). So let's hackfix it so that an alternate message is posted if the queue is
// "piling up."
if( m_pendingFlushes == 0 )
{
wxCommandEvent evt( wxEVT_FlushQueue );
evt.SetInt( 0 );
GetEventHandler()->AddPendingEvent( evt );
}
++m_pendingFlushes;
if( m_pendingFlushes > 32 && !wxThread::IsMain() )
{
++m_WaitingThreadsForFlush;
lock.Unlock();
if( !m_sem_QueueFlushed.WaitRaw( wxTimeSpan( 0,0,0,500 ) ) )
{
// Necessary since the main thread could grab the lock and process before
// the above function actually returns (gotta love threading!)
lock.Lock();
if( m_WaitingThreadsForFlush != 0 ) --m_WaitingThreadsForFlush;
}
else
{
// give gui thread time to repaint and handle other pending messages.
// (those are prioritized lower than wxEvents, typically)
Sleep(1);
}
}
}
void ConsoleLogFrame::Newline()
{
Write( L"\n" );
Write( Color_Current, L"\n" );
}
void ConsoleLogFrame::DoClose()
@ -364,7 +396,7 @@ void ConsoleLogFrame::DockedMove()
// * Logging Events
// =================================================================================
// Special event recieved from a window we're docked against.
// Special event received from a window we're docked against.
void ConsoleLogFrame::OnDockedMove( wxCommandEvent& event )
{
DockedMove();
@ -466,7 +498,7 @@ void ConsoleLogFrame::OnFontSize( wxMenuEvent& evt )
m_conf.FontSize = ptsize;
m_ColorTable.SetFont( ptsize );
m_TextCtrl.SetDefaultStyle( m_ColorTable[m_curcolor] );
m_TextCtrl.SetDefaultStyle( m_ColorTable[Color_White] );
// TODO: Process the attributes of each character and upgrade the font size,
// while still retaining color and bold settings... (might be slow but then
@ -478,92 +510,113 @@ void ConsoleLogFrame::OnFontSize( wxMenuEvent& evt )
// Logging Events (typically received from Console class interfaces)
// ----------------------------------------------------------------------------
void ConsoleLogFrame::OnWrite( wxCommandEvent& event )
{
Write( (ConsoleColors)event.GetExtraLong(), event.GetString() );
DoMessage();
}
void ConsoleLogFrame::OnNewline( wxCommandEvent& event )
{
Newline();
DoMessage();
}
void ConsoleLogFrame::OnSetTitle( wxCommandEvent& event )
{
SetTitle( event.GetString() );
}
void ConsoleLogFrame::OnSemaphoreWait( wxCommandEvent& event )
void ConsoleLogFrame::OnFlushEvent( wxCommandEvent& evt )
{
m_semaphore.Post();
ScopedLock locker( m_QueueLock );
if( m_CurQueuePos != 0 )
{
DoFlushQueue();
#ifdef __WXMSW__
// This nicely sets the scroll position to the end of our log window, regardless of if
// the textctrl has focus or not. The wxWidgets AppendText() function uses EM_LINESCROLL
// instead, which tends to be much faster for high-volume logs, but also ends up refreshing
// the console in sloppy fashion for normal logging.
// (both are needed, the WM_VSCROLL makes the scrolling smooth, and the EM_LINESCROLL avoids
// weird errors when the buffer reaches "max" and starts clearing old history)
::SendMessage((HWND)m_TextCtrl.GetHWND(), WM_VSCROLL, SB_BOTTOM, (LPARAM)NULL);
::SendMessage((HWND)m_TextCtrl.GetHWND(), EM_LINESCROLL, 0, m_TextCtrl.GetNumberOfLines());
#endif
//m_TextCtrl.Thaw();
}
// Implementation note: I tried desperately to move this into wxEVT_IDLE, on the theory that
// we don't actually want to wake up pending threads until after the GUI's finished all its
// paperwork. But wxEVT_IDLE doesn't work when you click menus or the title bar of a window,
// making it pretty well annoyingly useless for just about anything. >_<
// Workaround: I added a Sleep(1) to the DoWrite method to give the GUI some time to
// do its paperwork.
if( m_WaitingThreadsForFlush > 0 )
{
do {
m_sem_QueueFlushed.Post();
} while( --m_WaitingThreadsForFlush > 0 );
int count = m_sem_QueueFlushed.Count();
while( count < 0 ) m_sem_QueueFlushed.Post();
}
}
// ------------------------------------------------------------------------
// Deadlock protection: High volume logs will over-tax our message pump and cause the
// GUI to become inaccessible. The cool solution would be a threaded log window, but wx
// is entirely un-safe for that kind of threading. So instead I use a message counter
// that stalls non-GUI threads when they attempt to over-tax an already burdened log.
// If too many messages get queued up, non-gui threads are stalled to allow the gui to
// catch up.
void ConsoleLogFrame::CountMessage()
void ConsoleLogFrame::DoFlushQueue()
{
long result = _InterlockedIncrement( &m_msgcounter );
int len = m_QueueColorSection.GetLength();
pxAssert( len != 0 );
if( result > 0x20 ) // 0x20 -- arbitrary value that seems to work well (tested on P4 and C2D)
// Note, freezing/thawing actually seems to cause more overhead than it solves.
// It might be useful if we're posting like dozens of messages, but in our case
// we only post 1-4 typically, so better to leave things enabled.
//m_TextCtrl.Freeze();
// Manual InsertionPoint tracking avoids a lot of overhead in SetInsertionPointEnd()
wxTextPos insertPoint = m_TextCtrl.GetLastPosition();
// cap at 256k for now...
// fixme - 256k runs well on win32 but appears to be very sluggish on linux (but that could
// be a result of my using Xming + CoLinux). Might need platform dependent defaults here. --air
if( (insertPoint + m_CurQueuePos) > 0x40000 )
{
if( !wxThread::IsMain() )
int toKeep = 0x40000 - m_CurQueuePos;
if( toKeep <= 10 )
{
// Append an event that'll post up our semaphore. It'll get run "in
// order" which means when it posts all queued messages will have been
// processed.
wxCommandEvent evt( wxEVT_SemaphoreWait );
GetEventHandler()->AddPendingEvent( evt );
m_semaphore.WaitRaw();
m_TextCtrl.Clear();
insertPoint = 0;
}
else
{
int toRemove = 0x40000 - toKeep;
if( toRemove < 0x10000 ) toRemove = 0x10000;
m_TextCtrl.Remove( 0, toRemove );
insertPoint -= toRemove;
}
}
}
// Thread Safety note: This function expects to be called from the Main GUI thread
// only. If called from a thread other than Main, it will generate an assertion failure.
//
void ConsoleLogFrame::DoMessage()
{
AllowFromMainThreadOnly();
m_TextCtrl.SetInsertionPoint( insertPoint );
int cur = _InterlockedDecrement( &m_msgcounter );
// We need to freeze the control if there are more than 2 pending messages,
// otherwise the redraw of the console will prevent it from ever being able to
// catch up with the rate the queue is being filled, and the whole app could
// deadlock. >_<
if( m_TextCtrl.IsFrozen() )
for( int i=0; i<len; ++i )
{
if( cur < 1 )
m_TextCtrl.Thaw();
}
else if( cur >= 3 )
{
m_TextCtrl.Freeze();
}
}
if( m_QueueColorSection[i].color != Color_Current )
m_TextCtrl.SetDefaultStyle( m_ColorTable[m_QueueColorSection[i].color] );
const wxString passin( &m_QueueBuffer[m_QueueColorSection[i].startpoint] );
m_TextCtrl.WriteText( passin );
insertPoint += passin.Length();
}
m_TextCtrl.SetInsertionPoint( insertPoint );
m_CurQueuePos = 0;
m_QueueColorSection.Clear();
m_pendingFlushes = 0;
//m_TextCtrl.ShowPosition( insertPoint );
}
ConsoleLogFrame* Pcsx2App::GetProgramLog()
{
return m_ProgramLogBox;
}
void Pcsx2App::ProgramLog_CountMsg()
{
// New console log object model makes this check obsolete:
//if( m_ProgramLogBox == NULL ) return;
m_ProgramLogBox->CountMessage();
}
void Pcsx2App::ProgramLog_PostEvent( wxEvent& evt )
{
// New console log object model makes this check obsolete:
@ -645,37 +698,21 @@ template< const IConsoleWriter& secondary >
static void __concall ConsoleToWindow_Newline()
{
secondary.Newline();
wxCommandEvent evt( wxEVT_LOG_Newline );
((Pcsx2App&)*wxTheApp).ProgramLog_PostEvent( evt );
((Pcsx2App&)*wxTheApp).ProgramLog_CountMsg();
((Pcsx2App&)*wxTheApp).GetProgramLog()->Newline();
}
template< const IConsoleWriter& secondary >
static void __concall ConsoleToWindow_DoWrite( const wxString& fmt )
{
secondary.DoWrite( fmt );
wxCommandEvent evt( wxEVT_LOG_Write );
evt.SetString( fmt );
evt.SetExtraLong( th_CurrentColor );
((Pcsx2App&)*wxTheApp).ProgramLog_PostEvent( evt );
((Pcsx2App&)*wxTheApp).ProgramLog_CountMsg();
((Pcsx2App&)*wxTheApp).GetProgramLog()->Write( th_CurrentColor, fmt );
}
template< const IConsoleWriter& secondary >
static void __concall ConsoleToWindow_DoWriteLn( const wxString& fmt )
{
secondary.DoWriteLn( fmt );
// Implementation note: I've duplicated Write+Newline behavior here to avoid polluting
// the message pump with lots of erroneous messages (Newlines can be bound into Write message).
wxCommandEvent evt( wxEVT_LOG_Write );
evt.SetString( fmt + L"\n" );
evt.SetExtraLong( th_CurrentColor );
((Pcsx2App&)*wxTheApp).ProgramLog_PostEvent( evt );
((Pcsx2App&)*wxTheApp).ProgramLog_CountMsg();
((Pcsx2App&)*wxTheApp).GetProgramLog()->Write( th_CurrentColor, fmt + L"\n" );
}
typedef void __concall DoWriteFn(const wxString&);

71
pcsx2/gui/ConsoleLogger.h
View File

@ -121,26 +121,74 @@ protected:
}
};
class ColorSection
{
public:
ConsoleColors color;
int startpoint;
ColorSection() {}
ColorSection( ConsoleColors _color, int msgptr ) : color(_color), startpoint(msgptr) { }
};
protected:
ConLogConfig& m_conf;
wxTextCtrl& m_TextCtrl;
ColorArray m_ColorTable;
ConsoleColors m_curcolor;
volatile long m_msgcounter; // used to track queued messages and throttle load placed on the gui message pump
Semaphore m_semaphore;
// this int throttles freeze/thaw of the display, by cycling from -2 to 4, roughly.
// (negative values force thaw, positive values indicate thaw is disabled. This is
// needed because the wxWidgets Thaw implementation uses a belated paint message,
// and if we Freeze on the very next queued message after thawing, the repaint
// never happens)
int m_ThawThrottle;
// If a freeze is executed, this is set true (without this, wx asserts)
bool m_ThawNeeded;
// Set true when a Thaw message is sent (avoids cluttering the message pump with redundant
// requests)
bool m_ThawPending;
// ----------------------------------------------------------------------------
// Queue State Management Vars
// ----------------------------------------------------------------------------
// This is a counter of the total number of pending flushes across all threads.
// If the value exceeds a threshold, threads begin throttling to avoid deadlocking
// the GUI.
volatile int m_pendingFlushes;
// This is a counter of the number of threads waiting for the Queue to flush.
volatile int m_WaitingThreadsForFlush;
// Used by threads waiting on the queue to flush.
Semaphore m_sem_QueueFlushed;
// Lock object for accessing or modifying the following three vars:
// m_QueueBuffer, m_QueueColorSelection, m_CurQueuePos
MutexLockRecursive m_QueueLock;
// Describes a series of colored text sections in the m_QueueBuffer.
SafeList<ColorSection> m_QueueColorSection;
// Series of Null-terminated strings, each one has a corresponding entry in
// m_QueueColorSelection.
SafeArray<wxChar> m_QueueBuffer;
// Current write position into the m_QueueBuffer;
int m_CurQueuePos;
// Threaded log spammer, useful for testing console logging performance.
ConsoleTestThread* m_threadlogger;
// (alternatively you can enable Disasm logging in any recompiler and achieve
// a similar effect)
ConsoleTestThread* m_threadlogger;
public:
// ctor & dtor
ConsoleLogFrame( MainEmuFrame *pParent, const wxString& szTitle, ConLogConfig& options );
virtual ~ConsoleLogFrame();
virtual void Write( const wxString& text );
virtual void SetColor( ConsoleColors color );
virtual void ClearColor();
virtual void DockedMove();
// Retrieves the current configuration options settings for this box.
@ -149,11 +197,8 @@ public:
void Write( ConsoleColors color, const wxString& text );
void Newline();
void CountMessage();
void DoMessage();
protected:
// menu callbacks
virtual void OnOpen (wxMenuEvent& event);
virtual void OnClose(wxMenuEvent& event);
@ -164,14 +209,14 @@ protected:
virtual void OnCloseWindow(wxCloseEvent& event);
void OnWrite( wxCommandEvent& event );
void OnNewline( wxCommandEvent& event );
void OnSetTitle( wxCommandEvent& event );
void OnDockedMove( wxCommandEvent& event );
void OnSemaphoreWait( wxCommandEvent& event );
void OnIdleEvent( wxIdleEvent& event );
void OnFlushEvent( wxCommandEvent& event );
// common part of OnClose() and OnCloseWindow()
virtual void DoClose();
void DoFlushQueue();
void OnMoveAround( wxMoveEvent& evt );
void OnResize( wxSizeEvent& evt );