← Back to branch summary

~pierre-parent-k/kicad/length-tunning

« back to all changes in this revision

Viewing changes to common/gal/graphics_abstraction_layer.cpp

  • Committer: Pierre Parent
  • Date: 2014-07-06 10:32:13 UTC
  • mfrom: (4798.1.179 kicad)
  • Revision ID: pierre.parent@insa-rouen.fr-20140706103213-wjsdy0hc9q6wbz5v
Merge with lp:kicad 4977

Show diffs side-by-side

added added

removed removed

Lines of Context:
common/gal/graphics_abstraction_layer.cpp
31
31
 
32
32
using namespace KIGFX;
33
33
 
 
34
 
 
35
const double GAL::METRIC_UNIT_LENGTH = 1e9;
 
36
 
 
37
 
34
38
GAL::GAL() :
35
39
    strokeFont( this )
36
40
{
39
43
    SetIsStroke( true );
40
44
    SetFillColor( COLOR4D( 0.0, 0.0, 0.0, 0.0 ) );
41
45
    SetStrokeColor( COLOR4D( 1.0, 1.0, 1.0, 1.0 ) );
 
46
    SetLookAtPoint( VECTOR2D( 0, 0 ) );
42
47
    SetZoomFactor( 1.0 );
 
48
    SetWorldUnitLength( 1.0 / METRIC_UNIT_LENGTH * 2.54 );   // 1 inch in nanometers
 
49
    SetScreenDPI( 106 );                                     // Display resolution setting
43
50
    SetDepthRange( VECTOR2D( GAL::MIN_DEPTH, GAL::MAX_DEPTH ) );
44
51
    SetFlip( false, false );
45
52
    SetLineWidth( 1.0 );
85
92
 
86
93
    MATRIX3x3D translation;
87
94
    translation.SetIdentity();
88
 
    translation.SetTranslation( 0.5 * screenSize );
 
95
    translation.SetTranslation( 0.5 * VECTOR2D( screenSize ) );
89
96
 
90
97
    MATRIX3x3D scale;
91
98
    scale.SetIdentity();
112
119
    SetTarget( TARGET_NONCACHED );
113
120
 
114
121
    // Draw the origin marker
115
 
    double origSize = static_cast<double>( gridOriginMarkerSize ) / worldScale;
 
122
    double originSize = gridOriginMarkerSize / worldScale;
116
123
    SetLayerDepth( GAL::GRID_DEPTH );
117
124
    SetIsFill( false );
118
125
    SetIsStroke( true );
119
126
    SetStrokeColor( COLOR4D( 1.0, 1.0, 1.0, 1.0 ) );
120
127
    SetLineWidth( gridLineWidth / worldScale );
121
 
    DrawLine( gridOrigin + VECTOR2D( -origSize, -origSize ),
122
 
              gridOrigin + VECTOR2D( origSize, origSize ) );
123
 
    DrawLine( gridOrigin + VECTOR2D( -origSize, origSize ),
124
 
              gridOrigin + VECTOR2D( origSize, -origSize ) );
125
 
    DrawCircle( gridOrigin, origSize * 0.7 );
 
128
    DrawLine( gridOrigin + VECTOR2D( -originSize, -originSize ),
 
129
              gridOrigin + VECTOR2D( originSize, originSize ) );
 
130
    DrawLine( gridOrigin + VECTOR2D( -originSize, originSize ),
 
131
              gridOrigin + VECTOR2D( originSize, -originSize ) );
 
132
    DrawCircle( gridOrigin, originSize * 0.7 );
126
133
 
127
134
    // Draw the grid
128
135
    // For the drawing the start points, end points and increments have
129
136
    // to be calculated in world coordinates
130
 
    VECTOR2D    worldStartPoint = screenWorldMatrix * VECTOR2D( 0.0, 0.0 );
131
 
    VECTOR2D    worldEndPoint   = screenWorldMatrix * screenSize;
 
137
    gridOffset = VECTOR2D( (long) gridOrigin.x % (long) gridSize.x,
 
138
                           (long) gridOrigin.y % (long) gridSize.y );
 
139
 
 
140
    VECTOR2D worldStartPoint = screenWorldMatrix * VECTOR2D( 0.0, 0.0 );
 
141
    VECTOR2D worldEndPoint   = screenWorldMatrix * VECTOR2D( screenSize );
132
142
 
133
143
    int gridScreenSizeDense  = round( gridSize.x * worldScale );
134
144
    int gridScreenSizeCoarse = round( gridSize.x * static_cast<double>( gridTick ) * worldScale );
141
151
    if( std::max( gridScreenSizeDense, gridScreenSizeCoarse ) > gridDrawThreshold )
142
152
    {
143
153
        // Compute grid variables
144
 
        int gridStartX = round( worldStartPoint.x / gridSize.x );
145
 
        int gridEndX = round( worldEndPoint.x / gridSize.x );
146
 
        int gridStartY = round( worldStartPoint.y / gridSize.y );
147
 
        int gridEndY = round( worldEndPoint.y / gridSize.y );
 
154
        int gridStartX  = round( worldStartPoint.x / gridSize.x );
 
155
        int gridEndX    = round( worldEndPoint.x / gridSize.x );
 
156
        int gridStartY  = round( worldStartPoint.y / gridSize.y );
 
157
        int gridEndY    = round( worldEndPoint.y / gridSize.y );
148
158
 
149
 
        // Swap the coordinates, if they have not the right order
150
 
        SWAP( gridEndX, <, gridStartX );
151
 
        SWAP( gridEndY, <, gridStartY );
 
159
        assert( gridEndX >= gridStartX );
 
160
        assert( gridEndY >= gridStartY );
152
161
 
153
162
        // Correct the index, else some lines are not correctly painted
154
 
        gridStartX  -= 1;
155
 
        gridStartY  -= 1;
156
 
        gridEndX    += 1;
157
 
        gridEndY    += 1;
 
163
        gridStartX  -= ( gridOrigin.x / gridSize.x ) + 1;
 
164
        gridStartY  -= ( gridOrigin.y / gridSize.y ) + 1;
 
165
        gridEndX    += ( gridOrigin.x / gridSize.x ) + 1;
 
166
        gridEndY    += ( gridOrigin.y / gridSize.y ) + 1;
158
167
 
159
168
        // Draw the grid behind all other layers
160
169
        SetLayerDepth( depthRange.y * 0.75 );
166
175
            SetStrokeColor( gridColor );
167
176
 
168
177
            // Now draw the grid, every coarse grid line gets the double width
 
178
 
 
179
            // Vertical lines
169
180
            for( int j = gridStartY; j < gridEndY; j += 1 )
170
181
            {
171
182
                if( j % gridTick == 0 && gridScreenSizeDense > gridDrawThreshold )
176
187
                if( ( j % gridTick == 0 && gridScreenSizeCoarse > gridDrawThreshold )
177
188
                    || gridScreenSizeDense > gridDrawThreshold )
178
189
                {
179
 
                    drawGridLine( VECTOR2D( gridStartX * gridSize.x, j * gridSize.y ),
180
 
                                  VECTOR2D( gridEndX * gridSize.x,   j * gridSize.y ) );
 
190
                    drawGridLine( VECTOR2D( gridStartX * gridSize.x, j * gridSize.y + gridOrigin.y ),
 
191
                                  VECTOR2D( gridEndX * gridSize.x,   j * gridSize.y + gridOrigin.y ) );
181
192
                }
182
193
            }
183
194
 
 
195
            // Horizontal lines
184
196
            for( int i = gridStartX; i < gridEndX; i += 1 )
185
197
            {
186
198
                if( i % gridTick == 0 && gridScreenSizeDense > gridDrawThreshold )
191
203
                if( ( i % gridTick == 0 && gridScreenSizeCoarse > gridDrawThreshold )
192
204
                    || gridScreenSizeDense > gridDrawThreshold )
193
205
                {
194
 
                    drawGridLine( VECTOR2D( i * gridSize.x, gridStartY * gridSize.y ),
195
 
                                  VECTOR2D( i * gridSize.x, gridEndY * gridSize.y ) );
 
206
                    drawGridLine( VECTOR2D( i * gridSize.x + gridOrigin.x, gridStartY * gridSize.y ),
 
207
                                  VECTOR2D( i * gridSize.x + gridOrigin.x, gridEndY * gridSize.y ) );
196
208
                }
197
209
            }
198
210
        }
220
232
                    if( tickX || tickY || gridScreenSizeDense > gridDrawThreshold )
221
233
                    {
222
234
                        double radius = ( tickX && tickY ) ? doubleMarker : marker;
223
 
                        DrawRectangle( VECTOR2D( i * gridSize.x - radius,
224
 
                                                 j * gridSize.y - radius ),
225
 
                                       VECTOR2D( i * gridSize.x + radius,
226
 
                                                 j * gridSize.y + radius ) );
 
235
                        DrawRectangle( VECTOR2D( i * gridSize.x - radius + gridOrigin.x,
 
236
                                                 j * gridSize.y - radius + gridOrigin.y ),
 
237
                                       VECTOR2D( i * gridSize.x + radius + gridOrigin.x,
 
238
                                                 j * gridSize.y + radius + gridOrigin.y ) );
227
239
                    }
228
240
                }
229
241
            }
232
244
}
233
245
 
234
246
 
235
 
VECTOR2D GAL::GetGridPoint( VECTOR2D aPoint ) const
 
247
VECTOR2D GAL::GetGridPoint( const VECTOR2D& aPoint ) const
236
248
{
237
 
    VECTOR2D pointWorld = ToWorld( aPoint );
238
 
 
239
 
    pointWorld.x = round( pointWorld.x / gridSize.x ) * gridSize.x;
240
 
    pointWorld.y = round( pointWorld.y / gridSize.y ) * gridSize.y;
241
 
 
242
 
    return ToScreen( pointWorld );
 
249
    return VECTOR2D( round( ( aPoint.x - gridOffset.x ) / gridSize.x ) * gridSize.x + gridOffset.x,
 
250
                     round( ( aPoint.y - gridOffset.y ) / gridSize.y ) * gridSize.y + gridOffset.y );
243
251
}