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)
	Function ClipAndDrawPoly 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. More...
static void	GRSRect (EDA_RECT *aClipBox, wxDC *aDC, int x1, int y1, int x2, int y2, int aWidth, 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, COLOR4D Color, int width, wxPenStyle style)
	Function GRSetColorPen sets a pen style, width, color, and alpha into the given device context. More...
void	GRSetBrush (wxDC *DC, COLOR4D Color, bool fill)
void	GRForceBlackPen (bool flagforce)
	Function GRForceBlackPen. More...
bool	GetGRForceBlackPenState (void)
	Function GetGRForceBlackPenState. More...
void	GRPutPixel (EDA_RECT *ClipBox, wxDC *DC, int x, int y, COLOR4D Color)
void	GRLine (EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int width, COLOR4D Color, wxPenStyle aStyle)
void	GRLine (EDA_RECT *aClipBox, wxDC *aDC, wxPoint aStart, wxPoint aEnd, int aWidth, COLOR4D aColor, wxPenStyle aStyle)
void	GRMoveTo (int x, int y)
void	GRLineTo (EDA_RECT *ClipBox, wxDC *DC, int x, int y, int width, COLOR4D Color)
void	GRLineArray (EDA_RECT *aClipBox, wxDC *aDC, std::vector< wxPoint > &aLines, int aWidth, COLOR4D aColor)
	Function GRLineArray draws 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, COLOR4D Color)
void	GRCSegm (EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int width, COLOR4D Color)
void	GRCSegm (EDA_RECT *aClipBox, wxDC *aDC, wxPoint aStart, wxPoint aEnd, int aWidth, COLOR4D aColor)
void	GRFillCSegm (EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int width, COLOR4D Color)
void	GRFilledSegment (EDA_RECT *aClipBox, wxDC *aDC, wxPoint aStart, wxPoint aEnd, int aWidth, 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, COLOR4D Color, COLOR4D BgColor)
static void	GRSClosedPoly (EDA_RECT *aClipBox, wxDC *aDC, int aPointCount, const wxPoint *aPoints, bool aFill, int aWidth, COLOR4D aColor, COLOR4D aBgColor)
void	GRPoly (EDA_RECT *ClipBox, wxDC *DC, int n, const wxPoint *Points, bool Fill, int width, COLOR4D Color, COLOR4D BgColor)
void	GRClosedPoly (EDA_RECT *ClipBox, wxDC *DC, int n, const wxPoint *Points, bool Fill, COLOR4D Color, COLOR4D BgColor)
	Draw a closed polygon onto the drawing context aDC and optionally fills and/or draws a border around it. More...
