gr_basic.cpp File Reference

#include <gr_basic.h>
#include <trigo.h>
#include <eda_item.h>
#include <base_screen.h>
#include <bezier_curves.h>
#include <math_for_graphics.h>
#include <wx/graphics.h>
#include <geometry/geometry_utils.h>
#include <math/util.h>
#include <algorithm>
#include <SutherlandHodgmanClipPoly.h>

Go to the source code of this file.

Macros
#define	DEBUG_DUMP_CLIP_ERROR_COORDS   0
#define	DEBUG_DUMP_CLIP_COORDS   0

Functions
static void	ClipAndDrawPoly (EDA_RECT *aClipBox, wxDC *aDC, const wxPoint *Points, int n)
	Used to clip a polygon and draw it as Filled Polygon. More...
static void	GRSRect (EDA_RECT *aClipBox, wxDC *aDC, int x1, int y1, int x2, int y2, int aWidth, const COLOR4D &aColor, wxPenStyle aStyle=wxPENSTYLE_SOLID)
static void	WinClipAndDrawLine (EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int width)
void	GRResetPenAndBrush (wxDC *DC)
void	GRSetColorPen (wxDC *DC, const COLOR4D &Color, int width, wxPenStyle style)
void	GRSetBrush (wxDC *DC, const COLOR4D &Color, bool fill)
void	GRForceBlackPen (bool flagforce)
bool	GetGRForceBlackPenState (void)
void	GRPutPixel (EDA_RECT *ClipBox, wxDC *DC, int x, int y, const COLOR4D &Color)
void	GRLine (EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int width, const COLOR4D &Color, wxPenStyle aStyle)
void	GRLine (EDA_RECT *aClipBox, wxDC *aDC, const wxPoint &aStart, const wxPoint &aEnd, int aWidth, const COLOR4D &aColor, wxPenStyle aStyle)
void	GRMoveTo (int x, int y)
void	GRLineTo (EDA_RECT *ClipBox, wxDC *DC, int x, int y, int width, const COLOR4D &Color)
void	GRLineArray (EDA_RECT *aClipBox, wxDC *aDC, std::vector< wxPoint > &aLines, int aWidth, const COLOR4D &aColor)
	Draw an array of lines (not a polygon). More...
void	GRCSegm (EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int width, int aPenSize, const COLOR4D &Color)
void	GRCSegm (EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int width, const COLOR4D &Color)
void	GRCSegm (EDA_RECT *aClipBox, wxDC *aDC, const wxPoint &aStart, const wxPoint &aEnd, int aWidth, const COLOR4D &aColor)
void	GRFillCSegm (EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int width, const COLOR4D &Color)
void	GRFilledSegment (EDA_RECT *aClipBox, wxDC *aDC, const wxPoint &aStart, const wxPoint &aEnd, int aWidth, const COLOR4D &aColor)
static bool	IsGRSPolyDrawable (EDA_RECT *ClipBox, int n, const wxPoint *Points)
static void	GRSPoly (EDA_RECT *ClipBox, wxDC *DC, int n, const wxPoint *Points, bool Fill, int width, const COLOR4D &Color, const COLOR4D &BgColor)
	Draw a new polyline and fill it if Fill, in screen space. More...
static void	GRSClosedPoly (EDA_RECT *aClipBox, wxDC *aDC, int aPointCount, const wxPoint *aPoints, bool aFill, int aWidth, const COLOR4D &aColor, const COLOR4D &aBgColor)
	Draw a new closed polyline and fill it if Fill, in screen space. More...
void	GRPoly (EDA_RECT *ClipBox, wxDC *DC, int n, const wxPoint *Points, bool Fill, int width, const COLOR4D &Color, const COLOR4D &BgColor)
	Draw a new polyline and fill it if Fill, in drawing space. More...
void	GRClosedPoly (EDA_RECT *ClipBox, wxDC *DC, int n, const wxPoint *Points, bool Fill, const COLOR4D &Color, const COLOR4D &BgColor)
	Draw a closed polyline and fill it if Fill, in object space. More...
void	GRClosedPoly (EDA_RECT *ClipBox, wxDC *DC, int n, const wxPoint *Points, bool Fill, int width, const COLOR4D &Color, const COLOR4D &BgColor)
	Draw a closed polygon onto the drawing context aDC and optionally fills and/or draws a border around it. More...
static bool	clipCircle (EDA_RECT *aClipBox, int xc, int yc, int r, int aWidth)
void	GRCircle (EDA_RECT *ClipBox, wxDC *DC, int xc, int yc, int r, int width, const COLOR4D &Color)
void	GRCircle (EDA_RECT *ClipBox, wxDC *DC, int x, int y, int r, const COLOR4D &Color)
	Draw a circle onto the drawing context aDC centered at the user coordinates (x,y). More...
void	GRCircle (EDA_RECT *aClipBox, wxDC *aDC, const wxPoint &aPos, int aRadius, int aWidth, const COLOR4D &aColor)
void	GRFilledCircle (EDA_RECT *ClipBox, wxDC *DC, int x, int y, int r, int width, const COLOR4D &Color, const COLOR4D &BgColor)
void	GRFilledCircle (EDA_RECT *aClipBox, wxDC *aDC, const wxPoint &aPos, int aRadius, const COLOR4D &aColor)
void	GRArc1 (EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int xc, int yc, const COLOR4D &Color)
void	GRArc1 (EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int xc, int yc, int width, const COLOR4D &Color)
void	GRArc1 (EDA_RECT *aClipBox, wxDC *aDC, const wxPoint &aStart, const wxPoint &aEnd, const wxPoint &aCenter, int aWidth, const COLOR4D &aColor)
void	GRFilledArc (EDA_RECT *ClipBox, wxDC *DC, int x, int y, double StAngle, double EndAngle, int r, int width, const COLOR4D &Color, const COLOR4D &BgColor)
void	GRFilledArc (EDA_RECT *ClipBox, wxDC *DC, int x, int y, double StAngle, double EndAngle, int r, const COLOR4D &Color, const COLOR4D &BgColor)
void	GRArc (EDA_RECT *ClipBox, wxDC *DC, int xc, int yc, double StAngle, double EndAngle, int r, const COLOR4D &Color)
void	GRArc (EDA_RECT *ClipBox, wxDC *DC, int x, int y, double StAngle, double EndAngle, int r, int width, const COLOR4D &Color)
void	GRRect (EDA_RECT *aClipBox, wxDC *aDC, int x1, int y1, int x2, int y2, const COLOR4D &aColor)
void	GRRectPs (EDA_RECT *aClipBox, wxDC *aDC, const EDA_RECT &aRect, const COLOR4D &aColor, wxPenStyle aStyle)
void	GRRect (EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int width, const COLOR4D &Color)
void	GRRect (EDA_RECT *aClipBox, wxDC *aDC, const EDA_RECT &aRect, int aWidth, const COLOR4D &aColor)
void	GRFilledRect (EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, const COLOR4D &Color, const COLOR4D &BgColor)
void	GRFilledRect (EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int width, const COLOR4D &Color, const COLOR4D &BgColor)
void	GRSFilledRect (EDA_RECT *aClipBox, wxDC *aDC, int x1, int y1, int x2, int y2, int aWidth, const COLOR4D &aColor, const COLOR4D &aBgColor)
void	GRBezier (EDA_RECT *aClipBox, wxDC *aDC, std::vector< wxPoint > &aPoint, int aWidth, const COLOR4D &aColor)
	Draw cubic (4 points: start control1, control2, end) bezier curve. More...
