haskal
/
kicad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Code refactoring.

This commit is contained in:
Maciej Suminski 2013-07-30 18:29:54 +02:00
parent 790a1f8563
commit 190ed58568
16 changed files with 857 additions and 1060 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
common/gal/cairo/cairo_compositor.cpp
View File

@ -34,7 +34,7 @@
using namespace KiGfx; using namespace KiGfx;
CAIRO_COMPOSITOR::CAIRO_COMPOSITOR( cairo_t** aMainContext ) : CAIRO_COMPOSITOR::CAIRO_COMPOSITOR( cairo_t** aMainContext ) :
m_current( 0 ), m_currentContext( aMainContext ), m_mainContext( *aMainContext ) m_current( 0 ), m_currentContext( aMainContext ), m_mainContext( *aMainContext )
{ {
// Obtain the transformation matrix used in the main context // Obtain the transformation matrix used in the main context
cairo_get_matrix( m_mainContext, &m_matrix ); cairo_get_matrix( m_mainContext, &m_matrix );
@ -69,6 +69,7 @@ unsigned int CAIRO_COMPOSITOR::GetBuffer()
{ {
// Pixel storage // Pixel storage
BitmapPtr bitmap( new unsigned int[m_bufferSize] ); BitmapPtr bitmap( new unsigned int[m_bufferSize] );
memset( bitmap.get(), 0x00, m_bufferSize * sizeof(int) ); memset( bitmap.get(), 0x00, m_bufferSize * sizeof(int) );
// Create the Cairo surface // Create the Cairo surface
@ -105,6 +106,7 @@ void CAIRO_COMPOSITOR::SetBuffer( unsigned int aBufferHandle )
m_current = aBufferHandle - 1; m_current = aBufferHandle - 1;
*m_currentContext = m_buffers[m_current].context; *m_currentContext = m_buffers[m_current].context;
} }
#ifdef __WXDEBUG__ #ifdef __WXDEBUG__
else else
wxLogDebug( wxT( "Tried to use a not existing buffer" ) ); wxLogDebug( wxT( "Tried to use a not existing buffer" ) );
@ -141,6 +143,7 @@ void CAIRO_COMPOSITOR::DrawBuffer( unsigned int aBufferHandle )
// Restore the transformation matrix // Restore the transformation matrix
cairo_set_matrix( m_mainContext, &m_matrix ); cairo_set_matrix( m_mainContext, &m_matrix );
} }
#ifdef __WXDEBUG__ #ifdef __WXDEBUG__
else else
wxLogDebug( wxT( "Tried to use a not existing buffer" ) ); wxLogDebug( wxT( "Tried to use a not existing buffer" ) );

600
common/gal/cairo/cairo_gal.cpp
View File

