KiCad PCB EDA Suite
gr_basic.h File Reference
#include <gal/color4d.h>
#include <vector>
#include <eda_rect.h>
#include <wx/pen.h>
#include <wx/dc.h>

Go to the source code of this file.

Macros

#define GR_M_LEFT_DOWN   0x10000000
 
#define GR_M_RIGHT_DOWN   0x20000000
 
#define GR_M_MIDDLE_DOWN   0x40000000
 
#define GR_M_DCLICK   0x80000000
 

Enumerations

enum  GR_DRAWMODE {
  GR_OR = 0x01000000, GR_XOR = 0x02000000, GR_AND = 0x04000000, GR_NXOR = 0x08000000,
  GR_INVERT = 0x10000000, GR_ALLOW_HIGHCONTRAST = 0x20000000, GR_COPY = 0x40000000, GR_HIGHLIGHT = 0x80000000,
  UNSPECIFIED_DRAWMODE = -1
}
 Drawmode. Compositing mode plus a flag or two. More...
 
enum  GRLineStypeType { GR_SOLID_LINE = 0, GR_DOTTED_LINE = 1, GR_DASHED_LINE = 3 }
 

Functions

void DrawModeAddHighlight (GR_DRAWMODE *mode)
 
void DrawModeAllowHighContrast (GR_DRAWMODE *mode)
 
GR_DRAWMODE operator ~ (const GR_DRAWMODE &a)
 
GR_DRAWMODE operator| (const GR_DRAWMODE &a, const GR_DRAWMODE &b)
 
GR_DRAWMODE operator & (const GR_DRAWMODE &a, const GR_DRAWMODE &b)
 
void GRResetPenAndBrush (wxDC *DC)
 
void GRSetColorPen (wxDC *DC, COLOR4D Color, int width=1, wxPenStyle stype=wxPENSTYLE_SOLID)
 Function GRSetColorPen sets a pen style, width, color, and alpha into the given device context. More...
 
void GRSetBrush (wxDC *DC, COLOR4D Color, bool fill=false)
 
void GRForceBlackPen (bool flagforce)
 Function GRForceBlackPen. More...
 
bool GetGRForceBlackPenState (void)
 Function GetGRForceBlackPenState. More...
 
void GRLine (EDA_RECT *aClipBox, wxDC *aDC, wxPoint aStart, wxPoint aEnd, int aWidth, COLOR4D aColor, wxPenStyle aStyle=wxPENSTYLE_SOLID)
 
void GRLine (EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int width, COLOR4D Color, wxPenStyle aStyle=wxPENSTYLE_SOLID)
 
void GRMoveTo (int x, int y)
 
void GRLineTo (EDA_RECT *ClipBox, wxDC *DC, int x, int y, int width, COLOR4D Color)
 
void GRPoly (EDA_RECT *ClipBox, wxDC *DC, int n, const wxPoint *Points, bool Fill, int width, COLOR4D Color, COLOR4D BgColor)
 
void GRBezier (EDA_RECT *aClipBox, wxDC *aDC, std::vector< wxPoint > &aPoints, int aWidth, COLOR4D aColor)
 Draw cubic (4 points: start control1, control2, end) bezier curve. More...
 
void GRClosedPoly (EDA_RECT *ClipBox, wxDC *aDC, int aPointCount, const wxPoint *aPoints, bool doFill, COLOR4D aPenColor, COLOR4D aFillColor)
 Function GRClosedPoly draws 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 *aDC, int aPointCount, const wxPoint *aPoints, bool doFill, int aPenWidth, COLOR4D aPenColor, COLOR4D aFillColor)
 Function GRClosedPoly draws a closed polygon onto the drawing context aDC and optionally fills and/or draws a border around it. More...
 
void GRCircle (EDA_RECT *ClipBox, wxDC *aDC, int x, int y, int aRadius, COLOR4D aColor)
 Function GRCircle draws a circle onto the drawing context aDC centered at the user coordinates (x,y) More...
 
void GRCircle (EDA_RECT *ClipBox, wxDC *DC, int x, int y, int r, int width, COLOR4D Color)
 
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 GRCircle (EDA_RECT *aClipBox, wxDC *aDC, wxPoint aPos, int aRadius, int aWidth, COLOR4D aColor)
 
void GRArc (EDA_RECT *ClipBox, wxDC *DC, int x, int y, 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 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, COLOR4D Color, COLOR4D BgColor)
 
void GRFilledArc (EDA_RECT *ClipBox, wxDC *DC, int x, int y, double StAngle, double EndAngle, int r, int width, COLOR4D Color, COLOR4D BgColor)
 
void GRCSegm (EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int width, COLOR4D Color)
 
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)
 
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 *aClipBox, wxDC *aDC, wxPoint aStart, wxPoint aEnd, int aWidth, COLOR4D aColor)
 
void GRSetColor (COLOR4D Color)
 
void GRSetDefaultPalette ()
 
COLOR4D GRGetColor ()
 
void GRPutPixel (EDA_RECT *ClipBox, wxDC *DC, int x, int y, COLOR4D color)
 
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 GRRect (EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, COLOR4D Color)
 
void GRRect (EDA_RECT *ClipBox, wxDC *DC, const EDA_RECT &aRect, int aWidth, COLOR4D Color)
 
void GRRect (EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int width, COLOR4D Color)
 