void	GRDrawAnchor (EDA_RECT *aClipBox, wxDC *aDC, int x, int y, int aSize, const COLOR4D &aColor)
void	GRDrawWrappedText (wxDC &aDC, wxString const &aText)
	Draw text centered on a wxDC with wrapping. More...

Variables
static const bool	FILLED = true
static const bool	NOT_FILLED = false
GR_DRAWMODE	g_XorMode = GR_NXOR
static int	GRLastMoveToX
static int	GRLastMoveToY
static bool	s_ForceBlackPen
static int	xcliplo = 0
static int	ycliplo = 0
static int	xcliphi = 2000
static int	ycliphi = 2000
static COLOR4D	s_DC_lastcolor (0, 0, 0, 0)
static COLOR4D	s_DC_lastbrushcolor (0, 0, 0, 0)
static bool	s_DC_lastbrushfill = false
static wxDC *	s_DC_lastDC = nullptr

Macro Definition Documentation

DEBUG_DUMP_CLIP_COORDS

#define DEBUG_DUMP_CLIP_COORDS   0

Definition at line 61 of file gr_basic.cpp.

DEBUG_DUMP_CLIP_ERROR_COORDS

#define DEBUG_DUMP_CLIP_ERROR_COORDS   0

Definition at line 60 of file gr_basic.cpp.

Function Documentation

ClipAndDrawPoly()

void ClipAndDrawPoly ( EDA_RECT *  aClipBox, wxDC *  aDC, const wxPoint *  Points, int  n  )

static

Used to clip a polygon and draw it as Filled Polygon.

Uses the Sutherland and Hodgman algo to clip the given poly against a rectangle. This rectangle is the drawing area this is useful under Linux (2009) because filled polygons are incorrectly drawn if they have too large coordinates (seems due to integer overflows in calculations). Could be removed in some years, if become unnecessary.

Definition at line 874 of file gr_basic.cpp.

{
    if( aClipBox == nullptr )
    {
        aDC->DrawPolygon( n, Points );
        return;
    }

    // A clip box exists: clip and draw the polygon.
    static std::vector<wxPoint> clippedPolygon;
    static pointVector inputPolygon, outputPolygon;

    inputPolygon.clear();
    outputPolygon.clear();
    clippedPolygon.clear();

    for( int ii = 0; ii < n; ii++ )
        inputPolygon.push_back( PointF( (REAL) Points[ii].x, (REAL) Points[ii].y ) );

    RectF window( (REAL) aClipBox->GetX(), (REAL) aClipBox->GetY(),
                  (REAL) aClipBox->GetWidth(), (REAL) aClipBox->GetHeight() );

    SutherlandHodgman sh( window );
    sh.Clip( inputPolygon, outputPolygon );

    for( cpointIterator cit = outputPolygon.begin(); cit != outputPolygon.end(); ++cit )
    {
        clippedPolygon.emplace_back( KiROUND( cit->X ), KiROUND( cit->Y ) );
    }

    if( clippedPolygon.size() )
        aDC->DrawPolygon( clippedPolygon.size(), &clippedPolygon[0] );
}

References EDA_RECT::GetHeight(), EDA_RECT::GetWidth(), EDA_RECT::GetX(), EDA_RECT::GetY(), and KiROUND().

Referenced by GRSClosedPoly(), GRSFilledRect(), and GRSPoly().

clipCircle()

static bool clipCircle ( EDA_RECT *  aClipBox, int  xc, int  yc, int  r, int  aWidth  )

static

Definition at line 521 of file gr_basic.cpp.

{
    // Clip circles that are outside the ClipBox.
    if( aClipBox )
    {
        int x0, y0, xm, ym;
        x0 = aClipBox->GetX();
        y0 = aClipBox->GetY();
        xm = aClipBox->GetRight();
        ym = aClipBox->GetBottom();

        r += aWidth;

        if( xc < ( x0 - r ) )
            return true;

        if( yc < ( y0 - r ) )
            return true;

        if( xc > ( r + xm ) )
            return true;

        if( yc > ( r + ym ) )
            return true;
    }

    return false;
}

References EDA_RECT::GetBottom(), EDA_RECT::GetRight(), EDA_RECT::GetX(), and EDA_RECT::GetY().

Referenced by GRCircle(), and GRFilledCircle().

GetGRForceBlackPenState()

bool GetGRForceBlackPenState

(

void

)

Returns

True if a black pen was forced or false if not forced.

Definition at line 196 of file gr_basic.cpp.

{
    return s_ForceBlackPen;
}

References s_ForceBlackPen.

Referenced by BITMAP_BASE::DrawBitmap(), SCH_SHEET::Print(), and LIB_SYMBOL::Print().

GRArc() [1/2]

void GRArc	(	EDA_RECT *	ClipBox,
		wxDC *	DC,
		int	xc,
		int	yc,
		double	StAngle,
		double	EndAngle,
		int	r,
		const COLOR4D &	Color
	)

Definition at line 689 of file gr_basic.cpp.

{
    int x1, y1, x2, y2;

    /* Clip arcs off screen */
    if( ClipBox )
    {
        int radius = r + 1;
        int x0, y0, xm, ym, x, y;
        x0 = ClipBox->GetX();
        y0 = ClipBox->GetY();
        xm = ClipBox->GetRight();
        ym = ClipBox->GetBottom();
        x = xc;
        y = yc;

        if( x < ( x0 - radius ) )
            return;

        if( y < ( y0 - radius ) )
            return;

        if( x > ( xm + radius ) )
            return;

        if( y > ( ym + radius ) )
            return;
    }

    x1 = r;
    y1 = 0;
    RotatePoint( &x1, &y1, EndAngle );

    x2 = r;
    y2 = 0;
    RotatePoint( &x2, &y2, StAngle );

    GRSetBrush( DC, Color, NOT_FILLED );
    GRSetColorPen( DC, Color );
    DC->DrawArc( xc + x1, yc - y1, xc + x2, yc - y2, xc, yc );
}

References EDA_RECT::GetBottom(), EDA_RECT::GetRight(), EDA_RECT::GetX(), EDA_RECT::GetY(), GRSetBrush(), GRSetColorPen(), NOT_FILLED, and RotatePoint().

GRArc() [2/2]

void GRArc	(	EDA_RECT *	ClipBox,
		wxDC *	DC,
		int	x,
		int	y,
		double	StAngle,
		double	EndAngle,
		int	r,
		int	width,
		const COLOR4D &	Color
	)

Definition at line 733 of file gr_basic.cpp.