@ -87,117 +87,7 @@ CAIRO_GAL::~CAIRO_GAL()
} }
void CAIRO_GAL::onPaint( wxPaintEvent& aEvent ) void CAIRO_GAL::BeginDrawing()
{
PostPaint();
}
void CAIRO_GAL::ResizeScreen( int aWidth, int aHeight )
{
screenSize = VECTOR2D( aWidth, aHeight );
// Recreate the bitmaps
deleteBitmaps();
allocateBitmaps();
SetSize( wxSize( aWidth, aHeight ) );
}
void CAIRO_GAL::skipMouseEvent( wxMouseEvent& aEvent )
{
// Post the mouse event to the event listener registered in constructor, if any
if( mouseListener )
wxPostEvent( mouseListener, aEvent );
}
void CAIRO_GAL::initSurface()
{
wxASSERT( !isInitialized );
// Create the Cairo surface
surface = cairo_image_surface_create_for_data( (unsigned char*) bitmapBuffer, GAL_FORMAT,
screenSize.x, screenSize.y, stride );
context = cairo_create( surface );
#ifdef __WXDEBUG__
cairo_status_t status = cairo_status( context );
wxASSERT_MSG( status == CAIRO_STATUS_SUCCESS, "Cairo context creation error" );
#endif /* __WXDEBUG__ */
currentContext = context;
cairo_set_antialias( context, CAIRO_ANTIALIAS_SUBPIXEL );
// Clear the screen
ClearScreen();
// Compute the world <-> screen transformations
ComputeWorldScreenMatrix();
cairo_matrix_init( &cairoWorldScreenMatrix, worldScreenMatrix.m_data[0][0],
worldScreenMatrix.m_data[1][0], worldScreenMatrix.m_data[0][1],
worldScreenMatrix.m_data[1][1], worldScreenMatrix.m_data[0][2],
worldScreenMatrix.m_data[1][2] );
cairo_set_matrix( context, &cairoWorldScreenMatrix );
isSetAttributes = false;
// Start drawing with a new path
cairo_new_path( context );
isElementAdded = true;
cairo_set_line_join( context, CAIRO_LINE_JOIN_ROUND );
cairo_set_line_cap( context, CAIRO_LINE_CAP_ROUND );
lineWidth = 0;
isDeleteSavedPixels = true;
isInitialized = true;
}
void CAIRO_GAL::deinitSurface()
{
if( !isInitialized )
return;
// Destroy Cairo objects
cairo_destroy( context );
cairo_surface_destroy( surface );
isInitialized = false;
}
void CAIRO_GAL::setCompositor()
{
// Recreate the compositor with the new Cairo context
compositor.reset( new CAIRO_COMPOSITOR( &currentContext ) );
compositor->Resize( screenSize.x, screenSize.y );
// Prepare buffers
mainBuffer = compositor->GetBuffer();
overlayBuffer = compositor->GetBuffer();
}
unsigned int CAIRO_GAL::getNewGroupNumber()
{
wxASSERT_MSG( groups.size() < std::numeric_limits<unsigned int>::max(),
wxT( "There are no free slots to store a group" ) );
while( groups.find( groupCounter ) != groups.end() )
{
groupCounter++;
}
return groupCounter++;
}
void CAIRO_GAL::BeginDrawing() throw( int )
{ {
initSurface(); initSurface();
setCompositor(); setCompositor();
@ -245,65 +135,6 @@ void CAIRO_GAL::EndDrawing()
} }
void CAIRO_GAL::SaveScreen()
{
// Copy the current bitmap to the backup buffer
int offset = 0;
for( int j = 0; j < screenSize.y; j++ )
{
for( int i = 0; i < stride; i++ )
{
bitmapBufferBackup[offset + i] = bitmapBuffer[offset + i];
offset += stride;
}
}
}
void CAIRO_GAL::RestoreScreen()
{
int offset = 0;
for( int j = 0; j < screenSize.y; j++ )
{
for( int i = 0; i < stride; i++ )
{
bitmapBuffer[offset + i] = bitmapBufferBackup[offset + i];
offset += stride;
}
}
}
void CAIRO_GAL::SetTarget( RenderTarget aTarget )
{
// If the compositor is not set, that means that there is a recaching process going on
// and we do not need the compositor now
if( !compositor )
return;
// Cairo grouping prevents display of overlapping items on the same layer in the lighter color
cairo_pop_group_to_source( currentContext );
cairo_paint_with_alpha( currentContext, fillColor.a );
switch( aTarget )
{
default:
case TARGET_CACHED:
case TARGET_NONCACHED:
compositor->SetBuffer( mainBuffer );
break;
case TARGET_OVERLAY:
compositor->SetBuffer( overlayBuffer );
break;
}
cairo_push_group( currentContext );
}
void CAIRO_GAL::DrawLine( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ) void CAIRO_GAL::DrawLine( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint )
{ {
cairo_move_to( currentContext, aStartPoint.x, aStartPoint.y ); cairo_move_to( currentContext, aStartPoint.x, aStartPoint.y );
@ -335,7 +166,7 @@ void CAIRO_GAL::DrawSegment( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPo
cairo_translate( currentContext, aStartPoint.x, aStartPoint.y ); cairo_translate( currentContext, aStartPoint.x, aStartPoint.y );
cairo_rotate( currentContext, lineAngle ); cairo_rotate( currentContext, lineAngle );
cairo_arc( currentContext, 0.0, 0.0, aWidth / 2.0, M_PI / 2.0, 3.0 * M_PI / 2.0 ); cairo_arc( currentContext, 0.0, 0.0, aWidth / 2.0, M_PI / 2.0, 3.0 * M_PI / 2.0 );
cairo_arc( currentContext, lineLength, 0.0, aWidth / 2.0, -M_PI / 2.0, M_PI / 2.0 ); cairo_arc( currentContext, lineLength, 0.0, aWidth / 2.0, -M_PI / 2.0, M_PI / 2.0 );
cairo_move_to( currentContext, 0.0, aWidth / 2.0 ); cairo_move_to( currentContext, 0.0, aWidth / 2.0 );
@ -373,12 +204,30 @@ void CAIRO_GAL::DrawArc( const VECTOR2D& aCenterPoint, double aRadius, double aS
} }
void CAIRO_GAL::DrawRectangle( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint )
{
// Calculate the diagonal points
VECTOR2D diagonalPointA( aEndPoint.x, aStartPoint.y );
VECTOR2D diagonalPointB( aStartPoint.x, aEndPoint.y );
// The path is composed from 4 segments
cairo_move_to( currentContext, aStartPoint.x, aStartPoint.y );
cairo_line_to( currentContext, diagonalPointA.x, diagonalPointA.y );
cairo_line_to( currentContext, aEndPoint.x, aEndPoint.y );
cairo_line_to( currentContext, diagonalPointB.x, diagonalPointB.y );
cairo_close_path( currentContext );
isElementAdded = true;
}
void CAIRO_GAL::DrawPolyline( std::deque<VECTOR2D>& aPointList ) void CAIRO_GAL::DrawPolyline( std::deque<VECTOR2D>& aPointList )
{ {
// Iterate over the point list and draw the segments // Iterate over the point list and draw the segments
std::deque<VECTOR2D>::const_iterator it = aPointList.begin(); std::deque<VECTOR2D>::const_iterator it = aPointList.begin();
cairo_move_to( currentContext, it->x, it->y ); cairo_move_to( currentContext, it->x, it->y );
for( ++it; it != aPointList.end(); ++it ) for( ++it; it != aPointList.end(); ++it )
{ {
cairo_line_to( currentContext, it->x, it->y ); cairo_line_to( currentContext, it->x, it->y );
@ -394,6 +243,7 @@ void CAIRO_GAL::DrawPolygon( const std::deque<VECTOR2D>& aPointList )
std::deque<VECTOR2D>::const_iterator it = aPointList.begin(); std::deque<VECTOR2D>::const_iterator it = aPointList.begin();
cairo_move_to( currentContext, it->x, it->y ); cairo_move_to( currentContext, it->x, it->y );
for( ++it; it != aPointList.end(); ++it ) for( ++it; it != aPointList.end(); ++it )
{ {
cairo_line_to( currentContext, it->x, it->y ); cairo_line_to( currentContext, it->x, it->y );
@ -403,23 +253,6 @@ void CAIRO_GAL::DrawPolygon( const std::deque<VECTOR2D>& aPointList )
} }
void CAIRO_GAL::DrawRectangle( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint )
{
// Calculate the diagonal points
VECTOR2D diagonalPointA( aEndPoint.x, aStartPoint.y );
VECTOR2D diagonalPointB( aStartPoint.x, aEndPoint.y );
// The path is composed from 4 segments
cairo_move_to( currentContext, aStartPoint.x, aStartPoint.y );
cairo_line_to( currentContext, diagonalPointA.x, diagonalPointA.y );
cairo_line_to( currentContext, aEndPoint.x, aEndPoint.y );
cairo_line_to( currentContext, diagonalPointB.x, diagonalPointB.y );
cairo_close_path( currentContext );
isElementAdded = true;
}
void CAIRO_GAL::DrawCurve( const VECTOR2D& aStartPoint, const VECTOR2D& aControlPointA, void CAIRO_GAL::DrawCurve( const VECTOR2D& aStartPoint, const VECTOR2D& aControlPointA,
const VECTOR2D& aControlPointB, const VECTOR2D& aEndPoint ) const VECTOR2D& aControlPointB, const VECTOR2D& aEndPoint )
{ {
@ -432,9 +265,41 @@ void CAIRO_GAL::DrawCurve( const VECTOR2D& aStartPoint, const VECTOR2D& aControl
} }
void CAIRO_GAL::SetBackgroundColor( const COLOR4D& aColor ) void CAIRO_GAL::ResizeScreen( int aWidth, int aHeight )
{ {
backgroundColor = aColor; screenSize = VECTOR2D( aWidth, aHeight );
// Recreate the bitmaps
deleteBitmaps();
allocateBitmaps();
SetSize( wxSize( aWidth, aHeight ) );
}
bool CAIRO_GAL::Show( bool aShow )
{
bool s = wxWindow::Show( aShow );
if( aShow )
wxWindow::Raise();
return s;
}
void CAIRO_GAL::Flush()
{
storePath();
}
void CAIRO_GAL::ClearScreen()
{
cairo_set_source_rgb( currentContext,
backgroundColor.r, backgroundColor.g, backgroundColor.b );
cairo_rectangle( currentContext, 0.0, 0.0, screenSize.x, screenSize.y );
cairo_fill( currentContext );
} }
@ -528,15 +393,6 @@ void CAIRO_GAL::SetLineWidth( double aLineWidth )
} }
void CAIRO_GAL::ClearScreen()
{
cairo_set_source_rgb( currentContext,
backgroundColor.r, backgroundColor.g, backgroundColor.b );
cairo_rectangle( currentContext, 0.0, 0.0, screenSize.x, screenSize.y );
cairo_fill( currentContext );
}
void CAIRO_GAL::SetLayerDepth( double aLayerDepth ) void CAIRO_GAL::SetLayerDepth( double aLayerDepth )
{ {
super::SetLayerDepth( aLayerDepth ); super::SetLayerDepth( aLayerDepth );
@ -686,35 +542,6 @@ void CAIRO_GAL::EndGroup()
} }
void CAIRO_GAL::ClearCache()
{
for( int i = groups.size() - 1; i >= 0; --i )
{
DeleteGroup( i );
}
}
void CAIRO_GAL::DeleteGroup( int aGroupNumber )
{
storePath();
// Delete the Cairo paths
std::deque<GroupElement>::iterator it, end;
for( it = groups[aGroupNumber].begin(), end = groups[aGroupNumber].end(); it != end; ++it )
{
if( it->command == CMD_FILL_PATH || it->command == CMD_STROKE_PATH )
{
cairo_path_destroy( it->cairoPath );
}
}
// Delete the group
groups.erase( aGroupNumber );
}
void CAIRO_GAL::DrawGroup( int aGroupNumber ) void CAIRO_GAL::DrawGroup( int aGroupNumber )
{ {
// This method implements a small Virtual Machine - all stored commands // This method implements a small Virtual Machine - all stored commands
@ -828,103 +655,91 @@ void CAIRO_GAL::ChangeGroupDepth( int aGroupNumber, int aDepth )
} }
void CAIRO_GAL::Flush() void CAIRO_GAL::DeleteGroup( int aGroupNumber )
{ {
storePath(); storePath();
}
// Delete the Cairo paths
std::deque<GroupElement>::iterator it, end;
void CAIRO_GAL::ComputeWorldScreenMatrix() for( it = groups[aGroupNumber].begin(), end = groups[aGroupNumber].end(); it != end; ++it )
{
ComputeWorldScale();
worldScreenMatrix.SetIdentity();
MATRIX3x3D translation;
translation.SetIdentity();
translation.SetTranslation( 0.5 * screenSize );
MATRIX3x3D scale;
scale.SetIdentity();
scale.SetScale( VECTOR2D( worldScale, worldScale ) );
MATRIX3x3D lookat;
lookat.SetIdentity();
lookat.SetTranslation( -lookAtPoint );
worldScreenMatrix = translation * scale * lookat * worldScreenMatrix;
}
void CAIRO_GAL::storePath()
{
if( isElementAdded )
{ {
isElementAdded = false; if( it->command == CMD_FILL_PATH || it->command == CMD_STROKE_PATH )
if( !isGrouping )
{ {
if( isFillEnabled ) cairo_path_destroy( it->cairoPath );
{
cairo_set_source_rgb( currentContext, fillColor.r, fillColor.g, fillColor.b );
cairo_fill_preserve( currentContext );
}
if( isStrokeEnabled )
{
cairo_set_source_rgb( currentContext, strokeColor.r, strokeColor.g, strokeColor.b );
cairo_stroke_preserve( currentContext );
}
} }
else }
{
// Copy the actual path, append it to the global path list
// then check, if the path needs to be stroked/filled and
// add this command to the group list;
if( isStrokeEnabled )
{
GroupElement groupElement;
groupElement.cairoPath = cairo_copy_path( currentContext );
groupElement.command = CMD_STROKE_PATH;
currentGroup->push_back( groupElement );
}
if( isFillEnabled ) // Delete the group
{ groups.erase( aGroupNumber );
GroupElement groupElement; }
groupElement.cairoPath = cairo_copy_path( currentContext );
groupElement.command = CMD_FILL_PATH;
currentGroup->push_back( groupElement );
}
}
cairo_new_path( currentContext );
void CAIRO_GAL::ClearCache()
{
for( int i = groups.size() - 1; i >= 0; --i )
{
DeleteGroup( i );
} }
} }
// --------------- void CAIRO_GAL::SaveScreen()
// Cursor handling
// ---------------
void CAIRO_GAL::initCursor( int aCursorSize )
{ {
cursorPixels = new wxBitmap( aCursorSize, aCursorSize ); // Copy the current bitmap to the backup buffer
cursorPixelsSaved = new wxBitmap( aCursorSize, aCursorSize ); int offset = 0;
cursorSize = aCursorSize;
wxMemoryDC cursorShape( *cursorPixels ); for( int j = 0; j < screenSize.y; j++ )
{
for( int i = 0; i < stride; i++ )
{
bitmapBufferBackup[offset + i] = bitmapBuffer[offset + i];
offset += stride;
}
}
}
cursorShape.SetBackground( *wxTRANSPARENT_BRUSH );
wxColour color( cursorColor.r * cursorColor.a * 255, cursorColor.g * cursorColor.a * 255,
cursorColor.b * cursorColor.a * 255, 255 );
wxPen pen = wxPen( color );
cursorShape.SetPen( pen );
cursorShape.Clear();
cursorShape.DrawLine( 0, aCursorSize / 2, aCursorSize, aCursorSize / 2 ); void CAIRO_GAL::RestoreScreen()
cursorShape.DrawLine( aCursorSize / 2, 0, aCursorSize / 2, aCursorSize ); {
int offset = 0;
for( int j = 0; j < screenSize.y; j++ )
{
for( int i = 0; i < stride; i++ )
{
bitmapBuffer[offset + i] = bitmapBufferBackup[offset + i];
offset += stride;
}
}
}
void CAIRO_GAL::SetTarget( RenderTarget aTarget )
{
// If the compositor is not set, that means that there is a recaching process going on
// and we do not need the compositor now
if( !compositor )
return;
// Cairo grouping prevents display of overlapping items on the same layer in the lighter color
cairo_pop_group_to_source( currentContext );
cairo_paint_with_alpha( currentContext, fillColor.a );
switch( aTarget )
{
default:
case TARGET_CACHED:
case TARGET_NONCACHED:
compositor->SetBuffer( mainBuffer );
break;
case TARGET_OVERLAY:
compositor->SetBuffer( overlayBuffer );
break;
}
cairo_push_group( currentContext );
} }
@ -975,7 +790,7 @@ void CAIRO_GAL::DrawCursor( VECTOR2D aCursorPosition )
} }
void CAIRO_GAL::DrawGridLine( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ) void CAIRO_GAL::drawGridLine( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint )
{ {
cairo_move_to( currentContext, aStartPoint.x, aStartPoint.y ); cairo_move_to( currentContext, aStartPoint.x, aStartPoint.y );
cairo_line_to( currentContext, aEndPoint.x, aEndPoint.y ); cairo_line_to( currentContext, aEndPoint.x, aEndPoint.y );
@ -984,14 +799,96 @@ void CAIRO_GAL::DrawGridLine( const VECTOR2D& aStartPoint, const VECTOR2D& aEndP
} }
void CAIRO_GAL::storePath()
{
if( isElementAdded )
{
isElementAdded = false;
if( !isGrouping )
{
if( isFillEnabled )
{
cairo_set_source_rgb( currentContext, fillColor.r, fillColor.g, fillColor.b );
cairo_fill_preserve( currentContext );
}
if( isStrokeEnabled )
{
cairo_set_source_rgb( currentContext, strokeColor.r, strokeColor.g,
strokeColor.b );
cairo_stroke_preserve( currentContext );
}
}
else
{
// Copy the actual path, append it to the global path list
// then check, if the path needs to be stroked/filled and
// add this command to the group list;
if( isStrokeEnabled )
{
GroupElement groupElement;
groupElement.cairoPath = cairo_copy_path( currentContext );
groupElement.command = CMD_STROKE_PATH;
currentGroup->push_back( groupElement );
}
if( isFillEnabled )
{
GroupElement groupElement;
groupElement.cairoPath = cairo_copy_path( currentContext );
groupElement.command = CMD_FILL_PATH;
currentGroup->push_back( groupElement );
}
}
cairo_new_path( currentContext );
}
}
void CAIRO_GAL::onPaint( wxPaintEvent& aEvent )
{
PostPaint();
}
void CAIRO_GAL::skipMouseEvent( wxMouseEvent& aEvent )
{
// Post the mouse event to the event listener registered in constructor, if any
if( mouseListener )
wxPostEvent( mouseListener, aEvent );
}
void CAIRO_GAL::initCursor( int aCursorSize )
{
cursorPixels = new wxBitmap( aCursorSize, aCursorSize );
cursorPixelsSaved = new wxBitmap( aCursorSize, aCursorSize );
cursorSize = aCursorSize;
wxMemoryDC cursorShape( *cursorPixels );
cursorShape.SetBackground( *wxTRANSPARENT_BRUSH );
wxColour color( cursorColor.r * cursorColor.a * 255, cursorColor.g * cursorColor.a * 255,
cursorColor.b * cursorColor.a * 255, 255 );
wxPen pen = wxPen( color );
cursorShape.SetPen( pen );
cursorShape.Clear();
cursorShape.DrawLine( 0, aCursorSize / 2, aCursorSize, aCursorSize / 2 );
cursorShape.DrawLine( aCursorSize / 2, 0, aCursorSize / 2, aCursorSize );
}
void CAIRO_GAL::allocateBitmaps() void CAIRO_GAL::allocateBitmaps()
{ {
// Create buffer, use the system independent Cairo context backend // Create buffer, use the system independent Cairo context backend
stride = cairo_format_stride_for_width( GAL_FORMAT, screenSize.x ); stride = cairo_format_stride_for_width( GAL_FORMAT, screenSize.x );
bufferSize = stride * screenSize.y; bufferSize = stride * screenSize.y;
bitmapBuffer = new unsigned int[bufferSize]; bitmapBuffer = new unsigned int[bufferSize];
bitmapBufferBackup = new unsigned int[bufferSize]; bitmapBufferBackup = new unsigned int[bufferSize];
wxOutput = new unsigned char[bufferSize * 3]; wxOutput = new unsigned char[bufferSize * 3];
} }
@ -1004,12 +901,83 @@ void CAIRO_GAL::deleteBitmaps()
} }
bool CAIRO_GAL::Show( bool aShow ) void CAIRO_GAL::initSurface()
{ {
bool s = wxWindow::Show( aShow ); wxASSERT( !isInitialized );
if( aShow ) // Create the Cairo surface
wxWindow::Raise(); surface = cairo_image_surface_create_for_data( (unsigned char*) bitmapBuffer, GAL_FORMAT,
screenSize.x, screenSize.y, stride );
context = cairo_create( surface );
#ifdef __WXDEBUG__
cairo_status_t status = cairo_status( context );
wxASSERT_MSG( status == CAIRO_STATUS_SUCCESS, "Cairo context creation error" );
#endif /* __WXDEBUG__ */
currentContext = context;
return s; cairo_set_antialias( context, CAIRO_ANTIALIAS_SUBPIXEL );
// Clear the screen
ClearScreen();
// Compute the world <-> screen transformations
ComputeWorldScreenMatrix();
cairo_matrix_init( &cairoWorldScreenMatrix, worldScreenMatrix.m_data[0][0],
worldScreenMatrix.m_data[1][0], worldScreenMatrix.m_data[0][1],
worldScreenMatrix.m_data[1][1], worldScreenMatrix.m_data[0][2],
worldScreenMatrix.m_data[1][2] );
cairo_set_matrix( context, &cairoWorldScreenMatrix );
// Start drawing with a new path
cairo_new_path( context );
isElementAdded = true;
cairo_set_line_join( context, CAIRO_LINE_JOIN_ROUND );
cairo_set_line_cap( context, CAIRO_LINE_CAP_ROUND );
lineWidth = 0;
isDeleteSavedPixels = true;
isInitialized = true;
}
void CAIRO_GAL::deinitSurface()
{
if( !isInitialized )
return;
// Destroy Cairo objects
cairo_destroy( context );
cairo_surface_destroy( surface );
isInitialized = false;
}
void CAIRO_GAL::setCompositor()
{
// Recreate the compositor with the new Cairo context
compositor.reset( new CAIRO_COMPOSITOR( &currentContext ) );
compositor->Resize( screenSize.x, screenSize.y );
// Prepare buffers
mainBuffer = compositor->GetBuffer();
overlayBuffer = compositor->GetBuffer();
}
unsigned int CAIRO_GAL::getNewGroupNumber()
{
wxASSERT_MSG( groups.size() < std::numeric_limits<unsigned int>::max(),
wxT( "There are no free slots to store a group" ) );
while( groups.find( groupCounter ) != groups.end() )
{
groupCounter++;
}
return groupCounter++;
} }

31
common/gal/graphics_abstraction_layer.cpp
View File

@ -63,6 +63,33 @@ GAL::~GAL()
} }
void GAL::ComputeWorldScreenMatrix()
{
ComputeWorldScale();
worldScreenMatrix.SetIdentity();
MATRIX3x3D translation;
translation.SetIdentity();
translation.SetTranslation( 0.5 * screenSize );
MATRIX3x3D scale;
scale.SetIdentity();
scale.SetScale( VECTOR2D( worldScale, worldScale ) );
MATRIX3x3D flip;
flip.SetIdentity();
flip.SetScale( VECTOR2D( 1.0, 1.0 ) );
MATRIX3x3D lookat;
lookat.SetIdentity();
lookat.SetTranslation( -lookAtPoint );
worldScreenMatrix = translation * flip * scale * lookat * worldScreenMatrix;
}
void GAL::DrawGrid() void GAL::DrawGrid()
{ {
if( !gridVisibility ) if( !gridVisibility )
@ -136,7 +163,7 @@ void GAL::DrawGrid()
if( ( j % gridTick == 0 && gridScreenSizeCoarse > gridDrawThreshold ) if( ( j % gridTick == 0 && gridScreenSizeCoarse > gridDrawThreshold )
|| gridScreenSizeDense > gridDrawThreshold ) || gridScreenSizeDense > gridDrawThreshold )
{ {
DrawGridLine( VECTOR2D( gridStartX * gridSize.x, j * gridSize.y ), drawGridLine( VECTOR2D( gridStartX * gridSize.x, j * gridSize.y ),
VECTOR2D( gridEndX * gridSize.x, j * gridSize.y ) ); VECTOR2D( gridEndX * gridSize.x, j * gridSize.y ) );
} }
} }
@ -155,7 +182,7 @@ void GAL::DrawGrid()
if( ( i % gridTick == 0 && gridScreenSizeCoarse > gridDrawThreshold ) if( ( i % gridTick == 0 && gridScreenSizeCoarse > gridDrawThreshold )
|| gridScreenSizeDense > gridDrawThreshold ) || gridScreenSizeDense > gridDrawThreshold )
{ {
DrawGridLine( VECTOR2D( i * gridSize.x, gridStartY * gridSize.y ), drawGridLine( VECTOR2D( i * gridSize.x, gridStartY * gridSize.y ),
VECTOR2D( i * gridSize.x, gridEndY * gridSize.y ) ); VECTOR2D( i * gridSize.x, gridEndY * gridSize.y ) );
} }
} }