void GRRectPs (EDA_RECT *aClipBox, wxDC *aDC, const EDA_RECT &aRect, int aWidth, COLOR4D aColor, wxPenStyle aStyle=wxPENSTYLE_SOLID)
 
void GRSFilledRect (EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int width, COLOR4D Color, COLOR4D BgColor)
 
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 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

GR_DRAWMODE g_XorMode
 

Macro Definition Documentation

◆ GR_M_DCLICK

#define GR_M_DCLICK   0x80000000

Definition at line 79 of file gr_basic.h.

◆ GR_M_LEFT_DOWN

#define GR_M_LEFT_DOWN   0x10000000

Definition at line 76 of file gr_basic.h.

◆ GR_M_MIDDLE_DOWN

#define GR_M_MIDDLE_DOWN   0x40000000

Definition at line 78 of file gr_basic.h.

◆ GR_M_RIGHT_DOWN

#define GR_M_RIGHT_DOWN   0x20000000

Definition at line 77 of file gr_basic.h.

Enumeration Type Documentation

◆ GR_DRAWMODE

Drawmode. Compositing mode plus a flag or two.

Enumerator
GR_OR 
GR_XOR 
GR_AND 
GR_NXOR 
GR_INVERT 
GR_ALLOW_HIGHCONTRAST 
GR_COPY 
GR_HIGHLIGHT 
UNSPECIFIED_DRAWMODE 

Definition at line 39 of file gr_basic.h.

39  {
40  GR_OR = 0x01000000,
41  GR_XOR = 0x02000000,
42  GR_AND = 0x04000000,
43  GR_NXOR = 0x08000000,
44  GR_INVERT = 0x10000000,
45  GR_ALLOW_HIGHCONTRAST = 0x20000000,
46  GR_COPY = 0x40000000,
47  GR_HIGHLIGHT = 0x80000000,
49 };
Definition: gr_basic.h:40

◆ GRLineStypeType

Enumerator
GR_SOLID_LINE 
GR_DOTTED_LINE 
GR_DASHED_LINE 

Definition at line 84 of file gr_basic.h.