{
    int x1, y1, x2, y2;

    /* Clip arcs off screen. */
    if( ClipBox )
    {
        int x0, y0, xm, ym;
        x0 = ClipBox->GetX();
        y0 = ClipBox->GetY();
        xm = ClipBox->GetRight();
        ym = ClipBox->GetBottom();

        if( x < ( x0 - r - width ) )
            return;

        if( y < ( y0 - r - width ) )
            return;

        if( x > ( r + xm + width ) )
            return;

        if( y > ( r + ym + width ) )
            return;
    }

    x1 = r;
    y1 = 0;
    RotatePoint( &x1, &y1, EndAngle );

    x2 = r;
    y2 = 0;
    RotatePoint( &x2, &y2, StAngle );

    GRSetBrush( DC, Color );
    GRSetColorPen( DC, Color, width );
    DC->DrawArc( x + x1, y - y1, x + x2, y - y2, x, y );
}

References EDA_RECT::GetBottom(), EDA_RECT::GetRight(), EDA_RECT::GetX(), EDA_RECT::GetY(), GRSetBrush(), GRSetColorPen(), and RotatePoint().

GRArc1() [1/3]

void GRArc1	(	EDA_RECT *	ClipBox,
		wxDC *	DC,
		int	x1,
		int	y1,
		int	x2,
		int	y2,
		int	xc,
		int	yc,
		const COLOR4D &	Color
	)

Definition at line 594 of file gr_basic.cpp.

{
    GRArc1( ClipBox, DC, x1, y1, x2, y2, xc, yc, 0, Color );
}

References GRArc1().

Referenced by GRArc1(), LIB_ARC::print(), and GERBER_DRAW_ITEM::Print().

GRArc1() [2/3]

void GRArc1	(	EDA_RECT *	ClipBox,
		wxDC *	DC,
		int	x1,
		int	y1,
		int	x2,
		int	y2,
		int	xc,
		int	yc,
		int	width,
		const COLOR4D &	Color
	)

Definition at line 601 of file gr_basic.cpp.

{
    /* Clip arcs off screen. */
    if( ClipBox )
    {
        int x0, y0, xm, ym, r;
        x0 = ClipBox->GetX();
        y0 = ClipBox->GetY();
        xm = ClipBox->GetRight();
        ym = ClipBox->GetBottom();
        r  = KiROUND( Distance( x1, y1, xc, yc ) );

        if( xc < ( x0 - r ) )
            return;

        if( yc < ( y0 - r ) )
            return;

        if( xc > ( r + xm ) )
            return;

        if( yc > ( r + ym ) )
            return;
    }

    GRSetBrush( DC, Color );
    GRSetColorPen( DC, Color, width );
    DC->DrawArc( x1, y1, x2, y2, xc, yc );
}

References EDA_RECT::GetBottom(), EDA_RECT::GetRight(), EDA_RECT::GetX(), EDA_RECT::GetY(), GRSetBrush(), GRSetColorPen(), and KiROUND().

GRArc1() [3/3]

void GRArc1	(	EDA_RECT *	aClipBox,
		wxDC *	aDC,
		const wxPoint &	aStart,
		const wxPoint &	aEnd,
		const wxPoint &	aCenter,
		int	aWidth,
		const COLOR4D &	aColor
	)

Definition at line 633 of file gr_basic.cpp.

{
    GRArc1( aClipBox, aDC, aStart.x, aStart.y, aEnd.x, aEnd.y, aCenter.x, aCenter.y,
            aWidth, aColor );
}

References GRArc1().

GRBezier()

void GRBezier	(	EDA_RECT *	aClipBox,
		wxDC *	aDC,
		std::vector< wxPoint > &	aPoint,
		int	aWidth,
		const COLOR4D &	aColor
	)

Draw cubic (4 points: start control1, control2, end) bezier curve.

Definition at line 909 of file gr_basic.cpp.

{
    std::vector<wxPoint> output;

    BEZIER_POLY converter( aPoint );
    converter.GetPoly( output, aWidth );

    GRPoly( aClipBox, aDC, output.size(), &output[0], false, aWidth, aColor, aColor );
}

References BEZIER_POLY::GetPoly(), and GRPoly().

GRCircle() [1/3]

void GRCircle	(	EDA_RECT *	ClipBox,
		wxDC *	DC,
		int	xc,
		int	yc,
		int	r,
		int	width,
		const COLOR4D &	Color
	)

Definition at line 551 of file gr_basic.cpp.

{
    if( clipCircle( ClipBox, xc, yc, r, width ) || r <= 0 )
        return;

    GRSetBrush( DC, Color, NOT_FILLED );
    GRSetColorPen( DC, Color, width );
    DC->DrawEllipse( xc - r, yc - r, r + r, r + r );
}

References clipCircle(), GRSetBrush(), GRSetColorPen(), and NOT_FILLED.

Referenced by D_CODE::DrawFlashedShape(), GRCircle(), LIB_CIRCLE::print(), LIB_PIN::print(), GERBER_DRAW_ITEM::Print(), and LIB_PIN::printPinSymbol().

GRCircle() [2/3]

void GRCircle	(	EDA_RECT *	ClipBox,
		wxDC *	aDC,
		int	x,
		int	y,
		int	aRadius,
		const COLOR4D &	aColor
	)

Draw a circle onto the drawing context aDC centered at the user coordinates (x,y).

Parameters

ClipBox	defines a rectangular boundary outside of which no drawing will occur.
aDC	the device context into which drawing should occur.
x	The x coordinate in user space of the center of the circle.
y	The y coordinate in user space of the center of the circle.
aRadius	is the radius of the circle.
aColor	is the color to draw.

See also

COLOR4D

Definition at line 562 of file gr_basic.cpp.

{
    GRCircle( ClipBox, DC, x, y, r, 0, Color );
}

References GRCircle().

GRCircle() [3/3]

void GRCircle	(	EDA_RECT *	aClipBox,
		wxDC *	aDC,
		const wxPoint &	aPos,
		int	aRadius,
		int	aWidth,
		const COLOR4D &	aColor
	)

Definition at line 568 of file gr_basic.cpp.

{
    GRCircle( aClipBox, aDC, aPos.x, aPos.y, aRadius, aWidth, aColor );
}

References GRCircle().

GRClosedPoly() [1/2]

void GRClosedPoly	(	EDA_RECT *	ClipBox,
		wxDC *	DC,
		int	n,
		const wxPoint *	Points,
		bool	Fill,
		const COLOR4D &	Color,
		const COLOR4D &	BgColor
	)

Draw a closed polyline and fill it if Fill, in object space.

Draw a closed polygon onto the drawing context aDC and optionally fills and/or draws a border around it.

Definition at line 507 of file gr_basic.cpp.

{
    GRClosedPoly( ClipBox, DC, n, Points, Fill, 0, Color, BgColor );
}

References GRClosedPoly().

Referenced by APERTURE_MACRO::DrawApertureMacroShape(), D_CODE::DrawFlashedPolygon(), GRClosedPoly(), GERBER_DRAW_ITEM::PrintGerberPoly(), and MARKER_BASE::PrintMarker().

GRClosedPoly() [2/2]