2
common/gal/opengl/gpu_manager.cpp
View File

@ -52,7 +52,7 @@ GPU_MANAGER* GPU_MANAGER::MakeManager( VERTEX_CONTAINER* aContainer )
GPU_MANAGER::GPU_MANAGER( VERTEX_CONTAINER* aContainer ) : GPU_MANAGER::GPU_MANAGER( VERTEX_CONTAINER* aContainer ) :
m_isDrawing( false ), m_container( aContainer ), m_shader( NULL ) m_isDrawing( false ), m_container( aContainer ), m_shader( NULL )
{ {
} }

4
common/gal/opengl/opengl_compositor.cpp
View File

@ -104,7 +104,7 @@ unsigned int OPENGL_COMPOSITOR::GetBuffer()
wxASSERT( m_initialized ); wxASSERT( m_initialized );
if( m_buffers.size() >= m_maxBuffers ) if( m_buffers.size() >= m_maxBuffers )
return 0; // Unfortunately we have no more free buffers left return 0; // Unfortunately we have no more free buffers left
// GL_COLOR_ATTACHMENTn are consecutive integers // GL_COLOR_ATTACHMENTn are consecutive integers
GLuint attachmentPoint = GL_COLOR_ATTACHMENT0 + usedBuffers(); GLuint attachmentPoint = GL_COLOR_ATTACHMENT0 + usedBuffers();
@ -229,9 +229,11 @@ void OPENGL_COMPOSITOR::clean()
{ {
glDeleteTextures( 1, &it->textureTarget ); glDeleteTextures( 1, &it->textureTarget );
} }
m_buffers.clear(); m_buffers.clear();
m_initialized = false; m_initialized = false;
} }
GLuint OPENGL_COMPOSITOR::m_currentFbo = 0; GLuint OPENGL_COMPOSITOR::m_currentFbo = 0;

