Converted tabs to spaces. Removed trailing whitespaces.

common/drawpanel_gal.cpp

@@ -78,21 +78,21 @@ EDA_DRAW_PANEL_GAL::EDA_DRAW_PANEL_GAL( wxWindow* aParentWindow, wxWindowID aWin
     Connect( wxEVT_SIZE,        wxSizeEventHandler( EDA_DRAW_PANEL_GAL::onSize ), NULL, this );
 
     /* Generic events for the Tool Dispatcher */
-	Connect( wxEVT_MOTION,      wxEventHandler( EDA_DRAW_PANEL_GAL::onEvent ), NULL, this );
-	Connect( wxEVT_LEFT_UP,     wxEventHandler( EDA_DRAW_PANEL_GAL::onEvent ), NULL, this );
-	Connect( wxEVT_LEFT_DOWN,   wxEventHandler( EDA_DRAW_PANEL_GAL::onEvent ), NULL, this );
-	Connect( wxEVT_RIGHT_UP,    wxEventHandler( EDA_DRAW_PANEL_GAL::onEvent ), NULL, this );
-	Connect( wxEVT_RIGHT_DOWN,  wxEventHandler( EDA_DRAW_PANEL_GAL::onEvent ), NULL, this );
-	Connect( wxEVT_MIDDLE_UP,   wxEventHandler( EDA_DRAW_PANEL_GAL::onEvent ), NULL, this );
-	Connect( wxEVT_MIDDLE_DOWN, wxEventHandler( EDA_DRAW_PANEL_GAL::onEvent ), NULL, this );
-	Connect( wxEVT_MOUSEWHEEL,  wxEventHandler( EDA_DRAW_PANEL_GAL::onEvent ), NULL, this );
-	Connect( wxEVT_CHAR_HOOK,   wxEventHandler( EDA_DRAW_PANEL_GAL::skipEvent ) );
-	Connect( wxEVT_KEY_UP,      wxEventHandler( EDA_DRAW_PANEL_GAL::onEvent ), NULL, this );
-	Connect( wxEVT_KEY_DOWN,    wxEventHandler( EDA_DRAW_PANEL_GAL::onEvent ), NULL, this );
+    Connect( wxEVT_MOTION,      wxEventHandler( EDA_DRAW_PANEL_GAL::onEvent ), NULL, this );
+    Connect( wxEVT_LEFT_UP,     wxEventHandler( EDA_DRAW_PANEL_GAL::onEvent ), NULL, this );
+    Connect( wxEVT_LEFT_DOWN,   wxEventHandler( EDA_DRAW_PANEL_GAL::onEvent ), NULL, this );
+    Connect( wxEVT_RIGHT_UP,    wxEventHandler( EDA_DRAW_PANEL_GAL::onEvent ), NULL, this );
+    Connect( wxEVT_RIGHT_DOWN,  wxEventHandler( EDA_DRAW_PANEL_GAL::onEvent ), NULL, this );
+    Connect( wxEVT_MIDDLE_UP,   wxEventHandler( EDA_DRAW_PANEL_GAL::onEvent ), NULL, this );
+    Connect( wxEVT_MIDDLE_DOWN, wxEventHandler( EDA_DRAW_PANEL_GAL::onEvent ), NULL, this );
+    Connect( wxEVT_MOUSEWHEEL,  wxEventHandler( EDA_DRAW_PANEL_GAL::onEvent ), NULL, this );
+    Connect( wxEVT_CHAR_HOOK,   wxEventHandler( EDA_DRAW_PANEL_GAL::skipEvent ) );
+    Connect( wxEVT_KEY_UP,      wxEventHandler( EDA_DRAW_PANEL_GAL::onEvent ), NULL, this );
+    Connect( wxEVT_KEY_DOWN,    wxEventHandler( EDA_DRAW_PANEL_GAL::onEvent ), NULL, this );
     Connect( wxEVT_ENTER_WINDOW, wxEventHandler( EDA_DRAW_PANEL_GAL::onEnter ), NULL, this );
     Connect( KiGfx::WX_VIEW_CONTROLS::EVT_REFRESH_MOUSE,
              wxEventHandler( EDA_DRAW_PANEL_GAL::onEvent ), NULL, this );
-    
+
     m_refreshTimer.SetOwner( this );
     Connect( wxEVT_TIMER, wxTimerEventHandler( EDA_DRAW_PANEL_GAL::onRefreshTimer ), NULL, this );
 
@@ -171,7 +171,7 @@ void EDA_DRAW_PANEL_GAL::Refresh( bool eraseBackground, const wxRect* rect )
         m_refreshTimer.Start( ( MinRefreshPeriod - delta ).ToLong(), true );
         m_pendingRefresh = true;
     }
-} 
+}
 
 
 void EDA_DRAW_PANEL_GAL::SwitchBackend( GalType aGalType )
@@ -223,13 +223,13 @@ void EDA_DRAW_PANEL_GAL::SwitchBackend( GalType aGalType )
 
 void EDA_DRAW_PANEL_GAL::onEvent( wxEvent& aEvent )
 {
-	if( !m_eventDispatcher )
-	{
-		aEvent.Skip();
-		return;
-	}
-	else
-	{
+    if( !m_eventDispatcher )
+    {
+        aEvent.Skip();
+        return;
+    }
+    else
+    {
         m_eventDispatcher->DispatchWxEvent( aEvent );
     }
 

common/gal/color4d.cpp

@@ -159,7 +159,6 @@ void COLOR4D::FromHSV( double aInH, double aInS, double aInV )
         b = q;
         break;
     }
-    
 }
 
 
@@ -168,7 +167,7 @@ COLOR4D& COLOR4D::Saturate( double aFactor )
     double h, s, v;
     ToHSV( h, s, v );
     FromHSV( h, aFactor, 1.0 );
-    
+
     return *this;
 }
-        
+

common/gal/opengl/opengl_gal.cpp

@@ -127,7 +127,7 @@ void OPENGL_GAL::BeginDrawing()
         glViewport( 0, 0, (GLsizei) screenSize.x, (GLsizei) screenSize.y );
 
         // Create the screen transformation