void GRClosedPoly	(	EDA_RECT *	ClipBox,
		wxDC *	aDC,
		int	aPointCount,
		const wxPoint *	aPoints,
		bool	doFill,
		int	aPenWidth,
		const COLOR4D &	aPenColor,
		const COLOR4D &	aFillColor
	)

Draw a closed polygon onto the drawing context aDC and optionally fills and/or draws a border around it.

Parameters

ClipBox	defines a rectangular boundary outside of which no drawing will occur.
aDC	the device context into which drawing should occur.
aPointCount	the number of points in the array aPointArray.
aPoints	the points to draw.
doFill	true if polygon is to be filled, else false and only the boundary is drawn.
aPenWidth	is the width of the pen to use on the perimeter, can be zero.
aPenColor	the color of the border.
aFillColor	the fill color of the polygon's interior.

Definition at line 514 of file gr_basic.cpp.

{
    GRSClosedPoly( ClipBox, DC, n, Points, Fill, width, Color, BgColor );
}

References GRSClosedPoly().

GRCSegm() [1/3]

void GRCSegm	(	EDA_RECT *	ClipBox,
		wxDC *	DC,
		int	x1,
		int	y1,
		int	x2,
		int	y2,
		int	width,
		int	aPenSize,
		const COLOR4D &	Color
	)

Definition at line 271 of file gr_basic.cpp.

{
    GRLastMoveToX = x2;
    GRLastMoveToY = y2;

    if( ClipBox )
    {
        EDA_RECT clipbox( *ClipBox );
        clipbox.Inflate( width / 2 );

        if( ClipLine( &clipbox, x1, y1, x2, y2 ) )
            return;
    }

    if( width <= 2 )   /*  single line or 2 pixels */
    {
        GRSetColorPen( DC, Color, width );
        DC->DrawLine( x1, y1, x2, y2 );
        return;
    }

    GRSetBrush( DC, Color, NOT_FILLED );
    GRSetColorPen( DC, Color, aPenSize );

    int radius = ( width + 1 ) >> 1;
    int dx = x2 - x1;
    int dy = y2 - y1;
    double angle = -ArcTangente( dy, dx );
    wxPoint start;
    wxPoint end;
    wxPoint org( x1, y1 );
    int len = (int) hypot( dx, dy );

    // We know if the DC is mirrored, to draw arcs
    int slx = DC->DeviceToLogicalX( 1 ) - DC->DeviceToLogicalX( 0 );
    int sly = DC->DeviceToLogicalY( 1 ) - DC->DeviceToLogicalY( 0 );
    bool mirrored = ( slx > 0 && sly < 0 ) || ( slx < 0 && sly > 0 );

    // first edge
    start.x = 0;
    start.y = radius;
    end.x = len;
    end.y = radius;
    RotatePoint( &start, angle );
    RotatePoint( &end, angle );

    start += org;
    end += org;

    DC->DrawLine( start, end );

    // first rounded end
    end.x = 0;
    end.y = -radius;
    RotatePoint( &end, angle );
    end += org;

    if( !mirrored )
        DC->DrawArc( end, start, org );
    else
        DC->DrawArc( start, end, org );

    // second edge
    start.x = len;
    start.y = -radius;
    RotatePoint( &start, angle );
    start += org;

    DC->DrawLine( start, end );

    // second rounded end
    end.x = len;
    end.y = radius;
    RotatePoint( &end, angle);
    end += org;

    if( !mirrored )
        DC->DrawArc( end.x, end.y, start.x, start.y, x2, y2 );
    else
        DC->DrawArc( start.x, start.y, end.x, end.y, x2, y2 );
}

References PNS::angle(), ArcTangente(), ClipLine(), GRLastMoveToX, GRLastMoveToY, GRSetBrush(), GRSetColorPen(), EDA_RECT::Inflate(), NOT_FILLED, and RotatePoint().

Referenced by BASIC_GAL::doDrawPolyline(), D_CODE::DrawFlashedShape(), BASIC_GAL::DrawLine(), GRCSegm(), and GERBER_DRAW_ITEM::Print().

GRCSegm() [2/3]

void GRCSegm	(	EDA_RECT *	ClipBox,
		wxDC *	DC,
		int	x1,
		int	y1,
		int	x2,
		int	y2,
		int	width,
		const COLOR4D &	Color
	)

Definition at line 355 of file gr_basic.cpp.

{
    GRCSegm( ClipBox, DC, x1, y1, x2, y2, width, 0, Color );
}

References GRCSegm().

GRCSegm() [3/3]

void GRCSegm	(	EDA_RECT *	aClipBox,
		wxDC *	aDC,
		const wxPoint &	aStart,
		const wxPoint &	aEnd,
		int	aWidth,
		const COLOR4D &	aColor
	)

Definition at line 362 of file gr_basic.cpp.

{
    GRCSegm( aClipBox, aDC, aStart.x, aStart.y, aEnd.x, aEnd.y, aWidth, 0, aColor );
}

References GRCSegm().

GRDrawAnchor()

void GRDrawAnchor	(	EDA_RECT *	aClipBox,
		wxDC *	aDC,
		int	x,
		int	y,
		int	aSize,
		const COLOR4D &	aColor
	)

Definition at line 921 of file gr_basic.cpp.

{
        int anchor_size = aDC->DeviceToLogicalXRel( aSize );

        GRLine( aClipBox, aDC, x - anchor_size, y, x + anchor_size, y, 0, aColor );
        GRLine( aClipBox, aDC, x, y - anchor_size, x, y + anchor_size, 0, aColor );
}

References GRLine().

GRDrawWrappedText()

void GRDrawWrappedText	(	wxDC &	aDC,
		const wxString &	aText
	)

Draw text centered on a wxDC with wrapping.

Parameters

aDC	wxDC instance onto which the text will be drawn.
aText	the text to draw.

Definition at line 930 of file gr_basic.cpp.

{
    wxStringTokenizer tokenizer( aText, " " );
    wxSize const dc_size = aDC.GetSize();
    wxSize const margin = aDC.GetTextExtent( " " );
    std::vector<wxString> lines;
    wxString line_accumulator;
    int total_height = 0;

    while( tokenizer.HasMoreTokens() )
    {
        wxString word = tokenizer.GetNextToken();
        wxSize linesize = aDC.GetTextExtent( line_accumulator + " " + word );

        if( linesize.x >= dc_size.x - margin.x && !line_accumulator.IsEmpty() )
        {
            lines.push_back( line_accumulator );
            line_accumulator = word;
        }
        else
        {
            line_accumulator += " ";
            line_accumulator += word;
        }
    }

    if( !line_accumulator.IsEmpty() )
    {
        lines.push_back( line_accumulator );
    }

    for( auto const& line: lines )
    {
        wxSize linesize = aDC.GetTextExtent( line );
        total_height += linesize.y;
    }

    int top = ( dc_size.y - total_height ) / 2;
    int pos = top;

    for( auto const& line: lines )
    {
        wxSize linesize = aDC.GetTextExtent( line );
        aDC.DrawText( line, ( dc_size.x - linesize.x ) / 2, pos );
        pos += linesize.y;
    }
}

