kicad/common/gr_basic.cpp

1500 lines
43 KiB
C++
Raw Normal View History

2007-10-31 06:40:15 +00:00
/********************************/
/* Low level graphics routines */
/********************************/
#include "fctsys.h"
#include "gr_basic.h"
#include "common.h"
#include "trigo.h"
#include "macros.h"
#include "base_struct.h"
#include "class_base_screen.h"
#ifndef FILLED
#define FILLED 1
#endif
/* Important Note:
* These drawing functions clip draw item before send these items to wxDC draw functions.
* For guy who aks why i did it, see a sample of problems encounted when pixels
* coordinates overflow 16 bits values:
* http://trac.wxwidgets.org/ticket/10446
* Problems can be found under Windows **and** Linux (mainly when drawing arcs)
* (mainly at low zoom values (2, 1 or 0.5), in pcbnew)
* some of these problems could be now fixed in recent distributions.
*
* Currently (feb 2009) there are overflow problems when drawing solid (filled) polygons under linux without clipping
*
* So before removing cliping functions, be aware these bug (they are not in kicad or wxWidgets)
* are fixed by testing how are drawn complex lines arcs and solid polygons under Windows and Linux
* and remember users can have old versions with bugs
*/
/* variables generales */
// pour les trac<61>s en mode XOR = GR_XOR ou GR_NXOR selon couleur de fond
int g_XorMode = GR_NXOR;
// couleur de fond de la frame de dessin
int g_DrawBgColor = WHITE;
#define USE_CLIP_FILLED_POLYGONS
#ifdef USE_CLIP_FILLED_POLYGONS
void ClipAndDrawFilledPoly( EDA_Rect * ClipBox, wxDC * DC, wxPoint Points[], int n );
#endif
/* global variables */
2007-10-31 06:40:15 +00:00
extern BASE_SCREEN* ActiveScreen;
/* Variables locales */
static int GRLastMoveToX, GRLastMoveToY;
static int PenMinWidth = 1; /* largeur minimum de la plume (DOIT etre > 0)
* (utile pour trace sur imprimante) */
static int ForceBlackPen; /* si != 0 : traces en noir (utilise pour trace
* sur imprimante */
static int xcliplo = 0,
ycliplo = 0,
xcliphi = 2000,
ycliphi = 2000; /* coord de la surface de trace */
static int lastcolor = -1;
static int lastwidth = -1;
2007-10-31 06:40:15 +00:00
static int s_Last_Pen_Style = -1;
static wxDC* lastDC = NULL;
2007-10-31 06:40:15 +00:00
/*
2007-10-31 06:40:15 +00:00
* Macro de clipping du trace d'une ligne:
* la ligne (x1,y1 x2,y2) est clippee pour rester dans le cadre
* (xcliplo,ycliplo xcliphi,ycliphi) (variables globales,locales a ce fichier)
* Ceci est necessaire sous WIN95 car les coord de trace
* (bien que en int 32bits) sont tronquees en 16 bits (stupide BG)
*/
#ifndef us
#define us unsigned int
#endif
2007-10-31 06:40:15 +00:00
static inline int USCALE( us arg, us num, us den )
{
#ifndef WX_ZOOM
2007-10-31 06:40:15 +00:00
int ii;
ii = (int) ( ( (float) arg * num ) / den );
return ii;
#else
return arg;
#endif
}
static int inline ZoomValue( int val )
{
return ActiveScreen->Scale( val );
2007-10-31 06:40:15 +00:00
}
/****************************************/
/* External reference for the mappings. */
/****************************************/
2007-10-31 06:40:15 +00:00
int GRMapX( int x )
{
#ifndef WX_ZOOM
int coord = x - ActiveScreen->m_DrawOrg.x;
2007-10-31 06:40:15 +00:00
coord = ZoomValue( coord );
coord -= ActiveScreen->m_StartVisu.x;
return coord;
#else
return x;
#endif
}
2007-10-31 06:40:15 +00:00
int GRMapY( int y )
{
#ifndef WX_ZOOM
int coord = y - ActiveScreen->m_DrawOrg.y;
2007-10-31 06:40:15 +00:00
coord = ZoomValue( coord );
coord -= ActiveScreen->m_StartVisu.y;
return coord;
#else
return y;
#endif
}
2007-10-31 17:44:51 +00:00
#define WHEN_OUTSIDE return true;
2007-10-31 06:40:15 +00:00
#define WHEN_INSIDE
2007-10-31 17:44:51 +00:00
/**
* Function clip_line
* @return bool - true when WHEN_OUTSIDE fires, else false.
2008-04-02 14:16:14 +00:00
*/
2007-10-31 17:44:51 +00:00
static inline bool clip_line( int& x1, int& y1, int& x2, int& y2 )
2007-10-31 06:40:15 +00:00
{
int temp;
if( x1 > x2 )
{
2008-04-02 14:16:14 +00:00
EXCHG( x1, x2 );
2007-10-31 06:40:15 +00:00
EXCHG( y1, y2 );
}
if( (x2 < xcliplo) || (x1 > xcliphi) )
{
WHEN_OUTSIDE;
}
if( y1 < y2 )
{
if( (y2 < ycliplo) || (y1 > ycliphi) )
{
WHEN_OUTSIDE;
}
if( y1 < ycliplo )
{
temp = USCALE( (x2 - x1), (ycliplo - y1), (y2 - y1) );
if( (x1 += temp) > xcliphi )
{
WHEN_OUTSIDE;
}
y1 = ycliplo;
WHEN_INSIDE;
}
if( y2 > ycliphi )
{
temp = USCALE( (x2 - x1), (y2 - ycliphi), (y2 - y1) );
if( (x2 -= temp) < xcliplo )
{
WHEN_OUTSIDE;
}
y2 = ycliphi;
WHEN_INSIDE;
}
if( x1 < xcliplo )
{
temp = USCALE( (y2 - y1), (xcliplo - x1), (x2 - x1) );
y1 += temp;
x1 = xcliplo;
2007-10-31 06:40:15 +00:00
WHEN_INSIDE;
}
if( x2 > xcliphi )
{
temp = USCALE( (y2 - y1), (x2 - xcliphi), (x2 - x1) );
y2 -= temp;
x2 = xcliphi;
2007-10-31 06:40:15 +00:00
WHEN_INSIDE;
}
}
else
{
if( (y1 < ycliplo) || (y2 > ycliphi) )
{
WHEN_OUTSIDE;
}
if( y1 > ycliphi )
{
temp = USCALE( (x2 - x1), (y1 - ycliphi), (y1 - y2) );
if( (x1 += temp) > xcliphi )
{
WHEN_OUTSIDE;
}
y1 = ycliphi;
WHEN_INSIDE;
}
if( y2 < ycliplo )
{
temp = USCALE( (x2 - x1), (ycliplo - y2), (y1 - y2) );
if( (x2 -= temp) < xcliplo )
{
WHEN_OUTSIDE;
}
y2 = ycliplo;
WHEN_INSIDE;
}
if( x1 < xcliplo )
{
temp = USCALE( (y1 - y2), (xcliplo - x1), (x2 - x1) );
y1 -= temp;
x1 = xcliplo;
2007-10-31 06:40:15 +00:00
WHEN_INSIDE;
}
if( x2 > xcliphi )
{
temp = USCALE( (y1 - y2), (x2 - xcliphi), (x2 - x1) );
y2 += temp;
x2 = xcliphi;
2007-10-31 06:40:15 +00:00
WHEN_INSIDE;
}
}
2008-04-02 14:16:14 +00:00
2007-10-31 17:44:51 +00:00
return false;
2007-10-31 06:40:15 +00:00
}
static void WinClipAndDrawLine( EDA_Rect* ClipBox, wxDC* DC,
int x1, int y1, int x2, int y2,
int Color, int width = 1 )
{
GRLastMoveToX = x2;
GRLastMoveToY = y2;
if( ClipBox )
{
xcliplo = ClipBox->GetX();
ycliplo = ClipBox->GetY();
xcliphi = ClipBox->GetRight();
ycliphi = ClipBox->GetBottom();
xcliplo -= width;
ycliplo -= width;
xcliphi += width;
ycliphi += width;
2007-10-31 17:44:51 +00:00
if( clip_line( x1, y1, x2, y2 ) )
return;
2007-10-31 06:40:15 +00:00
}
GRSetColorPen( DC, Color, width );
DC->DrawLine( x1, y1, x2, y2 );
}
/* Routine de forcage de la reinit de la plume courante.
2007-10-31 06:40:15 +00:00
* Doit etre appelee par securite apres changement de contexte graphique
* avant tout trace
*/
2007-10-31 06:40:15 +00:00
void GRResetPenAndBrush( wxDC* DC )
{
2007-10-31 06:40:15 +00:00
lastcolor = -1;
GRSetBrush( DC, BLACK ); // Force no fill
lastDC = NULL;
}
2007-10-31 06:40:15 +00:00
/* routine d'ajustage de la largeur mini de plume */
2007-10-31 06:40:15 +00:00
void SetPenMinWidth( int minwidth )
{
2007-10-31 06:40:15 +00:00
PenMinWidth = minwidth;
if( PenMinWidth < 1 )
PenMinWidth = 1;
}
2008-04-02 14:16:14 +00:00
/**
* Function GRSetColorPen
* sets a pen style, width, color, and alpha into the given device context.
*/
2007-10-31 06:40:15 +00:00
void GRSetColorPen( wxDC* DC, int Color, int width, int style )
{
2007-10-31 06:40:15 +00:00
if( width < PenMinWidth )
width = PenMinWidth;
2008-07-20 12:59:52 +00:00
if( ForceBlackPen )
2008-04-02 14:16:14 +00:00
{
2007-10-31 06:40:15 +00:00
Color = BLACK;
2008-04-02 14:16:14 +00:00
}
2008-04-02 14:16:14 +00:00
if( lastcolor != Color
|| lastwidth != width
|| s_Last_Pen_Style != style
|| lastDC != DC )
2007-10-31 06:40:15 +00:00
{
wxPen pen;
2008-04-02 14:16:14 +00:00
wxColour wx_color = MakeColour( Color );
2008-04-02 14:16:14 +00:00
pen.SetColour( wx_color );
pen.SetWidth( width );
pen.SetStyle( style );
DC->SetPen( pen );
lastcolor = Color;
lastwidth = width;
lastDC = DC;
2008-04-02 14:16:14 +00:00
2007-10-31 06:40:15 +00:00
s_Last_Pen_Style = style;
}
}
2007-10-31 06:40:15 +00:00
/***********************************************/
2007-10-31 06:40:15 +00:00
void GRSetBrush( wxDC* DC, int Color, int fill )
/***********************************************/
{
2007-10-31 06:40:15 +00:00
Color &= MASKCOLOR; // Pour 32 couleurs Max
2008-07-20 12:59:52 +00:00
if( ForceBlackPen )
2007-10-31 06:40:15 +00:00
Color = BLACK;
wxBrush DrawBrush;
DrawBrush.SetColour(
ColorRefs[Color].m_Red,
ColorRefs[Color].m_Green,
ColorRefs[Color].m_Blue
);
2007-10-31 06:40:15 +00:00
if( fill )
DrawBrush.SetStyle( wxSOLID );
else
DrawBrush.SetStyle( wxTRANSPARENT );
DC->SetBrush( DrawBrush );
}
2007-10-31 06:40:15 +00:00
/*************************************/
2007-10-31 06:40:15 +00:00
void GRForceBlackPen( bool flagforce )
/*************************************/
/** function GRForceBlackPen
* @param flagforce True to force a black pen whenever the asked color
*/
{
2007-10-31 06:40:15 +00:00
ForceBlackPen = flagforce;
}
/***********************************/
bool GetGRForceBlackPenState( void )
/***********************************/
/** function GetGRForceBlackPenState
* @return ForceBlackPen (True if a black pen was forced)
*/
{
return ForceBlackPen;
}
2007-10-31 06:40:15 +00:00
/**********************************************/
/* Routine pour selectionner le mode de trace */
/**********************************************/
2007-10-31 06:40:15 +00:00
void GRSetDrawMode( wxDC* DC, int draw_mode )
{
2007-10-31 06:40:15 +00:00
if( draw_mode & GR_OR )
#if defined(__WXMAC__) && wxMAC_USE_CORE_GRAPHICS
2008-04-02 14:16:14 +00:00
DC->SetLogicalFunction( wxCOPY );
#else
2007-10-31 06:40:15 +00:00
DC->SetLogicalFunction( wxOR );
2008-04-02 14:16:14 +00:00
#endif
2007-10-31 06:40:15 +00:00
else if( draw_mode & GR_XOR )
DC->SetLogicalFunction( wxXOR );
else if( draw_mode & GR_NXOR )
2009-03-26 19:27:50 +00:00
#if defined (__WXMAC__) && wxMAC_USE_CORE_GRAPHICS
DC->SetLogicalFunction( wxXOR );
#else
DC->SetLogicalFunction( wxEQUIV );
#endif
else
2007-10-31 06:40:15 +00:00
DC->SetLogicalFunction( wxCOPY );
}
/*********************************************************************/
2007-10-31 06:40:15 +00:00
void GRPutPixel( EDA_Rect* ClipBox, wxDC* DC, int x, int y, int Color )
/*********************************************************************/
{
2007-10-31 06:40:15 +00:00
GRSPutPixel( ClipBox, DC, GRMapX( x ), GRMapY( y ), Color );
}
/********************************************************************/
2007-10-31 06:40:15 +00:00
void GRSPutPixel( EDA_Rect* ClipBox, wxDC* DC, int x, int y, int Color )
/********************************************************************/
{
if( ClipBox && !ClipBox->Inside( x, y ) )
return;
2007-10-31 06:40:15 +00:00
GRSetColorPen( DC, Color );
DC->DrawPoint( x, y );
}
2007-10-31 06:40:15 +00:00
/*******************************************/
/* int GRGetPixel(wxDC * DC, int x, int y) */
/*******************************************/
int GRGetPixel( wxDC* DC, int x, int y )
{
2007-10-31 06:40:15 +00:00
wxColour colour;
unsigned char r, g, b;
int ii;
2007-10-31 06:40:15 +00:00
DC->GetPixel( (long) x, (long) y, &colour );
r = colour.Red();
b = colour.Blue();
g = colour.Green();
for( ii = 0; ii < NBCOLOR; ii++ )
{
if( ( r == ColorRefs[ii].m_Red )
&& ( g == ColorRefs[ii].m_Green )
&& ( b == ColorRefs[ii].m_Blue ) )
break;
}
2007-10-31 06:40:15 +00:00
return ii;
}
/****************************************************************************
* Routine to draw a line, in Object spaces. *
****************************************************************************/
2007-10-31 06:40:15 +00:00
void GRLine( EDA_Rect* ClipBox, wxDC* DC, int x1, int y1, int x2, int y2, int width, int Color )
{
2007-10-31 06:40:15 +00:00
GRSLine( ClipBox, DC, GRMapX( x1 ), GRMapY( y1 ), GRMapX( x2 ), GRMapY( y2 ), ZoomValue(
width ), Color );
}
2007-10-31 06:40:15 +00:00
/***************************************************/
/* Routine to draw a Dashed line, in Screen space. */
/***************************************************/
2007-10-31 06:40:15 +00:00
void GRSDashedLine( EDA_Rect* ClipBox,
wxDC* DC,
int x1,
int y1,
int x2,
int y2,
int width,
int Color )
{
2007-10-31 06:40:15 +00:00
GRLastMoveToX = x2;
GRLastMoveToY = y2;
lastcolor = -1;
2007-10-31 06:40:15 +00:00
GRSetColorPen( DC, Color, width, wxSHORT_DASH );
GRSLine( ClipBox, DC, x1, y1, x2, y2, width, Color );
lastcolor = -1;
GRSetColorPen( DC, Color, width );
}
2007-10-31 06:40:15 +00:00
void GRSDashedLineTo( EDA_Rect* ClipBox, wxDC* DC, int x2, int y2, int width, int Color )
{
2007-10-31 06:40:15 +00:00
lastcolor = -1;
GRSetColorPen( DC, Color, width, wxSHORT_DASH );
GRSLine( ClipBox, DC, GRLastMoveToX, GRLastMoveToY, x2, y2, width, Color );
lastcolor = -1;
GRSetColorPen( DC, Color, width );
GRLastMoveToX = x2;
GRLastMoveToY = y2;
}
2007-10-31 06:40:15 +00:00
/****************************************************************************
* Routine to draw a Dashed line, in Object spaces. *
****************************************************************************/
2007-10-31 06:40:15 +00:00
void GRDashedLineTo( EDA_Rect* ClipBox, wxDC* DC, int x2, int y2, int width, int Color )
{
2007-10-31 06:40:15 +00:00
GRSDashedLineTo( ClipBox, DC, GRMapX( x2 ), GRMapY( y2 ), ZoomValue( width ), Color );
}
2007-10-31 06:40:15 +00:00
void GRDashedLine( EDA_Rect* ClipBox,
wxDC* DC,
int x1,
int y1,
int x2,
int y2,
int width,
int Color )
{
2007-10-31 06:40:15 +00:00
GRSDashedLine( ClipBox, DC, GRMapX( x1 ), GRMapY( y1 ), GRMapX( x2 ), GRMapY( y2 ),
ZoomValue( width ), Color );
}
/****************************************************************************
* Routine to move to a new position, in Object space. *
****************************************************************************/
2007-10-31 06:40:15 +00:00
void GRMoveTo( int x, int y )
{
2007-10-31 06:40:15 +00:00
GRLastMoveToX = GRMapX( x );
GRLastMoveToY = GRMapY( y );
}
2007-10-31 06:40:15 +00:00
/*******************************************************/
/* Routine to draw to a new position, in Object space. */
/*******************************************************/
2007-10-31 06:40:15 +00:00
void GRLineTo( EDA_Rect* ClipBox, wxDC* DC, int x, int y, int width, int Color )
{
2007-10-31 06:40:15 +00:00
int GRLineToX, GRLineToY;
2007-10-31 06:40:15 +00:00
GRLineToX = GRMapX( x ); GRLineToY = GRMapY( y );
GRSLine( ClipBox, DC, GRLastMoveToX, GRLastMoveToY, GRLineToX, GRLineToY, ZoomValue(
width ), Color );
}
2007-10-31 06:40:15 +00:00
/*************************************************/
/* Routine to draw a Mixed line, in Object space */
/*************************************************/
2007-10-31 06:40:15 +00:00
void GRMixedLine( EDA_Rect* ClipBox,
wxDC* DC,
int x1,
int y1,
int x2,
int y2,
int width,
int Color )
{
2007-10-31 06:40:15 +00:00
GRSMixedLine( ClipBox, DC, GRMapX( x1 ), GRMapY( y1 ), GRMapX( x2 ), GRMapY( y2 ),
ZoomValue( width ), Color );
}
2007-10-31 06:40:15 +00:00
/***********************************************************/
/* Routine to draw a Mixed line, in Screen (Pixels) space */
/***********************************************************/
2007-10-31 06:40:15 +00:00
void GRSMixedLine( EDA_Rect* ClipBox,
wxDC* DC,
int x1,
int y1,
int x2,
int y2,
int width,
int Color )
{
2007-10-31 06:40:15 +00:00
GRSetColorPen( DC, Color, width, wxDOT_DASH );
GRSLine( ClipBox, DC, x1, y1, x2, y2, width, Color );
GRSetColorPen( DC, Color, width );
}
/****************************************************************************
* Routine to move to a new position, in Screen (pixels) space. *
****************************************************************************/
2007-10-31 06:40:15 +00:00
void GRSMoveTo( int x, int y )
{
2007-10-31 06:40:15 +00:00
GRLastMoveToX = x;
GRLastMoveToY = y;
}
2007-10-31 06:40:15 +00:00
/****************************************************************************
* Routine to draw to a new position, in Screen (pixels) space. *
****************************************************************************/
2007-10-31 06:40:15 +00:00
void GRSLineTo( EDA_Rect* ClipBox, wxDC* DC, int x, int y, int width, int Color )
{
2007-10-31 06:40:15 +00:00
GRSLine( ClipBox, DC, GRLastMoveToX, GRLastMoveToY, x, y, width, Color );
GRLastMoveToX = x; GRLastMoveToY = y;
}
2007-10-31 06:40:15 +00:00
/****************************************************************************
* Routine to draw to a new position, in Screen (pixels) space. *
****************************************************************************/
2007-10-31 06:40:15 +00:00
void GRSLine( EDA_Rect* ClipBox, wxDC* DC, int x1, int y1, int x2, int y2, int width, int Color )
{
2007-10-31 06:40:15 +00:00
WinClipAndDrawLine( ClipBox, DC, x1, y1, x2, y2, Color, width );
GRLastMoveToX = x2; GRLastMoveToY = y2;
}
2007-10-31 06:40:15 +00:00
/****************************************************************************/
/* Routine to move to a new position relative to current one, as in Object */
/* space. */
/****************************************************************************/
2007-10-31 06:40:15 +00:00
void GRMoveRel( int x, int y )
{
2007-10-31 06:40:15 +00:00
GRLastMoveToX += ZoomValue( x );
GRLastMoveToY += ZoomValue( y );
}
2007-10-31 06:40:15 +00:00
/****************************************************************************
* Routine to line to a new position relative to current one, as in Object *
* space. *
****************************************************************************/
2007-10-31 06:40:15 +00:00
void GRLineRel( EDA_Rect* ClipBox, wxDC* DC, int x, int y, int width, int Color )
{
2007-10-31 06:40:15 +00:00
int GRLineToX = GRLastMoveToX,
GRLineToY = GRLastMoveToY;
2007-10-31 06:40:15 +00:00
GRLineToX += ZoomValue( x );
GRLineToY += ZoomValue( y );
2007-10-31 06:40:15 +00:00
GRSLine( ClipBox, DC, GRLastMoveToX, GRLastMoveToY, GRLineToX, GRLineToY, ZoomValue(
width ), Color );
}
2007-10-31 06:40:15 +00:00
/****************************************************************************
* Routine to move to a new position relative to current one, as in Screen *
* space (pixel coords.). *
****************************************************************************/
2007-10-31 06:40:15 +00:00
void GRSMoveRel( int x, int y )
{
2007-10-31 06:40:15 +00:00
GRLastMoveToX += x;
GRLastMoveToY += y;
}
2007-10-31 06:40:15 +00:00
/****************************************************************************
* Routine to line to a new position relative to current one, as in Screen *
* space (pixel coords.). *
****************************************************************************/
2007-10-31 06:40:15 +00:00
void GRSLineRel( EDA_Rect* ClipBox, wxDC* DC, int x, int y, int width, int Color )
{
2007-10-31 06:40:15 +00:00
long GRLineToX = GRLastMoveToX + x,
GRLineToY = GRLastMoveToY + y;
2007-10-31 06:40:15 +00:00
GRSLine( ClipBox, DC, GRLastMoveToX, GRLastMoveToY, GRLineToX, GRLineToY, width, Color );
GRLastMoveToX = GRLineToX;
GRLastMoveToY = GRLineToY;
}
2007-10-31 06:40:15 +00:00
/**************************************************/
/* Routine de trace d'un segment a bouts arrondis */
/* Object space = real coords.). */
/**************************************************/
2007-10-31 06:40:15 +00:00
void GRCSegm( EDA_Rect* ClipBox, wxDC* DC, int x1, int y1, int x2, int y2,
int width, int Color )
{
2007-10-31 06:40:15 +00:00
GRSCSegm( ClipBox, DC, GRMapX( x1 ), GRMapY( y1 ), GRMapX( x2 ), GRMapY( y2 ),
ZoomValue( width ), Color );
}
2007-10-31 06:40:15 +00:00
/*******************************************************************
2007-10-31 06:40:15 +00:00
* Routine de trace d'un segment (plein) a bouts arrondis in Object *
* space (real coords.). *
********************************************************************/
void GRFillCSegm( EDA_Rect* ClipBox, wxDC* DC, int x1, int y1, int x2, int y2,
int width, int Color )
{
2007-10-31 06:40:15 +00:00
GRSFillCSegm( ClipBox, DC, GRMapX( x1 ), GRMapY( y1 ), GRMapX( x2 ), GRMapY( y2 ),
ZoomValue( width ), Color );
}
2007-10-31 06:40:15 +00:00
/**********************************************************/
/* Routine de trace d'un segment (plein) a bouts arrondis */
/* ( Screen space = pixel coords.). */
/**********************************************************/
2007-10-31 06:40:15 +00:00
void GRSFillCSegm( EDA_Rect* ClipBox,
wxDC* DC,
int x1,
int y1,
int x2,
int y2,
int width,
int Color )
{
2007-10-31 06:40:15 +00:00
WinClipAndDrawLine( ClipBox, DC, x1, y1, x2, y2, Color, width );
}
/****************************************************************/
/* Routine de trace d'un segment a bouts arrondis (Mode SKETCH) */
/* Screen space (pixel coords.). */
/****************************************************************/
2007-10-31 06:40:15 +00:00
void GRSCSegm( EDA_Rect* ClipBox, wxDC* DC, int x1, int y1, int x2, int y2, int width, int Color )
{
2007-12-22 07:16:45 +00:00
long rayon;
int dwx, dwy;
2007-10-31 06:40:15 +00:00
long dx, dy, dwx2, dwy2;
long sx1, sy1, ex1, ey1; /* coord du 1er bord */
long sx2, sy2, ex2, ey2; /* coord du 1eme bord */
bool swap_ends = FALSE;
GRLastMoveToX = x2;
GRLastMoveToY = y2;
if( ClipBox )
{
xcliplo = ClipBox->GetX();
ycliplo = ClipBox->GetY();
xcliphi = ClipBox->GetRight();
ycliphi = ClipBox->GetHeight();
xcliplo -= width;
ycliplo -= width;
xcliphi += width;
ycliphi += width;
2007-10-31 17:44:51 +00:00
if( clip_line( x1, y1, x2, y2 ) )
return;
2007-10-31 06:40:15 +00:00
}
if( width <= 2 ) /* ligne simple ou epaisse de 2 pixels*/
{
GRSetColorPen( DC, Color, width );
DC->DrawLine( x1, y1, x2, y2 );
return;
}
GRSetColorPen( DC, Color );
GRSetBrush( DC, Color, FALSE );
rayon = (width + 1) >> 1;
2008-04-02 14:16:14 +00:00
dx = x2 - x1;
2007-12-22 07:16:45 +00:00
dy = y2 - y1;
2008-04-02 14:16:14 +00:00
2007-10-31 06:40:15 +00:00
if( dx == 0 ) /* segment vertical */
{
dwx = rayon;
if( dy >= 0 )
dwx = -dwx;
2008-04-02 14:16:14 +00:00
sx1 = x1 - dwx;
2007-12-22 07:16:45 +00:00
sy1 = y1;
2008-04-02 14:16:14 +00:00
ex1 = x2 - dwx;
2007-12-22 07:16:45 +00:00
ey1 = y2;
2008-04-02 14:16:14 +00:00
2007-10-31 06:40:15 +00:00
DC->DrawLine( sx1, sy1, ex1, ey1 );
2008-04-02 14:16:14 +00:00
sx2 = x1 + dwx;
2007-12-22 07:16:45 +00:00
sy2 = y1;
2008-04-02 14:16:14 +00:00
ex2 = x2 + dwx;
2007-12-22 07:16:45 +00:00
ey2 = y2;
2008-04-02 14:16:14 +00:00
2007-10-31 06:40:15 +00:00
DC->DrawLine( sx2, sy2, ex2, ey2 );
}
else if( dy == 0 ) /* segment horizontal */
{
dwy = rayon;
if( dx < 0 )
dwy = -dwy;
2008-04-02 14:16:14 +00:00
2007-12-22 07:16:45 +00:00
sx1 = x1;
sy1 = y1 - dwy;
2008-04-02 14:16:14 +00:00
ex1 = x2;
2007-12-22 07:16:45 +00:00
ey1 = y2 - dwy;
2008-04-02 14:16:14 +00:00
2007-10-31 06:40:15 +00:00
DC->DrawLine( sx1, sy1, ex1, ey1 );
2008-04-02 14:16:14 +00:00
sx2 = x1;
2007-12-22 07:16:45 +00:00
sy2 = y1 + dwy;
2008-04-02 14:16:14 +00:00
ex2 = x2;
2007-12-22 07:16:45 +00:00
ey2 = y2 + dwy;
2008-04-02 14:16:14 +00:00
2007-10-31 06:40:15 +00:00
DC->DrawLine( sx2, sy2, ex2, ey2 );
}
else
{
if( ABS( dx ) == ABS( dy ) ) /* segment a 45 degre */
{
dwx = dwy = ( (width * 5) + 4 ) / 7; // = width/2 * 0.707
if( dy < 0 )
{
if( dx <= 0 )
{
dwx = -dwx; swap_ends = TRUE;
}
}
else
{
if( dx > 0 )
{
dwy = -dwy; swap_ends = TRUE;
}
}
}
else
{
int delta_angle = ArcTangente( dy, dx );
2008-04-02 14:16:14 +00:00
dwx = 0;
2007-12-22 07:16:45 +00:00
dwy = width;
RotatePoint( &dwx, &dwy, -delta_angle );
2007-10-31 06:40:15 +00:00
}
2008-04-02 14:16:14 +00:00
dwx2 = dwx >> 1;
2007-12-22 07:16:45 +00:00
dwy2 = dwy >> 1;
2008-04-02 14:16:14 +00:00
sx1 = x1 - dwx2;
2007-12-22 07:16:45 +00:00
sy1 = y1 - dwy2;
2008-04-02 14:16:14 +00:00
ex1 = x2 - dwx2;
2007-12-22 07:16:45 +00:00
ey1 = y2 - dwy2;
2008-04-02 14:16:14 +00:00
2007-10-31 06:40:15 +00:00
DC->DrawLine( sx1, sy1, ex1, ey1 );
2008-04-02 14:16:14 +00:00
sx2 = x1 + dwx2;
2007-12-22 07:16:45 +00:00
sy2 = y1 + dwy2;
2008-04-02 14:16:14 +00:00
ex2 = x2 + dwx2;
2007-12-22 07:16:45 +00:00
ey2 = y2 + dwy2;
2008-04-02 14:16:14 +00:00
2007-10-31 06:40:15 +00:00
DC->DrawLine( sx2, sy2, ex2, ey2 );
}
if( swap_ends )
{
DC->DrawArc( sx2, sy2, sx1, sy1, x1, y1 );
DC->DrawArc( ex1, ey1, ex2, ey2, x2, y2 );
}
else
{
DC->DrawArc( sx1, sy1, sx2, sy2, x1, y1 );
DC->DrawArc( ex2, ey2, ex1, ey1, x2, y2 );
}
}
static bool IsGRSPolyDrawable( EDA_Rect* ClipBox, int n, wxPoint Points[] )
2007-10-31 06:40:15 +00:00
{
int Xmin, Xmax, Ymin, Ymax;
Xmin = Xmax = Points[0].x;
Ymin = Ymax = Points[0].y;
2007-10-31 06:40:15 +00:00
for( int ii = 1; ii < n; ii++ ) // calcul du rectangle d'encadrement
2007-10-31 06:40:15 +00:00
{
Xmin = MIN( Xmin, Points[ii].x );
Xmax = MAX( Xmax, Points[ii].x );
Ymin = MIN( Ymin, Points[ii].y );
Ymax = MAX( Ymax, Points[ii].y );
2007-10-31 06:40:15 +00:00
}
xcliplo = ClipBox->GetX();
ycliplo = ClipBox->GetY();
xcliphi = ClipBox->GetRight();
ycliphi = ClipBox->GetBottom();
2007-10-31 06:40:15 +00:00
if( Xmax < xcliplo )
return FALSE;
if( Xmin > xcliphi )
return FALSE;
if( Ymax < ycliplo )
return FALSE;
if( Ymin > ycliphi )
return FALSE;
return TRUE;
}
2007-10-31 06:40:15 +00:00
/************************************************************************/
/* Routine to draw a new polyline and fill it if Fill, in screen space. */
/************************************************************************/
static void GRSPoly( EDA_Rect* ClipBox, wxDC* DC, int n, wxPoint Points[], bool Fill,
int width, int Color, int BgColor )
{
2007-10-31 06:40:15 +00:00
if( !IsGRSPolyDrawable( ClipBox, n, Points ) )
return;
2007-10-31 06:40:15 +00:00
GRSetColorPen( DC, Color, width );
2007-10-31 06:40:15 +00:00
if( Fill && ( n > 2 ) )
{
GRSetBrush( DC, BgColor, FILLED );
/* clip before send the filled polygon to wxDC, because under linux (GTK?)
* polygonsl having large coordinates are incorrectly drawn
*/
#ifdef USE_CLIP_FILLED_POLYGONS
ClipAndDrawFilledPoly( ClipBox, DC, Points, n );
#else
DC->DrawPolygon( n, Points ); //does not work very well under linux
#endif
2007-10-31 06:40:15 +00:00
}
else
{
wxPoint endPt = Points[n - 1];
2008-04-02 14:16:14 +00:00
2007-10-31 06:40:15 +00:00
GRSetBrush( DC, Color );
DC->DrawLines( n, Points );
// The last point is not drawn by DrawLine and DrawLines
// Add it if the polygon is not closed
if( endPt != Points[0] )
DC->DrawPoint( endPt.x, endPt.y );
2007-10-31 06:40:15 +00:00
}
}
/******************************************************************************/
/* Routine to draw a new closed polyline and fill it if Fill, in screen space */
/******************************************************************************/
static void GRSClosedPoly( EDA_Rect* ClipBox, wxDC* DC, int aPointCount, wxPoint aPoints[],
bool Fill, int width, int Color, int BgColor )
{
if( !IsGRSPolyDrawable( ClipBox, aPointCount, aPoints ) )
2007-10-31 06:40:15 +00:00
return;
2007-10-31 06:40:15 +00:00
GRSetColorPen( DC, Color, width );
if( Fill && ( aPointCount > 2 ) )
2007-10-31 06:40:15 +00:00
{
GRSMoveTo( aPoints[aPointCount - 1].x, aPoints[aPointCount - 1].y );
2007-10-31 06:40:15 +00:00
GRSetBrush( DC, BgColor, FILLED );
DC->DrawPolygon( aPointCount, aPoints, 0, 0, wxODDEVEN_RULE );
2007-10-31 06:40:15 +00:00
}
else
{
GRSetBrush( DC, BgColor );
DC->DrawLines( aPointCount, aPoints );
2007-10-31 06:40:15 +00:00
/* Fermeture du polygone */
if( aPoints[aPointCount - 1] != aPoints[0] )
2007-10-31 06:40:15 +00:00
{
GRSLine( ClipBox, DC, aPoints[0].x, aPoints[0].y,
aPoints[aPointCount - 1].x, aPoints[aPointCount - 1].y, width, Color );
2007-10-31 06:40:15 +00:00
}
}
}
/* not used
* static void GRSClosedPoly( EDA_Rect* ClipBox, wxDC* DC, int n, wxPoint Points[],
* bool Fill, int Color, int BgColor )
* {
* GRSClosedPoly( ClipBox, DC, n, Points, Fill, 0, Color, BgColor );
* }
*/
/************************************************************************/
/* Routine to draw a new polyline and fill it if Fill, in drawing space. */
/************************************************************************/
void GRPoly( EDA_Rect* ClipBox, wxDC* DC, int n, wxPoint Points[],
bool Fill, int width, int Color, int BgColor )
{
for( int i = 0; i<n; ++i )
2007-10-31 06:40:15 +00:00
{
Points[i].x = GRMapX( Points[i].x );
Points[i].y = GRMapY( Points[i].y );
2007-10-31 06:40:15 +00:00
}
width = ZoomValue( width );
2007-10-31 06:40:15 +00:00
GRSPoly( ClipBox, DC, n, Points, Fill, width, Color, BgColor );
}
2007-10-31 06:40:15 +00:00
/**************************************************************************/
/* Routine to draw a closed polyline and fill it if Fill, in object space */
/**************************************************************************/
void GRClosedPoly( EDA_Rect* ClipBox, wxDC* DC, int n, wxPoint Points[],
bool Fill, int Color, int BgColor )
{
2007-10-31 06:40:15 +00:00
GRClosedPoly( ClipBox, DC, n, Points, Fill, 0, Color, BgColor );
}
2007-10-31 06:40:15 +00:00
void GRClosedPoly( EDA_Rect* ClipBox, wxDC* DC, int n, wxPoint Points[],
bool Fill, int width, int Color, int BgColor )
{
for( int i = 0; i<n; ++i )
2007-10-31 06:40:15 +00:00
{
Points[i].x = GRMapX( Points[i].x );
Points[i].y = GRMapY( Points[i].y );
2007-10-31 06:40:15 +00:00
}
width = ZoomValue( width );
2007-10-31 06:40:15 +00:00
GRSClosedPoly( ClipBox, DC, n, Points, Fill, width, Color, BgColor );
}
2007-10-31 06:40:15 +00:00
/***********************************************/
/* Routine to draw a circle, in object space. */
/***********************************************/
2007-10-31 06:40:15 +00:00
void GRCircle( EDA_Rect* ClipBox, wxDC* DC, int x, int y, int r, int Color )
{
2007-10-31 06:40:15 +00:00
int cx = GRMapX( x );
int cy = GRMapY( y );
int rayon = ZoomValue( r );
2007-10-31 06:40:15 +00:00
GRSCircle( ClipBox, DC, cx, cy, rayon, 0, Color );
}
2007-10-31 06:40:15 +00:00
/*****************************************************/
/* Routine to draw a Filled circle, in object space. */
/*****************************************************/
2007-10-31 06:40:15 +00:00
void GRFilledCircle( EDA_Rect* ClipBox, wxDC* DC, int x, int y, int r,
int width, int Color, int BgColor )
{
2007-10-31 06:40:15 +00:00
r = ZoomValue( r );
width = ZoomValue( width );
GRSFilledCircle( ClipBox, DC, GRMapX( x ), GRMapY( y ), r, width, Color, BgColor );
}
2007-10-31 06:40:15 +00:00
/******************************************************/
/* Routine to draw a FILLED circle, in drawing space. */
/******************************************************/
2007-10-31 06:40:15 +00:00
void GRSFilledCircle( EDA_Rect* ClipBox, wxDC* DC, int x, int y, int r,
int width, int Color, int BgColor )
{
/* suppression des cercles hors ecran */
if( ClipBox )
{
int x0, y0, xm, ym;
x0 = ClipBox->GetX();
y0 = ClipBox->GetY();
xm = ClipBox->GetRight();
ym = ClipBox->GetBottom();
if( x < (x0 - r) )
return;
if( y < (y0 - r) )
return;
if( x > (r + xm) )
return;
if( y > (r + ym) )
return;
}
GRSetColorPen( DC, Color, width );
GRSetBrush( DC, BgColor, FILLED );
DC->DrawEllipse( x - r, y - r, r + r, r + r );
}
/***********************************************************/
/* Routine to draw a circle, in object space. */
/***********************************************************/
2007-10-31 06:40:15 +00:00
void GRCircle( EDA_Rect* ClipBox, wxDC* DC, int x, int y, int r, int width, int Color )
{
2007-10-31 06:40:15 +00:00
r = ZoomValue( r );
width = ZoomValue( width );
GRSCircle( ClipBox, DC, GRMapX( x ), GRMapY( y ), r, width, Color );
}
/***********************************************/
/* Routine to draw a circle, in drawing space. */
/***********************************************/
2007-10-31 06:40:15 +00:00
void GRSCircle( EDA_Rect* ClipBox, wxDC* DC, int xc, int yc, int r, int width, int Color )
{
/* suppression des cercles hors ecran */
if( ClipBox )
{
int x0, y0, xm, ym;
x0 = ClipBox->GetX();
y0 = ClipBox->GetY();
xm = ClipBox->GetRight();
ym = ClipBox->GetBottom();
if( xc < (x0 - r - width) )
return;
if( yc < (y0 - r - width) )
return;
if( xc > (r + xm + width) )
return;
if( yc > (r + ym + width) )
return;
}
GRSetColorPen( DC, Color, width );
GRSetBrush( DC, Color, FALSE );
DC->DrawEllipse( xc - r, yc - r, r + r, r + r );
}
/************************************************/
/* Routine to draw an arc, in USER space. */
/* Debut et fin de l'arc donnes par leur coord. */
/************************************************/
2007-10-31 06:40:15 +00:00
void GRArc1( EDA_Rect* ClipBox, wxDC* DC, int x1, int y1, int x2, int y2,
int xc, int yc, int Color )
{
2007-10-31 06:40:15 +00:00
GRSArc1( ClipBox, DC,
GRMapX( x1 ), GRMapY( y1 ), GRMapX( x2 ), GRMapY( y2 ),
GRMapX( xc ), GRMapY( yc ), 0, Color );
}
2007-10-31 06:40:15 +00:00
/************************************************/
/* Routine to draw an arc, width = width in USER space. */
/* Debut et fin de l'arc donnes par leur coord. */
/************************************************/
2007-10-31 06:40:15 +00:00
void GRArc1( EDA_Rect* ClipBox, wxDC* DC, int x1, int y1, int x2, int y2,
int xc, int yc, int width, int Color )
{
2007-10-31 06:40:15 +00:00
GRSArc1( ClipBox, DC,
GRMapX( x1 ), GRMapY( y1 ), GRMapX( x2 ), GRMapY( y2 ),
GRMapX( xc ), GRMapY( yc ), ZoomValue( width ), Color );
}
/************************************************/
/* Routine to draw an arc, width = width, in screen space. */
/* Debut et fin de l'arc donnes par leur coord. */
/************************************************/
2007-10-31 06:40:15 +00:00
void GRSArc1( EDA_Rect* ClipBox, wxDC* DC, int x1, int y1, int x2, int y2,
int xc, int yc, int width, int Color )
{
/* suppression des cercles hors ecran */
if( ClipBox )
{
int x0, y0, xm, ym, r;
x0 = ClipBox->GetX();
y0 = ClipBox->GetY();
xm = ClipBox->GetRight();
ym = ClipBox->GetBottom();
r = (int) hypot( x1 - xc, y1 - yc );
if( xc < (x0 - r) )
return;
if( yc < (y0 - r) )
return;
if( xc > (r + xm) )
return;
if( yc > (r + ym) )
return;
}
GRSetColorPen( DC, Color, width );
GRSetBrush( DC, Color );
DC->DrawArc( x1, y1, x2, y2, xc, yc );
}
2007-10-31 06:40:15 +00:00
/********************************************************************/
/* Routine to draw an arc, in screen space. */
/* As the Y axe is inverted the Angles should be inverted as well. */
/********************************************************************/
2007-10-31 06:40:15 +00:00
void GRSArc( EDA_Rect* ClipBox, wxDC* DC, int xc, int yc, int StAngle, int EndAngle,
int r, int width, int Color )
{
2007-10-31 06:40:15 +00:00
int x1, y1, x2, y2;
2007-10-31 06:40:15 +00:00
/* suppression des cercles hors ecran */
if( ClipBox )
{
int x0, y0, xm, ym;
x0 = ClipBox->GetX();
y0 = ClipBox->GetY();
xm = ClipBox->GetRight();
ym = ClipBox->GetBottom();
if( xc < (x0 - r - width) )
return;
if( yc < (y0 - r - width) )
return;
if( xc > (r + xm + width) )
return;
if( yc > (r + ym + width) )
return;
}
2007-10-31 06:40:15 +00:00
x1 = r; y1 = 0;
RotatePoint( &x1, &y1, EndAngle );
2007-10-31 06:40:15 +00:00
x2 = r; y2 = 0;
RotatePoint( &x2, &y2, StAngle );
2007-10-31 06:40:15 +00:00
GRSetColorPen( DC, Color, width );
GRSetBrush( DC, Color );
DC->DrawArc( xc + x1, yc - y1, xc + x2, yc - y2, xc, yc );
}
2007-10-31 06:40:15 +00:00
/********************************************************************/
/* Routine to draw an Filled arc, in screen space. */
/* As the Y axes is inverted the Angles should be inverted as well. */
/********************************************************************/
2007-10-31 06:40:15 +00:00
void GRSFilledArc( EDA_Rect* ClipBox, wxDC* DC, int xc, int yc,
int StAngle, int EndAngle, int r, int width, int Color, int BgColor )
{
2007-10-31 06:40:15 +00:00
int x1, y1, x2, y2;
2007-10-31 06:40:15 +00:00
/* suppression des cercles hors ecran */
if( ClipBox )
{
int x0, y0, xm, ym;
x0 = ClipBox->GetX();
y0 = ClipBox->GetY();
xm = ClipBox->GetRight();
ym = ClipBox->GetBottom();
if( xc < (x0 - r - 1) )
return;
if( yc < (y0 - r - 1) )
return;
if( xc > (r + xm + 1) )
return;
if( yc > (r + ym + 1) )
return;
}
2007-10-31 06:40:15 +00:00
x1 = r; y1 = 0;
RotatePoint( &x1, &y1, EndAngle );
2007-10-31 06:40:15 +00:00
x2 = r; y2 = 0;
RotatePoint( &x2, &y2, StAngle );
2007-10-31 06:40:15 +00:00
GRSetBrush( DC, BgColor, FILLED );
GRSetColorPen( DC, Color, width );
DC->DrawArc( xc + x1, yc - y1, xc + x2, yc - y2, xc, yc );
}
2007-10-31 06:40:15 +00:00
/********************************************************************/
/* Routine to draw a Filled arc, in drawing space. */
/* As the Y axes is inverted the Angles should be inverted as well. */
/********************************************************************/
2007-10-31 06:40:15 +00:00
void GRFilledArc( EDA_Rect* ClipBox, wxDC* DC, int x, int y,
int StAngle, int EndAngle, int r, int width, int Color, int BgColor )
{
2007-10-31 06:40:15 +00:00
width = ZoomValue( width );
GRSFilledArc( ClipBox, DC, GRMapX( x ), GRMapY( y ),
StAngle, EndAngle,
ZoomValue( r ), width, Color, BgColor );
}
2007-10-31 06:40:15 +00:00
void GRFilledArc( EDA_Rect* ClipBox, wxDC* DC, int x, int y,
int StAngle, int EndAngle, int r, int Color, int BgColor )
{
2007-10-31 06:40:15 +00:00
GRSFilledArc( ClipBox, DC, GRMapX( x ), GRMapY( y ),
StAngle, EndAngle,
ZoomValue( r ), 0, Color, BgColor );
}
2007-10-31 06:40:15 +00:00
/********************************************************************/
/* Routine to draw an arc, in drawing space. */
/* As the Y axes is inverted the Angles should be inverted as well. */
/********************************************************************/
2007-10-31 06:40:15 +00:00
void GRArc( EDA_Rect* ClipBox, wxDC* DC, int xc, int yc, int StAngle,
int EndAngle, int r, int Color )
{
int x1, y1, x2, y2;
/* suppression des cercles hors ecran */
if( ClipBox )
{
int rayon = ZoomValue( r ) + 1;
int x0, y0, xm, ym, x, y;
x0 = ClipBox->GetX();
y0 = ClipBox->GetY();
xm = ClipBox->GetRight();
ym = ClipBox->GetBottom();
x = GRMapX( xc ); y = GRMapY( yc );
if( x < (x0 - rayon) )
return;
if( y < (y0 - rayon) )
return;
if( x > (xm + rayon) )
return;
if( y > (ym + rayon) )
return;
}
x1 = r; y1 = 0;
RotatePoint( &x1, &y1, EndAngle );
x2 = r; y2 = 0;
RotatePoint( &x2, &y2, StAngle );
GRSetColorPen( DC, Color );
GRSetBrush( DC, Color, FALSE );
DC->DrawArc( GRMapX( xc + x1 ), GRMapY( yc - y1 ),
GRMapX( xc + x2 ), GRMapY( yc - y2 ),
GRMapX( xc ), GRMapY( yc ) );
}
2007-10-31 06:40:15 +00:00
/********************************************************************/
/* Routine to draw an arc, width = width, in drawing space. */
/* As the Y axes is inverted the Angles should be inverted as well. */
/********************************************************************/
2007-10-31 06:40:15 +00:00
void GRArc( EDA_Rect* ClipBox, wxDC* DC, int x, int y, int StAngle, int EndAngle,
int r, int width, int Color )
{
2007-10-31 06:40:15 +00:00
GRSArc( ClipBox, DC, GRMapX( x ), GRMapY( y ),
StAngle, EndAngle,
ZoomValue( r ),
ZoomValue( width ),
Color );
}
2007-10-31 06:40:15 +00:00
/**************************************************/
/* Routine to draw a Rectangle, in drawing space. */
/**************************************************/
2007-10-31 06:40:15 +00:00
void GRRect( EDA_Rect* ClipBox, wxDC* DC, int x1, int y1, int x2, int y2, int Color )
{
2007-10-31 06:40:15 +00:00
x1 = GRMapX( x1 ); y1 = GRMapY( y1 );
x2 = GRMapX( x2 ); y2 = GRMapY( y2 );
2007-10-31 06:40:15 +00:00
GRSRect( ClipBox, DC, x1, y1, x2, y2, Color );
}
2007-10-31 06:40:15 +00:00
/**************************************************/
/* Routine to draw a Rectangle, in drawing space. */
/**************************************************/
2007-10-31 06:40:15 +00:00
void GRRect( EDA_Rect* ClipBox, wxDC* DC, int x1, int y1, int x2, int y2, int width, int Color )
{
2007-10-31 06:40:15 +00:00
x1 = GRMapX( x1 ); y1 = GRMapY( y1 );
x2 = GRMapX( x2 ); y2 = GRMapY( y2 );
width = ZoomValue( width );
2007-10-31 06:40:15 +00:00
GRSRect( ClipBox, DC, x1, y1, x2, y2, width, Color );
}
2007-10-31 06:40:15 +00:00
/************************************************************************************/
2007-10-31 06:40:15 +00:00
void GRFilledRect( EDA_Rect* ClipBox, wxDC* DC, int x1, int y1, int x2, int y2,
int Color, int BgColor )
/************************************************************************************/
/* Routine to draw a Rectangle (filled with AreaColor), in drawing space. */
{
2007-10-31 06:40:15 +00:00
x1 = GRMapX( x1 ); y1 = GRMapY( y1 );
x2 = GRMapX( x2 ); y2 = GRMapY( y2 );
2007-10-31 06:40:15 +00:00
GRSFilledRect( ClipBox, DC, x1, y1, x2, y2, 0, Color, BgColor );
}
2007-10-31 06:40:15 +00:00
/************************************************************************************/
2007-10-31 06:40:15 +00:00
void GRFilledRect( EDA_Rect* ClipBox, wxDC* DC, int x1, int y1, int x2, int y2,
int width, int Color, int BgColor )
/************************************************************************************/
/* Routine to draw a Rectangle (filled with AreaColor), in drawing space. */
{
2007-10-31 06:40:15 +00:00
x1 = GRMapX( x1 ); y1 = GRMapY( y1 );
x2 = GRMapX( x2 ); y2 = GRMapY( y2 );
width = ZoomValue( width );
2007-10-31 06:40:15 +00:00
GRSFilledRect( ClipBox, DC, x1, y1, x2, y2, width, Color, BgColor );
}
2007-10-31 06:40:15 +00:00
/*************************************************/
/* Routine to draw a Rectangle, in screen space. */
/*************************************************/
2007-10-31 06:40:15 +00:00
void GRSRect( EDA_Rect* ClipBox, wxDC* DC, int x1, int y1, int x2, int y2, int Color )
{
2007-10-31 06:40:15 +00:00
GRSRect( ClipBox, DC, x1, y1, x2, y2, 0, Color );
}
2007-10-31 06:40:15 +00:00
void GRSRect( EDA_Rect* ClipBox, wxDC* DC, int x1, int y1, int x2, int y2,
int width, int Color )
{
2007-10-31 06:40:15 +00:00
if( x1 > x2 )
EXCHG( x1, x2 );
if( y1 > y2 )
EXCHG( y1, y2 );
2007-10-31 06:40:15 +00:00
/* Clipping des coordonnees */
if( ClipBox )
{
int xmin = ClipBox->GetX();
int ymin = ClipBox->GetY();
int xmax = ClipBox->GetRight();
int ymax = ClipBox->GetBottom();
2007-10-31 06:40:15 +00:00
if( x1 > xmax )
return;
if( x2 < xmin )
return;
if( y1 > ymax )
return;
if( y2 < ymin )
return;
}
2007-10-31 06:40:15 +00:00
GRSetColorPen( DC, Color, width );
if( (x1 == x2) || (y1 == y2) )
DC->DrawLine( x1, y1, x2, y2 );
else
{
GRSetBrush( DC, BLACK );
DC->DrawRectangle( x1, y1, x2 - x1, y2 - y1 );
}
}
/* Routine to draw a Filled Rectangle, in screen space. */
/***************************************************************************************/
2007-10-31 06:40:15 +00:00
void GRSFilledRect( EDA_Rect* ClipBox, wxDC* DC, int x1, int y1, int x2, int y2,
int Color, int BgColor )
/***************************************************************************************/
{
2007-10-31 06:40:15 +00:00
GRSFilledRect( ClipBox, DC, x1, y1, x2, y2, 0, Color, BgColor );
}
2007-10-31 06:40:15 +00:00
/***************************************************************************************/
2007-10-31 06:40:15 +00:00
void GRSFilledRect( EDA_Rect* ClipBox, wxDC* DC, int x1, int y1, int x2, int y2,
int width, int Color, int BgColor )
/***************************************************************************************/
{
2007-10-31 06:40:15 +00:00
if( x1 > x2 )
EXCHG( x1, x2 );
if( y1 > y2 )
EXCHG( y1, y2 );
if( ClipBox )
{
int xmin = ClipBox->GetX();
int ymin = ClipBox->GetY();
int xmax = ClipBox->GetRight();
int ymax = ClipBox->GetBottom();
if( x1 > xmax )
return;
if( x2 < xmin )
return;
if( y1 > ymax )
return;
if( y2 < ymin )
return;
// Clipping coordinates
if( x1 < xmin )
x1 = xmin - 1;
if( y1 < ymin )
y1 = ymin - 1;
if( x2 > xmax )
x2 = xmax + 1;
if( y2 > ymax )
y2 = ymax + 1;
}
GRSetColorPen( DC, Color, width );
if( (x1 == x2) || (y1 == y2) )
DC->DrawLine( x1, y1, x2, y2 );
else
{
GRSetBrush( DC, BgColor, FILLED );
DC->DrawRectangle( x1, y1, x2 - x1, y2 - y1 );
}
}
#ifdef USE_CLIP_FILLED_POLYGONS
/** Function ClipAndDrawFilledPoly
* 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 unnecesary.
*/
#include "SutherlandHodgmanClipPoly.h"
void ClipAndDrawFilledPoly( EDA_Rect* aClipBox, wxDC* aDC, wxPoint aPoints[], int n )
{
static 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)aPoints[ii].x, (REAL)aPoints[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.push_back( wxPoint( (int)round( cit->X ), (int)round( cit->Y ) ) );
}
if ( clippedPolygon.size() )
aDC->DrawPolygon( clippedPolygon.size(), &clippedPolygon[0] );
}
#endif