84  {
85  /* Line styles for Get/SetLineStyle. */
86  GR_SOLID_LINE = 0,
87  GR_DOTTED_LINE = 1,
88  GR_DASHED_LINE = 3
GRLineStypeType
Definition: gr_basic.h:84

Function Documentation

◆ DrawModeAddHighlight()

void DrawModeAddHighlight ( GR_DRAWMODE mode)
inline

Definition at line 51 of file gr_basic.h.

52 {
53  *mode = static_cast<GR_DRAWMODE>( int( *mode ) | GR_HIGHLIGHT );
54 }

References GR_HIGHLIGHT.

◆ DrawModeAllowHighContrast()

void DrawModeAllowHighContrast ( GR_DRAWMODE mode)
inline

Definition at line 56 of file gr_basic.h.

57 {
58  *mode = static_cast<GR_DRAWMODE>( int( *mode ) | GR_ALLOW_HIGHCONTRAST );
59 }

References GR_ALLOW_HIGHCONTRAST.

◆ GetGRForceBlackPenState()

bool GetGRForceBlackPenState ( void  )

Function GetGRForceBlackPenState.

Returns
ForceBlackPen (True if a black pen was forced)
s_ForceBlackPen (True if a black pen was forced)

Definition at line 209 of file gr_basic.cpp.

210 {
211  return s_ForceBlackPen;
212 }
static bool s_ForceBlackPen
Definition: gr_basic.cpp:86

References s_ForceBlackPen.

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

◆ GRArc() [1/2]

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

Definition at line 747 of file gr_basic.cpp.

749 {
750  int x1, y1, x2, y2;
751 
752  /* Clip arcs off screen */
753  if( ClipBox )
754  {
755  int radius = r + 1;
756  int x0, y0, xm, ym, x, y;
757  x0 = ClipBox->GetX();
758  y0 = ClipBox->GetY();
759  xm = ClipBox->GetRight();
760  ym = ClipBox->GetBottom();
761  x = xc;
762  y = yc;
763 
764  if( x < ( x0 - radius ) )
765  return;
766  if( y < ( y0 - radius ) )
767  return;
768  if( x > ( xm + radius ) )
769  return;
770  if( y > ( ym + radius ) )
771  return;
772  }
773 
774  x1 = r;
775  y1 = 0;
776  RotatePoint( &x1, &y1, EndAngle );
777 
778  x2 = r;
779  y2 = 0;
780  RotatePoint( &x2, &y2, StAngle );
781 
782  GRSetBrush( DC, Color, NOT_FILLED );
783  GRSetColorPen( DC, Color );
784  DC->DrawArc( xc + x1, yc - y1, xc + x2, yc - y2, xc, yc );
785 }
int GetX() const
Definition: eda_rect.h:111
void RotatePoint(int *pX, int *pY, double angle)
Definition: trigo.cpp:208
int GetBottom() const
Definition: eda_rect.h:124
static const bool NOT_FILLED
Definition: gr_basic.cpp:40
int GetRight() const
Definition: eda_rect.h:121
void GRSetBrush(wxDC *DC, COLOR4D Color, bool fill)
Definition: gr_basic.cpp:168
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: gr_basic.cpp:131
int GetY() const
Definition: eda_rect.h:112

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.

800 {
801  int x1, y1, x2, y2;
802 
803  /* Clip arcs off screen. */
804  if( ClipBox )
805  {
806  int x0, y0, xm, ym;
807  x0 = ClipBox->GetX();
808  y0 = ClipBox->GetY();
809  xm = ClipBox->GetRight();
810  ym = ClipBox->GetBottom();
811 
812  if( x < ( x0 - r - width ) )
813  return;
814 
815  if( y < ( y0 - r - width ) )
816  return;
817 
818  if( x > ( r + xm + width ) )
819  return;
820 
821  if( y > ( r + ym + width ) )
822  return;
823  }
824 
825  x1 = r;
826  y1 = 0;
827  RotatePoint( &x1, &y1, EndAngle );
828 
829  x2 = r;
830  y2 = 0;
831  RotatePoint( &x2, &y2, StAngle );
832 
833  GRSetBrush( DC, Color );
834  GRSetColorPen( DC, Color, width );
835  DC->DrawArc( x + x1, y - y1, x + x2, y - y2, x, y );
836 }
int GetX() const
Definition: eda_rect.h:111
void RotatePoint(int *pX, int *pY, double angle)
Definition: trigo.cpp:208
int GetBottom() const
Definition: eda_rect.h:124
int GetRight() const
Definition: eda_rect.h:121
void GRSetBrush(wxDC *DC, COLOR4D Color, bool fill)
Definition: gr_basic.cpp:168
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: gr_basic.cpp:131
int GetY() const
Definition: eda_rect.h:112

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.

640 {
641  GRArc1( ClipBox, DC, x1, y1, x2, y2, xc, yc, 0, Color );
642 }
void GRArc1(EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int xc, int yc, COLOR4D Color)
Definition: gr_basic.cpp:638

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.

650 {
651  /* Clip arcs off screen. */
652  if( ClipBox )
653  {
654  int x0, y0, xm, ym, r;
655  x0 = ClipBox->GetX();
656  y0 = ClipBox->GetY();
657  xm = ClipBox->GetRight();
658  ym = ClipBox->GetBottom();
659  r = KiROUND( Distance( x1, y1, xc, yc ) );
660  if( xc < ( x0 - r ) )
661  return;
662  if( yc < ( y0 - r ) )
663  return;
664  if( xc > ( r + xm ) )
665  return;
666  if( yc > ( r + ym ) )
667  return;
668  }
669 
670  GRSetBrush( DC, Color );
671  GRSetColorPen( DC, Color, width );
672  DC->DrawArc( x1, y1, x2, y2, xc, yc );
673 }
int GetX() const
Definition: eda_rect.h:111
int GetBottom() const
Definition: eda_rect.h:124
int GetRight() const
Definition: eda_rect.h:121
void GRSetBrush(wxDC *DC, COLOR4D Color, bool fill)
Definition: gr_basic.cpp:168
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: gr_basic.cpp:131
constexpr ret_type KiROUND(fp_type v)
Round a floating point number to an integer using "round halfway cases away from zero".
Definition: util.h:68
int GetY() const
Definition: eda_rect.h:112

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.

678 {
679  GRArc1( aClipBox, aDC, aStart.x, aStart.y, aEnd.x, aEnd.y, aCenter.x, aCenter.y,
680  aWidth, aColor );
681 }
void GRArc1(EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int xc, int yc, COLOR4D Color)
Definition: gr_basic.cpp:638

References GRArc1(), wxPoint::x, and wxPoint::y.

◆ GRBezier()

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

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

Definition at line 990 of file gr_basic.cpp.

993 {
994  std::vector<wxPoint> output;
995 
996  BEZIER_POLY converter( aPoint );
997  converter.GetPoly( output, aWidth );
998 
999  GRPoly( aClipBox, aDC, output.size(), &output[0], false, aWidth, aColor, aColor );
1000 }
void GRPoly(EDA_RECT *ClipBox, wxDC *DC, int n, const wxPoint *Points, bool Fill, int width, COLOR4D Color, COLOR4D BgColor)
Definition: gr_basic.cpp:540
Bezier curves to polygon converter.
Definition: bezier_curves.h:35

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

◆ GRCircle() [1/3]

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

Function GRCircle draws a circle onto the drawing context aDC centered at the user coordinates (x,y)

Parameters
ClipBoxdefines a rectangular boundary outside of which no drawing will occur.
aDCthe device context into which drawing should occur.
xThe x coordinate in user space of the center of the circle.
yThe y coordinate in user space of the center of the circle.
aRadiusis the radius of the circle.
aColoris the color to draw
See also
COLOR4D

Definition at line 605 of file gr_basic.cpp.

606 {
607  GRCircle( ClipBox, DC, x, y, r, 0, Color );
608 }
void GRCircle(EDA_RECT *ClipBox, wxDC *DC, int xc, int yc, int r, int width, COLOR4D Color)
Definition: gr_basic.cpp:594

References GRCircle().

◆ GRCircle() [2/3]

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

Definition at line 594 of file gr_basic.cpp.

595 {
596  if( clipCircle( ClipBox, xc, yc, r, width ) || r <= 0 )
597  return;
598 
599  GRSetBrush( DC, Color, NOT_FILLED );
600  GRSetColorPen( DC, Color, width );
601  DC->DrawEllipse( xc - r, yc - r, r + r, r + r );
602 }
static bool clipCircle(EDA_RECT *aClipBox, int xc, int yc, int r, int aWidth)
Definition: gr_basic.cpp:564
static const bool NOT_FILLED
Definition: gr_basic.cpp:40
void GRSetBrush(wxDC *DC, COLOR4D Color, bool fill)
Definition: gr_basic.cpp:168
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: gr_basic.cpp:131

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() [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.

612 {
613  GRCircle( aClipBox, aDC, aPos.x, aPos.y, aRadius, aWidth, aColor );
614 }
void GRCircle(EDA_RECT *ClipBox, wxDC *DC, int xc, int yc, int r, int width, COLOR4D Color)
Definition: gr_basic.cpp:594

References GRCircle(), wxPoint::x, and wxPoint::y.

◆ GRClosedPoly() [1/2]

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

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

Parameters
ClipBoxdefines a rectangular boundary outside of which no drawing will occur.
aDCthe device context into which drawing should occur.
aPointCountthe number of points in the array aPoints.
aPointsThe points to draw.
doFilltrue if polygon is to be filled, else false and only the boundary is drawn.
aPenColorthe color of the border.
aFillColorthe fill color of the polygon's interior.

Definition at line 550 of file gr_basic.cpp.

552 {
553  GRClosedPoly( ClipBox, DC, n, Points, Fill, 0, Color, BgColor );
554 }
void GRClosedPoly(EDA_RECT *ClipBox, wxDC *DC, int n, const wxPoint *Points, bool Fill, COLOR4D Color, COLOR4D BgColor)
Function GRClosedPoly draws a closed polygon onto the drawing context aDC and optionally fills and/or...
Definition: gr_basic.cpp:550

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 
)

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

Parameters
ClipBoxdefines a rectangular boundary outside of which no drawing will occur.
aDCthe device context into which drawing should occur.
aPointCountthe number of points in the array aPointArray.
aPointsthe points to draw.
doFilltrue if polygon is to be filled, else false and only the boundary is drawn.
aPenWidthis the width of the pen to use on the perimeter, can be zero.
aPenColorthe color of the border.
aFillColorthe fill color of the polygon's interior.

Definition at line 557 of file gr_basic.cpp.

559 {
560  GRSClosedPoly( ClipBox, DC, n, Points, Fill, width, Color, BgColor );
561 }
static void GRSClosedPoly(EDA_RECT *aClipBox, wxDC *aDC, int aPointCount, const wxPoint *aPoints, bool aFill, int aWidth, COLOR4D aColor, COLOR4D aBgColor)
Definition: gr_basic.cpp:503

References GRSClosedPoly().

◆ GRCSegm() [1/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.

398 {
399  GRCSegm( ClipBox, DC, x1, y1, x2, y2, width, 0, Color );
400 }
void GRCSegm(EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int width, int aPenSize, COLOR4D Color)
Definition: gr_basic.cpp:310

References GRCSegm().

◆ GRCSegm() [2/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.

312 {
313  GRLastMoveToX = x2;
314  GRLastMoveToY = y2;
315 
316  if( ClipBox )
317  {
318  EDA_RECT clipbox(*ClipBox);
319  clipbox.Inflate(width/2);
320 
321  if( ClipLine( &clipbox, x1, y1, x2, y2 ) )
322  return;
323  }
324 
325 
326  if( width <= 2 ) /* single line or 2 pixels */
327  {
328  GRSetColorPen( DC, Color, width );
329  DC->DrawLine( x1, y1, x2, y2 );
330  return;
331  }
332 
333  GRSetBrush( DC, Color, NOT_FILLED );
334  GRSetColorPen( DC, Color, aPenSize );
335 
336  int radius = (width + 1) >> 1;
337  int dx = x2 - x1;
338  int dy = y2 - y1;
339  double angle = -ArcTangente( dy, dx );
340  wxPoint start;
341  wxPoint end;
342  wxPoint org( x1, y1);
343  int len = (int) hypot( dx, dy );
344 
345  // We know if the DC is mirrored, to draw arcs
346  int slx = DC->DeviceToLogicalX( 1 ) - DC->DeviceToLogicalX( 0 );
347  int sly = DC->DeviceToLogicalY( 1 ) - DC->DeviceToLogicalY( 0 );
348  bool mirrored = (slx > 0 && sly < 0) || (slx < 0 && sly > 0);
349 
350  // first edge
351  start.x = 0;
352  start.y = radius;
353  end.x = len;
354  end.y = radius;
355  RotatePoint( &start, angle);
356  RotatePoint( &end, angle);
357 
358  start += org;
359  end += org;
360 
361  DC->DrawLine( start, end );
362 
363  // first rounded end
364  end.x = 0;
365  end.y = -radius;
366  RotatePoint( &end, angle);
367  end += org;
368 
369  if( !mirrored )
370  DC->DrawArc( end, start, org );
371  else
372  DC->DrawArc( start, end, org );
373 
374 
375  // second edge
376  start.x = len;
377  start.y = -radius;
378  RotatePoint( &start, angle);
379  start += org;
380 
381  DC->DrawLine( start, end );
382 
383  // second rounded end
384  end.x = len;
385  end.y = radius;
386  RotatePoint( &end, angle);
387  end += org;
388 
389  if( !mirrored )
390  DC->DrawArc( end.x, end.y, start.x, start.y, x2, y2 );
391  else
392  DC->DrawArc( start.x, start.y, end.x, end.y, x2, y2 );
393 }
void RotatePoint(int *pX, int *pY, double angle)
Definition: trigo.cpp:208
static int GRLastMoveToX
Definition: gr_basic.cpp:85
bool ClipLine(const EDA_RECT *aClipBox, int &x1, int &y1, int &x2, int &y2)
Test if any part of a line falls within the bounds of a rectangle.
static const bool NOT_FILLED
Definition: gr_basic.cpp:40
static int GRLastMoveToY
Definition: gr_basic.cpp:85
void GRSetBrush(wxDC *DC, COLOR4D Color, bool fill)
Definition: gr_basic.cpp:168
static DIRECTION_45::AngleType angle(const VECTOR2I &a, const VECTOR2I &b)
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: gr_basic.cpp:131
EDA_RECT handles the component boundary box.
Definition: eda_rect.h:44
double ArcTangente(int dy, int dx)
Definition: trigo.cpp:162

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

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

◆ 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.

405 {
406  GRCSegm( aClipBox, aDC, aStart.x, aStart.y, aEnd.x, aEnd.y, aWidth, 0, aColor );
407 }
void GRCSegm(EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int width, int aPenSize, COLOR4D Color)
Definition: gr_basic.cpp:310

References GRCSegm(), wxPoint::x, and wxPoint::y.

◆ 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.

1005 {
1006  int anchor_size = aDC->DeviceToLogicalXRel( aSize );
1007 
1008  GRLine( aClipBox, aDC,
1009  x - anchor_size, y,
1010  x + anchor_size, y, 0, aColor );
1011  GRLine( aClipBox, aDC,
1012  x, y - anchor_size,
1013  x, y + anchor_size, 0, aColor );
1014 }
void GRLine(EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int width, COLOR4D Color, wxPenStyle aStyle)
Definition: gr_basic.cpp:228

References GRLine().

◆ GRDrawWrappedText()

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

Draw text centered on a wxDC with wrapping.

Parameters
aDCwxDC instance onto which the text will be drawn
aTextthe text to draw

Definition at line 1017 of file gr_basic.cpp.

1018 {
1019  wxStringTokenizer tokenizer( aText, " " );
1020  wxSize const dc_size = aDC.GetSize();
1021  wxSize const margin = aDC.GetTextExtent( " " );
1022  std::vector<wxString> lines;
1023  wxString line_accumulator;
1024  int total_height = 0;
1025 
1026  while( tokenizer.HasMoreTokens() )
1027  {
1028  wxString word = tokenizer.GetNextToken();
1029  wxSize linesize = aDC.GetTextExtent( line_accumulator + " " + word );
1030 
1031  if( linesize.x >= dc_size.x - margin.x && !line_accumulator.IsEmpty() )
1032  {
1033  lines.push_back( line_accumulator );
1034  line_accumulator = word;
1035  }
1036  else
1037  {
1038  line_accumulator += " ";
1039  line_accumulator += word;
1040  }
1041  }
1042 
1043  if( !line_accumulator.IsEmpty() )
1044  {
1045  lines.push_back( line_accumulator );
1046  }
1047 
1048  for( auto const& line: lines )
1049  {
1050  wxSize linesize = aDC.GetTextExtent( line );
1051  total_height += linesize.y;
1052  }
1053 
1054  int top = ( dc_size.y - total_height ) / 2;
1055  int pos = top;
1056 
1057  for( auto const& line: lines )
1058  {
1059  wxSize linesize = aDC.GetTextExtent( line );
1060  aDC.DrawText( line, ( dc_size.x - linesize.x ) / 2, pos );
1061  pos += linesize.y;
1062  }
1063 }

◆ 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.

415 {
416  GRSetColorPen( DC, Color, width );
417  WinClipAndDrawLine( ClipBox, DC, x1, y1, x2, y2, width );
418 }
static void WinClipAndDrawLine(EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int width)
Definition: gr_basic.cpp:98
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: gr_basic.cpp:131

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,
COLOR4D  Color,
COLOR4D  BgColor 
)

Definition at line 736 of file gr_basic.cpp.

739 {
740  GRFilledArc( ClipBox, DC, x, y, StAngle, EndAngle, r, 0, Color, BgColor );
741 }
void GRFilledArc(EDA_RECT *ClipBox, wxDC *DC, int x, int y, double StAngle, double EndAngle, int r, int width, COLOR4D Color, COLOR4D BgColor)
Definition: gr_basic.cpp:687

References GRFilledArc().

◆ GRFilledArc() [2/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.

697 {
698  int x1, y1, x2, y2;
699 
700  /* Clip arcs off screen */
701  if( ClipBox )
702  {
703  int x0, y0, xm, ym;
704  x0 = ClipBox->GetX();
705  y0 = ClipBox->GetY();
706  xm = ClipBox->GetRight();
707  ym = ClipBox->GetBottom();
708 
709  if( x < ( x0 - r - 1 ) )
710  return;
711 
712  if( y < ( y0 - r - 1 ) )
713  return;
714 
715  if( x > ( r + xm + 1 ) )
716  return;
717 
718  if( y > ( r + ym + 1 ) )
719  return;
720  }
721 
722  x1 = r;
723  y1 = 0;
724  RotatePoint( &x1, &y1, EndAngle );
725 
726  x2 = r;
727  y2 = 0;
728  RotatePoint( &x2, &y2, StAngle );
729 
730  GRSetBrush( DC, BgColor, FILLED );
731  GRSetColorPen( DC, Color, width );
732  DC->DrawArc( x + x1, y - y1, x + x2, y - y2, x, y );
733 }
static const bool FILLED
Definition: gr_basic.cpp:39
int GetX() const
Definition: eda_rect.h:111
void RotatePoint(int *pX, int *pY, double angle)
Definition: trigo.cpp:208
int GetBottom() const
Definition: eda_rect.h:124
int GetRight() const
Definition: eda_rect.h:121
void GRSetBrush(wxDC *DC, COLOR4D Color, bool fill)
Definition: gr_basic.cpp:168
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: gr_basic.cpp:131
int GetY() const
Definition: eda_rect.h:112

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().

◆ 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.

619 {
620  if( clipCircle( ClipBox, x, y, r, width ) || r <= 0 )
621  return;
622 
623  GRSetBrush( DC, BgColor, FILLED );
624  GRSetColorPen( DC, Color, width );
625  DC->DrawEllipse( x - r, y - r, r + r, r + r );
626 }
static const bool FILLED
Definition: gr_basic.cpp:39
static bool clipCircle(EDA_RECT *aClipBox, int xc, int yc, int r, int aWidth)
Definition: gr_basic.cpp:564
void GRSetBrush(wxDC *DC, COLOR4D Color, bool fill)
Definition: gr_basic.cpp:168
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: gr_basic.cpp:131

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.

630 {
631  GRFilledCircle( aClipBox, aDC, aPos.x, aPos.y, aRadius, 0, aColor, aColor );
632 }
void GRFilledCircle(EDA_RECT *ClipBox, wxDC *DC, int x, int y, int r, int width, COLOR4D Color, COLOR4D BgColor)
Definition: gr_basic.cpp:617

References GRFilledCircle(), wxPoint::x, and wxPoint::y.

◆ 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.

884 {
885  GRSFilledRect( ClipBox, DC, x1, y1, x2, y2, 0, Color, BgColor );
886 }
void GRSFilledRect(EDA_RECT *aClipBox, wxDC *aDC, int x1, int y1, int x2, int y2, int aWidth, COLOR4D aColor, COLOR4D aBgColor)
Definition: gr_basic.cpp:917

References GRSFilledRect().

Referenced by D_CODE::DrawFlashedShape(), LIB_RECTANGLE::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.

894 {
895  GRSFilledRect( ClipBox, DC, x1, y1, x2, y2, width, Color, BgColor );
896 }
void GRSFilledRect(EDA_RECT *aClipBox, wxDC *aDC, int x1, int y1, int x2, int y2, int aWidth, COLOR4D aColor, COLOR4D aBgColor)
Definition: gr_basic.cpp:917

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.

423 {
424  GRSetColorPen( aDC, aColor, aWidth );
425  WinClipAndDrawLine( aClipBox, aDC, aStart.x, aStart.y, aEnd.x, aEnd.y, aWidth );
426 }
static void WinClipAndDrawLine(EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int width)
Definition: gr_basic.cpp:98
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: gr_basic.cpp:131

References GRSetColorPen(), WinClipAndDrawLine(), wxPoint::x, and wxPoint::y.

Referenced by GERBER_DRAW_ITEM::Print().

◆ GRForceBlackPen()

void GRForceBlackPen ( bool  flagforce)

Function GRForceBlackPen.

Parameters
flagforceTrue to force a black pen whenever the asked color

Definition at line 199 of file gr_basic.cpp.

200 {
201  s_ForceBlackPen = flagforce;
202 }
static bool s_ForceBlackPen
Definition: gr_basic.cpp:86

References s_ForceBlackPen.

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

◆ GRGetColor()

COLOR4D GRGetColor ( )

◆ GRLine() [1/2]

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

Definition at line 245 of file gr_basic.cpp.

246 {
247  GRLine( aClipBox, aDC, aStart.x, aStart.y, aEnd.x, aEnd.y, aWidth, aColor, aStyle );
248 }
void GRLine(EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int width, COLOR4D Color, wxPenStyle aStyle)
Definition: gr_basic.cpp:228

References GRLine(), wxPoint::x, and wxPoint::y.

◆ GRLine() [2/2]

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

Definition at line 228 of file gr_basic.cpp.

237 {
238  GRSetColorPen( DC, Color, width, aStyle );
239  WinClipAndDrawLine( ClipBox, DC, x1, y1, x2, y2, width );
240  GRLastMoveToX = x2;
241  GRLastMoveToY = y2;
242 }
static int GRLastMoveToX
Definition: gr_basic.cpp:85
static int GRLastMoveToY
Definition: gr_basic.cpp:85
static void WinClipAndDrawLine(EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int width)
Definition: gr_basic.cpp:98
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: gr_basic.cpp:131

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 WS_DRAW_ITEM_LINE::PrintWsItem().

◆ 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).

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

284 {
285  if( aLines.empty() )
286  return;
287 
288  GRSetColorPen( aDC, aColor, aWidth );
289 
290  if( aClipBox )
291  aClipBox->Inflate( aWidth / 2 );
292 
293  for( unsigned i = 0; i < aLines.size(); i += 2 )
294  {
295  int x1 = aLines[i].x;
296  int y1 = aLines[i].y;
297  int x2 = aLines[i + 1].x;
298  int y2 = aLines[i + 1].y;
299  if( ( aClipBox == NULL ) || !ClipLine( aClipBox, x1, y1, x2, y2 ) )
300  aDC->DrawLine( x1, y1, x2, y2 );
301  }
302 
303  GRMoveTo( aLines[aLines.size() - 1].x, aLines[aLines.size() - 1].y );
304 
305  if( aClipBox )
306  aClipBox->Inflate(-aWidth/2);
307 }
bool ClipLine(const EDA_RECT *aClipBox, int &x1, int &y1, int &x2, int &y2)
Test if any part of a line falls within the bounds of a rectangle.
#define NULL
void GRMoveTo(int x, int y)
Definition: gr_basic.cpp:254
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: gr_basic.cpp:131
EDA_RECT & Inflate(wxCoord dx, wxCoord dy)
Function Inflate inflates the rectangle horizontally by dx and vertically by dy.
Definition: eda_rect.cpp:363

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.

265 {
266  GRLine( ClipBox, DC, GRLastMoveToX, GRLastMoveToY, x, y, width, Color );
267 }
static int GRLastMoveToX
Definition: gr_basic.cpp:85
static int GRLastMoveToY
Definition: gr_basic.cpp:85
void GRLine(EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int width, COLOR4D Color, wxPenStyle aStyle)
Definition: gr_basic.cpp:228

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.

255 {
256  GRLastMoveToX = x;
257  GRLastMoveToY = y;
258 }
static int GRLastMoveToX
Definition: gr_basic.cpp:85
static int GRLastMoveToY
Definition: gr_basic.cpp:85

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.

542 {
543  GRSPoly( ClipBox, DC, n, Points, Fill, width, Color, BgColor );
544 }
static void GRSPoly(EDA_RECT *ClipBox, wxDC *DC, int n, const wxPoint *Points, bool Fill, int width, COLOR4D Color, COLOR4D BgColor)
Definition: gr_basic.cpp:471

References GRSPoly().

Referenced by BASIC_GAL::DrawPolyline(), GRBezier(), LIB_POLYLINE::print(), LIB_BEZIER::print(), SCH_GLOBALLABEL::Print(), SCH_HIERLABEL::Print(), and WS_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.

216 {
217  if( ClipBox && !ClipBox->Contains( x, y ) )
218  return;
219 
220  GRSetColorPen( DC, Color );
221  DC->DrawPoint( x, y );
222 }
bool Contains(const wxPoint &aPoint) const
Function Contains.
Definition: eda_rect.cpp:57
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: gr_basic.cpp:131

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

◆ GRRect() [1/3]

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

Definition at line 842 of file gr_basic.cpp.

843 {
844  GRSRect( aClipBox, aDC, x1, y1, x2, y2, 0, aColor );
845 }
static void GRSRect(EDA_RECT *aClipBox, wxDC *aDC, int x1, int y1, int x2, int y2, int aWidth, COLOR4D aColor, wxPenStyle aStyle=wxPENSTYLE_SOLID)
Definition: gr_basic.cpp:903

References GRSRect().

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

◆ GRRect() [2/3]

void GRRect ( EDA_RECT ClipBox,
wxDC *  DC,
const EDA_RECT aRect,
int  aWidth,
COLOR4D  Color 
)

Definition at line 868 of file gr_basic.cpp.

869 {
870  int x1 = aRect.GetX();
871  int y1 = aRect.GetY();
872  int x2 = aRect.GetRight();
873  int y2 = aRect.GetBottom();
874 
875  GRSRect( aClipBox, aDC, x1, y1, x2, y2, aWidth, aColor );
876 }
int GetX() const
Definition: eda_rect.h:111
int GetBottom() const
Definition: eda_rect.h:124
int GetRight() const
Definition: eda_rect.h:121
int GetY() const
Definition: eda_rect.h:112
static void GRSRect(EDA_RECT *aClipBox, wxDC *aDC, int x1, int y1, int x2, int y2, int aWidth, COLOR4D aColor, wxPenStyle aStyle=wxPENSTYLE_SOLID)
Definition: gr_basic.cpp:903

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

◆ GRRect() [3/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.

863 {
864  GRSRect( ClipBox, DC, x1, y1, x2, y2, width, Color );
865 }
static void GRSRect(EDA_RECT *aClipBox, wxDC *aDC, int x1, int y1, int x2, int y2, int aWidth, COLOR4D aColor, wxPenStyle aStyle=wxPENSTYLE_SOLID)
Definition: gr_basic.cpp:903

References GRSRect().

◆ GRRectPs()

void GRRectPs ( EDA_RECT aClipBox,
wxDC *  aDC,
const EDA_RECT aRect,
int  aWidth,
COLOR4D  aColor,
wxPenStyle  aStyle = wxPENSTYLE_SOLID 
)

◆ GRResetPenAndBrush()

void GRResetPenAndBrush ( wxDC *  DC)

Definition at line 118 of file gr_basic.cpp.

119 {
120  GRSetBrush( DC, BLACK ); // Force no fill
121  s_DC_lastbrushcolor = COLOR4D::UNSPECIFIED;
122  s_DC_lastcolor = COLOR4D::UNSPECIFIED;
123  s_DC_lastDC = NULL;
124 }
Definition: color4d.h:45
#define NULL
static wxDC * s_DC_lastDC
Definition: gr_basic.cpp:96
static COLOR4D s_DC_lastbrushcolor(0, 0, 0, 0)
static COLOR4D s_DC_lastcolor(0, 0, 0, 0)
void GRSetBrush(wxDC *DC, COLOR4D Color, bool fill)
Definition: gr_basic.cpp:168

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().

◆ GRSetBrush()

void GRSetBrush ( wxDC *  DC,
COLOR4D  Color,
bool  fill = false 
)

Definition at line 168 of file gr_basic.cpp.

169 {
170  if( s_ForceBlackPen )
171  Color = COLOR4D::BLACK;
172 
173  if( s_DC_lastbrushcolor != Color
174  || s_DC_lastbrushfill != fill
175  || s_DC_lastDC != DC )
176  {
177  wxBrush brush;
178 
179  brush.SetColour( Color.ToColour() );
180 
181  if( fill )
182  brush.SetStyle( wxBRUSHSTYLE_SOLID );
183  else
184  brush.SetStyle( wxBRUSHSTYLE_TRANSPARENT );
185 
186  DC->SetBrush( brush );
187 
188  s_DC_lastbrushcolor = Color;
189  s_DC_lastbrushfill = fill;
190  s_DC_lastDC = DC;
191  }
192 }
Definition: color4d.h:45
static wxDC * s_DC_lastDC
Definition: gr_basic.cpp:96
static COLOR4D s_DC_lastbrushcolor(0, 0, 0, 0)
static bool s_DC_lastbrushfill
Definition: gr_basic.cpp:95
static bool s_ForceBlackPen
Definition: gr_basic.cpp:86

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().

◆ GRSetColor()

void GRSetColor ( COLOR4D  Color)

◆ GRSetColorPen()

void GRSetColorPen ( wxDC *  DC,
COLOR4D  Color,
int  width = 1,
wxPenStyle  stype = wxPENSTYLE_SOLID 
)

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

Definition at line 131 of file gr_basic.cpp.

132 {
133  wxDash dots[2] = { 1, 3 };
134  // Under OSX and while printing when wxPen is set to 0, renderer follows the request drawing
135  // nothing & in the bitmap world the minimum is enough to light a pixel, in vectorial one not
136  if( width <= 1 )
137  width = DC->DeviceToLogicalXRel( 1 );
138 
139  if( s_ForceBlackPen )
140  Color = COLOR4D::BLACK;
141 
142  const wxPen& curr_pen = DC->GetPen();
143 
144  if( !curr_pen.IsOk() || curr_pen.GetColour() != Color.ToColour()
145  || curr_pen.GetWidth() != width
146  || curr_pen.GetStyle() != style )
147  {
148  wxPen pen;
149  pen.SetColour( Color.ToColour() );
150  if( style == wxPENSTYLE_DOT )
151  {
152  style = wxPENSTYLE_USER_DASH;
153  pen.SetDashes( 2, dots );
154  }
155  pen.SetWidth( width );
156  pen.SetStyle( style );
157  DC->SetPen( pen );
158  }
159  else
160  // Should be not needed, but on Linux, in printing process
161  // the curr pen settings needs to be sometimes re-initialized
162  // Clearly, this is due to a bug, related to SetBrush(),
163  // but we have to live with it, at least on wxWidgets 3.0
164  DC->SetPen( curr_pen );
165 }
Definition: color4d.h:45
static bool s_ForceBlackPen
Definition: gr_basic.cpp:86

References BLACK, and s_ForceBlackPen.

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

◆ GRSetDefaultPalette()

void GRSetDefaultPalette ( )

◆ GRSFilledRect()

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

Definition at line 917 of file gr_basic.cpp.

919 {
920  wxPoint points[5];
921  points[0] = wxPoint(x1, y1);
922  points[1] = wxPoint(x1, y2);
923  points[2] = wxPoint(x2, y2);
924  points[3] = wxPoint(x2, y1);
925  points[4] = points[0];
926 
927  GRSetBrush( aDC, aBgColor, FILLED );
928  GRSetColorPen( aDC, aBgColor, aWidth );
929 
930  if( aClipBox && (aWidth > 0) )
931  {
932  EDA_RECT clipbox(*aClipBox);
933  clipbox.Inflate(aWidth);
934  ClipAndDrawPoly(&clipbox, aDC, points, 5); // polygon approach is more accurate
935  }
936  else
937  ClipAndDrawPoly(aClipBox, aDC, points, 5 );
938 }
static const bool FILLED
Definition: gr_basic.cpp:39
void GRSetBrush(wxDC *DC, COLOR4D Color, bool fill)
Definition: gr_basic.cpp:168
static void ClipAndDrawPoly(EDA_RECT *ClipBox, wxDC *DC, const wxPoint *Points, int n)
Function ClipAndDrawPoly Used to clip a polygon and draw it as Filled Polygon uses the Sutherland and...
Definition: gr_basic.cpp:955
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: gr_basic.cpp:131
EDA_RECT handles the component boundary box.
Definition: eda_rect.h:44

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

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

◆ operator &()

GR_DRAWMODE operator & ( const GR_DRAWMODE a,
const GR_DRAWMODE b 
)
inline

Definition at line 71 of file gr_basic.h.

72 {
73  return static_cast<GR_DRAWMODE>( int( a ) & int( b ) );
74 }

◆ operator ~()

GR_DRAWMODE operator ~ ( const GR_DRAWMODE a)
inline

Definition at line 61 of file gr_basic.h.

62 {
63  return static_cast<GR_DRAWMODE>( ~int( a ) );
64 }

◆ operator|()

GR_DRAWMODE operator| ( const GR_DRAWMODE a,
const GR_DRAWMODE b 
)
inline

Definition at line 66 of file gr_basic.h.

67 {
68  return static_cast<GR_DRAWMODE>( int( a ) | int( b ) );
69 }

Variable Documentation

◆ g_XorMode

GR_DRAWMODE g_XorMode

Definition at line 70 of file gr_basic.cpp.