GRFillCSegm()

void GRFillCSegm	(	EDA_RECT *	ClipBox,
		wxDC *	DC,
		int	x1,
		int	y1,
		int	x2,
		int	y2,
		int	width,
		const COLOR4D &	Color
	)

Definition at line 369 of file gr_basic.cpp.

{
    GRSetColorPen( DC, Color, width );
    WinClipAndDrawLine( ClipBox, DC, x1, y1, x2, y2, width );
}

References GRSetColorPen(), and WinClipAndDrawLine().

Referenced by D_CODE::DrawFlashedShape().

GRFilledArc() [1/2]

void GRFilledArc	(	EDA_RECT *	ClipBox,
		wxDC *	DC,
		int	x,
		int	y,
		double	StAngle,
		double	EndAngle,
		int	r,
		int	width,
		const COLOR4D &	Color,
		const COLOR4D &	BgColor
	)

Definition at line 641 of file gr_basic.cpp.

{
    int x1, y1, x2, y2;

    /* Clip arcs off screen */
    if( ClipBox )
    {
        int x0, y0, xm, ym;
        x0 = ClipBox->GetX();
        y0 = ClipBox->GetY();
        xm = ClipBox->GetRight();
        ym = ClipBox->GetBottom();

        if( x < ( x0 - r - 1 ) )
            return;

        if( y < ( y0 - r - 1 ) )
            return;

        if( x > ( r + xm + 1 ) )
            return;

        if( y > ( r + ym + 1 ) )
            return;
    }

    x1 = r;
    y1 = 0;
    RotatePoint( &x1, &y1, EndAngle );

    x2 = r;
    y2 = 0;
    RotatePoint( &x2, &y2, StAngle );

    GRSetBrush( DC, BgColor, FILLED );
    GRSetColorPen( DC, Color, width );
    DC->DrawArc( x + x1, y - y1, x + x2, y - y2, x, y );
}

References FILLED, EDA_RECT::GetBottom(), EDA_RECT::GetRight(), EDA_RECT::GetX(), EDA_RECT::GetY(), GRSetBrush(), GRSetColorPen(), and RotatePoint().

Referenced by GRFilledArc(), and LIB_ARC::print().

GRFilledArc() [2/2]

void GRFilledArc	(	EDA_RECT *	ClipBox,
		wxDC *	DC,
		int	x,
		int	y,
		double	StAngle,
		double	EndAngle,
		int	r,
		const COLOR4D &	Color,
		const COLOR4D &	BgColor
	)

Definition at line 682 of file gr_basic.cpp.

{
    GRFilledArc( ClipBox, DC, x, y, StAngle, EndAngle, r, 0, Color, BgColor );
}

References GRFilledArc().

GRFilledCircle() [1/2]

void GRFilledCircle	(	EDA_RECT *	ClipBox,
		wxDC *	DC,
		int	x,
		int	y,
		int	r,
		int	width,
		const COLOR4D &	Color,
		const COLOR4D &	BgColor
	)

Definition at line 575 of file gr_basic.cpp.

{
    if( clipCircle( ClipBox, x, y, r, width ) || r <= 0 )
        return;

    GRSetBrush( DC, BgColor, FILLED );
    GRSetColorPen( DC, Color, width );
    DC->DrawEllipse( x - r, y - r, r + r, r + r );
}

References clipCircle(), FILLED, GRSetBrush(), and GRSetColorPen().

Referenced by D_CODE::DrawFlashedShape(), GRFilledCircle(), SCH_JUNCTION::Print(), and LIB_CIRCLE::print().

GRFilledCircle() [2/2]

void GRFilledCircle	(	EDA_RECT *	aClipBox,
		wxDC *	aDC,
		const wxPoint &	aPos,
		int	aRadius,
		const COLOR4D &	aColor
	)

Definition at line 587 of file gr_basic.cpp.

{
    GRFilledCircle( aClipBox, aDC, aPos.x, aPos.y, aRadius, 0, aColor, aColor );
}

References GRFilledCircle().

GRFilledRect() [1/2]

void GRFilledRect	(	EDA_RECT *	ClipBox,
		wxDC *	DC,
		int	x1,
		int	y1,
		int	x2,
		int	y2,
		const COLOR4D &	Color,
		const COLOR4D &	BgColor
	)

Definition at line 811 of file gr_basic.cpp.

{
    GRSFilledRect( ClipBox, DC, x1, y1, x2, y2, 0, Color, BgColor );
}

References GRSFilledRect().

Referenced by D_CODE::DrawFlashedShape(), LIB_RECTANGLE::print(), SCH_SHEET::Print(), and DIALOG_PAGES_SETTINGS::UpdateDrawingSheetExample().

GRFilledRect() [2/2]

void GRFilledRect	(	EDA_RECT *	ClipBox,
		wxDC *	DC,
		int	x1,
		int	y1,
		int	x2,
		int	y2,
		int	width,
		const COLOR4D &	Color,
		const COLOR4D &	BgColor
	)

Definition at line 818 of file gr_basic.cpp.

{
    GRSFilledRect( ClipBox, DC, x1, y1, x2, y2, width, Color, BgColor );
}

References GRSFilledRect().

GRFilledSegment()

void GRFilledSegment	(	EDA_RECT *	aClipBox,
		wxDC *	aDC,
		const wxPoint &	aStart,
		const wxPoint &	aEnd,
		int	aWidth,
		const COLOR4D &	aColor
	)

Definition at line 377 of file gr_basic.cpp.

{
    GRSetColorPen( aDC, aColor, aWidth );
    WinClipAndDrawLine( aClipBox, aDC, aStart.x, aStart.y, aEnd.x, aEnd.y, aWidth );
}

References GRSetColorPen(), and WinClipAndDrawLine().

Referenced by GERBER_DRAW_ITEM::Print().

GRForceBlackPen()

void GRForceBlackPen

(

bool

flagforce

)

Parameters

flagforce

True to force a black pen whenever the asked color.

Definition at line 190 of file gr_basic.cpp.

{
    s_ForceBlackPen = flagforce;
}

References s_ForceBlackPen.

Referenced by SCH_EDIT_FRAME::DrawCurrentSheetToClipboard(), PLEDITOR_PRINTOUT::PrintPage(), and SCH_PRINTOUT::PrintPage().

GRLine() [1/2]

void GRLine	(	EDA_RECT *	ClipBox,
		wxDC *	DC,
		int	x1,
		int	y1,
		int	x2,
		int	y2,
		int	width,
		const COLOR4D &	Color,
		wxPenStyle	aStyle
	)

Definition at line 212 of file gr_basic.cpp.

{
    GRSetColorPen( DC, Color, width, aStyle );
    WinClipAndDrawLine( ClipBox, DC, x1, y1, x2, y2, width );
    GRLastMoveToX = x2;
    GRLastMoveToY = y2;
}

References GRLastMoveToX, GRLastMoveToY, GRSetColorPen(), and WinClipAndDrawLine().