void	GRClosedPoly (EDA_RECT *ClipBox, wxDC *DC, int n, const wxPoint *Points, bool Fill, int width, COLOR4D Color, 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, COLOR4D Color)
void	GRCircle (EDA_RECT *ClipBox, wxDC *DC, int x, int y, int r, 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, wxPoint aPos, int aRadius, int aWidth, COLOR4D aColor)
void	GRFilledCircle (EDA_RECT *ClipBox, wxDC *DC, int x, int y, int r, int width, COLOR4D Color, COLOR4D BgColor)
void	GRFilledCircle (EDA_RECT *aClipBox, wxDC *aDC, wxPoint aPos, int aRadius, COLOR4D aColor)
void	GRArc1 (EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int xc, int yc, COLOR4D Color)
void	GRArc1 (EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int xc, int yc, int width, COLOR4D Color)
void	GRArc1 (EDA_RECT *aClipBox, wxDC *aDC, wxPoint aStart, wxPoint aEnd, wxPoint aCenter, int aWidth, COLOR4D aColor)
void	GRFilledArc (EDA_RECT *ClipBox, wxDC *DC, int x, int y, double StAngle, double EndAngle, int r, int width, COLOR4D Color, COLOR4D BgColor)
void	GRFilledArc (EDA_RECT *ClipBox, wxDC *DC, int x, int y, double StAngle, double EndAngle, int r, COLOR4D Color, COLOR4D BgColor)
void	GRArc (EDA_RECT *ClipBox, wxDC *DC, int xc, int yc, double StAngle, double EndAngle, int r, COLOR4D Color)
void	GRArc (EDA_RECT *ClipBox, wxDC *DC, int x, int y, double StAngle, double EndAngle, int r, int width, COLOR4D Color)
void	GRRect (EDA_RECT *aClipBox, wxDC *aDC, int x1, int y1, int x2, int y2, COLOR4D aColor)
void	GRRectPs (EDA_RECT *aClipBox, wxDC *aDC, const EDA_RECT &aRect, COLOR4D aColor, wxPenStyle aStyle)
void	GRRect (EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int width, COLOR4D Color)
void	GRRect (EDA_RECT *aClipBox, wxDC *aDC, const EDA_RECT &aRect, int aWidth, COLOR4D aColor)
void	GRFilledRect (EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, COLOR4D Color, COLOR4D BgColor)
void	GRFilledRect (EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int width, COLOR4D Color, COLOR4D BgColor)
void	GRSFilledRect (EDA_RECT *aClipBox, wxDC *aDC, int x1, int y1, int x2, int y2, int aWidth, COLOR4D aColor, COLOR4D aBgColor)
void	GRBezier (EDA_RECT *aClipBox, wxDC *aDC, std::vector< wxPoint > &aPoint, int aWidth, 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, 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 = NULL

Macro Definition Documentation

DEBUG_DUMP_CLIP_COORDS

#define DEBUG_DUMP_CLIP_COORDS   0

Definition at line 66 of file gr_basic.cpp.

DEBUG_DUMP_CLIP_ERROR_COORDS

#define DEBUG_DUMP_CLIP_ERROR_COORDS   0

Definition at line 65 of file gr_basic.cpp.

Function Documentation

ClipAndDrawPoly()

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

static

Function ClipAndDrawPoly 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 955 of file gr_basic.cpp.

{
    if( aClipBox == NULL )
    {
        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(), KiROUND(), and NULL.

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 564 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

)

Function GetGRForceBlackPenState.

Returns

s_ForceBlackPen (True if a black pen was forced)

Definition at line 209 of file gr_basic.cpp.

{
    return s_ForceBlackPen;
}

References s_ForceBlackPen.

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

GRArc() [1/2]

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

Definition at line 747 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,
		COLOR4D	Color
	)

Definition at line 791 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,
		COLOR4D	Color
	)

Definition at line 638 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,
		COLOR4D	Color
	)

Definition at line 648 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,
		wxPoint	aStart,
		wxPoint	aEnd,
		wxPoint	aCenter,
		int	aWidth,
		COLOR4D	aColor
	)

Definition at line 676 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,
		COLOR4D	aColor
	)

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

Definition at line 990 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,
		COLOR4D	Color
	)

Definition at line 594 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(), GERBER_DRAW_ITEM::Print(), and LIB_PIN::printPinSymbol().

GRCircle() [2/3]

void GRCircle	(	EDA_RECT *	ClipBox,
		wxDC *	aDC,
		int	x,
		int	y,
		int	aRadius,
		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 605 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,
		wxPoint	aPos,
		int	aRadius,
		int	aWidth,
		COLOR4D	aColor
	)

Definition at line 611 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 *	aDC,
		int	aPointCount,
		const wxPoint *	aPoints,
		bool	doFill,
		COLOR4D	aPenColor,
		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 aPoints.
aPoints	The points to draw.
doFill	true if polygon is to be filled, else false and only the boundary is drawn.
aPenColor	the color of the border.
aFillColor	the fill color of the polygon's interior.

Definition at line 550 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,
		COLOR4D	aPenColor,
		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 557 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,
		COLOR4D	Color
	)

Definition at line 310 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,
		COLOR4D	Color
	)

Definition at line 396 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,
		wxPoint	aStart,
		wxPoint	aEnd,
		int	aWidth,
		COLOR4D	aColor
	)

Definition at line 403 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,
		COLOR4D	aColor
	)

Definition at line 1003 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,
		wxString const &	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 1017 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,
		COLOR4D	Color
	)