-        glOrtho( 0, (GLint) screenSize.x, 0, (GLsizei) screenSize.y, 
+        glOrtho( 0, (GLint) screenSize.x, 0, (GLsizei) screenSize.y,
                 -depthRange.x, -depthRange.y );
 
         // Prepare rendering target buffers

common/gal/opengl/shader.frag

@@ -49,7 +49,7 @@ void strokedCircle( vec2 aCoord, float aRadius, float aWidth )
     float innerRadius = aRadius - ( aWidth / 2 );
     float relWidth = innerRadius / outerRadius;
 
-    if( ( dot( aCoord, aCoord ) < 1.0f ) && 
+    if( ( dot( aCoord, aCoord ) < 1.0f ) &&
         ( dot( aCoord, aCoord ) > relWidth * relWidth ) )
         gl_FragColor = gl_Color;
     else

common/gal/opengl/shader.vert

@@ -42,23 +42,23 @@ void main()
 {
     // Pass attributes to the fragment shader
     shaderParams = attrShaderParams;
-    
+
     if( shaderParams[0] == SHADER_LINE )
     {
         float lineWidth = shaderParams[3];
         float worldScale = gl_ModelViewMatrix[0][0];
         float scale;
-     
+
         // Make lines appear to be at least 1 pixel wide
         if( worldScale * lineWidth < MIN_WIDTH )
             scale = MIN_WIDTH / ( worldScale * lineWidth );
         else
             scale = 1.0f;
-        
-        gl_Position = gl_ModelViewProjectionMatrix * 
+
+        gl_Position = gl_ModelViewProjectionMatrix *
             ( gl_Vertex + vec4( shaderParams.yz * scale, 0.0, 0.0 ) );
     }
-    else if( ( shaderParams[0] == SHADER_STROKED_CIRCLE ) || 
+    else if( ( shaderParams[0] == SHADER_STROKED_CIRCLE ) ||
              ( shaderParams[0] == SHADER_FILLED_CIRCLE  ) )
     {
         // Compute relative circle coordinates basing on indices
@@ -69,7 +69,7 @@ void main()
             circleCoords = vec2( sqrt( 3.0f ), -1.0f );
         else if( shaderParams[1] == 3.0f )
             circleCoords = vec2( 0.0f, 2.0f );
-            
+
         // Semicircle
         else if( shaderParams[1] == 4.0f )
             circleCoords = vec2( -3.0f / sqrt( 3.0f ), 0.0f );
@@ -81,7 +81,7 @@ void main()
         // Make the line appear to be at least 1 pixel wide
         float lineWidth = shaderParams[3];
         float worldScale = gl_ModelViewMatrix[0][0];
-     
+
         // Make lines appear to be at least 1 pixel width
         if( worldScale * lineWidth < MIN_WIDTH )
             shaderParams[3] = shaderParams[3] / ( worldScale * lineWidth );
@@ -93,7 +93,7 @@ void main()
         // Pass through the coordinates like in the fixed pipeline
         gl_Position = ftransform();
     }
-    
+
     gl_FrontColor = gl_Color;
 }
 

common/geometry/seg.cpp

@@ -32,38 +32,38 @@ template<typename T> int sgn( T val ) {
 
 bool SEG::PointCloserThan( const VECTOR2I& aP, int dist ) const
 {
-	VECTOR2I   	  d = b - a;
-	ecoord dist_sq = (ecoord) dist * dist;
+    VECTOR2I         d = b - a;
+    ecoord dist_sq = (ecoord) dist * dist;
 
- 	SEG::ecoord l_squared = d.Dot( d );
+    SEG::ecoord l_squared = d.Dot( d );
     SEG::ecoord t = d.Dot( aP - a );
 
     if( t <= 0 || !l_squared )
-    	return ( aP - a ).SquaredEuclideanNorm() < dist_sq;
-    else if( t >= l_squared ) 
-    	return ( aP - b ).SquaredEuclideanNorm() < dist_sq;
+        return ( aP - a ).SquaredEuclideanNorm() < dist_sq;
+    else if( t >= l_squared )
+        return ( aP - b ).SquaredEuclideanNorm() < dist_sq;
 
-	int dxdy = abs( d.x ) - abs( d.y );
+    int dxdy = abs( d.x ) - abs( d.y );
 
     if( ( dxdy >= -1 && dxdy <= 1 ) || abs( d.x ) <= 1 || abs( d.y ) <= 1 )
     {
-    	int ca = -sgn( d.y );
-    	int cb = sgn( d.x );
-    	int cc = -ca * a.x - cb * a.y;
-    	
-		ecoord num = ca * aP.x + cb * aP.y + cc;
-		num *= num;
-
-		if( ca && cb )
-			num >>= 1;
-
-		if( num > ( dist_sq + 100 ) )
-			return false;
-		else if( num < ( dist_sq - 100 ) )
-			return true;
+        int ca = -sgn( d.y );
+        int cb = sgn( d.x );
+        int cc = -ca * a.x - cb * a.y;
+
+        ecoord num = ca * aP.x + cb * aP.y + cc;
+        num *= num;
+
+        if( ca && cb )
+            num >>= 1;
+
+        if( num > ( dist_sq + 100 ) )
+            return false;
+        else if( num < ( dist_sq - 100 ) )
+            return true;
     }
 
-	VECTOR2I nearest;    
+    VECTOR2I nearest;
     nearest.x = a.x + rescale( t, (ecoord)d.x, l_squared );
     nearest.y = a.y + rescale( t, (ecoord)d.y, l_squared );
 
@@ -71,7 +71,7 @@ bool SEG::PointCloserThan( const VECTOR2I& aP, int dist ) const
 }
 
 
-SEG::ecoord SEG::SquaredDistance( const SEG& aSeg ) const 
+SEG::ecoord SEG::SquaredDistance( const SEG& aSeg ) const
 {
     // fixme: rather inefficient....
     if( Intersect( aSeg ) )
@@ -91,62 +91,62 @@ SEG::ecoord SEG::SquaredDistance( const SEG& aSeg ) const
 
     return m;
 }
-	
+
 
 OPT_VECTOR2I SEG::Intersect( const SEG& aSeg, bool aIgnoreEndpoints, bool aLines ) const
 {
-	const VECTOR2I e ( b - a );
-	const VECTOR2I f ( aSeg.b - aSeg.a );
-	const VECTOR2I ac ( aSeg.a - a );
-	
-	ecoord d = f.Cross( e );
-	ecoord p = f.Cross( ac );
-	ecoord q = e.Cross( ac );
-	
-	if( d == 0 )
-		return OPT_VECTOR2I();
-	if ( !aLines && d > 0 && ( q < 0 || q > d || p < 0 || p > d ) )
-		return OPT_VECTOR2I();
-	if ( !aLines && d < 0 && ( q < d || p < d || p > 0 || q > 0 ) )
-		return OPT_VECTOR2I();
-	if ( !aLines && aIgnoreEndpoints && ( q == 0 || q == d ) && ( p == 0 || p == d ) )
-		return OPT_VECTOR2I();
-	
-	 VECTOR2I ip( aSeg.a.x + rescale( q, (ecoord)f.x, d ),
-	              aSeg.a.y + rescale( q, (ecoord)f.y, d ) );
-
-	 return ip;
+    const VECTOR2I e ( b - a );
+    const VECTOR2I f ( aSeg.b - aSeg.a );
+    const VECTOR2I ac ( aSeg.a - a );
+
+    ecoord d = f.Cross( e );
+    ecoord p = f.Cross( ac );
+    ecoord q = e.Cross( ac );
+
+    if( d == 0 )
+        return OPT_VECTOR2I();
+    if ( !aLines && d > 0 && ( q < 0 || q > d || p < 0 || p > d ) )
+        return OPT_VECTOR2I();
+    if ( !aLines && d < 0 && ( q < d || p < d || p > 0 || q > 0 ) )
+        return OPT_VECTOR2I();
+    if ( !aLines && aIgnoreEndpoints && ( q == 0 || q == d ) && ( p == 0 || p == d ) )
+        return OPT_VECTOR2I();
+
+     VECTOR2I ip( aSeg.a.x + rescale( q, (ecoord)f.x, d ),
+                  aSeg.a.y + rescale( q, (ecoord)f.y, d ) );
+
+     return ip;
 }
 
 
 bool SEG::ccw( const VECTOR2I& a, const VECTOR2I& b, const VECTOR2I& c ) const
 {
-	return (ecoord)( c.y - a.y ) * ( b.x - a.x ) > (ecoord)( b.y - a.y ) * ( c.x - a.x );
+    return (ecoord)( c.y - a.y ) * ( b.x - a.x ) > (ecoord)( b.y - a.y ) * ( c.x - a.x );
 }
 
 
-bool SEG::Collide( const SEG& aSeg, int aClearance ) const 
+bool SEG::Collide( const SEG& aSeg, int aClearance ) const
 {
-	// check for intersection 
-	// fixme: move to a method
-	if( ccw( a, aSeg.a, aSeg.b ) != ccw( b, aSeg.a, aSeg.b ) &&
-	        ccw( a, b, aSeg.a ) != ccw( a, b, aSeg.b ) )
-		return true;
+    // check for intersection
+    // fixme: move to a method
+    if( ccw( a, aSeg.a, aSeg.b ) != ccw( b, aSeg.a, aSeg.b ) &&
+            ccw( a, b, aSeg.a ) != ccw( a, b, aSeg.b ) )
+        return true;
 
 #define CHK(_seg, _pt) \
-	if( (_seg).PointCloserThan (_pt, aClearance ) ) return true;
-	
-	CHK( *this, aSeg.a );
-	CHK( *this, aSeg.b );
-	CHK( aSeg, a );
-	CHK( aSeg, b );
+    if( (_seg).PointCloserThan (_pt, aClearance ) ) return true;
+
+    CHK( *this, aSeg.a );
+    CHK( *this, aSeg.b );
+    CHK( aSeg, a );
+    CHK( aSeg, b );
 #undef CHK
 
-	return false;
+    return false;
 }
 
 
 bool SEG::Contains( const VECTOR2I& aP ) const
 {
-	return PointCloserThan( aP, 1 );
+    return PointCloserThan( aP, 1 );
 }

common/system/fcontext.s

 /*
-	Boost::Context assembly wrapper - done to avoid compiling the whole boost binary library
-	which may be unpleasant, in particular under Windows (we don't support VC++, while boost::context
-	does not support mingw */
+    Boost::Context assembly wrapper - done to avoid compiling the whole boost binary library
+    which may be unpleasant, in particular under Windows (we don't support VC++, while boost::context
+    does not support mingw */
 
 #ifdef __APPLE__
 

common/system/make_i386_pe_gas.S

@@ -9,39 +9,39 @@
 .align 2
 
 _make_fcontext:
-	mov    0x4(%esp),%eax
-	lea    -0x34(%eax),%eax
-	and    $0xfffffff0,%eax
-	mov    0x4(%esp),%ecx
-	mov    %ecx,0x18(%eax)
-	mov    0x8(%esp),%edx
-	mov    %edx,0x1c(%eax)
-	neg    %edx
-	lea    (%edx,%ecx,1),%ecx
-	mov    %ecx,0x20(%eax)
-	mov    0xc(%esp),%ecx
-	mov    %ecx,0x14(%eax)
-	stmxcsr 0x2c(%eax)
-	fnstcw 0x30(%eax)
-	lea    -0x1c(%eax),%edx
-	mov    %edx,0x10(%eax)
-	mov    $0x0,%ecx
-	mov    %ecx,(%edx)
-	mov    %fs:0x18,%ecx
-	mov    (%ecx),%edx
-	inc    %edx
-	je     _make_fcontext+0x4c // <_make_fcontext+0x4c>
-	dec    %edx
-	xchg   %edx,%ecx
-	jmp    _make_fcontext+0x42 // <_make_fcontext+0x42>
-	mov    0x4(%ecx),%ecx
-	mov    0x10(%eax),%edx
-	mov    %ecx,0x18(%edx)
-	mov    $0xffffffff,%ecx
-	mov    %ecx,0x14(%edx)
-	lea    0x14(%edx),%ecx
-	mov    %ecx,0x24(%eax)
-	ret    
+    mov    0x4(%esp),%eax
+    lea    -0x34(%eax),%eax
+    and    $0xfffffff0,%eax
+    mov    0x4(%esp),%ecx
+    mov    %ecx,0x18(%eax)
+    mov    0x8(%esp),%edx
+    mov    %edx,0x1c(%eax)
+    neg    %edx
+    lea    (%edx,%ecx,1),%ecx
+    mov    %ecx,0x20(%eax)
+    mov    0xc(%esp),%ecx
+    mov    %ecx,0x14(%eax)
+    stmxcsr 0x2c(%eax)
+    fnstcw 0x30(%eax)
+    lea    -0x1c(%eax),%edx
+    mov    %edx,0x10(%eax)
+    mov    $0x0,%ecx
+    mov    %ecx,(%edx)
+    mov    %fs:0x18,%ecx
+    mov    (%ecx),%edx
+    inc    %edx
+    je     _make_fcontext+0x4c // <_make_fcontext+0x4c>
+    dec    %edx
+    xchg   %edx,%ecx
+    jmp    _make_fcontext+0x42 // <_make_fcontext+0x42>
+    mov    0x4(%ecx),%ecx
+    mov    0x10(%eax),%edx
+    mov    %ecx,0x18(%edx)
+    mov    $0xffffffff,%ecx
+    mov    %ecx,0x14(%edx)
+    lea    0x14(%edx),%ecx
+    mov    %ecx,0x24(%eax)
+    ret
 
 finish:
     xor    %eax,%eax

common/tool/context_menu.cpp

@@ -31,14 +31,14 @@
 CONTEXT_MENU::CONTEXT_MENU() :
     m_titleSet( false ), m_handler( this ), m_tool( NULL )
 {
-	m_menu.Connect( wxEVT_MENU_HIGHLIGHT, wxEventHandler( CMEventHandler::onEvent ),
-	                 NULL, &m_handler );
-	m_menu.Connect( wxEVT_COMMAND_MENU_SELECTED, wxEventHandler( CMEventHandler::onEvent ),
-	                 NULL, &m_handler );
-
-	// Workaround for the case when mouse cursor never reaches menu (it hangs up tools using menu)
-	wxMenuEvent menuEvent( wxEVT_MENU_HIGHLIGHT, -1, &m_menu );
-	m_menu.AddPendingEvent( menuEvent );
+    m_menu.Connect( wxEVT_MENU_HIGHLIGHT, wxEventHandler( CMEventHandler::onEvent ),
+                     NULL, &m_handler );
+    m_menu.Connect( wxEVT_COMMAND_MENU_SELECTED, wxEventHandler( CMEventHandler::onEvent ),
+                     NULL, &m_handler );
+
+    // Workaround for the case when mouse cursor never reaches menu (it hangs up tools using menu)
+    wxMenuEvent menuEvent( wxEVT_MENU_HIGHLIGHT, -1, &m_menu );
+    m_menu.AddPendingEvent( menuEvent );
 }
 
 
@@ -72,16 +72,16 @@ void CONTEXT_MENU::SetTitle( const wxString& aTitle )
     // TODO handle an empty string (remove title and separator)
 
     // Unfortunately wxMenu::SetTitle() does nothing..
-	if( m_titleSet )
-	{
+    if( m_titleSet )
+    {
         m_menu.FindItemByPosition( 0 )->SetItemLabel( aTitle );
-	}
-	else
-	{
+    }
+    else
+    {
         m_menu.InsertSeparator( 0 );
         m_menu.Insert( 0, new wxMenuItem( &m_menu, -1, aTitle, wxEmptyString, wxITEM_NORMAL ) );
         m_titleSet = true;
-	}
+    }
 }
 
 
@@ -92,7 +92,7 @@ void CONTEXT_MENU::Add( const wxString& aLabel, int aId )
         wxLogWarning( wxT( "Adding more than one menu entry with the same ID may result in"
                 "undefined behaviour" ) );
 #endif
-	m_menu.Append( new wxMenuItem( &m_menu, aId, aLabel, wxEmptyString, wxITEM_NORMAL ) );
+    m_menu.Append( new wxMenuItem( &m_menu, aId, aLabel, wxEmptyString, wxITEM_NORMAL ) );
 }
 
 
@@ -104,7 +104,7 @@ void CONTEXT_MENU::Add( const TOOL_ACTION& aAction )
 
     if( aAction.HasHotKey() )
         menuEntry = wxString( ( aAction.GetMenuItem() + '\t' + getHotKeyDescription( aAction ) ).c_str(),
-        				      wxConvUTF8 );
+                              wxConvUTF8 );
     else
         menuEntry = wxString( aAction.GetMenuItem().c_str(), wxConvUTF8 );
 
@@ -117,13 +117,13 @@ void CONTEXT_MENU::Add( const TOOL_ACTION& aAction )
 
 void CONTEXT_MENU::Clear()
 {
-	m_titleSet = false;
+    m_titleSet = false;
 
-	// Remove all the entries from context menu
-	for( unsigned i = 0; i < m_menu.GetMenuItemCount(); ++i )
-	    m_menu.Destroy( m_menu.FindItemByPosition( 0 ) );
+    // Remove all the entries from context menu
+    for( unsigned i = 0; i < m_menu.GetMenuItemCount(); ++i )
+        m_menu.Destroy( m_menu.FindItemByPosition( 0 ) );
 
-	m_toolActions.clear();
+    m_toolActions.clear();
 }
 
 

common/tool/tool_base.cpp

@@ -27,23 +27,23 @@
 
 KiGfx::VIEW* TOOL_BASE::getView() const
 {
-	return m_toolMgr->GetView();
+    return m_toolMgr->GetView();
 }
 
 
 KiGfx::VIEW_CONTROLS* TOOL_BASE::getViewControls() const
-{	
-	return m_toolMgr->GetViewControls();
+{
+    return m_toolMgr->GetViewControls();
 }
 
 
 wxWindow* TOOL_BASE::getEditFrameInt() const
 {
-	return m_toolMgr->GetEditFrame();
+    return m_toolMgr->GetEditFrame();
 }
 
 
 EDA_ITEM* TOOL_BASE::getModelInt() const
 {
-	return m_toolMgr->GetModel();
+    return m_toolMgr->GetModel();
 }

common/tool/tool_event.cpp

@@ -35,22 +35,22 @@ using namespace std;
 
 struct FlagString
 {
-	int flag;		
-	std::string str;
+    int flag;
+    std::string str;
 };
 
 
 static const std::string flag2string( int flag, const FlagString* exps )
 {
-	std::string rv;
+    std::string rv;
 
-	for( int i = 0; exps[i].str.length(); i++ )
-	{
-		if( exps[i].flag & flag )
-			rv += exps[i].str + " ";
-	}
+    for( int i = 0; exps[i].str.length(); i++ )
+    {
+        if( exps[i].flag & flag )
+            rv += exps[i].str + " ";
+    }
 
-	return rv;
+    return rv;
 }
 
 
@@ -62,97 +62,97 @@ bool TOOL_EVENT::IsAction( const TOOL_ACTION* aAction ) const
 
 const std::string TOOL_EVENT::Format() const
 {
-	std::string ev;
-
-	const FlagString categories[] = {
-		{ TC_Mouse, "mouse" },
-		{ TC_Keyboard, "keyboard" },
-		{ TC_Command, "command" },
-		{ TC_Message, "message" },
-		{ TC_View, "view" },
-		{ 0, "" }
-	};
-
-	const FlagString actions[] = {
-		{ TA_MouseClick, "click" },
-		{ TA_MouseUp, "button-up" },
-		{ TA_MouseDown, "button-down" },
-		{ TA_MouseDrag, "drag" },
-		{ TA_MouseMotion, "motion" },
-		{ TA_MouseWheel, "wheel" },
-		{ TA_KeyUp, "key-up" },
-		{ TA_KeyDown, "key-down" },
-		{ TA_ViewRefresh, "view-refresh" },
-		{ TA_ViewZoom, "view-zoom" },
-		{ TA_ViewPan, "view-pan" },
-		{ TA_ViewDirty, "view-dirty" },
-		{ TA_ChangeLayer, "change-layer" },
-		{ TA_CancelTool, "cancel-tool" },
-		{ TA_ContextMenuUpdate, "context-menu-update" },
-		{ TA_ContextMenuChoice, "context-menu-choice" },
-		{ TA_Action, "action" },
-		{ 0, "" }
-	};
-
-	const FlagString buttons[] = {
-		{ MB_None, "none" },
-		{ MB_Left, "left" },
-		{ MB_Right, "right" },
-		{ MB_Middle, "middle" },
-		{ 0, "" }
-	};
-
-	const FlagString modifiers[] = {
+    std::string ev;
+
+    const FlagString categories[] = {
+        { TC_Mouse, "mouse" },
+        { TC_Keyboard, "keyboard" },
+        { TC_Command, "command" },
+        { TC_Message, "message" },
+        { TC_View, "view" },
+        { 0, "" }
+    };
+
+    const FlagString actions[] = {
+        { TA_MouseClick, "click" },
+        { TA_MouseUp, "button-up" },
+        { TA_MouseDown, "button-down" },
+        { TA_MouseDrag, "drag" },
+        { TA_MouseMotion, "motion" },
+        { TA_MouseWheel, "wheel" },
+        { TA_KeyUp, "key-up" },
+        { TA_KeyDown, "key-down" },
+        { TA_ViewRefresh, "view-refresh" },
+        { TA_ViewZoom, "view-zoom" },
+        { TA_ViewPan, "view-pan" },
+        { TA_ViewDirty, "view-dirty" },
+        { TA_ChangeLayer, "change-layer" },
+        { TA_CancelTool, "cancel-tool" },
+        { TA_ContextMenuUpdate, "context-menu-update" },
+        { TA_ContextMenuChoice, "context-menu-choice" },
+        { TA_Action, "action" },
+        { 0, "" }
+    };
+
+    const FlagString buttons[] = {
+        { MB_None, "none" },
+        { MB_Left, "left" },
+        { MB_Right, "right" },
+        { MB_Middle, "middle" },
+        { 0, "" }
+    };
+
+    const FlagString modifiers[] = {
         { MD_ModShift, "shift" },
         { MD_ModCtrl, "ctrl" },
         { MD_ModAlt, "alt" },
         { 0, "" }
-	};
-
-	ev = "category: ";
-	ev += flag2string( m_category, categories );
-	ev += " action: ";
-	ev += flag2string( m_actions, actions );
-	
-	if( m_actions & TA_Mouse )
-	{
-		ev += " btns: ";
-		ev += flag2string( m_mouseButtons, buttons );
-	}
-
-	if( m_actions & TA_Keyboard )
-	{
+    };
+
+    ev = "category: ";
+    ev += flag2string( m_category, categories );
+    ev += " action: ";
+    ev += flag2string( m_actions, actions );
+
+    if( m_actions & TA_Mouse )
+    {
+        ev += " btns: ";
+        ev += flag2string( m_mouseButtons, buttons );
+    }
+
+    if( m_actions & TA_Keyboard )
+    {
         char tmp[128];
         sprintf( tmp, "key: %d", m_keyCode );
         ev += tmp;
-	}
-	
-	if( m_actions & ( TA_Mouse | TA_Keyboard ) )
-	{
-	    ev += " mods: ";
-	    ev += flag2string( m_modifiers, modifiers );
-	}
-
-	if( m_commandId )
-	{
-		char tmp[128];
-		sprintf( tmp, "cmd-id: %d", *m_commandId );
-		ev += tmp;
-	}
-
-	if( m_commandStr )
-		ev += "cmd-str: " + ( *m_commandStr );
-		
-	return ev;
+    }
+
+    if( m_actions & ( TA_Mouse | TA_Keyboard ) )
+    {
+        ev += " mods: ";
+        ev += flag2string( m_modifiers, modifiers );
+    }
+
+    if( m_commandId )
+    {
+        char tmp[128];
+        sprintf( tmp, "cmd-id: %d", *m_commandId );
+        ev += tmp;
+    }
+
+    if( m_commandStr )
+        ev += "cmd-str: " + ( *m_commandStr );
+
+    return ev;
 }
 
 
 const std::string TOOL_EVENT_LIST::Format() const
 {
-	string s;
+    string s;
+
+    BOOST_FOREACH( TOOL_EVENT e, m_events )
+        s += e.Format() + " ";
 
-	BOOST_FOREACH( TOOL_EVENT e, m_events )
-		s += e.Format() + " ";
-	
-	return s;
+    return s;
 }

common/tool/tool_interactive.cpp

@@ -30,13 +30,13 @@
 #include <tool/context_menu.h>
 
 TOOL_INTERACTIVE::TOOL_INTERACTIVE( TOOL_ID aId, const std::string& aName ) :
-	TOOL_BASE( TOOL_Interactive, aId, aName )
-	{};
+    TOOL_BASE( TOOL_Interactive, aId, aName )
+    {};
 
 
 TOOL_INTERACTIVE::TOOL_INTERACTIVE( const std::string& aName ) :
-	TOOL_BASE( TOOL_Interactive, TOOL_MANAGER::MakeToolId( aName ), aName )
-	{};
+    TOOL_BASE( TOOL_Interactive, TOOL_MANAGER::MakeToolId( aName ), aName )
+    {};
 
 
 TOOL_INTERACTIVE::~TOOL_INTERACTIVE()
@@ -46,18 +46,18 @@ TOOL_INTERACTIVE::~TOOL_INTERACTIVE()
 
 OPT_TOOL_EVENT TOOL_INTERACTIVE::Wait( const TOOL_EVENT_LIST& aEventList )
 {
-	return m_toolMgr->ScheduleWait( this, aEventList );
+    return m_toolMgr->ScheduleWait( this, aEventList );
 }
 
 
 void TOOL_INTERACTIVE::goInternal( TOOL_STATE_FUNC& aState, const TOOL_EVENT_LIST& aConditions )
 {
-	m_toolMgr->ScheduleNextState( this, aState, aConditions );
+    m_toolMgr->ScheduleNextState( this, aState, aConditions );
 }
 
 
 void TOOL_INTERACTIVE::SetContextMenu( CONTEXT_MENU* aMenu, CONTEXT_MENU_TRIGGER aTrigger )
 {
-	aMenu->setTool( this );
-	m_toolMgr->ScheduleContextMenu( this, aMenu, aTrigger );
+    aMenu->setTool( this );
+    m_toolMgr->ScheduleContextMenu( this, aMenu, aTrigger );
 }

include/class_drawpanel_gal.h

@@ -87,7 +87,7 @@ public:
     {
         return m_view;
     }
-    
+
     /**
      * Function GetViewControls()
      * Returns a pointer to the VIEW_CONTROLS instance used in the panel.

include/gal/color4d.h

@@ -131,7 +131,7 @@ public:
      * Saturates the color to a given factor (in HSV model)
      */
     COLOR4D& Saturate( double aFactor );
-    
+
     /**
      * Function Brightened
      * Returns a color that is brighter by a given factor, without modifying object.

include/gal/opengl/shader.h

@@ -172,11 +172,11 @@ private:
     void programInfo( GLuint aProgram );
 
     /**
-	 * @brief Get the shader information.
-	 *
-	 * @param aShader is the shader number.
-	 */
-	void shaderInfo( GLuint aShader );
+     * @brief Get the shader information.
+     *
+     * @param aShader is the shader number.
+     */
+    void shaderInfo( GLuint aShader );
 
     /**
      * @brief Read the shader source file

include/geometry/shape.h

@@ -36,109 +36,109 @@
  */
 
 enum ShapeType {
-	SH_RECT = 0, 	///> axis-aligned rectangle
-	SH_SEGMENT,		///> line segment
-	SH_LINE_CHAIN,	///> line chain (polyline)
-	SH_CIRCLE		///> circle
+    SH_RECT = 0,     ///> axis-aligned rectangle
+    SH_SEGMENT,        ///> line segment
+    SH_LINE_CHAIN,    ///> line chain (polyline)
+    SH_CIRCLE        ///> circle
 };
 
 /**
  * Class SHAPE
- * 
+ *
  * Represents an abstract shape on 2D plane.
- */	
+ */
 class SHAPE {
-	protected:
-		typedef VECTOR2I::extended_type ecoord;
-
-	public:
-		/**
-		 * Constructor
-		 *
-		 * Creates an empty shape of type aType
-		 */
-
-		SHAPE ( ShapeType aType ) : m_type( aType ) { };
-		
-		// Destructor
-		virtual ~SHAPE() {};
-
-		/**
-		 * Function Type()
-		 *
-		 * Returns the type of the shape.
-		 * @retval the type
-		 */
-		ShapeType Type() const { return m_type; }
-
-		/**
-		 * Function Clone()
-		 *
-		 * Returns a dynamically allocated copy of the shape
-		 * @retval copy of the shape
-		 */
-		virtual SHAPE* Clone() const { 
-			assert( false );
-			return NULL; 
-		};
-
-		/**
-		 * Function Collide()
-		 *
-		 * Checks if the boundary of shape (this) lies closer to the point aP than aClearance, indicating
-		 * a collision.
-		 * @return true, if there is a collision.
-		 */
-		virtual bool Collide( const VECTOR2I& aP, int aClearance = 0 ) const
-		{
-			return Collide( SEG( aP, aP ), aClearance );
-		}
-		
-		/**
-		 * Function Collide()
-		 *
-		 * Checks if the boundary of shape (this) lies closer to the shape aShape than aClearance, indicating
-		 * a collision.
-		 * @param aShape shape to check collision against
-		 * @param aClearance minimum clearance
-		 * @param aMTV minimum translation vector
-		 * @return true, if there is a collision.
-		 */
-		virtual bool Collide( const SHAPE* aShape, int aClerance, VECTOR2I& aMTV ) const;
-		virtual bool Collide( const SHAPE* aShape, int aClerance = 0 ) const;
-		/**
-		 * Function Collide()
-		 *
-		 * Checks if the boundary of shape (this) lies closer to the segment aSeg than aClearance, indicating
-		 * a collision.
-		 * @return true, if there is a collision.
-		 */
-		virtual bool Collide( const SEG& aSeg, int aClearance = 0 ) const = 0;
-	
-		/**
-		 * Function Collide()
-		 *
-		 * Computes a bounding box of the shape, with a margin of aClearance
-		 * a collision.
-		 * @aClearance how much the bounding box is expanded wrs to the minimum enclosing rectangle for the shape.
-		 * @return the bounding box.
-		 */
-		virtual const BOX2I BBox( int aClearance = 0 ) const = 0;
-
-		/**
-		 * Function Centre()
-		 *
-		 * Computes a center-of-mass of the shape
-		 * @return the center-of-mass point
-		 */
-		virtual VECTOR2I Centre() const
-		{
-			return BBox( 0 ).Centre(); // if nothing better is available....
-		}
-
-	private:
-		///> type of our shape
-		ShapeType m_type;
+    protected:
+        typedef VECTOR2I::extended_type ecoord;
+
+    public:
+        /**
+         * Constructor
+         *
+         * Creates an empty shape of type aType
+         */
+
+        SHAPE ( ShapeType aType ) : m_type( aType ) { };
+
+        // Destructor
+        virtual ~SHAPE() {};
+
+        /**
+         * Function Type()
+         *
+         * Returns the type of the shape.
+         * @retval the type
+         */
+        ShapeType Type() const { return m_type; }
+
+        /**
+         * Function Clone()
+         *
+         * Returns a dynamically allocated copy of the shape
+         * @retval copy of the shape
+         */
+        virtual SHAPE* Clone() const {
+            assert( false );
+            return NULL;
+        };
+
+        /**
+         * Function Collide()
+         *
+         * Checks if the boundary of shape (this) lies closer to the point aP than aClearance, indicating
+         * a collision.
+         * @return true, if there is a collision.
+         */
+        virtual bool Collide( const VECTOR2I& aP, int aClearance = 0 ) const
+        {
+            return Collide( SEG( aP, aP ), aClearance );
+        }
+
+        /**
+         * Function Collide()
+         *
+         * Checks if the boundary of shape (this) lies closer to the shape aShape than aClearance, indicating
+         * a collision.
+         * @param aShape shape to check collision against
+         * @param aClearance minimum clearance
+         * @param aMTV minimum translation vector
+         * @return true, if there is a collision.
+         */
+        virtual bool Collide( const SHAPE* aShape, int aClerance, VECTOR2I& aMTV ) const;
+        virtual bool Collide( const SHAPE* aShape, int aClerance = 0 ) const;
+        /**
+         * Function Collide()
+         *
+         * Checks if the boundary of shape (this) lies closer to the segment aSeg than aClearance, indicating
+         * a collision.
+         * @return true, if there is a collision.
+         */
+        virtual bool Collide( const SEG& aSeg, int aClearance = 0 ) const = 0;
+
+        /**
+         * Function Collide()
+         *
+         * Computes a bounding box of the shape, with a margin of aClearance
+         * a collision.
+         * @aClearance how much the bounding box is expanded wrs to the minimum enclosing rectangle for the shape.
+         * @return the bounding box.
+         */
+        virtual const BOX2I BBox( int aClearance = 0 ) const = 0;
+
+        /**
+         * Function Centre()
+         *
+         * Computes a center-of-mass of the shape
+         * @return the center-of-mass point
+         */
+        virtual VECTOR2I Centre() const
+        {
+            return BBox( 0 ).Centre(); // if nothing better is available....
+        }
+
+    private:
+        ///> type of our shape
+        ShapeType m_type;
 
 };
 

include/geometry/shape_circle.h

@@ -30,48 +30,48 @@
 class SHAPE_CIRCLE : public SHAPE {
 
 public:
-	SHAPE_CIRCLE(): 
-		SHAPE( SH_CIRCLE ), m_radius( 0 ) {};
-			
-	SHAPE_CIRCLE( const VECTOR2I& aCenter, int aRadius ): 
-		SHAPE( SH_CIRCLE ), m_radius( aRadius ), m_center( aCenter ) {};
+    SHAPE_CIRCLE():
+        SHAPE( SH_CIRCLE ), m_radius( 0 ) {};
 
-	~SHAPE_CIRCLE() {};
+    SHAPE_CIRCLE( const VECTOR2I& aCenter, int aRadius ):
+        SHAPE( SH_CIRCLE ), m_radius( aRadius ), m_center( aCenter ) {};
 
-	const BOX2I BBox( int aClearance = 0 ) const
-	{
-		const VECTOR2I rc( m_radius + aClearance, m_radius + aClearance );
-		return BOX2I( m_center - rc, rc * 2 );
-	}
+    ~SHAPE_CIRCLE() {};
 
-	bool Collide( const SEG& aSeg, int aClearance = 0 ) const
-	{
-		int rc = aClearance + m_radius;
-		return aSeg.Distance( m_center ) <= rc;
-	}
+    const BOX2I BBox( int aClearance = 0 ) const
+    {
+        const VECTOR2I rc( m_radius + aClearance, m_radius + aClearance );
+        return BOX2I( m_center - rc, rc * 2 );
+    }
 
-	void SetRadius( int aRadius )
-	{
-		m_radius = aRadius;
-	}
+    bool Collide( const SEG& aSeg, int aClearance = 0 ) const
+    {
+        int rc = aClearance + m_radius;
+        return aSeg.Distance( m_center ) <= rc;
+    }
 
-	void SetCenter( const VECTOR2I& aCenter )
-	{
-		m_center = aCenter;
-	}
+    void SetRadius( int aRadius )
+    {
+        m_radius = aRadius;
+    }
 
-	int GetRadius() const 
-	{
-		return m_radius;
-	}
+    void SetCenter( const VECTOR2I& aCenter )
+    {
+        m_center = aCenter;
+    }
 
-	const VECTOR2I GetCenter() const
-	{
-		return m_center;
-	}
+    int GetRadius() const
+    {
+        return m_radius;
+    }
+
+    const VECTOR2I GetCenter() const
+    {
+        return m_center;
+    }
 private:
-	int m_radius;
-	VECTOR2I m_center;
+    int m_radius;
+    VECTOR2I m_center;
 };
 
 #endif

include/geometry/shape_index.h

@@ -276,11 +276,11 @@ class SHAPE_INDEX
         {
             BOX2I box = aShape->BBox();
             box.Inflate( aMinDistance );
-         
-			int min[2] = { box.GetX(), 		box.GetY() };
-            int max[2] = { box.GetRight(), 	box.GetBottom() };
 
-			return this->m_tree->Search( min, max, aVisitor );
+            int min[2] = { box.GetX(),         box.GetY() };
+            int max[2] = { box.GetRight(),     box.GetBottom() };
+
+            return this->m_tree->Search( min, max, aVisitor );
         }
 
         /**

include/geometry/shape_index_list.h

@@ -29,205 +29,205 @@
 
 template <class T> const SHAPE* defaultShapeFunctor( const T aItem )
 {
-	return aItem->GetShape();
+    return aItem->GetShape();
 }
 
 template <class T, const SHAPE* (ShapeFunctor)(const T) = defaultShapeFunctor<T> >
 
 class SHAPE_INDEX_LIST {
-	
-	struct ShapeEntry {
-		ShapeEntry( T aParent )
-		{
-			shape = ShapeFunctor( aParent );
-			bbox = shape->BBox( 0 );
-			parent = aParent;
-		}
-
-		~ShapeEntry()
-		{
-		}
-
-		T parent;
-		const SHAPE* shape;
-		BOX2I bbox;
-	};
-
-	typedef std::vector<ShapeEntry> ShapeVec;
-	typedef typename std::vector<ShapeEntry>::iterator ShapeVecIter;	
-	
+
+    struct ShapeEntry {
+        ShapeEntry( T aParent )
+        {
+            shape = ShapeFunctor( aParent );
+            bbox = shape->BBox( 0 );
+            parent = aParent;
+        }
+
+        ~ShapeEntry()
+        {
+        }
+
+        T parent;
+        const SHAPE* shape;
+        BOX2I bbox;
+    };
+
+    typedef std::vector<ShapeEntry> ShapeVec;
+    typedef typename std::vector<ShapeEntry>::iterator ShapeVecIter;
+
 public:
-	// "Normal" iterator interface, for STL algorithms.
-	class iterator {
-		public:
-			iterator() {};
-
-			iterator( ShapeVecIter aCurrent )
-				: m_current( aCurrent ) {};
-
-			iterator( const iterator &aB ) :
-				m_current( aB.m_current ) {};
-
-			T operator*() const
-			{
-				return (*m_current).parent;
-			}
-
-			void operator++()
-			{
-				++m_current;
-			}
-
-			iterator& operator++( int aDummy )
-			{
-				++m_current;
-				return *this;
-			}
-
-			bool operator==( const iterator& aRhs ) const
-			{
-				return m_current == aRhs.m_current;
-			}
-
-			bool operator!=( const iterator& aRhs ) const
-			{
-				return m_current != aRhs.m_current;
-			}
-
-			const iterator& operator=( const iterator& aRhs )
-			{
-				m_current = aRhs.m_current;
-				return *this;
-			}
-
-		private:
-			ShapeVecIter m_current;
-	};
-
-	// "Query" iterator, for iterating over a set of spatially matching shapes.
-	class query_iterator {
-		public:
-			query_iterator()
-			{
-			}
-
-			query_iterator( ShapeVecIter aCurrent, ShapeVecIter aEnd, SHAPE* aShape,
-			                int aMinDistance, bool aExact ) :
-				  m_end( aEnd ),
-				  m_current( aCurrent ),
-				  m_shape( aShape ),
-				  m_minDistance( aMinDistance ),
-				  m_exact( aExact )
-			{
-				if( aShape )
-				{
-					m_refBBox = aShape->BBox();
-					next();
-				}
-			}
-
-			query_iterator( const query_iterator &aB ) :
-				  m_end( aB.m_end ),
-				  m_current( aB.m_current ),
-				  m_shape( aB.m_shape ),
-				  m_minDistance( aB.m_minDistance ),
-				  m_exact( aB.m_exact ),
-				  m_refBBox( aB.m_refBBox )
-			{
-			}
-			
-			T operator*() const
-			{
-				return (*m_current).parent;
-			}
-
-			query_iterator& operator++()
-			{
-				++m_current;
-				next();
-			 	return *this;
-			}
-
-			query_iterator& operator++( int aDummy )
-			{
-				++m_current;
-				next();
-				return *this;
-			}
-
-			bool operator==( const query_iterator& aRhs ) const
-			{
-				return m_current == aRhs.m_current;
-			}
-
-			bool operator!=( const query_iterator& aRhs ) const
-			{
-				return m_current != aRhs.m_current;
-			}
-
-			const query_iterator& operator=( const query_iterator& aRhs )
-			{
-				m_end = aRhs.m_end;
-				m_current = aRhs.m_current;
-				m_shape = aRhs.m_shape;
-				m_minDistance = aRhs.m_minDistance;
-				m_exact = aRhs.m_exact;
-				m_refBBox = aRhs.m_refBBox;
-				return *this;
-			}
-
-		private:
-			void next()
-			{
-				while( m_current != m_end )
-				{
-					if( m_refBBox.Distance( m_current->bbox ) <= m_minDistance )
-					{
-						if( !m_exact || m_current->shape->Collide( m_shape, m_minDistance ) )
-							return;
-					}
-
-					++m_current;
-				}
-			}
-
-			ShapeVecIter m_end;
-			ShapeVecIter m_current;
-			BOX2I m_refBBox;
-			bool m_exact;
-			SHAPE *m_shape;
-			int m_minDistance;
-	};
-
-	void Add( T aItem )
-	{
-		ShapeEntry s( aItem );
-
-		m_shapes.push_back(s);
-	}
-	
-	void Remove( const T aItem )
-	{
-		ShapeVecIter i;
-		
-		for( i = m_shapes.begin(); i != m_shapes.end(); ++i )
-		{
-			if( i->parent == aItem )
-				break;
-		}
-
-		if( i == m_shapes.end() )
-			return;
-
-		m_shapes.erase( i );
-	}
-
-	int Size() const
-	{
-		return m_shapes.size();
-	}
-
-	template<class Visitor>
+    // "Normal" iterator interface, for STL algorithms.
+    class iterator {
+        public:
+            iterator() {};
+
+            iterator( ShapeVecIter aCurrent )
+                : m_current( aCurrent ) {};
+
+            iterator( const iterator &aB ) :
+                m_current( aB.m_current ) {};
+
+            T operator*() const
+            {
+                return (*m_current).parent;
+            }
+
+            void operator++()
+            {
+                ++m_current;
+            }
+
+            iterator& operator++( int aDummy )
+            {
+                ++m_current;
+                return *this;
+            }
+
+            bool operator==( const iterator& aRhs ) const
+            {
+                return m_current == aRhs.m_current;
+            }
+
+            bool operator!=( const iterator& aRhs ) const
+            {
+                return m_current != aRhs.m_current;
+            }
+
+            const iterator& operator=( const iterator& aRhs )
+            {
+                m_current = aRhs.m_current;
+                return *this;
+            }
+
+        private:
+            ShapeVecIter m_current;
+    };
+
+    // "Query" iterator, for iterating over a set of spatially matching shapes.
+    class query_iterator {
+        public:
+            query_iterator()
+            {
+            }
+
+            query_iterator( ShapeVecIter aCurrent, ShapeVecIter aEnd, SHAPE* aShape,
+                            int aMinDistance, bool aExact ) :
+                  m_end( aEnd ),
+                  m_current( aCurrent ),
+                  m_shape( aShape ),
+                  m_minDistance( aMinDistance ),
+                  m_exact( aExact )
+            {
+                if( aShape )
+                {
+                    m_refBBox = aShape->BBox();
+                    next();
+                }
+            }
+
+            query_iterator( const query_iterator &aB ) :
+                  m_end( aB.m_end ),
+                  m_current( aB.m_current ),
+                  m_shape( aB.m_shape ),
+                  m_minDistance( aB.m_minDistance ),
+                  m_exact( aB.m_exact ),
+                  m_refBBox( aB.m_refBBox )
+            {
+            }
+
+            T operator*() const
+            {
+                return (*m_current).parent;
+            }
+
+            query_iterator& operator++()
+            {
+                ++m_current;
+                next();
+                 return *this;
+            }
+
+            query_iterator& operator++( int aDummy )
+            {
+                ++m_current;
+                next();
+                return *this;
+            }
+
+            bool operator==( const query_iterator& aRhs ) const
+            {
+                return m_current == aRhs.m_current;
+            }
+
+            bool operator!=( const query_iterator& aRhs ) const
+            {
+                return m_current != aRhs.m_current;
+            }
+
+            const query_iterator& operator=( const query_iterator& aRhs )
+            {
+                m_end = aRhs.m_end;
+                m_current = aRhs.m_current;
+                m_shape = aRhs.m_shape;
+                m_minDistance = aRhs.m_minDistance;
+                m_exact = aRhs.m_exact;
+                m_refBBox = aRhs.m_refBBox;
+                return *this;
+            }
+
+        private:
+            void next()
+            {
+                while( m_current != m_end )
+                {
+                    if( m_refBBox.Distance( m_current->bbox ) <= m_minDistance )
+                    {
+                        if( !m_exact || m_current->shape->Collide( m_shape, m_minDistance ) )
+                            return;
+                    }
+
+                    ++m_current;
+                }
+            }
+
+            ShapeVecIter m_end;
+            ShapeVecIter m_current;
+            BOX2I m_refBBox;
+            bool m_exact;
+            SHAPE *m_shape;
+            int m_minDistance;
+    };
+
+    void Add( T aItem )
+    {
+        ShapeEntry s( aItem );
+
+        m_shapes.push_back(s);
+    }
+
+    void Remove( const T aItem )
+    {
+        ShapeVecIter i;
+
+        for( i = m_shapes.begin(); i != m_shapes.end(); ++i )
+        {
+            if( i->parent == aItem )
+                break;
+        }
+
+        if( i == m_shapes.end() )
+            return;
+
+        m_shapes.erase( i );
+    }
+
+    int Size() const
+    {
+        return m_shapes.size();
+    }
+
+    template<class Visitor>
     int Query( const SHAPE *aShape, int aMinDistance, Visitor &aV, bool aExact = true ) //const
     {
         ShapeVecIter i;
@@ -251,33 +251,33 @@ public:
         return n;
     }
 
-	void Clear()
-	{
-		m_shapes.clear();
-	}
-	
-	query_iterator qbegin( SHAPE* aShape, int aMinDistance, bool aExact )
-	{
-		return query_iterator( m_shapes.begin(), m_shapes.end(), aShape, aMinDistance, aExact );
-	}
-
-	const query_iterator qend() 
-	{
-			return query_iterator( m_shapes.end(), m_shapes.end(), NULL, 0, false );
-	}
-
-	iterator begin()
-	{
-		return iterator( m_shapes.begin() );
-	}
-
-	iterator end()
-	{
-		return iterator( m_shapes.end() );
-	}
+    void Clear()
+    {
+        m_shapes.clear();
+    }
+
+    query_iterator qbegin( SHAPE* aShape, int aMinDistance, bool aExact )
+    {
+        return query_iterator( m_shapes.begin(), m_shapes.end(), aShape, aMinDistance, aExact );
+    }
+
+    const query_iterator qend()
+    {
+            return query_iterator( m_shapes.end(), m_shapes.end(), NULL, 0, false );
+    }
+
+    iterator begin()
+    {
+        return iterator( m_shapes.begin() );
+    }
+
+    iterator end()
+    {
+        return iterator( m_shapes.end() );
+    }
 
 private:
-	ShapeVec m_shapes;
+    ShapeVec m_shapes;
 };
 
 #endif

include/geometry/shape_rect.h

@@ -31,114 +31,114 @@
 #include <geometry/seg.h>
 
 class SHAPE_RECT : public SHAPE {
-	public:
-		/**
-		 * Constructor
-		 * Creates an empty (0-sized) rectangle
-		 */
-		SHAPE_RECT() :
-			SHAPE( SH_RECT ), m_w( 0 ), m_h( 0 ) {};
-			
-		/**
-		 * Constructor
-		 * Creates a rectangle defined by top-left corner (aX0, aY0), width aW and height aH.
-		 */
-		SHAPE_RECT( int aX0, int aY0, int aW, int aH ) :
-			SHAPE( SH_RECT ), m_p0( aX0, aY0 ), m_w( aW ), m_h( aH ) {};
-
-		/**
-		 * Constructor
-		 * Creates a rectangle defined by top-left corner aP0, width aW and height aH.
-		 */
-		 SHAPE_RECT( const VECTOR2I &aP0, int aW, int aH ) :
-			SHAPE( SH_RECT ), m_p0( aP0 ), m_w( aW ), m_h( aH ) {};
-
-		/// @copydoc SHAPE::BBox()
-		const BOX2I BBox(int aClearance = 0) const
-		{
-			BOX2I bbox( VECTOR2I( m_p0.x - aClearance, m_p0.y - aClearance ),
-						  VECTOR2I( m_w + 2 * aClearance, m_h + 2 * aClearance ) );
-			//printf("bb : %s\n",bbox.Format().c_str());
-			return bbox;
-		}
-
-		/**
-		 * Function Diagonal()
-		 * 
-		 * Returns length of the diagonal of the rectangle
-		 * @return diagonal length
-		 */
-		int Diagonal() const
-		{
-			return VECTOR2I( m_w, m_h ).EuclideanNorm();
-		}
-
-		/// @copydoc SHAPE::Collide()
-		bool Collide( const SEG& aSeg, int aClearance = 0 ) const
-		{
-			//VECTOR2I pmin = VECTOR2I(std::min(aSeg.a.x, aSeg.b.x), std::min(aSeg.a.y, aSeg.b.y));
-			//VECTOR2I pmax = VECTOR2I(std::max(aSeg.a.x, aSeg.b.x), std::max(aSeg.a.y, aSeg.b.y));
-			//BOX2I r(pmin, VECTOR2I(pmax.x - pmin.x, pmax.y - pmin.y));
-
-			//if (BBox(0).SquaredDistance(r) > aClearance * aClearance)
-			//	return false;
-	
-			if( BBox( 0 ).Contains( aSeg.a ) || BBox( 0 ).Contains( aSeg.b ) )
-				return true;
-
- 			VECTOR2I vts[] = { 	VECTOR2I( m_p0.x, m_p0.y ),
-								VECTOR2I( m_p0.x, m_p0.y + m_h ),
-								VECTOR2I( m_p0.x + m_w, m_p0.y + m_h ),
-								VECTOR2I( m_p0.x + m_w, m_p0.y ),
-								VECTOR2I( m_p0.x, m_p0.y ) };
-
-			for( int i = 0; i < 4; i++ )
-			{
-				SEG s( vts[i], vts[i + 1], i );
-				if( s.Distance( aSeg ) <= aClearance )
-					return true;
-			}
-			
-			return false;
-		};
-
-		/**
-		 * Function GetPosition()
-		 * 
-		 * @return top-left corner of the rectangle
-		 */
-		const VECTOR2I& GetPosition() const { return m_p0; }
-		
-		/**
-		 * Function GetSize()
-		 * 
-		 * @return size of the rectangle
-		 */
-		const VECTOR2I GetSize() const { return VECTOR2I( m_w, m_h ); }
-
-		/**
-		 * Function GetWidth()
-		 * 
-		 * @return width of the rectangle
-		 */
- 		const int GetWidth() const { return m_w; }
-
-		/**
-		 * Function GetHeight()
-		 * 
-		 * @return height of the rectangle
-		 */
-		const int GetHeight() const { return m_h; }
-
-	private:
-		///> Top-left corner
-		VECTOR2I m_p0;
-
-		///> Width
-		int m_w;
-
-		///> Height
-		int m_h;
-	};
+    public:
+        /**
+         * Constructor
+         * Creates an empty (0-sized) rectangle
+         */
+        SHAPE_RECT() :
+            SHAPE( SH_RECT ), m_w( 0 ), m_h( 0 ) {};
+
+        /**
+         * Constructor
+         * Creates a rectangle defined by top-left corner (aX0, aY0), width aW and height aH.
+         */
+        SHAPE_RECT( int aX0, int aY0, int aW, int aH ) :
+            SHAPE( SH_RECT ), m_p0( aX0, aY0 ), m_w( aW ), m_h( aH ) {};
+
+        /**
+         * Constructor
+         * Creates a rectangle defined by top-left corner aP0, width aW and height aH.
+         */
+         SHAPE_RECT( const VECTOR2I &aP0, int aW, int aH ) :
+            SHAPE( SH_RECT ), m_p0( aP0 ), m_w( aW ), m_h( aH ) {};
+
+        /// @copydoc SHAPE::BBox()
+        const BOX2I BBox(int aClearance = 0) const
+        {
+            BOX2I bbox( VECTOR2I( m_p0.x - aClearance, m_p0.y - aClearance ),
+                          VECTOR2I( m_w + 2 * aClearance, m_h + 2 * aClearance ) );
+            //printf("bb : %s\n",bbox.Format().c_str());
+            return bbox;
+        }
+
+        /**
+         * Function Diagonal()
+         *
+         * Returns length of the diagonal of the rectangle
+         * @return diagonal length
+         */
+        int Diagonal() const
+        {
+            return VECTOR2I( m_w, m_h ).EuclideanNorm();
+        }
+
+        /// @copydoc SHAPE::Collide()
+        bool Collide( const SEG& aSeg, int aClearance = 0 ) const
+        {
+            //VECTOR2I pmin = VECTOR2I(std::min(aSeg.a.x, aSeg.b.x), std::min(aSeg.a.y, aSeg.b.y));
+            //VECTOR2I pmax = VECTOR2I(std::max(aSeg.a.x, aSeg.b.x), std::max(aSeg.a.y, aSeg.b.y));
+            //BOX2I r(pmin, VECTOR2I(pmax.x - pmin.x, pmax.y - pmin.y));
+
+            //if (BBox(0).SquaredDistance(r) > aClearance * aClearance)
+            //    return false;
+
+            if( BBox( 0 ).Contains( aSeg.a ) || BBox( 0 ).Contains( aSeg.b ) )
+                return true;
+
+             VECTOR2I vts[] = {     VECTOR2I( m_p0.x, m_p0.y ),
+                                VECTOR2I( m_p0.x, m_p0.y + m_h ),
+                                VECTOR2I( m_p0.x + m_w, m_p0.y + m_h ),
+                                VECTOR2I( m_p0.x + m_w, m_p0.y ),
+                                VECTOR2I( m_p0.x, m_p0.y ) };
+
+            for( int i = 0; i < 4; i++ )
+            {
+                SEG s( vts[i], vts[i + 1], i );
+                if( s.Distance( aSeg ) <= aClearance )
+                    return true;
+            }
+
+            return false;
+        };
+
+        /**
+         * Function GetPosition()
+         *
+         * @return top-left corner of the rectangle
+         */
+        const VECTOR2I& GetPosition() const { return m_p0; }
+
+        /**
+         * Function GetSize()
+         *
+         * @return size of the rectangle
+         */
+        const VECTOR2I GetSize() const { return VECTOR2I( m_w, m_h ); }
+
+        /**
+         * Function GetWidth()
+         *
+         * @return width of the rectangle
+         */
+         const int GetWidth() const { return m_w; }
+
+        /**
+         * Function GetHeight()
+         *
+         * @return height of the rectangle
+         */
+        const int GetHeight() const { return m_h; }
+
+    private:
+        ///> Top-left corner
+        VECTOR2I m_p0;
+
+        ///> Width
+        int m_w;
+
+        ///> Height
+        int m_h;
+    };
 
 #endif // __SHAPE_RECT_H

include/math/box2.h

@@ -66,7 +66,7 @@ public:
     BOX2( const Vec& aPos, const Vec& aSize ) :
         m_Pos( aPos ),
         m_Size( aSize )
-    { 
+    {
         Normalize();
     }
 
@@ -420,7 +420,7 @@ public:
         ecoord_type y2 = m_Pos.y + m_Size.y;
         ecoord_type xdiff = std::max( aP.x < m_Pos.x ? m_Pos.x - aP.x : m_Pos.x - x2, (ecoord_type)0 );
         ecoord_type ydiff = std::max( aP.y < m_Pos.y ? m_Pos.y - aP.y : m_Pos.y - y2, (ecoord_type)0 );
-        return xdiff * xdiff + ydiff * ydiff;    
+        return xdiff * xdiff + ydiff * ydiff;
     }
 
     ecoord_type Distance( const Vec& aP ) const

include/math/vector2d.h

@@ -224,7 +224,7 @@ public:
 
     /// Division with a factor
     VECTOR2<T> operator/( const T& aFactor ) const;
-    
+
     /// Equality operator
     const bool operator==( const VECTOR2<T>& aVector ) const;
 

include/tool/context_menu.h

@@ -37,105 +37,105 @@ class TOOL_INTERACTIVE;
  * Defines the structure of a context (usually right-click) popup menu
  * for a given tool.
  */
-class CONTEXT_MENU 
+class CONTEXT_MENU
 {
 public:
     ///> Default constructor
-	CONTEXT_MENU();
-
-	///> Copy constructor
-	CONTEXT_MENU( const CONTEXT_MENU& aMenu );
-
-	/**
-	 * Function SetTitle()
-	 * Sets title for the context menu. The title is shown as a text label shown on the top of
-	 * the menu.
-	 * @param aTitle is the new title.
-	 */
-	void SetTitle( const wxString& aTitle );
-
-	/**
-	 * Function Add()
-	 * Adds an entry to the menu. After highlighting/selecting the entry, a TOOL_EVENT command is
-	 * sent that contains ID of the entry.
-	 * @param aLabel is the text label show in the menu.
-	 * @param aId is the ID that is sent in the TOOL_EVENT. It should be unique for every entry.
-	 */
-	void Add( const wxString& aLabel, int aId );
-
-	/**
-	 * Function Add()
-	 * Adds an entry to the menu, basing on the TOOL_ACTION object. After selecting the entry,
-	 * a TOOL_EVENT command containing name of the action is sent.
-	 * @param aAction is the action to be added to menu entry.
-	 */
-	void Add( const TOOL_ACTION& aAction );
-
-	/**
-	 * Function Clear()
-	 * Removes all the entries from the menu (as well as its title). It leaves the menu in the
-	 * initial state.
-	 */
-	void Clear();
-
-	/**
-	 * Function GetMenu()
-	 * Returns the instance of wxMenu object used to display the menu.
-	 */
-	wxMenu* GetMenu() const
-	{
-		return const_cast<wxMenu*>( &m_menu );
-	}
+    CONTEXT_MENU();
+
+    ///> Copy constructor
+    CONTEXT_MENU( const CONTEXT_MENU& aMenu );
+
+    /**
+     * Function SetTitle()
+     * Sets title for the context menu. The title is shown as a text label shown on the top of
+     * the menu.
+     * @param aTitle is the new title.
+     */
+    void SetTitle( const wxString& aTitle );
+
+    /**
+     * Function Add()
+     * Adds an entry to the menu. After highlighting/selecting the entry, a TOOL_EVENT command is
+     * sent that contains ID of the entry.
+     * @param aLabel is the text label show in the menu.
+     * @param aId is the ID that is sent in the TOOL_EVENT. It should be unique for every entry.
+     */
+    void Add( const wxString& aLabel, int aId );
+
+    /**
+     * Function Add()
+     * Adds an entry to the menu, basing on the TOOL_ACTION object. After selecting the entry,
+     * a TOOL_EVENT command containing name of the action is sent.
+     * @param aAction is the action to be added to menu entry.
+     */
+    void Add( const TOOL_ACTION& aAction );
+
+    /**
+     * Function Clear()
+     * Removes all the entries from the menu (as well as its title). It leaves the menu in the
+     * initial state.
+     */
+    void Clear();
+
+    /**
+     * Function GetMenu()
+     * Returns the instance of wxMenu object used to display the menu.
+     */
+    wxMenu* GetMenu() const
+    {
+        return const_cast<wxMenu*>( &m_menu );
+    }
 
 private:
-	///> Class CMEventHandler takes care of handling menu events. After reception of particular
-	///> events, it translates them to TOOL_EVENTs that may control tools.
-	class CMEventHandler : public wxEvtHandler
-	{
-	public:
-	    ///> Default constructor
-	    ///> aMenu is the CONTEXT_MENU instance for which it handles events.
-	    CMEventHandler( CONTEXT_MENU* aMenu ) : m_menu( aMenu ) {};
-
-	    ///> Handler for menu events.
-	    void onEvent( wxEvent& aEvent );
-
-	private:
-	    ///> CONTEXT_MENU instance for which it handles events.
-	    CONTEXT_MENU* m_menu;
-	};
-	
-	friend class TOOL_INTERACTIVE;
-
-	/**
-	 * Function setTool()
-	 * Sets a tool that is the creator of the menu.
-	 * @param aTool is the tool that created the menu.
-	 */
-	void setTool( TOOL_INTERACTIVE* aTool )
-	{
-		m_tool = aTool;
-	}
-
-	/**
-	 * Function getHotKeyDescription()
-	 * Returns a hot key in the string format accepted by wxMenu.
-	 * @param aAction is the action with hot key to be translated..
-	 * @return Hot key in the string format compatible with wxMenu.
-	 */
-	std::string getHotKeyDescription( const TOOL_ACTION& aAction ) const;
-
-	///> Flag indicating that the menu title was set up.
-	bool m_titleSet;
-
-	///> Instance of wxMenu used for display of the context menu.
-	wxMenu m_menu;
-
-	///> Instance of menu event handler.
-	CMEventHandler m_handler;
-
-	///> Creator of the menu
-	TOOL_INTERACTIVE* m_tool;
+    ///> Class CMEventHandler takes care of handling menu events. After reception of particular
+    ///> events, it translates them to TOOL_EVENTs that may control tools.
+    class CMEventHandler : public wxEvtHandler
+    {
+    public:
+        ///> Default constructor
+        ///> aMenu is the CONTEXT_MENU instance for which it handles events.
+        CMEventHandler( CONTEXT_MENU* aMenu ) : m_menu( aMenu ) {};
+
+        ///> Handler for menu events.
+        void onEvent( wxEvent& aEvent );
+
+    private:
+        ///> CONTEXT_MENU instance for which it handles events.
+        CONTEXT_MENU* m_menu;
+    };
+
+    friend class TOOL_INTERACTIVE;
+
+    /**
+     * Function setTool()
+     * Sets a tool that is the creator of the menu.
+     * @param aTool is the tool that created the menu.
+     */
+    void setTool( TOOL_INTERACTIVE* aTool )
+    {
+        m_tool = aTool;
+    }
+
+    /**
+     * Function getHotKeyDescription()
+     * Returns a hot key in the string format accepted by wxMenu.
+     * @param aAction is the action with hot key to be translated..
+     * @return Hot key in the string format compatible with wxMenu.
+     */
+    std::string getHotKeyDescription( const TOOL_ACTION& aAction ) const;
+
+    ///> Flag indicating that the menu title was set up.
+    bool m_titleSet;
+
+    ///> Instance of wxMenu used for display of the context menu.
+    wxMenu m_menu;
+
+    ///> Instance of menu event handler.
+    CMEventHandler m_handler;
+
+    ///> Creator of the menu
+    TOOL_INTERACTIVE* m_tool;
 
     /// Menu items with ID higher than that are considered TOOL_ACTIONs
     static const int m_actionId = 10000;

include/tool/coroutine.h

@@ -34,13 +34,13 @@
 /**
   Class COROUNTINE.
   Implements a coroutine. Wikipedia has a good explanation:
-  
-  "Coroutines are computer program components that generalize subroutines to 
-  allow multiple entry points for suspending and resuming execution at certain locations. 
-  Coroutines are well-suited for implementing more familiar program components such as cooperative 
+
+  "Coroutines are computer program components that generalize subroutines to
+  allow multiple entry points for suspending and resuming execution at certain locations.
+  Coroutines are well-suited for implementing more familiar program components such as cooperative
   tasks, exceptions, event loop, iterators, infinite lists and pipes."
 
-  In other words, a coroutine can be considered a lightweight thread - which can be 
+  In other words, a coroutine can be considered a lightweight thread - which can be
   preempted only when it deliberately yields the control to the caller. This way,
   we avoid concurrency problems such as locking / race conditions.
 
@@ -56,82 +56,82 @@ template<class ReturnType, class ArgType>
 class COROUTINE
 {
 public:
-	COROUTINE()
-	{
-		m_stackSize = c_defaultStackSize;
-		m_stack = NULL;		
-		m_saved = NULL;
-	}
-	
-	/**
-	 * Constructor
-	 * Creates a coroutine from a member method of an object 
-	 */
-	template<class T>
-	COROUTINE( T* object, ReturnType (T::*ptr)( ArgType ) ) :
-		m_func( object, ptr ), m_saved( NULL ), m_stack( NULL ), m_stackSize( c_defaultStackSize )
-	{
-	}
-
-	/**
-	 * Constructor
-	 * Creates a coroutine from a delegate object
-	 */
-	COROUTINE( DELEGATE<ReturnType, ArgType> aEntry ) :
+    COROUTINE()
+    {
+        m_stackSize = c_defaultStackSize;
+        m_stack = NULL;
+        m_saved = NULL;
+    }
+
+    /**
+     * Constructor
+     * Creates a coroutine from a member method of an object
+     */
+    template<class T>
+    COROUTINE( T* object, ReturnType (T::*ptr)( ArgType ) ) :
+        m_func( object, ptr ), m_saved( NULL ), m_stack( NULL ), m_stackSize( c_defaultStackSize )
+    {
+    }
+
+    /**
+     * Constructor
+     * Creates a coroutine from a delegate object
+     */
+    COROUTINE( DELEGATE<ReturnType, ArgType> aEntry ) :
             m_func( aEntry ), m_saved( NULL ), m_stack( NULL ), m_stackSize( c_defaultStackSize )
-	{};
+    {};
 
-	~COROUTINE()
-	{
+    ~COROUTINE()
+    {
         if( m_saved )
             delete m_saved;
         if( m_stack )
             free( m_stack );
-	}
-
-	/**
-	 * Function Yield()
-	 *
-	 * Stops execution of the coroutine and returns control to the caller.
-	 * After a yield, Call() or Resume() methods invoked by the caller will 
-	 * immediately return true, indicating that we are not done yet, just asleep.
-	 */
-	void Yield()
-	{
-		boost::context::jump_fcontext( m_self, m_saved, 0 );
-	}
-
-	/**
-	 * Function Yield() 
-	 *
-	 * Yield with a value - passes a value of given type to the caller.
-	 * Useful for implementing generator objects.
-	 */
-	void Yield( ReturnType& retVal )
-	{
-		m_retVal = retVal;
-		boost::context::jump_fcontext( m_self, m_saved, 0 );
-	}
-
-	/**
-	 <F11>* Function SetEntry()
-	 * 
-	 * Defines the entry point for the coroutine, if not set in the constructor.
-	 */
-	void SetEntry( DELEGATE<ReturnType, ArgType> aEntry )
-	{
-		m_func = aEntry;
-	}
-
-	/* Function Call()
-	 *
-	 * Starts execution of a coroutine, passing args as its arguments.
-	 * @return true, if the coroutine has yielded and false if it has finished its
-	 * execution (returned).
-	 */
-	bool Call( ArgType args )
-	{
-		// fixme: Clean up stack stuff. Add a guard 
+    }
+
+    /**
+     * Function Yield()
+     *
+     * Stops execution of the coroutine and returns control to the caller.
+     * After a yield, Call() or Resume() methods invoked by the caller will
+     * immediately return true, indicating that we are not done yet, just asleep.
+     */
+    void Yield()
+    {
+        boost::context::jump_fcontext( m_self, m_saved, 0 );
+    }
+
+    /**
+     * Function Yield()
+     *
+     * Yield with a value - passes a value of given type to the caller.
+     * Useful for implementing generator objects.
+     */
+    void Yield( ReturnType& retVal )
+    {
+        m_retVal = retVal;
+        boost::context::jump_fcontext( m_self, m_saved, 0 );
+    }
+
+    /**
+     <F11>* Function SetEntry()
+     *
+     * Defines the entry point for the coroutine, if not set in the constructor.
+     */
+    void SetEntry( DELEGATE<ReturnType, ArgType> aEntry )
+    {
+        m_func = aEntry;
+    }
+
+    /* Function Call()
+     *
+     * Starts execution of a coroutine, passing args as its arguments.
+     * @return true, if the coroutine has yielded and false if it has finished its
+     * execution (returned).
+     */
+    bool Call( ArgType args )
+    {
+        // fixme: Clean up stack stuff. Add a guard
         m_stack = malloc( c_defaultStackSize );
 
         // align to 16 bytes
@@ -145,87 +145,87 @@ public:
         // off we go!
         boost::context::jump_fcontext( m_saved, m_self, reinterpret_cast<intptr_t>( this ) );
         return m_running;
-	}
-
-	/**
-	 * Function Resume()
-	 * 
-	 * Resumes execution of a previously yielded coroutine.
-	 * @return true, if the coroutine has yielded again and false if it has finished its
-	 * execution (returned).
-	 */
-	bool Resume()
-	{
+    }
+
+    /**
+     * Function Resume()
+     *
+     * Resumes execution of a previously yielded coroutine.
+     * @return true, if the coroutine has yielded again and false if it has finished its
+     * execution (returned).
+     */
+    bool Resume()
+    {
         boost::context::jump_fcontext( m_saved, m_self, 0 );
         return m_running;
-	}
-
-	/**
-	 * Function ReturnValue()
-	 * 
-	 * Returns the yielded value (the argument Yield() was called with)
-	 */
-	const ReturnType& ReturnValue() const
-	{
-		return m_retVal;
-	}
-
-	/** 
-	 * Function Running()
-	 *
-	 * @return true, if the coroutine is active
-	 */
-	bool Running() const
-	{
-		return m_running;
-	}
+    }
+
+    /**
+     * Function ReturnValue()
+     *
+     * Returns the yielded value (the argument Yield() was called with)
+     */
+    const ReturnType& ReturnValue() const
+    {
+        return m_retVal;
+    }
+
+    /**
+     * Function Running()
+     *
+     * @return true, if the coroutine is active
+     */
+    bool Running() const
+    {
+        return m_running;
+    }
 
 private:
-	static const int c_defaultStackSize = 2000000; // fixme: make configurable
-
-	/* real entry point of the coroutine */
-	static void callerStub( intptr_t data )
-	{
-		// get pointer to self 
-		COROUTINE<ReturnType, ArgType>* cor = reinterpret_cast<COROUTINE<ReturnType, ArgType>*>( data );
-
-		// call the coroutine method
-		cor->m_retVal = cor->m_func( *cor->m_args );
-		cor->m_running = false;		
-
-		// go back to wherever we came from.
-		boost::context::jump_fcontext( cor->m_self, cor->m_saved, 0 ); //reinterpret_cast<intptr_t>( this ));
-	}
-
-	template <typename T> struct strip_ref
-	{
-  		typedef T result;
-	};
-
-	template <typename T> struct strip_ref<T&>
-	{
-  		typedef T result;
-	};
-
-	DELEGATE<ReturnType, ArgType> m_func;
-	
-	///< pointer to coroutine entry arguments. Stripped of references
-	///< to avoid compiler errors.
-	typename strip_ref<ArgType>::result* m_args;
-	ReturnType m_retVal;
-	
-	///< saved caller context
-	boost::context::fcontext_t* m_saved;
-	
-	///< saved coroutine context
-	boost::context::fcontext_t* m_self;
-
-	///< coroutine stack
-	void* m_stack;
-
-	size_t m_stackSize;
-
-	bool m_running;
+    static const int c_defaultStackSize = 2000000; // fixme: make configurable
+
+    /* real entry point of the coroutine */
+    static void callerStub( intptr_t data )
+    {
+        // get pointer to self
+        COROUTINE<ReturnType, ArgType>* cor = reinterpret_cast<COROUTINE<ReturnType, ArgType>*>( data );
+
+        // call the coroutine method
+        cor->m_retVal = cor->m_func( *cor->m_args );
+        cor->m_running = false;
+
+        // go back to wherever we came from.
+        boost::context::jump_fcontext( cor->m_self, cor->m_saved, 0 ); //reinterpret_cast<intptr_t>( this ));
+    }
+
+    template <typename T> struct strip_ref
+    {
+          typedef T result;
+    };
+
+    template <typename T> struct strip_ref<T&>
+    {
+          typedef T result;
+    };
+
+    DELEGATE<ReturnType, ArgType> m_func;
+
+    ///< pointer to coroutine entry arguments. Stripped of references
+    ///< to avoid compiler errors.
+    typename strip_ref<ArgType>::result* m_args;
+    ReturnType m_retVal;
+
+    ///< saved caller context
+    boost::context::fcontext_t* m_saved;
+
+    ///< saved coroutine context
+    boost::context::fcontext_t* m_self;
+
+    ///< coroutine stack
+    void* m_stack;
+
+    size_t m_stackSize;
+
+    bool m_running;
 };
 
 #endif

include/tool/examples/coroutine_example.cpp

@@ -9,40 +9,40 @@ typedef COROUTINE<int, int> MyCoroutine;
 
 class MyClass {
 
-	public:
-		int CountTo(int n)
-		{
-			printf("%s: Coroutine says hi. I will count from 1 to %d and yield each value.\n", __FUNCTION__, n);
-			for(int i = 1; i <= n; i++)
-			{
-				printf("%s: Yielding %d\n", __FUNCTION__, i);
-				cofunc.Yield(i);
-			}
-		}
-
-		void Run()
-		{
-			cofunc = MyCoroutine (this, &MyClass::CountTo);
-			printf("%s: Calling coroutine that will count from 1 to 5.\n", __FUNCTION__);
-			cofunc.Call(5);
-			while (cofunc.Running())
-			{
-				printf("%s: Got value: %d\n", __FUNCTION__, cofunc.ReturnValue());
-				cofunc.Resume();
-			}
-	
-			printf("%s: Done!\n", __FUNCTION__);
-		}
-
-		MyCoroutine cofunc;
+    public:
+        int CountTo(int n)
+        {
+            printf("%s: Coroutine says hi. I will count from 1 to %d and yield each value.\n", __FUNCTION__, n);
+            for(int i = 1; i <= n; i++)
+            {
+                printf("%s: Yielding %d\n", __FUNCTION__, i);
+                cofunc.Yield(i);
+            }
+        }
+
+        void Run()
+        {
+            cofunc = MyCoroutine (this, &MyClass::CountTo);
+            printf("%s: Calling coroutine that will count from 1 to 5.\n", __FUNCTION__);
+            cofunc.Call(5);
+            while (cofunc.Running())
+            {
+                printf("%s: Got value: %d\n", __FUNCTION__, cofunc.ReturnValue());
+                cofunc.Resume();
+            }
+
+            printf("%s: Done!\n", __FUNCTION__);
+        }
+
+        MyCoroutine cofunc;
 };
 
 
 main()
 {
-	MyClass obj;
+    MyClass obj;
 
-	obj.Run();
-	
-	return 0;
-}	
+    obj.Run();
+
+    return 0;
+}

include/tool/tool_dispatcher.h

@@ -33,12 +33,12 @@ class TOOL_MANAGER;
 class PCB_BASE_FRAME;
 
 namespace KiGfx {
-	class VIEW;
+    class VIEW;
 };
 
-/** 
+/**
  * Class TOOL_DISPATCHER
- * 
+ *
  * - takes wx events,
  * - fixes all wx quirks (mouse warping, panning, ordering problems, etc)
  * - translates coordinates to world space