Referenced by BASIC_GAL::DrawLine(), GRDrawAnchor(), GRLine(), GRLineTo(), DIALOG_PAD_PRIMITIVE_POLY_PROPS::onPaintPolyPanel(), SCH_NO_CONNECT::Print(), SCH_BUS_ENTRY_BASE::Print(), SCH_LINE::Print(), LIB_PIN::printPinSymbol(), and DS_DRAW_ITEM_LINE::PrintWsItem().

GRLine() [2/2]

void GRLine	(	EDA_RECT *	aClipBox,
		wxDC *	aDC,
		const wxPoint &	aStart,
		const wxPoint &	aEnd,
		int	aWidth,
		const COLOR4D &	aColor,
		wxPenStyle	aStyle
	)

Definition at line 222 of file gr_basic.cpp.

{
    GRLine( aClipBox, aDC, aStart.x, aStart.y, aEnd.x, aEnd.y, aWidth, aColor, aStyle );
}

References GRLine().

GRLineArray()

void GRLineArray	(	EDA_RECT *	aClipBox,
		wxDC *	aDC,
		std::vector< wxPoint > &	aLines,
		int	aWidth,
		const COLOR4D &	aColor
	)

Draw an array of lines (not a polygon).

Parameters

aClipBox	the clip box.
aDC	the device context into which drawing should occur.
aLines	a list of pair of coordinate in user space: a pair for each line.
aWidth	the width of each line.
aColor	the color of the lines.

See also

COLOR4D

Definition at line 242 of file gr_basic.cpp.

{
    if( aLines.empty() )
        return;

    GRSetColorPen( aDC, aColor, aWidth );

    if( aClipBox )
        aClipBox->Inflate( aWidth / 2 );

    for( unsigned i = 0; i < aLines.size(); i += 2 )
    {
        int x1 = aLines[i].x;
        int y1 = aLines[i].y;
        int x2 = aLines[i + 1].x;
        int y2 = aLines[i + 1].y;

        if( ( aClipBox == nullptr ) || !ClipLine( aClipBox, x1, y1, x2, y2 ) )
            aDC->DrawLine( x1, y1, x2, y2 );
    }

    GRMoveTo( aLines[aLines.size() - 1].x, aLines[aLines.size() - 1].y );

    if( aClipBox )
        aClipBox->Inflate( -aWidth / 2 );
}

References ClipLine(), GRMoveTo(), GRSetColorPen(), and EDA_RECT::Inflate().

GRLineTo()

void GRLineTo	(	EDA_RECT *	ClipBox,
		wxDC *	DC,
		int	x,
		int	y,
		int	width,
		const COLOR4D &	Color
	)

Definition at line 236 of file gr_basic.cpp.

{
    GRLine( ClipBox, DC, GRLastMoveToX, GRLastMoveToY, x, y, width, Color );
}

References GRLastMoveToX, GRLastMoveToY, and GRLine().

Referenced by GRSClosedPoly(), GRSPoly(), and LIB_PIN::printPinSymbol().

GRMoveTo()

void GRMoveTo	(	int	x,
		int	y
	)

Definition at line 229 of file gr_basic.cpp.

{
    GRLastMoveToX = x;
    GRLastMoveToY = y;
}

References GRLastMoveToX, and GRLastMoveToY.

Referenced by GRLineArray(), GRSClosedPoly(), GRSPoly(), and LIB_PIN::printPinSymbol().

GRPoly()

void GRPoly	(	EDA_RECT *	ClipBox,
		wxDC *	DC,
		int	n,
		const wxPoint *	Points,
		bool	Fill,
		int	width,
		const COLOR4D &	Color,
		const COLOR4D &	BgColor
	)

Draw a new polyline and fill it if Fill, in drawing space.

Definition at line 497 of file gr_basic.cpp.

{
    GRSPoly( ClipBox, DC, n, Points, Fill, width, Color, BgColor );
}

References GRSPoly().

Referenced by BASIC_GAL::doDrawPolyline(), GRBezier(), LIB_BEZIER::print(), LIB_POLYLINE::print(), SCH_GLOBALLABEL::Print(), SCH_HIERLABEL::Print(), and DS_DRAW_ITEM_POLYPOLYGONS::PrintWsItem().

GRPutPixel()

void GRPutPixel	(	EDA_RECT *	ClipBox,
		wxDC *	DC,
		int	x,
		int	y,
		const COLOR4D &	Color
	)

Definition at line 202 of file gr_basic.cpp.

{
    if( ClipBox && !ClipBox->Contains( x, y ) )
        return;

    GRSetColorPen( DC, Color );
    DC->DrawPoint( x, y );
}

References EDA_RECT::Contains(), and GRSetColorPen().

GRRect() [1/3]

void GRRect	(	EDA_RECT *	aClipBox,
		wxDC *	aDC,
		int	x1,
		int	y1,
		int	x2,
		int	y2,
		const COLOR4D &	aColor
	)

Definition at line 774 of file gr_basic.cpp.

{
    GRSRect( aClipBox, aDC, x1, y1, x2, y2, 0, aColor );
}

References GRSRect().

Referenced by D_CODE::DrawFlashedShape(), LIB_RECTANGLE::print(), SCH_SHEET::Print(), and DS_DRAW_ITEM_RECT::PrintWsItem().

GRRect() [2/3]

void GRRect	(	EDA_RECT *	ClipBox,
		wxDC *	DC,
		int	x1,
		int	y1,
		int	x2,
		int	y2,
		int	width,
		const COLOR4D &	Color
	)

Definition at line 792 of file gr_basic.cpp.

{
    GRSRect( ClipBox, DC, x1, y1, x2, y2, width, Color );
}

References GRSRect().

GRRect() [3/3]

void GRRect	(	EDA_RECT *	aClipBox,
		wxDC *	aDC,
		const EDA_RECT &	aRect,
		int	aWidth,
		const COLOR4D &	aColor
	)

Definition at line 799 of file gr_basic.cpp.

{
    int x1 = aRect.GetX();
    int y1 = aRect.GetY();
    int x2 = aRect.GetRight();
    int y2 = aRect.GetBottom();

    GRSRect( aClipBox, aDC, x1, y1, x2, y2, aWidth, aColor );
}

References EDA_RECT::GetBottom(), EDA_RECT::GetRight(), EDA_RECT::GetX(), EDA_RECT::GetY(), and GRSRect().

GRRectPs()

void GRRectPs	(	EDA_RECT *	aClipBox,
		wxDC *	aDC,
		const EDA_RECT &	aRect,
		const COLOR4D &	aColor,
		wxPenStyle	aStyle
	)

Definition at line 780 of file gr_basic.cpp.

{
    int x1 = aRect.GetX();
    int y1 = aRect.GetY();
    int x2 = aRect.GetRight();
    int y2 = aRect.GetBottom();

    GRSRect( aClipBox, aDC, x1, y1, x2, y2, 0, aColor, aStyle );
}

References EDA_RECT::GetBottom(), EDA_RECT::GetRight(), EDA_RECT::GetX(), EDA_RECT::GetY(), and GRSRect().

GRResetPenAndBrush()

void GRResetPenAndBrush

