gr_basic.cpp File Reference

#include <gr_basic.h>
#include <trigo.h>
#include <eda_item.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)
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	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	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)
	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, 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	GRFilledArc1 (EDA_RECT *ClipBox, wxDC *DC, const wxPoint &aStart, const wxPoint &aEnd, const wxPoint &aCenter, int width, 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 *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int width, const COLOR4D &Color)
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)

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_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 59 of file gr_basic.cpp.

DEBUG_DUMP_CLIP_ERROR_COORDS

#define DEBUG_DUMP_CLIP_ERROR_COORDS   0

Definition at line 58 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 775 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 477 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(), EDA_RECT::GetY(), and r.

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 191 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 620 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, r, 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 664 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(), r, and RotatePoint().

GRArc1() [1/2]

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 548 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(), KiROUND(), and r.

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

GRArc1() [2/2]

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

Definition at line 580 of file gr_basic.cpp.

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

References GRArc1().

GRCircle() [1/2]

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

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 507 of file gr_basic.cpp.

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

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

 // Draw two arcs here to make a circle. Unfortunately, the printerDC doesn't handle
 // transparent brushes when used with circles. It does work for for arcs, however
 DC->DrawArc(xc + r, yc, xc - r, yc, xc, yc);
 DC->DrawArc(xc - r, yc, xc + r, yc, xc, yc);
}

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

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

GRCircle() [2/2]

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

Definition at line 522 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 463 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 470 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 227 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 311 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 318 of file gr_basic.cpp.

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

References GRCSegm().

GRFillCSegm()

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

Definition at line 325 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().

GRFilledArc1()

void GRFilledArc1	(	EDA_RECT *	ClipBox,
		wxDC *	DC,
		const wxPoint &	aStart,
		const wxPoint &	aEnd,
		const wxPoint &	aCenter,
		int	width,
		const COLOR4D &	Color,
		const COLOR4D &	BgColor
	)

Definition at line 588 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( aStart.x, aStart.y, aCenter.x, aCenter.y ) );

 if( aCenter.x < ( x0 - r ) )
 return;

 if( aCenter.y < ( y0 - r ) )
 return;

 if( aCenter.x > ( r + xm ) )
 return;

 if( aCenter.y > ( r + ym ) )
 return;
 }

 GRSetBrush( DC, BgColor, FILLED );
 GRSetColorPen( DC, Color, width );
 DC->DrawArc( aStart.x, aStart.y, aEnd.x, aEnd.y, aCenter.x, aCenter.y );
}

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

Referenced by LIB_SHAPE::print().

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 529 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(), GRSetColorPen(), and r.

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

GRFilledCircle() [2/2]

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

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

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

References GRSFilledRect().

Referenced by D_CODE::DrawFlashedShape(), LIB_SHAPE::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 719 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 333 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 185 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 197 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(), 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 207 of file gr_basic.cpp.

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

References GRLine().

GRLineTo()

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

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

{
 GRLastMoveToX = x;
 GRLastMoveToY = y;
}

References GRLastMoveToX, and GRLastMoveToY.

Referenced by 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 453 of file gr_basic.cpp.

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

References GRSPoly().

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

GRRect()

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

Definition at line 705 of file gr_basic.cpp.

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

References GRSRect().

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

GRResetPenAndBrush()

void GRResetPenAndBrush

(

wxDC *

DC

)

Definition at line 107 of file gr_basic.cpp.

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

References BLACK, GRSetBrush(), s_DC_lastbrushcolor, 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 415 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 158 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(), GRFilledArc1(), GRFilledCircle(), GRResetPenAndBrush(), GRSClosedPoly(), GRSFilledRect(), and GRSPoly().

GRSetColorPen()

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

Definition at line 115 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(), GRFilledArc1(), GRFilledCircle(), GRFilledSegment(), GRLine(), 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 739 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 382 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  )

static

Definition at line 726 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().

IsGRSPolyDrawable()

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

static

Definition at line 340 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 89 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 32 of file gr_basic.cpp.

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

g_XorMode

GR_DRAWMODE g_XorMode = GR_NXOR

Definition at line 63 of file gr_basic.cpp.

GRLastMoveToX

int GRLastMoveToX

static

Definition at line 77 of file gr_basic.cpp.

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

GRLastMoveToY

int GRLastMoveToY

static

Definition at line 77 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 33 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 86 of file gr_basic.cpp.

Referenced by GRSetBrush().

s_DC_lastDC

wxDC* s_DC_lastDC = nullptr

static

Definition at line 87 of file gr_basic.cpp.

Referenced by GRResetPenAndBrush(), and GRSetBrush().

s_ForceBlackPen

bool s_ForceBlackPen

static

Definition at line 78 of file gr_basic.cpp.

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

xcliphi

int xcliphi = 2000

static

Definition at line 82 of file gr_basic.cpp.

Referenced by IsGRSPolyDrawable().

xcliplo

int xcliplo = 0

static

Definition at line 80 of file gr_basic.cpp.

Referenced by IsGRSPolyDrawable().

ycliphi

int ycliphi = 2000

static

Definition at line 83 of file gr_basic.cpp.

Referenced by IsGRSPolyDrawable().

ycliplo

int ycliplo = 0

static

Definition at line 81 of file gr_basic.cpp.

Referenced by IsGRSPolyDrawable().