Definition at line 413 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,
		COLOR4D	Color,
		COLOR4D	BgColor
	)

Definition at line 687 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,
		COLOR4D	Color,
		COLOR4D	BgColor
	)

Definition at line 736 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,
		COLOR4D	Color,
		COLOR4D	BgColor
	)

Definition at line 617 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,
		wxPoint	aPos,
		int	aRadius,
		COLOR4D	aColor
	)

Definition at line 629 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,
		COLOR4D	Color,
		COLOR4D	BgColor
	)

Definition at line 882 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::UpdatePageLayoutExample().

GRFilledRect() [2/2]

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

Definition at line 892 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,
		wxPoint	aStart,
		wxPoint	aEnd,
		int	aWidth,
		COLOR4D	aColor
	)

Definition at line 421 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

)

Function GRForceBlackPen.

Parameters

flagforce

True to force a black pen whenever the asked color

Definition at line 199 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,
		COLOR4D	Color,
		wxPenStyle	aStyle
	)

Definition at line 228 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,
		wxPoint	aStart,
		wxPoint	aEnd,
		int	aWidth,
		COLOR4D	aColor,
		wxPenStyle	aStyle
	)

Definition at line 245 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,
		COLOR4D	aColor
	)

Function GRLineArray draws an array of lines (not a polygon).

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	= color to draw the lines

See also

COLOR4D

Definition at line 282 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 == NULL ) || !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(), EDA_RECT::Inflate(), and NULL.

GRLineTo()

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

Definition at line 264 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 254 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,
		COLOR4D	Color,
		COLOR4D	BgColor
	)

Definition at line 540 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,
		COLOR4D	Color
	)

Definition at line 215 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,
		COLOR4D	aColor
	)

Definition at line 842 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,
		COLOR4D	Color
	)

Definition at line 862 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,
		COLOR4D	aColor
	)

Definition at line 868 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,
		COLOR4D	aColor,
		wxPenStyle	aStyle
	)

Definition at line 848 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 118 of file gr_basic.cpp.

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

References BLACK, GRSetBrush(), NULL, 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::UpdatePageLayoutExample().

GRSClosedPoly()

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

static

Definition at line 503 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,
		COLOR4D	Color,
		bool	fill
	)

Definition at line 168 of file gr_basic.cpp.

{
    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, 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,
		COLOR4D	Color,
		int	width,
		wxPenStyle	style
	)

Function GRSetColorPen sets a pen style, width, color, and alpha into the given device context.

Definition at line 131 of file gr_basic.cpp.

{
    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, 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,
		COLOR4D	aColor,
		COLOR4D	aBgColor
	)

Definition at line 917 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, COLOR4D  Color, COLOR4D  BgColor  )

static

Definition at line 471 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, COLOR4D  aColor, wxPenStyle  aStyle = wxPENSTYLE_SOLID  )

static

Definition at line 903 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 429 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 98 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 39 of file gr_basic.cpp.

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

g_XorMode

GR_DRAWMODE g_XorMode = GR_NXOR

Definition at line 70 of file gr_basic.cpp.

GRLastMoveToX

int GRLastMoveToX

static

Definition at line 85 of file gr_basic.cpp.

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

GRLastMoveToY

int GRLastMoveToY

static

Definition at line 85 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 40 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 95 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 = NULL

static

Definition at line 96 of file gr_basic.cpp.

Referenced by GRResetPenAndBrush(), and GRSetBrush().

s_ForceBlackPen

bool s_ForceBlackPen

static

Definition at line 86 of file gr_basic.cpp.

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

xcliphi

int xcliphi = 2000

static

Definition at line 90 of file gr_basic.cpp.

Referenced by IsGRSPolyDrawable().

xcliplo

int xcliplo = 0

static

Definition at line 88 of file gr_basic.cpp.

Referenced by IsGRSPolyDrawable().

ycliphi

int ycliphi = 2000

static

Definition at line 91 of file gr_basic.cpp.

Referenced by IsGRSPolyDrawable().

ycliplo

int ycliplo = 0

static

Definition at line 89 of file gr_basic.cpp.

Referenced by IsGRSPolyDrawable().