(

wxDC *

DC

)

Definition at line 111 of file gr_basic.cpp.

{
    GRSetBrush( DC, BLACK );  // Force no fill
    s_DC_lastbrushcolor = COLOR4D::UNSPECIFIED;
    s_DC_lastcolor =  COLOR4D::UNSPECIFIED;
    s_DC_lastDC    = nullptr;
}

References BLACK, GRSetBrush(), s_DC_lastbrushcolor, s_DC_lastcolor, and s_DC_lastDC.

Referenced by SCH_EDIT_FRAME::DrawCurrentSheetToClipboard(), DIALOG_PAD_PRIMITIVE_POLY_PROPS::onPaintPolyPanel(), DIALOG_PIN_PROPERTIES::OnPaintShowPanel(), PLEDITOR_PRINTOUT::PrintPage(), SCH_PRINTOUT::PrintPage(), and DIALOG_PAGES_SETTINGS::UpdateDrawingSheetExample().

GRSClosedPoly()

static void GRSClosedPoly ( EDA_RECT *  aClipBox, wxDC *  aDC, int  aPointCount, const wxPoint *  aPoints, bool  aFill, int  aWidth, const COLOR4D &  aColor, const COLOR4D &  aBgColor  )

static

Draw a new closed polyline and fill it if Fill, in screen space.

Definition at line 459 of file gr_basic.cpp.

{
    if( !IsGRSPolyDrawable( aClipBox, aPointCount, aPoints ) )
        return;

    if( aFill && ( aPointCount > 2 ) )
    {
        GRLastMoveToX = aPoints[aPointCount - 1].x;
        GRLastMoveToY = aPoints[aPointCount - 1].y;
        GRSetBrush( aDC, aBgColor, FILLED );
        GRSetColorPen( aDC, aColor, aWidth );
        ClipAndDrawPoly( aClipBox, aDC, aPoints, aPointCount );
    }
    else
    {

        GRMoveTo( aPoints[0].x, aPoints[0].y );

        for( int i = 1; i < aPointCount; ++i )
        {
            GRLineTo( aClipBox, aDC, aPoints[i].x, aPoints[i].y, aWidth, aColor );
        }

        int lastpt = aPointCount - 1;

        // Close the polygon
        if( aPoints[lastpt] != aPoints[0] )
        {
            GRLineTo( aClipBox, aDC, aPoints[0].x, aPoints[0].y, aWidth, aColor );
        }
    }
}

References ClipAndDrawPoly(), FILLED, GRLastMoveToX, GRLastMoveToY, GRLineTo(), GRMoveTo(), GRSetBrush(), GRSetColorPen(), and IsGRSPolyDrawable().

Referenced by GRClosedPoly(), and GRSRect().

GRSetBrush()

void GRSetBrush	(	wxDC *	DC,
		const COLOR4D &	Color,
		bool	fill
	)

Definition at line 163 of file gr_basic.cpp.

{
    COLOR4D color = Color;

    if( s_ForceBlackPen )
        color = COLOR4D::BLACK;

    if( s_DC_lastbrushcolor != color || s_DC_lastbrushfill  != fill || s_DC_lastDC != DC )
    {
        wxBrush brush;

        brush.SetColour( color.ToColour() );

        if( fill )
            brush.SetStyle( wxBRUSHSTYLE_SOLID );
        else
            brush.SetStyle( wxBRUSHSTYLE_TRANSPARENT );

        DC->SetBrush( brush );

        s_DC_lastbrushcolor = color;
        s_DC_lastbrushfill  = fill;
        s_DC_lastDC = DC;
    }
}

References BLACK, color, s_DC_lastbrushcolor, s_DC_lastbrushfill, s_DC_lastDC, and s_ForceBlackPen.

Referenced by GRArc(), GRArc1(), GRCircle(), GRCSegm(), GRFilledArc(), GRFilledCircle(), GRResetPenAndBrush(), GRSClosedPoly(), GRSFilledRect(), and GRSPoly().

GRSetColorPen()

void GRSetColorPen	(	wxDC *	DC,
		const COLOR4D &	Color,
		int	width,
		wxPenStyle	style
	)

Definition at line 120 of file gr_basic.cpp.

{
    COLOR4D color = Color;

    wxDash dots[2] = { 1, 3 };

    // Under OSX and while printing when wxPen is set to 0, renderer follows the request drawing
    // nothing & in the bitmap world the minimum is enough to light a pixel, in vectorial one not
    if( width <= 1 )
        width = DC->DeviceToLogicalXRel( 1 );

    if( s_ForceBlackPen )
        color = COLOR4D::BLACK;

    const wxPen& curr_pen = DC->GetPen();

    if( !curr_pen.IsOk() || curr_pen.GetColour() != color.ToColour()
       || curr_pen.GetWidth() != width || curr_pen.GetStyle() != style )
    {
        wxPen pen;
        pen.SetColour( color.ToColour() );

        if( style == wxPENSTYLE_DOT )
        {
            style = wxPENSTYLE_USER_DASH;
            pen.SetDashes( 2, dots );
        }

        pen.SetWidth( width );
        pen.SetStyle( style );
        DC->SetPen( pen );
    }
    else
    {
        // Should be not needed, but on Linux, in printing process
        // the curr pen settings needs to be sometimes re-initialized
        // Clearly, this is due to a bug, related to SetBrush(),
        // but we have to live with it, at least on wxWidgets 3.0
        DC->SetPen( curr_pen );
    }
}

References BLACK, color, and s_ForceBlackPen.

Referenced by GRArc(), GRArc1(), GRCircle(), GRCSegm(), GRFillCSegm(), GRFilledArc(), GRFilledCircle(), GRFilledSegment(), GRLine(), GRLineArray(), GRPutPixel(), GRSClosedPoly(), GRSFilledRect(), and GRSPoly().

GRSFilledRect()

void GRSFilledRect	(	EDA_RECT *	aClipBox,
		wxDC *	aDC,
		int	x1,
		int	y1,
		int	x2,
		int	y2,
		int	aWidth,
		const COLOR4D &	aColor,
		const COLOR4D &	aBgColor
	)

Definition at line 838 of file gr_basic.cpp.

{
    wxPoint points[5];
    points[0] = wxPoint( x1, y1 );
    points[1] = wxPoint( x1, y2 );
    points[2] = wxPoint( x2, y2 );
    points[3] = wxPoint( x2, y1 );
    points[4] = points[0];

    GRSetBrush( aDC, aBgColor, FILLED );
    GRSetColorPen( aDC, aBgColor, aWidth );

    if( aClipBox && ( aWidth > 0 ) )
    {
        EDA_RECT clipbox( *aClipBox );
        clipbox.Inflate( aWidth );
        ClipAndDrawPoly( &clipbox, aDC, points, 5 ); // polygon approach is more accurate
    }
    else
    {
        ClipAndDrawPoly(aClipBox, aDC, points, 5 );
    }
}

References ClipAndDrawPoly(), FILLED, GRSetBrush(), GRSetColorPen(), and EDA_RECT::Inflate().