887
common/gal/opengl/opengl_gal.cpp
View File

File diff suppressed because it is too large Load Diff

17
common/gal/opengl/shader.cpp
View File

@ -37,12 +37,12 @@
using namespace KiGfx; using namespace KiGfx;
SHADER::SHADER() : SHADER::SHADER() :
isProgramCreated( false ), isProgramCreated( false ),
isShaderLinked( false ), isShaderLinked( false ),
active( false ), active( false ),
maximumVertices( 4 ), maximumVertices( 4 ),
geomInputType( GL_LINES ), geomInputType( GL_LINES ),
geomOutputType( GL_LINES ) geomOutputType( GL_LINES )
{ {
} }
@ -97,7 +97,8 @@ bool SHADER::Link()
programInfo( programNumber ); programInfo( programNumber );
// Check the Link state // Check the Link state
glGetObjectParameterivARB( programNumber, GL_OBJECT_LINK_STATUS_ARB, (GLint*) &isShaderLinked ); glGetObjectParameterivARB( programNumber, GL_OBJECT_LINK_STATUS_ARB,
(GLint*) &isShaderLinked );
#ifdef __WXDEBUG__ #ifdef __WXDEBUG__
if( !isShaderLinked ) if( !isShaderLinked )
@ -253,6 +254,7 @@ bool SHADER::addSource( const std::string& aShaderSource, ShaderType aShaderType
glCompileShader( shaderNumber ); glCompileShader( shaderNumber );
GLint status; GLint status;
glGetShaderiv( shaderNumber, GL_COMPILE_STATUS, &status ); glGetShaderiv( shaderNumber, GL_COMPILE_STATUS, &status );
if( status != GL_TRUE ) if( status != GL_TRUE )
{ {
wxLogError( wxT( "Shader compilation error" ) ); wxLogError( wxT( "Shader compilation error" ) );
@ -275,4 +277,3 @@ bool SHADER::addSource( const std::string& aShaderSource, ShaderType aShaderType
return true; return true;
} }

11
common/gal/opengl/vertex_manager.cpp
View File

@ -37,7 +37,7 @@
using namespace KiGfx; using namespace KiGfx;
VERTEX_MANAGER::VERTEX_MANAGER( bool aCached ) : VERTEX_MANAGER::VERTEX_MANAGER( bool aCached ) :
m_noTransform( true ), m_transform( 1.0f ) m_noTransform( true ), m_transform( 1.0f )
{ {
m_container.reset( VERTEX_CONTAINER::MakeContainer( aCached ) ); m_container.reset( VERTEX_CONTAINER::MakeContainer( aCached ) );
m_gpu.reset( GPU_MANAGER::MakeManager( m_container.get() ) ); m_gpu.reset( GPU_MANAGER::MakeManager( m_container.get() ) );
@ -52,6 +52,7 @@ void VERTEX_MANAGER::Vertex( GLfloat aX, GLfloat aY, GLfloat aZ ) const
{ {
// Obtain the pointer to the vertex in the currently used container // Obtain the pointer to the vertex in the currently used container
VERTEX* newVertex = m_container->Allocate( 1 ); VERTEX* newVertex = m_container->Allocate( 1 );
if( newVertex == NULL ) if( newVertex == NULL )
{ {
wxLogError( wxT( "Vertex allocation error" ) ); wxLogError( wxT( "Vertex allocation error" ) );
@ -66,6 +67,7 @@ void VERTEX_MANAGER::Vertices( const VERTEX aVertices[], unsigned int aSize ) co
{ {
// Obtain pointer to the vertex in currently used container // Obtain pointer to the vertex in currently used container
VERTEX* newVertex = m_container->Allocate( aSize ); VERTEX* newVertex = m_container->Allocate( aSize );
if( newVertex == NULL ) if( newVertex == NULL )
{ {
wxLogError( wxT( "Vertex allocation error" ) ); wxLogError( wxT( "Vertex allocation error" ) );
@ -95,7 +97,7 @@ void VERTEX_MANAGER::FreeItem( VERTEX_ITEM& aItem ) const
void VERTEX_MANAGER::ChangeItemColor( const VERTEX_ITEM& aItem, const COLOR4D& aColor ) const void VERTEX_MANAGER::ChangeItemColor( const VERTEX_ITEM& aItem, const COLOR4D& aColor ) const
{ {
unsigned int size = aItem.GetSize(); unsigned int size = aItem.GetSize();
unsigned int offset = aItem.GetOffset(); unsigned int offset = aItem.GetOffset();
VERTEX* vertex = m_container->GetVertices( offset ); VERTEX* vertex = m_container->GetVertices( offset );
@ -114,7 +116,7 @@ void VERTEX_MANAGER::ChangeItemColor( const VERTEX_ITEM& aItem, const COLOR4D& a
void VERTEX_MANAGER::ChangeItemDepth( const VERTEX_ITEM& aItem, GLfloat aDepth ) const void VERTEX_MANAGER::ChangeItemDepth( const VERTEX_ITEM& aItem, GLfloat aDepth ) const
{ {
unsigned int size = aItem.GetSize(); unsigned int size = aItem.GetSize();
unsigned int offset = aItem.GetOffset(); unsigned int offset = aItem.GetOffset();
VERTEX* vertex = m_container->GetVertices( offset ); VERTEX* vertex = m_container->GetVertices( offset );
@ -131,7 +133,7 @@ void VERTEX_MANAGER::ChangeItemDepth( const VERTEX_ITEM& aItem, GLfloat aDepth )
VERTEX* VERTEX_MANAGER::GetVertices( const VERTEX_ITEM& aItem ) const VERTEX* VERTEX_MANAGER::GetVertices( const VERTEX_ITEM& aItem ) const
{ {
if( aItem.GetSize() == 0 ) if( aItem.GetSize() == 0 )
return NULL; // The item is not stored in the container return NULL; // The item is not stored in the container
return m_container->GetVertices( aItem.GetOffset() ); return m_container->GetVertices( aItem.GetOffset() );
} }
@ -158,6 +160,7 @@ void VERTEX_MANAGER::BeginDrawing() const
void VERTEX_MANAGER::DrawItem( const VERTEX_ITEM& aItem ) const void VERTEX_MANAGER::DrawItem( const VERTEX_ITEM& aItem ) const
{ {
int size = aItem.GetSize(); int size = aItem.GetSize();
if( size > 0 ) if( size > 0 )
{ {
int offset = aItem.GetOffset(); int offset = aItem.GetOffset();

1
common/view/wx_view_controls.cpp
View File

@ -85,7 +85,6 @@ void WX_VIEW_CONTROLS::onWheel( wxMouseEvent& event )
else else
scrollSpeed = scrollVec.y; scrollSpeed = scrollVec.y;
VECTOR2D t = m_view->GetScreenPixelSize();
VECTOR2D delta( event.ControlDown() ? -scrollSpeed : 0.0, VECTOR2D delta( event.ControlDown() ? -scrollSpeed : 0.0,
event.ShiftDown() ? -scrollSpeed : 0.0 ); event.ShiftDown() ? -scrollSpeed : 0.0 );

18
include/gal/cairo/cairo_compositor.h
View File

@ -38,7 +38,6 @@
namespace KiGfx namespace KiGfx
{ {
class CAIRO_COMPOSITOR : public COMPOSITOR class CAIRO_COMPOSITOR : public COMPOSITOR
{ {
public: public:
@ -67,25 +66,25 @@ protected:
typedef boost::shared_array<unsigned int> BitmapPtr; typedef boost::shared_array<unsigned int> BitmapPtr;
typedef struct typedef struct
{ {
cairo_t* context; ///< Main texture handle cairo_t* context; ///< Main texture handle
cairo_surface_t* surface; ///< Point to which an image from texture is attached cairo_surface_t* surface; ///< Point to which an image from texture is attached
BitmapPtr bitmap; ///< Pixel storage BitmapPtr bitmap; ///< Pixel storage
} CAIRO_BUFFER; } CAIRO_BUFFER;
unsigned int m_current; ///< Currently used buffer handle unsigned int m_current; ///< Currently used buffer handle
typedef std::deque<CAIRO_BUFFER> CAIRO_BUFFERS; typedef std::deque<CAIRO_BUFFER> CAIRO_BUFFERS;
/// Pointer to the current context, so it can be changed /// Pointer to the current context, so it can be changed
cairo_t** m_currentContext; cairo_t** m_currentContext;
/// Rendering target used for compositing (the main display) /// Rendering target used for compositing (the main display)
cairo_t* m_mainContext; cairo_t* m_mainContext;
/// Transformation matrix /// Transformation matrix
cairo_matrix_t m_matrix; cairo_matrix_t m_matrix;
/// Stores information about initialized buffers /// Stores information about initialized buffers
CAIRO_BUFFERS m_buffers; CAIRO_BUFFERS m_buffers;
unsigned int m_stride; ///< Stride to use given the desired format and width unsigned int m_stride; ///< Stride to use given the desired format and width
unsigned int m_bufferSize; ///< Amount of memory needed to store a buffer unsigned int m_bufferSize; ///< Amount of memory needed to store a buffer
@ -102,7 +101,6 @@ protected:
return m_buffers.size(); return m_buffers.size();
} }
}; };
} // namespace KiGfx } // namespace KiGfx
#endif /* COMPOSITOR_H_ */ #endif /* COMPOSITOR_H_ */

101
include/gal/cairo/cairo_gal.h
View File

@ -45,9 +45,6 @@
#endif #endif
#endif #endif
#define EXCEPTION_ZERO_CLIENT_RECTANGLE 0
#define EXCEPTION_ZERO_CONTEXT 1
/** /**
* @brief Class CAIRO_GAL is the cairo implementation of the graphics abstraction layer. * @brief Class CAIRO_GAL is the cairo implementation of the graphics abstraction layer.
* *
@ -92,7 +89,7 @@ public:
// --------------- // ---------------
/// @copydoc GAL::BeginDrawing() /// @copydoc GAL::BeginDrawing()
virtual void BeginDrawing() throw (int); virtual void BeginDrawing();
/// @copydoc GAL::EndDrawing() /// @copydoc GAL::EndDrawing()
virtual void EndDrawing(); virtual void EndDrawing();
@ -103,19 +100,19 @@ public:
/// @copydoc GAL::DrawSegment() /// @copydoc GAL::DrawSegment()
virtual void DrawSegment( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint, double aWidth ); virtual void DrawSegment( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint, double aWidth );
/// @copydoc GAL::DrawPolyline()
virtual void DrawPolyline( std::deque<VECTOR2D>& aPointList );
/// @copydoc GAL::DrawCircle() /// @copydoc GAL::DrawCircle()
virtual void DrawCircle( const VECTOR2D& aCenterPoint, double aRadius ); virtual void DrawCircle( const VECTOR2D& aCenterPoint, double aRadius );
/// @copydoc GAL::DrawArc() /// @copydoc GAL::DrawArc()
virtual void virtual void DrawArc( const VECTOR2D& aCenterPoint, double aRadius,
DrawArc( const VECTOR2D& aCenterPoint, double aRadius, double aStartAngle, double aEndAngle ); double aStartAngle, double aEndAngle );
/// @copydoc GAL::DrawRectangle() /// @copydoc GAL::DrawRectangle()
virtual void DrawRectangle( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ); virtual void DrawRectangle( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint );
/// @copydoc GAL::DrawPolyline()
virtual void DrawPolyline( std::deque<VECTOR2D>& aPointList );
/// @copydoc GAL::DrawPolygon() /// @copydoc GAL::DrawPolygon()
virtual void DrawPolygon( const std::deque<VECTOR2D>& aPointList ); virtual void DrawPolygon( const std::deque<VECTOR2D>& aPointList );
@ -149,24 +146,15 @@ public:
/// @copydoc GAL::SetIsStroke() /// @copydoc GAL::SetIsStroke()
virtual void SetIsStroke( bool aIsStrokeEnabled ); virtual void SetIsStroke( bool aIsStrokeEnabled );
/// @copydoc GAL::SetFillColor()
virtual void SetFillColor( const COLOR4D& aColor );
/// @copydoc GAL::SetStrokeColor() /// @copydoc GAL::SetStrokeColor()
virtual void SetStrokeColor( const COLOR4D& aColor ); virtual void SetStrokeColor( const COLOR4D& aColor );
/// @copydoc GAL::GetStrokeColor() /// @copydoc GAL::SetFillColor()
COLOR4D GetStrokeColor(); virtual void SetFillColor( const COLOR4D& aColor );
/// @copydoc GAL::SetBackgroundColor()
virtual void SetBackgroundColor( const COLOR4D& aColor );
/// @copydoc GAL::SetLineWidth() /// @copydoc GAL::SetLineWidth()
virtual void SetLineWidth( double aLineWidth ); virtual void SetLineWidth( double aLineWidth );
/// @copydoc GAL::GetLineWidth()
double GetLineWidth();
/// @copydoc GAL::SetLayerDepth() /// @copydoc GAL::SetLayerDepth()
virtual void SetLayerDepth( double aLayerDepth ); virtual void SetLayerDepth( double aLayerDepth );
@ -221,33 +209,6 @@ public:
// Handling the world <-> screen transformation // Handling the world <-> screen transformation
// -------------------------------------------------------- // --------------------------------------------------------
/// @copydoc GAL::ComputeWorldScreenMatrix()
virtual void ComputeWorldScreenMatrix();
/// @copydoc GAL::GetWorldScreenMatrix()
MATRIX3x3D GetWorldScreenMatrix();
/// @copydoc GAL::SetWorldScreenMatrix()
void SetWorldScreenMatrix( MATRIX3x3D aMatrix );
/// @copydoc GAL::SetWorldUnitLength()
void SetWorldUnitLength( double aWorldUnitLength );
/// @copydoc GAL::SetScreenDPI()
void SetScreenDPI( double aScreenDPI );
/// @copydoc GAL::SetLookAtPoint()
void SetLookAtPoint( const VECTOR2D& aPoint );
/// @copydoc GAL::GetLookAtPoint()
VECTOR2D GetLookAtPoint();
/// @copydoc GAL::SetZoomFactor()
void SetZoomFactor( double aZoomFactor );
/// @copydoc GAL::GetZoomFactor()
double GetZoomFactor();
/// @copydoc GAL::SaveScreen() /// @copydoc GAL::SaveScreen()
virtual void SaveScreen(); virtual void SaveScreen();
@ -264,9 +225,6 @@ public:
/// @copydoc GAL::ComputeCursorToWorld() /// @copydoc GAL::ComputeCursorToWorld()
virtual VECTOR2D ComputeCursorToWorld( const VECTOR2D& aCursorPosition ); virtual VECTOR2D ComputeCursorToWorld( const VECTOR2D& aCursorPosition );
/// @copydoc GAL::SetIsCursorEnabled()
void SetIsCursorEnabled( bool aIsCursorEnabled );
/// @copydoc GAL::DrawCursor() /// @copydoc GAL::DrawCursor()
virtual void DrawCursor( VECTOR2D aCursorPosition ); virtual void DrawCursor( VECTOR2D aCursorPosition );
@ -295,7 +253,7 @@ public:
} }
protected: protected:
virtual void DrawGridLine( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ); virtual void drawGridLine( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint );
private: private:
/// Super class definition /// Super class definition
@ -303,30 +261,29 @@ private:
// Compositing variables // Compositing variables
boost::shared_ptr<CAIRO_COMPOSITOR> compositor; ///< Object for layers compositing boost::shared_ptr<CAIRO_COMPOSITOR> compositor; ///< Object for layers compositing
unsigned int mainBuffer; ///< Handle to the main buffer unsigned int mainBuffer; ///< Handle to the main buffer
unsigned int overlayBuffer; ///< Handle to the overlay buffer unsigned int overlayBuffer; ///< Handle to the overlay buffer
// Variables related to wxWidgets // Variables related to wxWidgets
wxWindow* parentWindow; ///< Parent window wxWindow* parentWindow; ///< Parent window
wxEvtHandler* mouseListener; ///< Mouse listener wxEvtHandler* mouseListener; ///< Mouse listener
wxEvtHandler* paintListener; ///< Paint listener wxEvtHandler* paintListener; ///< Paint listener
unsigned int bufferSize; ///< Size of buffers cairoOutput, bitmapBuffers unsigned int bufferSize; ///< Size of buffers cairoOutput, bitmapBuffers
unsigned char* wxOutput; ///< wxImage comaptible buffer unsigned char* wxOutput; ///< wxImage comaptible buffer
// Cursor variables // Cursor variables
std::deque<wxColour> savedCursorPixels; ///< Saved pixels of the cursor std::deque<wxColour> savedCursorPixels; ///< Saved pixels of the cursor
bool isDeleteSavedPixels; ///< True, if the saved pixels can be discarded bool isDeleteSavedPixels; ///< True, if the saved pixels can be discarded
wxPoint savedCursorPosition; ///< The last cursor position wxPoint savedCursorPosition; ///< The last cursor position
wxBitmap* cursorPixels; ///< Cursor pixels wxBitmap* cursorPixels; ///< Cursor pixels
wxBitmap* cursorPixelsSaved; ///< Saved cursor pixels wxBitmap* cursorPixelsSaved; ///< Saved cursor pixels
int cursorSize; ///< Cursor size int cursorSize; ///< Cursor size
/// Maximum number of arguments for one command /// Maximum number of arguments for one command
static const int MAX_CAIRO_ARGUMENTS = 6; static const int MAX_CAIRO_ARGUMENTS = 6;
/// Definitions for the command recorder /// Definitions for the command recorder
enum GraphicsCommand enum GraphicsCommand {
{
CMD_SET_FILL, ///< Enable/disable filling CMD_SET_FILL, ///< Enable/disable filling
CMD_SET_STROKE, ///< Enable/disable stroking CMD_SET_STROKE, ///< Enable/disable stroking
CMD_SET_FILLCOLOR, ///< Set the fill color CMD_SET_FILLCOLOR, ///< Set the fill color
@ -392,18 +349,18 @@ private:
/// @copydoc GAL::initCursor() /// @copydoc GAL::initCursor()
virtual void initCursor( int aCursorSize ); virtual void initCursor( int aCursorSize );
/// Allocate the bitmaps for drawing
void allocateBitmaps();
/// Allocate the bitmaps for drawing
void deleteBitmaps();
/// Prepare Cairo surfaces for drawing /// Prepare Cairo surfaces for drawing
void initSurface(); void initSurface();
/// Destroy Cairo surfaces when are not needed anymore /// Destroy Cairo surfaces when are not needed anymore
void deinitSurface(); void deinitSurface();
/// Allocate the bitmaps for drawing
void allocateBitmaps();
/// Allocate the bitmaps for drawing
void deleteBitmaps();
/// Prepare the compositor /// Prepare the compositor
void setCompositor(); void setCompositor();

10
include/gal/graphics_abstraction_layer.h
View File

@ -231,7 +231,10 @@ public:
* *
* @param aColor is the color for background filling. * @param aColor is the color for background filling.
*/ */
virtual void SetBackgroundColor( const COLOR4D& aColor ) = 0; inline virtual void SetBackgroundColor( const COLOR4D& aColor )
{
backgroundColor = aColor;
}
/** /**
* @brief Set the line width. * @brief Set the line width.
@ -417,7 +420,7 @@ public:
// -------------------------------------------------------- // --------------------------------------------------------
/// @brief Compute the world <-> screen transformation matrix /// @brief Compute the world <-> screen transformation matrix
virtual void ComputeWorldScreenMatrix() = 0; virtual void ComputeWorldScreenMatrix();
/** /**
* @brief Get the world <-> screen transformation matrix. * @brief Get the world <-> screen transformation matrix.
@ -745,7 +748,6 @@ protected:
bool isFillEnabled; ///< Is filling of graphic objects enabled ? bool isFillEnabled; ///< Is filling of graphic objects enabled ?
bool isStrokeEnabled; ///< Are the outlines stroked ? bool isStrokeEnabled; ///< Are the outlines stroked ?
bool isSetAttributes; ///< True, if the attributes have been set
COLOR4D backgroundColor; ///< The background color COLOR4D backgroundColor; ///< The background color
COLOR4D fillColor; ///< The fill color COLOR4D fillColor; ///< The fill color
@ -784,7 +786,7 @@ protected:
* @param aStartPoint is the start point of the line. * @param aStartPoint is the start point of the line.
* @param aEndPoint is the end point of the line. * @param aEndPoint is the end point of the line.
*/ */
virtual void DrawGridLine( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ) = 0; virtual void drawGridLine( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ) = 0;
/** /**
* @brief Initialize the cursor. * @brief Initialize the cursor.

12
include/gal/opengl/cached_container.h
View File

@ -94,12 +94,12 @@ protected:
unsigned int m_itemSize; unsigned int m_itemSize;
/** /**
* Function reallocate() * Function reallocate()
* resizes the chunk that stores the current item to the given size. * resizes the chunk that stores the current item to the given size.
* *
* @param aSize is the number of vertices to be stored. * @param aSize is the number of vertices to be stored.
* @return offset of the new chunk. * @return offset of the new chunk.
*/ */
virtual unsigned int reallocate( unsigned int aSize ); virtual unsigned int reallocate( unsigned int aSize );
/** /**

2
include/gal/opengl/opengl_compositor.h
View File

@ -37,7 +37,6 @@
namespace KiGfx namespace KiGfx
{ {
class OPENGL_COMPOSITOR : public COMPOSITOR class OPENGL_COMPOSITOR : public COMPOSITOR
{ {
public: public:
@ -94,7 +93,6 @@ protected:
return m_buffers.size(); return m_buffers.size();
} }
}; };
} // namespace KiGfx } // namespace KiGfx
#endif /* COMPOSITOR_H_ */ #endif /* COMPOSITOR_H_ */

209
include/gal/opengl/opengl_gal.h
View File

@ -104,19 +104,19 @@ public:
/// @copydoc GAL::DrawSegment() /// @copydoc GAL::DrawSegment()
virtual void DrawSegment( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint, double aWidth ); virtual void DrawSegment( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint, double aWidth );
/// @copydoc GAL::DrawPolyline()
virtual void DrawPolyline( std::deque<VECTOR2D>& aPointList );
/// @copydoc GAL::DrawCircle() /// @copydoc GAL::DrawCircle()
virtual void DrawCircle( const VECTOR2D& aCenterPoint, double aRadius ); virtual void DrawCircle( const VECTOR2D& aCenterPoint, double aRadius );
/// @copydoc GAL::DrawArc() /// @copydoc GAL::DrawArc()
virtual void virtual void DrawArc( const VECTOR2D& aCenterPoint, double aRadius,
DrawArc( const VECTOR2D& aCenterPoint, double aRadius, double aStartAngle, double aEndAngle ); double aStartAngle, double aEndAngle );
/// @copydoc GAL::DrawRectangle() /// @copydoc GAL::DrawRectangle()
virtual void DrawRectangle( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ); virtual void DrawRectangle( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint );
/// @copydoc GAL::DrawPolyline()
virtual void DrawPolyline( std::deque<VECTOR2D>& aPointList );
/// @copydoc GAL::DrawPolygon() /// @copydoc GAL::DrawPolygon()
virtual void DrawPolygon( const std::deque<VECTOR2D>& aPointList ); virtual void DrawPolygon( const std::deque<VECTOR2D>& aPointList );
@ -129,7 +129,7 @@ public:
// -------------- // --------------
/// @brief Resizes the canvas. /// @brief Resizes the canvas.
virtual void ResizeScreen ( int aWidth, int aHeight ); virtual void ResizeScreen( int aWidth, int aHeight );
/// @brief Shows/hides the GAL canvas /// @brief Shows/hides the GAL canvas
virtual bool Show( bool aShow ); virtual bool Show( bool aShow );
@ -144,42 +144,9 @@ public:
// Attribute setting // Attribute setting
// ----------------- // -----------------
/// @copydoc GAL::SetIsFill()
virtual void SetIsFill( bool aIsFillEnabled )
{
isFillEnabled = aIsFillEnabled;
}
/// @copydoc GAL::SetIsStroke()
virtual void SetIsStroke( bool aIsStrokeEnabled )
{
isStrokeEnabled = aIsStrokeEnabled;
}
/// @copydoc GAL::SetFillColor()
virtual void SetFillColor( const COLOR4D& aColor );
/// @copydoc GAL::SetStrokeColor() /// @copydoc GAL::SetStrokeColor()
virtual void SetStrokeColor( const COLOR4D& aColor ); virtual void SetStrokeColor( const COLOR4D& aColor );
/// @copydoc GAL::GetStrokeColor()
COLOR4D GetStrokeColor();
/// @copydoc GAL::SetBackgroundColor()
virtual void SetBackgroundColor( const COLOR4D& aColor );
/// @copydoc GAL::SetLineWidth()
virtual void SetLineWidth( double aLineWidth );
/// @copydoc GAL::GetLineWidth()
double GetLineWidth();
/// @copydoc GAL::SetLayerDepth()
virtual void SetLayerDepth( double aLayerDepth )
{
super::SetLayerDepth( aLayerDepth );
}
// -------------- // --------------
// Transformation // Transformation
// -------------- // --------------
@ -231,33 +198,6 @@ public:
// Handling the world <-> screen transformation // Handling the world <-> screen transformation
// -------------------------------------------------------- // --------------------------------------------------------
/// @copydoc GAL::ComputeWorldScreenMatrix()
virtual void ComputeWorldScreenMatrix();
/// @copydoc GAL::GetWorldScreenMatrix()
MATRIX3x3D GetWorldScreenMatrix();
/// @copydoc GAL::SetWorldScreenMatrix()
void SetWorldScreenMatrix( MATRIX3x3D aMatrix );
/// @copydoc GAL::SetWorldUnitLength()
void SetWorldUnitLength( double aWorldUnitLength );
/// @copydoc GAL::SetScreenDPI()
void SetScreenDPI( double aScreenDPI );
/// @copydoc GAL::SetLookAtPoint()
void SetLookAtPoint( const VECTOR2D& aPoint );
/// @copydoc GAL::GetLookAtPoint()
VECTOR2D GetLookAtPoint();
/// @copydoc GAL::SetZoomFactor()
void SetZoomFactor( double aZoomFactor );
/// @copydoc GAL::GetZoomFactor()
double GetZoomFactor();
/// @copydoc GAL::SaveScreen() /// @copydoc GAL::SaveScreen()
virtual void SaveScreen(); virtual void SaveScreen();
@ -274,9 +214,6 @@ public:
/// @copydoc GAL::ComputeCursorToWorld() /// @copydoc GAL::ComputeCursorToWorld()
virtual VECTOR2D ComputeCursorToWorld( const VECTOR2D& aCursorPosition ); virtual VECTOR2D ComputeCursorToWorld( const VECTOR2D& aCursorPosition );
/// @copydoc GAL::SetIsCursorEnabled()
void SetIsCursorEnabled( bool aIsCursorEnabled );
/// @copydoc GAL::DrawCursor() /// @copydoc GAL::DrawCursor()
virtual void DrawCursor( VECTOR2D aCursorPosition ); virtual void DrawCursor( VECTOR2D aCursorPosition );
@ -312,7 +249,7 @@ public:
} TessParams; } TessParams;
protected: protected:
virtual void DrawGridLine( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ); virtual void drawGridLine( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint );
private: private:
/// Super class definition /// Super class definition
@ -321,90 +258,114 @@ private:
static const int CIRCLE_POINTS = 64; ///< The number of points for circle approximation static const int CIRCLE_POINTS = 64; ///< The number of points for circle approximation
static const int CURVE_POINTS = 32; ///< The number of points for curve approximation static const int CURVE_POINTS = 32; ///< The number of points for curve approximation
wxClientDC* clientDC; ///< Drawing context wxClientDC* clientDC; ///< Drawing context
wxGLContext* glContext; ///< OpenGL context of wxWidgets wxGLContext* glContext; ///< OpenGL context of wxWidgets
wxWindow* parentWindow; ///< Parent window wxWindow* parentWindow; ///< Parent window
wxEvtHandler* mouseListener; wxEvtHandler* mouseListener;
wxEvtHandler* paintListener; wxEvtHandler* paintListener;
// Precomputed vertices for faster circle & semicircle drawing
NONCACHED_CONTAINER circleContainer; ///< Container for storing circle vertices
// Vertex buffer objects related fields // Vertex buffer objects related fields
typedef std::map< unsigned int, boost::shared_ptr<VERTEX_ITEM> > GroupsMap; typedef std::map< unsigned int, boost::shared_ptr<VERTEX_ITEM> > GroupsMap;
GroupsMap groups; ///< Stores informations about VBO objects (groups) GroupsMap groups; ///< Stores informations about VBO objects (groups)
unsigned int groupCounter; ///< Counter used for generating keys for groups unsigned int groupCounter; ///< Counter used for generating keys for groups
VERTEX_MANAGER* currentManager; ///< Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs) VERTEX_MANAGER* currentManager; ///< Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
VERTEX_MANAGER cachedManager; ///< Container for storing cached VERTEX_ITEMs VERTEX_MANAGER cachedManager; ///< Container for storing cached VERTEX_ITEMs
VERTEX_MANAGER nonCachedManager; ///< Container for storing non-cached VERTEX_ITEMs VERTEX_MANAGER nonCachedManager; ///< Container for storing non-cached VERTEX_ITEMs
VERTEX_MANAGER overlayManager; ///< Container for storing overlaid VERTEX_ITEMs VERTEX_MANAGER overlayManager; ///< Container for storing overlaid VERTEX_ITEMs
// Framebuffer & compositing // Framebuffer & compositing
OPENGL_COMPOSITOR compositor; ///< Handles multiple rendering targets OPENGL_COMPOSITOR compositor; ///< Handles multiple rendering targets
unsigned int mainBuffer; ///< Main rendering target unsigned int mainBuffer; ///< Main rendering target
unsigned int overlayBuffer; ///< Auxiliary rendering target (for menus etc.) unsigned int overlayBuffer; ///< Auxiliary rendering target (for menus etc.)
// Polygon tesselation
GLUtesselator* tesselator; ///< Pointer to the tesselator
std::vector<GLdouble*> tessIntersects; ///< Storage of intersecting points
// Shader // Shader
SHADER shader; ///< There is only one shader used for different objects SHADER shader; ///< There is only one shader used for different objects
// Cursor // Cursor
int cursorSize; ///< Size of the cursor in pixels int cursorSize; ///< Size of the cursor in pixels
GLubyte* cursorShape; ///< Cursor pixel storage GLubyte* cursorShape; ///< Cursor pixel storage
GLubyte* cursorSave; ///< Saved cursor pixels GLubyte* cursorSave; ///< Saved cursor pixels
VECTOR2D savedCursorPosition; ///< Last saved cursor position VECTOR2D savedCursorPosition; ///< Last saved cursor position
// Internal flags // Internal flags
bool isGlewInitialized; ///< Is GLEW initialized? bool isGlewInitialized; ///< Is GLEW initialized?
bool isFramebufferInitialized; ///< Are the framebuffers initialized? bool isFramebufferInitialized; ///< Are the framebuffers initialized?
bool isShaderInitialized; ///< Was the shader initialized? bool isShaderInitialized; ///< Was the shader initialized?
bool isGrouping; ///< Was a group started? bool isGrouping; ///< Was a group started?
// Polygon tesselation
GLUtesselator* tesselator; ///< Pointer to the tesselator
std::vector<GLdouble*> tessIntersects; ///< Storage of intersecting points
// Structure used for tesselation of polygons
struct OGLPOINT
{
OGLPOINT() :
x( 0.0 ), y( 0.0 ), z( 0.0 )
{}
OGLPOINT( const char* fastest )
{
// do nothing for fastest speed, and keep inline
}
OGLPOINT( const VECTOR2D& aPoint ) :
x( aPoint.x ), y( aPoint.y ), z( 0.0 )
{}
OGLPOINT& operator=( const VECTOR2D& aPoint )
{
x = aPoint.x;
y = aPoint.y;
z = 0.0;
return *this;
}
GLdouble x;
GLdouble y;
GLdouble z;
};
/** /**
* @brief Draw a semi circle. Depending on settings (isStrokeEnabled & isFilledEnabled) it runs * @brief Draw a quad for the line.
*
* @param aStartPoint is the start point of the line.
* @param aEndPoint is the end point of the line.
*/
inline void drawLineQuad( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint );
/**
* @brief Draw a semicircle. Depending on settings (isStrokeEnabled & isFilledEnabled) it runs
* the proper function (drawStrokedSemiCircle or drawFilledSemiCircle). * the proper function (drawStrokedSemiCircle or drawFilledSemiCircle).
* *
* @param aCenterPoint is the center point. * @param aCenterPoint is the center point.
* @param aRadius is the radius of the semi-circle. * @param aRadius is the radius of the semicircle.
* @param aAngle is the angle of the semi-circle. * @param aAngle is the angle of the semicircle.
* *
*/ */
void drawSemiCircle( const VECTOR2D& aCenterPoint, double aRadius, double aAngle ); void drawSemiCircle( const VECTOR2D& aCenterPoint, double aRadius, double aAngle );
/** /**
* @brief Draw a filled semi circle. * @brief Draw a filled semicircle.
* *
* @param aCenterPoint is the center point. * @param aCenterPoint is the center point.
* @param aRadius is the radius of the semi-circle. * @param aRadius is the radius of the semicircle.
* @param aAngle is the angle of the semi-circle. * @param aAngle is the angle of the semicircle.
* *
*/ */
void drawFilledSemiCircle( const VECTOR2D& aCenterPoint, double aRadius, double aAngle ); void drawFilledSemiCircle( const VECTOR2D& aCenterPoint, double aRadius, double aAngle );
/** /**
* @brief Draw a stroked semi circle. * @brief Draw a stroked semicircle.
* *
* @param aCenterPoint is the center point. * @param aCenterPoint is the center point.
* @param aRadius is the radius of the semi-circle. * @param aRadius is the radius of the semicircle.
* @param aAngle is the angle of the semi-circle. * @param aAngle is the angle of the semicircle.
* *
*/ */
void drawStrokedSemiCircle( const VECTOR2D& aCenterPoint, double aRadius, double aAngle ); void drawStrokedSemiCircle( const VECTOR2D& aCenterPoint, double aRadius, double aAngle );
/// Compute the points of the unit circle and store them in VBO.
void computeCircle();
// Event handling // Event handling
/**
* @brief This is the window creation event handler.
*
* @param aEvent is the window creation event.
*/
void onCreate( wxWindowCreateEvent& aEvent );
/** /**
* @brief This is the OnPaint event handler. * @brief This is the OnPaint event handler.
* *
@ -419,20 +380,12 @@ private:
*/ */
void skipMouseEvent( wxMouseEvent& aEvent ); void skipMouseEvent( wxMouseEvent& aEvent );
/// Initialize GLEW. /// Initialize GLEW
void initGlew(); void initGlew();
/// @copydoc GAL::initCursor() /// @copydoc GAL::initCursor()
virtual void initCursor( int aCursorSize ); virtual void initCursor( int aCursorSize );
/**
* @brief Draw a quad for the line.
*
* @param aStartPoint is the start point of the line.
* @param aEndPoint is the end point of the line.
*/
inline void drawLineQuad( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint );
/** /**
* @brief Returns a valid key that can be used as a new group number. * @brief Returns a valid key that can be used as a new group number.
* *

7
include/gal/opengl/vertex_common.h
View File

@ -35,9 +35,8 @@
namespace KiGfx namespace KiGfx
{ {
// Possible types of shaders // Possible types of shaders
enum SHADER_TYPE enum SHADER_TYPE {
{ SHADER_NONE = 0,
SHADER_NONE = 0,
SHADER_LINE, SHADER_LINE,
SHADER_FILLED_CIRCLE, SHADER_FILLED_CIRCLE,
SHADER_STROKED_CIRCLE, SHADER_STROKED_CIRCLE,
@ -60,7 +59,7 @@ const unsigned int CoordStride = CoordSize / sizeof(GLfloat);
// Offset of color data from the beginning of each vertex data // Offset of color data from the beginning of each vertex data
const unsigned int ColorOffset = offsetof(VERTEX, r); const unsigned int ColorOffset = offsetof(VERTEX, r);
const unsigned int ColorSize = sizeof(VERTEX().r) + sizeof(VERTEX().g) + const unsigned int ColorSize = sizeof(VERTEX().r) + sizeof(VERTEX().g) +
sizeof(VERTEX().b) + sizeof(VERTEX().a); sizeof(VERTEX().b) + sizeof(VERTEX().a);
const unsigned int ColorStride = ColorSize / sizeof(GLubyte); const unsigned int ColorStride = ColorSize / sizeof(GLubyte);
// Shader attributes // Shader attributes