Referenced by GRFilledRect(), and SCH_PRINTOUT::PrintPage().

GRSPoly()

static void GRSPoly ( EDA_RECT *  ClipBox, wxDC *  DC, int  n, const wxPoint *  Points, bool  Fill, int  width, const COLOR4D &  Color, const COLOR4D &  BgColor  )

static

Draw a new polyline and fill it if Fill, in screen space.

Definition at line 426 of file gr_basic.cpp.

{
    if( !IsGRSPolyDrawable( ClipBox, n, Points ) )
        return;

    if( Fill && ( n > 2 ) )
    {
        GRSetBrush( DC, BgColor, FILLED );
        GRSetColorPen( DC, Color, width );

        /* clip before send the filled polygon to wxDC, because under linux
         * (GTK?) polygons having large coordinates are incorrectly drawn
         * (integer overflow in coordinates, I am guessing)
         */
        ClipAndDrawPoly( ClipBox, DC, Points, n );
    }
    else
    {

        GRMoveTo( Points[0].x, Points[0].y );

        for( int i = 1; i < n; ++i )
        {
            GRLineTo( ClipBox, DC, Points[i].x, Points[i].y, width, Color );
        }
    }
}

References ClipAndDrawPoly(), FILLED, GRLineTo(), GRMoveTo(), GRSetBrush(), GRSetColorPen(), and IsGRSPolyDrawable().

Referenced by GRPoly().

GRSRect()

void GRSRect ( EDA_RECT *  aClipBox, wxDC *  aDC, int  x1, int  y1, int  x2, int  y2, int  aWidth, const COLOR4D &  aColor, wxPenStyle  aStyle = wxPENSTYLE_SOLID  )

static

Definition at line 825 of file gr_basic.cpp.

{
    wxPoint points[5];
    points[0] = wxPoint( x1, y1 );
    points[1] = wxPoint( x1, y2 );
    points[2] = wxPoint( x2, y2 );
    points[3] = wxPoint( x2, y1 );
    points[4] = points[0];
    GRSClosedPoly( aClipBox, aDC, 5, points, NOT_FILLED, aWidth, aColor, aColor );
}

References GRSClosedPoly(), and NOT_FILLED.

Referenced by GRRect(), and GRRectPs().

IsGRSPolyDrawable()

static bool IsGRSPolyDrawable ( EDA_RECT *  ClipBox, int  n, const wxPoint *  Points  )

static

Definition at line 384 of file gr_basic.cpp.

{
    if( !ClipBox )
        return true;

    if( n <= 0 )
        return false;

    int Xmin, Xmax, Ymin, Ymax;

    Xmin = Xmax = Points[0].x;
    Ymin = Ymax = Points[0].y;

    for( int ii = 1; ii < n; ii++ )     // calculate rectangle
    {
        Xmin = std::min( Xmin, Points[ii].x );
        Xmax = std::max( Xmax, Points[ii].x );
        Ymin = std::min( Ymin, Points[ii].y );
        Ymax = std::max( Ymax, Points[ii].y );
    }

    xcliplo = ClipBox->GetX();
    ycliplo = ClipBox->GetY();
    xcliphi = ClipBox->GetRight();
    ycliphi = ClipBox->GetBottom();

    if( Xmax < xcliplo )
        return false;
    if( Xmin > xcliphi )
        return false;
    if( Ymax < ycliplo )
        return false;
    if( Ymin > ycliphi )
        return false;

    return true;
}

References EDA_RECT::GetBottom(), EDA_RECT::GetRight(), EDA_RECT::GetX(), EDA_RECT::GetY(), xcliphi, xcliplo, ycliphi, and ycliplo.

Referenced by GRSClosedPoly(), and GRSPoly().

WinClipAndDrawLine()

static void WinClipAndDrawLine ( EDA_RECT *  ClipBox, wxDC *  DC, int  x1, int  y1, int  x2, int  y2, int  width  )

static

Definition at line 93 of file gr_basic.cpp.

{
    GRLastMoveToX = x2;
    GRLastMoveToY = y2;

    if( ClipBox )
    {
        EDA_RECT clipbox(*ClipBox);
        clipbox.Inflate(width/2);
        if( ClipLine( &clipbox, x1, y1, x2, y2 ) )
            return;
    }

    DC->DrawLine( x1, y1, x2, y2 );
}

References ClipLine(), GRLastMoveToX, GRLastMoveToY, and EDA_RECT::Inflate().

Referenced by GRFillCSegm(), GRFilledSegment(), and GRLine().

Variable Documentation

FILLED

const bool FILLED = true

static

Definition at line 34 of file gr_basic.cpp.

Referenced by GRFilledArc(), GRFilledCircle(), GRSClosedPoly(), GRSFilledRect(), and GRSPoly().

g_XorMode

GR_DRAWMODE g_XorMode = GR_NXOR

Definition at line 65 of file gr_basic.cpp.

GRLastMoveToX

int GRLastMoveToX

static

Definition at line 80 of file gr_basic.cpp.

Referenced by GRCSegm(), GRLine(), GRLineTo(), GRMoveTo(), GRSClosedPoly(), and WinClipAndDrawLine().

GRLastMoveToY

int GRLastMoveToY

static

Definition at line 80 of file gr_basic.cpp.

Referenced by GRCSegm(), GRLine(), GRLineTo(), GRMoveTo(), GRSClosedPoly(), and WinClipAndDrawLine().

NOT_FILLED

const bool NOT_FILLED = false

static

Definition at line 35 of file gr_basic.cpp.

Referenced by GRArc(), GRCircle(), GRCSegm(), and GRSRect().

s_DC_lastbrushcolor

COLOR4D s_DC_lastbrushcolor(0, 0, 0, 0)

static

Referenced by GRResetPenAndBrush(), and GRSetBrush().

s_DC_lastbrushfill

bool s_DC_lastbrushfill = false

static

Definition at line 90 of file gr_basic.cpp.

Referenced by GRSetBrush().

s_DC_lastcolor

COLOR4D s_DC_lastcolor(0, 0, 0, 0)

static

Referenced by GRResetPenAndBrush().

s_DC_lastDC

wxDC* s_DC_lastDC = nullptr

static

Definition at line 91 of file gr_basic.cpp.

Referenced by GRResetPenAndBrush(), and GRSetBrush().

s_ForceBlackPen

bool s_ForceBlackPen

static

Definition at line 81 of file gr_basic.cpp.

Referenced by GetGRForceBlackPenState(), GRForceBlackPen(), GRSetBrush(), and GRSetColorPen().

xcliphi

int xcliphi = 2000

static

Definition at line 85 of file gr_basic.cpp.

Referenced by IsGRSPolyDrawable().

xcliplo

int xcliplo = 0

static

Definition at line 83 of file gr_basic.cpp.

Referenced by IsGRSPolyDrawable().

ycliphi

int ycliphi = 2000

static

Definition at line 86 of file gr_basic.cpp.

Referenced by IsGRSPolyDrawable().

ycliplo

int ycliplo = 0

static

Definition at line 84 of file gr_basic.cpp.

Referenced by IsGRSPolyDrawable().