haskal
/
kicad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
kicad/eeschema/eelibs2.cpp

975 lines
31 KiB
C++
Raw Blame History

/********************************************************/
/* Module to handle libraries (second part - drawing ). */
/********************************************************/
#include "fctsys.h"
#include "gr_basic.h"
#include "common.h"
#include "program.h"
#include "libcmp.h"
#include "component_class.h"
#include "general.h"
#include "trigo.h"
#include "protos.h"
#define UNVISIBLE_COLOR DARKGRAY
//#define DRAW_ARC_WITH_ANGLE // pour trace arc avec routine utilsant les angles
/* Fonctions locales */
/* Description du composant <DUMMY> utilisé lorsque des composants non trouvés
en librarie doivent etre dessinés */
/*
ce composant est un rectangle de 400 mils de coté avec le texte ?? au centre
DEF DUMMY U 0 40 Y Y 1 0 N
F0 "U" 0 -350 60 H V
F1 "DUMMY" 0 350 60 H V
DRAW
T 0 0 0 150 0 0 0 ??
S -200 200 200 -200 0 1 0
ENDDRAW
ENDDEF
*/
static int s_ItemSelectColor = BROWN;
static EDA_LibComponentStruct * DummyCmp;
static int * Buf_Poly_Drawings, Buf_Poly_Size; // Used fo polyline drawings
static void DrawLibPartAux(WinEDA_DrawPanel * panel, wxDC * DC,
EDA_SchComponentStruct *Component,
EDA_LibComponentStruct *Entry,
const wxPoint & Pos,
int TransMat[2][2],
int Multi, int convert,
int DrawMode, int Color = -1, bool DrawPinText = TRUE);
/******************************/
static void CreateDummyCmp(void)
/******************************/
{
DummyCmp = new EDA_LibComponentStruct( NULL);
LibDrawSquare * Square = new LibDrawSquare();
Square->m_Start = wxPoint(- 200,200);
Square->m_End = wxPoint(200, - 200);
Square->m_Width = 4;
LibDrawText * Text = new LibDrawText();
Text->m_Size.x = Text->m_Size.y = 150;
Text->m_Text = wxT("??");
DummyCmp->m_Drawings = Square;
Square->Pnext = Text;
}
/*************************************************************/
void DrawLibEntry(WinEDA_DrawPanel * panel,wxDC * DC,
EDA_LibComponentStruct *LibEntry,
int posX, int posY,
int Multi, int convert,
int DrawMode, int Color)
/**************************************************************/
/* Routine de dessin d'un composant d'une librairie
LibEntry = pointeur sur la description en librairie
posX, posY = position du composant
DrawMode = GrOR ..
Color = 0 : dessin en vraies couleurs, sinon couleur = Color
Une croix symbolise le point d'accrochage (ref position) du composant
Le composant est toujours trace avec orientation 0
*/
{
int color;
int TransMat[2][2];
wxString Prefix;
LibDrawField * Field;
wxPoint text_pos;
/* Orientation normale */
TransMat[0][0] = 1; TransMat[1][1] = -1;
TransMat[1][0] = TransMat[0][1] = 0;
DrawLibPartAux(panel, DC, NULL, LibEntry, wxPoint(posX, posY),
TransMat, Multi,
convert, DrawMode, Color);
/* Trace des 2 champs ref et value (Attention aux coord: la matrice
de transformation change de signe les coord Y */
GRSetDrawMode(DC, DrawMode);
if( LibEntry->m_Prefix.m_Attributs & TEXT_NO_VISIBLE )
{
if( Color >= 0 ) color = Color;
else color = UNVISIBLE_COLOR;
}
else {
if( Color >= 0) color = Color;
else color = ReturnLayerColor(LAYER_REFERENCEPART);
}
if (LibEntry->m_UnitCount > 1)
Prefix.Printf( wxT("%s?%c"),LibEntry->m_Prefix.m_Text.GetData(),Multi + 'A' - 1);
else Prefix = LibEntry->m_Prefix.m_Text + wxT("?");
text_pos.x = LibEntry->m_Prefix.m_Pos.x + posX;
text_pos.y = posY - LibEntry->m_Prefix.m_Pos.y;
DrawGraphicText(panel, DC, text_pos,
color,LibEntry->m_Prefix.m_Text.GetData(),
LibEntry->m_Prefix.m_Orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ,
LibEntry->m_Prefix.m_Size,
LibEntry->m_Prefix.m_HJustify, LibEntry->m_Prefix.m_VJustify);
if( LibEntry->m_Name.m_Attributs & TEXT_NO_VISIBLE )
{
if( Color >= 0) color = Color;
else color = UNVISIBLE_COLOR;
}
else {
if( Color >= 0 ) color = Color;
else color = ReturnLayerColor(LAYER_VALUEPART);
}
text_pos.x = LibEntry->m_Name.m_Pos.x + posX;
text_pos.y = posY - LibEntry->m_Name.m_Pos.y;
DrawGraphicText(panel, DC, text_pos,
color, LibEntry->m_Name.m_Text.GetData(),
LibEntry->m_Name.m_Orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ,
LibEntry->m_Name.m_Size,
LibEntry->m_Name.m_HJustify, LibEntry->m_Name.m_VJustify);
for( Field = LibEntry->Fields; Field != NULL; Field = (LibDrawField *)Field->Pnext )
{
if( Field->m_Text.IsEmpty() ) return;
if( Field->m_Attributs & TEXT_NO_VISIBLE )
{
if( Color >= 0) color = Color;
else color = UNVISIBLE_COLOR;
}
else {
if( Color >= 0) color = Color;
else color = ReturnLayerColor(LAYER_FIELDS);
}
text_pos.x = Field->m_Pos.x + posX;
text_pos.y = posY - Field->m_Pos.y;
DrawGraphicText(panel, DC, text_pos,
color, Field->m_Text,
Field->m_Orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ,
Field->m_Size,
Field->m_HJustify, Field->m_VJustify);
}
// Tracé de l'ancre
int len = 3 * panel->GetZoom();
GRLine(&panel->m_ClipBox, DC, posX, posY - len, posX, posY + len, color);
GRLine(&panel->m_ClipBox, DC, posX - len, posY, posX + len, posY, color);
}
/*****************************************************************************
* Routine to draw the given part at given position, transformed/mirror as *
* specified, and in the given drawing mode. Only this one is visible... *
*****************************************************************************/
void EDA_SchComponentStruct::Draw(WinEDA_DrawPanel * panel,wxDC * DC,
const wxPoint & offset, int DrawMode, int Color)
{
EDA_LibComponentStruct *Entry;
int ii;
bool dummy = FALSE;
if( (Entry = FindLibPart(m_ChipName.GetData(),wxEmptyString,FIND_ROOT)) == NULL)
{ /* composant non trouvé, on affiche un composant "dummy" */
dummy = TRUE;
if( DummyCmp == NULL ) CreateDummyCmp();
Entry = DummyCmp;
}
DrawLibPartAux(panel, DC, this, Entry, m_Pos + offset,
m_Transform,
dummy ? 0 : m_Multi,
dummy ? 0 : m_Convert,
DrawMode);
/* Trace des champs, avec placement et orientation selon orient. du
composant
*/
if( ((m_Field[REFERENCE].m_Attributs & TEXT_NO_VISIBLE) == 0)
&& ! (m_Field[REFERENCE].m_Flags & IS_MOVED) )
{
if ( Entry->m_UnitCount > 1 )
DrawTextField(panel, DC, &m_Field[REFERENCE],1,DrawMode);
else
DrawTextField(panel, DC, &m_Field[REFERENCE],0,DrawMode);
}
for( ii = VALUE; ii < NUMBER_OF_FIELDS; ii++ )
{
if (m_Field[ii].m_Flags & IS_MOVED) continue;
DrawTextField(panel, DC, &m_Field[ii],0,DrawMode);
}
}
/***********************************************************/
void DrawTextField(WinEDA_DrawPanel * panel,wxDC * DC,
PartTextStruct * Field, int IsMulti, int DrawMode)
/***********************************************************/
/* Routine de trace des textes type Field du composant.
entree:
IsMulti: flag Non Null si il y a plusieurs parts par boitier.
n'est utile que pour le champ reference pour ajouter a celui ci
l'identification de la part ( A, B ... )
DrawMode: mode de trace
*/
{
int orient, color;
wxPoint pos; /* Position des textes */
EDA_SchComponentStruct *DrawLibItem = (EDA_SchComponentStruct *) Field->m_Parent;
int hjustify, vjustify;
if( Field->m_Attributs & TEXT_NO_VISIBLE ) return;
if( Field->IsVoid() ) return;
GRSetDrawMode(DC, DrawMode);
/* Calcul de la position des textes, selon orientation du composant */
orient = Field->m_Orient;
hjustify = Field->m_HJustify; vjustify = Field->m_VJustify;
pos.x = Field->m_Pos.x - DrawLibItem->m_Pos.x;
pos.y = Field->m_Pos.y - DrawLibItem->m_Pos.y;
pos = DrawLibItem->GetScreenCoord(pos);
pos.x += DrawLibItem->m_Pos.x;
pos.y += DrawLibItem->m_Pos.y;
/* Y a t-il rotation (pour l'orientation, la justification)*/
if(DrawLibItem->m_Transform[0][1]) // Rotation du composant de 90deg
{
if ( orient == TEXT_ORIENT_HORIZ) orient = TEXT_ORIENT_VERT;
else orient = TEXT_ORIENT_HORIZ;
/* Y a t-il rotation, miroir (pour les justifications)*/
EXCHG(hjustify, vjustify);
if (DrawLibItem->m_Transform[1][0] < 0 ) vjustify = - vjustify;
if (DrawLibItem->m_Transform[1][0] > 0 ) hjustify = - hjustify;
}
else
{ /* Texte horizontal: Y a t-il miroir (pour les justifications)*/
if (DrawLibItem->m_Transform[0][0] < 0 )
hjustify = - hjustify;
if (DrawLibItem->m_Transform[1][1] > 0 )
vjustify = - vjustify;
}
if( Field->m_FieldId == REFERENCE )
color = ReturnLayerColor(LAYER_REFERENCEPART);
else if( Field->m_FieldId == VALUE )
color = ReturnLayerColor(LAYER_VALUEPART);
else color = ReturnLayerColor(LAYER_FIELDS);
if( !IsMulti || (Field->m_FieldId != REFERENCE) )
{
DrawGraphicText(panel, DC, pos, color, Field->m_Text.GetData(),
orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ,
Field->m_Size,
hjustify, vjustify);
}
else /* Le champ est la reference, et il y a plusieurs parts par boitier */
{/* On ajoute alors A ou B ... a la reference */
wxString fulltext = Field->m_Text;
fulltext.Append('A' - 1 + DrawLibItem->m_Multi);
DrawGraphicText(panel, DC, pos, color, fulltext.GetData(),
orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ,
Field->m_Size,
hjustify, vjustify);
}
}
/********************************************************************************/
EDA_LibComponentStruct *FindLibPart(const wxChar *Name, const wxString & LibName, int Alias)
/********************************************************************************/
/*
Routine to find a part in one of the libraries given its name.
Name = Name of part.
LibName = Name of Lib; if "": seach in all libs
Alias = Flag: si flag != 0, retourne un pointeur sur une part ou un alias
si flag = 0, retourne un pointeur sur une part meme si le nom
correspond a un alias
Alias = FIND_ROOT, ou Alias = FIND_ALIAS
*/
{
EDA_LibComponentStruct *Entry;
static EDA_LibComponentStruct DummyEntry(wxEmptyString); /* Used only to call PQFind. */
LibraryStruct *Lib = g_LibraryList;
DummyEntry.m_Drawings = NULL; /* Used only to call PQFind. */
DummyEntry.m_Name.m_Text = Name;
PQCompFunc((PQCompFuncType) LibraryEntryCompare);
Entry = NULL; FindLibName.Empty();
while (Lib)
{
if( ! LibName.IsEmpty() )
{
if( Lib->m_Name != LibName )
{
Lib = Lib->m_Pnext; continue ;
}
}
if( Lib == NULL ) break;
Entry = (EDA_LibComponentStruct*)PQFind(Lib->m_Entries, &DummyEntry);
if( Entry != NULL)
{
FindLibName = Lib->m_Name;
break;
}
Lib = Lib->m_Pnext;
}
/* Si le nom est un alias, recherche du vrai composant */
if( Entry )
{
if( (Entry->Type != ROOT ) && (Alias == FIND_ROOT) )
Entry = FindLibPart( ((EDA_LibCmpAliasStruct*)Entry)->m_RootName.GetData() ,
Lib->m_Name, FIND_ROOT);
}
return (Entry);
}
/*****************************************************************************
* Routine to draw the given part at given position, transformed/mirror as
* specified, and in the given drawing mode.
* if Color < 0: Draw in normal color
* else draw in color = Color
*****************************************************************************/
/* DrawMode = GrXOR, GrOR ..*/
void DrawLibPartAux(WinEDA_DrawPanel * panel,wxDC * DC,
EDA_SchComponentStruct *Component,
EDA_LibComponentStruct *Entry,
const wxPoint & Pos,
int TransMat[2][2],
int Multi, int convert, int DrawMode,
int Color, bool DrawPinText)
{
int i, x1, y1, x2, y2, t1, t2, orient;
LibEDA_BaseStruct *DEntry = NULL;
int CharColor;
int fill_option;
int SetHightColor;
//#define GETCOLOR(l) Color < 0 ? (ReturnLayerColor(l)| SetHightColor) : Color;
#define GETCOLOR(l) Color < 0 ? SetHightColor ? s_ItemSelectColor : (ReturnLayerColor(l)| SetHightColor) : Color;
if (Entry->m_Drawings == NULL) return;
GRSetDrawMode(DC, DrawMode);
for( DEntry = Entry->m_Drawings; DEntry != NULL;DEntry = DEntry->Next())
{
/* Elimination des elements non relatifs a l'unite */
if( Multi && DEntry->m_Unit && (DEntry->m_Unit != Multi) ) continue;
if( convert && DEntry->m_Convert && (DEntry->m_Convert != convert) )
continue;
if ( DEntry->m_Flags & IS_MOVED ) continue; // Element en deplacement non trace
SetHightColor = (DEntry->m_Selected & IS_SELECTED) ? HIGHT_LIGHT_FLAG : 0;
switch (DEntry->m_StructType)
{
case COMPONENT_ARC_DRAW_TYPE:
{
int xc,yc, x2, y2;
LibDrawArc * Arc = (LibDrawArc *) DEntry;
CharColor = GETCOLOR(LAYER_DEVICE);
xc = Pos.x + TransMat[0][0] * Arc->m_Pos.x +
TransMat[0][1] * Arc->m_Pos.y;
yc = Pos.y + TransMat[1][0] * Arc->m_Pos.x +
TransMat[1][1] * Arc->m_Pos.y;
x2 = Pos.x + TransMat[0][0] * Arc->m_Start.x +
TransMat[0][1] * Arc->m_Start.y;;
y2 = Pos.y + TransMat[1][0] * Arc->m_Start.x +
TransMat[1][1] * Arc->m_Start.y;
x1 = Pos.x + TransMat[0][0] * Arc->m_End.x +
TransMat[0][1] * Arc->m_End.y;;
y1 = Pos.y + TransMat[1][0] * Arc->m_End.x +
TransMat[1][1] * Arc->m_End.y;
t1 = Arc->t1; t2 = Arc->t2;
bool swap = MapAngles(&t1, &t2, TransMat);
if ( swap ) { EXCHG(x1,x2); EXCHG(y1, y2) }
fill_option = Arc->m_Fill & (~g_PrintFillMask);
if ( Color < 0 ) // Normal Color Layer
{
if ( (fill_option == FILLED_WITH_BG_BODYCOLOR) && ! g_IsPrinting )
GRFilledArc(&panel->m_ClipBox, DC, xc, yc, t1, t2,
Arc->m_Rayon, CharColor,
ReturnLayerColor(LAYER_DEVICE_BACKGROUND));
else if ( fill_option == FILLED_SHAPE)
GRFilledArc(&panel->m_ClipBox, DC, xc, yc, t1, t2,
Arc->m_Rayon, CharColor, CharColor);
#ifdef DRAW_ARC_WITH_ANGLE
else GRArc(&panel->m_ClipBox, DC, xc, yc, t1, t2,
Arc->m_Rayon, CharColor);
#else
else GRArc1(&panel->m_ClipBox, DC, x1, y1, x2, y2,
xc, yc , CharColor);
#endif
}
#ifdef DRAW_ARC_WITH_ANGLE
else GRArc(&panel->m_ClipBox, DC, xc, yc, t1, t2,
Arc->m_Rayon, CharColor);
#else
else GRArc1(&panel->m_ClipBox, DC, x1, y1, x2, y2,
xc, yc, CharColor);
#endif
}
break;
case COMPONENT_CIRCLE_DRAW_TYPE:
{
LibDrawCircle * Circle = (LibDrawCircle *) DEntry;
CharColor = GETCOLOR(LAYER_DEVICE);
x1 = Pos.x + TransMat[0][0] * Circle->m_Pos.x +
TransMat[0][1] * Circle->m_Pos.y;
y1 = Pos.y + TransMat[1][0] * Circle->m_Pos.x +
TransMat[1][1] * Circle->m_Pos.y;
fill_option = Circle->m_Fill & (~g_PrintFillMask);
if ( Color < 0 )
{
if ( (fill_option == FILLED_WITH_BG_BODYCOLOR) && ! g_IsPrinting )
GRFilledCircle(&panel->m_ClipBox, DC, x1, y1,
Circle->m_Rayon, CharColor,
ReturnLayerColor(LAYER_DEVICE_BACKGROUND));
else if ( fill_option == FILLED_SHAPE)
GRFilledCircle(&panel->m_ClipBox, DC, x1, y1,
Circle->m_Rayon, CharColor, CharColor);
else GRCircle(&panel->m_ClipBox, DC, x1, y1,
Circle->m_Rayon, CharColor);
}
else GRCircle(&panel->m_ClipBox, DC, x1, y1,
Circle->m_Rayon, CharColor);
}
break;
case COMPONENT_GRAPHIC_TEXT_DRAW_TYPE:
{
LibDrawText * Text = (LibDrawText *) DEntry;
CharColor = GETCOLOR(LAYER_DEVICE);
/* The text orientation may need to be flipped if the
transformation matrix cuases xy axes to be flipped. */
t1 = (TransMat[0][0] != 0) ^ (Text->m_Horiz != 0);
x1 = Pos.x + TransMat[0][0] * Text->m_Pos.x
+ TransMat[0][1] * Text->m_Pos.y;
y1 = Pos.y + TransMat[1][0] * Text->m_Pos.x
+ TransMat[1][1] * Text->m_Pos.y;
PutTextInfo(panel, DC, t1 ? TEXT_ORIENT_HORIZ : TEXT_ORIENT_VERT,
wxPoint(x1, y1),
Text->m_Size,
Text->m_Text, DrawMode,CharColor);
}
break;
case COMPONENT_RECT_DRAW_TYPE:
{
LibDrawSquare * Square = (LibDrawSquare *) DEntry;
CharColor = GETCOLOR(LAYER_DEVICE);
x1 = Pos.x + TransMat[0][0] * Square->m_Start.x
+ TransMat[0][1] * Square->m_Start.y;
y1 = Pos.y + TransMat[1][0] * Square->m_Start.x
+ TransMat[1][1] * Square->m_Start.y;
x2 = Pos.x + TransMat[0][0] * Square->m_End.x
+ TransMat[0][1] * Square->m_End.y;
y2 = Pos.y + TransMat[1][0] * Square->m_End.x
+ TransMat[1][1] * Square->m_End.y;
fill_option = Square->m_Fill & (~g_PrintFillMask);
if ( Color < 0 )
{
if ( (fill_option == FILLED_WITH_BG_BODYCOLOR) && ! g_IsPrinting )
GRFilledRect(&panel->m_ClipBox, DC, x1, y1, x2, y2,
CharColor,
ReturnLayerColor(LAYER_DEVICE_BACKGROUND));
else if ( fill_option == FILLED_SHAPE)
GRFilledRect(&panel->m_ClipBox, DC, x1, y1, x2, y2,
CharColor, CharColor);
else GRRect(&panel->m_ClipBox, DC, x1, y1, x2, y2,
CharColor);
}
else GRRect(&panel->m_ClipBox, DC, x1, y1, x2, y2,
CharColor);
}
break;
case COMPONENT_PIN_DRAW_TYPE: /* Trace des Pins */
{
LibDrawPin * Pin = (LibDrawPin *) DEntry;
if(Pin->m_Attributs & PINNOTDRAW)
{
if( (ActiveScreen->m_Type == SCHEMATIC_FRAME) &&
!g_ShowAllPins )
break;
}
/* Calcul de l'orientation reelle de la Pin */
orient = Pin->ReturnPinDrawOrient(TransMat);
/* Calcul de la position du point de reference */
x2 = Pos.x + (TransMat[0][0] * Pin->m_Pos.x)
+ (TransMat[0][1] * Pin->m_Pos.y);
y2 = Pos.y + (TransMat[1][0] * Pin->m_Pos.x)
+ (TransMat[1][1] * Pin->m_Pos.y);
/* Dessin de la pin et du symbole special associe */
CharColor = GETCOLOR(LAYER_PIN);
DrawPinSymbol(panel, DC, x2, y2, Pin->m_PinLen, orient,
Pin->m_PinShape, DrawMode,
CharColor );
if ( DrawPinText )
{
wxPoint pinpos(x2,y2);
CharColor = SetHightColor ? s_ItemSelectColor : Color;
Pin->DrawPinTexts(panel, DC, pinpos, orient,
Entry->m_TextInside,
Entry->m_DrawPinNum,Entry->m_DrawPinName,
CharColor, DrawMode);
}
}
break;
case COMPONENT_POLYLINE_DRAW_TYPE:
{
LibDrawPolyline * polyline = (LibDrawPolyline *) DEntry;
CharColor = GETCOLOR(LAYER_DEVICE);
if ( Buf_Poly_Drawings == NULL )
{
Buf_Poly_Size = polyline->n;
Buf_Poly_Drawings = (int *) MyMalloc(sizeof(int) * 2 * Buf_Poly_Size);
}
else if ( Buf_Poly_Size < polyline->n )
{
Buf_Poly_Size = polyline->n;
Buf_Poly_Drawings = (int *) realloc(Buf_Poly_Drawings,
sizeof(int) * 2 * Buf_Poly_Size);
}
for (i = 0; i < polyline->n; i++)
{
Buf_Poly_Drawings[i * 2] = Pos.x +
TransMat[0][0] * polyline->PolyList[i * 2] +
TransMat[0][1] * polyline->PolyList[i * 2 + 1];
Buf_Poly_Drawings[i * 2 + 1] = Pos.y +
TransMat[1][0] * polyline->PolyList[i * 2] +
TransMat[1][1] * polyline->PolyList[i * 2 + 1];
}
fill_option = polyline->m_Fill & (~g_PrintFillMask);
if ( Color < 0 )
{
if ( (fill_option == FILLED_WITH_BG_BODYCOLOR) && ! g_IsPrinting )
GRPoly(&panel->m_ClipBox, DC, polyline->n,
Buf_Poly_Drawings, 1, CharColor,
ReturnLayerColor(LAYER_DEVICE_BACKGROUND));
else if ( fill_option == FILLED_SHAPE)
GRPoly(&panel->m_ClipBox, DC, polyline->n,
Buf_Poly_Drawings, 1, CharColor, CharColor);
else GRPoly(&panel->m_ClipBox, DC, polyline->n,
Buf_Poly_Drawings, 0, CharColor, CharColor);
}
else GRPoly(&panel->m_ClipBox, DC, polyline->n,
Buf_Poly_Drawings, 0, CharColor, CharColor);
}
break;
default:
wxBell();
break;
} /* Fin Switch */
} /* Fin Boucle de dessin */
if ( g_DebugLevel > 4 ) /* Draw the component boundary box */
{
EDA_Rect BoundaryBox;
if ( Component ) BoundaryBox = Component->GetBoundaryBox();
else BoundaryBox = Entry->GetBoundaryBox(Multi, convert);
x1 = BoundaryBox.GetX();
y1 = BoundaryBox.GetY();
x2 = BoundaryBox.GetRight();
y2 = BoundaryBox.GetBottom();
GRRect(&panel->m_ClipBox, DC, x1, y1, x2, y2, BROWN);
BoundaryBox = Component->m_Field[REFERENCE].GetBoundaryBox();
x1 = BoundaryBox.GetX();
y1 = BoundaryBox.GetY();
x2 = BoundaryBox.GetRight();
y2 = BoundaryBox.GetBottom();
GRRect(&panel->m_ClipBox, DC, x1, y1, x2, y2, BROWN);
BoundaryBox = Component->m_Field[VALUE].GetBoundaryBox();
x1 = BoundaryBox.GetX();
y1 = BoundaryBox.GetY();
x2 = BoundaryBox.GetRight();
y2 = BoundaryBox.GetBottom();
GRRect(&panel->m_ClipBox, DC, x1, y1, x2, y2, BROWN);
}
}
/*******************************************************/
void DrawPinSymbol(WinEDA_DrawPanel * panel, wxDC * DC,
int posX, int posY, int len, int orient,
int Shape, int DrawMode, int Color)
/*******************************************************/
/* Dessine la pin du symbole en cours de trace
si Color != 0 dessin en couleur Color, sinon en couleurs standard.
*/
{
int MapX1, MapY1, x1, y1;
int color;
if( Color >= 0) color = Color;
else color = ReturnLayerColor(LAYER_PIN);
GRSetDrawMode(DC, DrawMode);
MapX1 = MapY1 = 0; x1 = posX; y1 = posY;
switch ( orient )
{
case PIN_UP:
y1 = posY - len; MapY1 = 1;
break;
case PIN_DOWN:
y1 = posY + len; MapY1 = -1;
break;
case PIN_LEFT:
x1 = posX - len, MapX1 = 1;
break;
case PIN_RIGHT:
x1 = posX + len; MapX1 = -1;
break;
}
if( Shape & INVERT)
{
GRCircle(&panel->m_ClipBox, DC, MapX1 * INVERT_PIN_RADIUS + x1,
MapY1 * INVERT_PIN_RADIUS + y1,
INVERT_PIN_RADIUS, color);
GRMoveTo(MapX1 * INVERT_PIN_RADIUS * 2 + x1,
MapY1 * INVERT_PIN_RADIUS * 2 + y1);
GRLineTo(&panel->m_ClipBox, DC, posX, posY, color);
}
else
{
GRMoveTo(x1, y1);
GRLineTo(&panel->m_ClipBox, DC, posX, posY, color);
}
if(Shape & CLOCK)
{
if(MapY1 == 0 ) /* MapX1 = +- 1 */
{
GRMoveTo(x1, y1 + CLOCK_PIN_DIM);
GRLineTo(&panel->m_ClipBox, DC, x1 - MapX1 * CLOCK_PIN_DIM, y1, color);
GRLineTo(&panel->m_ClipBox, DC, x1, y1 - CLOCK_PIN_DIM, color);
}
else /* MapX1 = 0 */
{
GRMoveTo(x1 + CLOCK_PIN_DIM, y1 );
GRLineTo(&panel->m_ClipBox, DC, x1, y1 - MapY1 * CLOCK_PIN_DIM, color);
GRLineTo(&panel->m_ClipBox, DC, x1 - CLOCK_PIN_DIM, y1, color);
}
}
if(Shape & LOWLEVEL_IN) /* IEEE symbol "Active Low Input" */
{
if(MapY1 == 0 ) /* MapX1 = +- 1 */
{
GRMoveTo(x1 + MapX1 * IEEE_SYMBOL_PIN_DIM*2, y1);
GRLineTo(&panel->m_ClipBox, DC, x1 + MapX1 * IEEE_SYMBOL_PIN_DIM*2,
y1 - IEEE_SYMBOL_PIN_DIM, color);
GRLineTo(&panel->m_ClipBox, DC, x1, y1, color);
}
else /* MapX1 = 0 */
{
GRMoveTo(x1, y1 + MapY1 * IEEE_SYMBOL_PIN_DIM*2);
GRLineTo(&panel->m_ClipBox, DC, x1 - IEEE_SYMBOL_PIN_DIM,
y1 + MapY1 * IEEE_SYMBOL_PIN_DIM*2, color);
GRLineTo(&panel->m_ClipBox, DC, x1 , y1, color);
}
}
if(Shape & LOWLEVEL_OUT) /* IEEE symbol "Active Low Output" */
{
if(MapY1 == 0 ) /* MapX1 = +- 1 */
{
GRMoveTo(x1, y1 - IEEE_SYMBOL_PIN_DIM);
GRLineTo(&panel->m_ClipBox, DC, x1 + MapX1 * IEEE_SYMBOL_PIN_DIM*2, y1, color);
}
else /* MapX1 = 0 */
{
GRMoveTo(x1 - IEEE_SYMBOL_PIN_DIM, y1);
GRLineTo(&panel->m_ClipBox, DC, x1 , y1 + MapY1 * IEEE_SYMBOL_PIN_DIM*2, color);
}
}
/* Draw the pin end target (active end of the pin) */
if ( ! g_IsPrinting ) // Draw but do not print the pin end target */
GRCircle(&panel->m_ClipBox, DC, posX,posY,TARGET_PIN_DIAM, color);
}
/*****************************************************************************
* Routine to rotate the given angular direction by the given Transformation. *
* Input (and output) angles must be as follows: *
* Unit is 0.1 degre *
* Angle1 in [0..3600], Angle2 > Angle1 in [0..7200]. Arc is assumed to be less *
* than 180.0 degrees. *
* Algorithm: *
* Map the angles to a point on the unit circle which is mapped using the *
* transform (only mirror and rotate so it remains on the unit circle) to *
* a new point which is used to detect new angle. *
*****************************************************************************/
bool MapAngles(int *Angle1, int *Angle2, int TransMat[2][2])
{
int Angle, Delta;
double x, y, t;
bool swap = FALSE;
Delta = *Angle2 - *Angle1;
if ( Delta >= 1800 )
{
*Angle1 -=1;
*Angle2 +=1;
}
x = cos(*Angle1 * M_PI / 1800.0);
y = sin(*Angle1 * M_PI / 1800.0);
t = x * TransMat[0][0] + y * TransMat[0][1];
y = x * TransMat[1][0] + y * TransMat[1][1];
x = t;
*Angle1 = (int) (atan2(y, x) * 1800.0 / M_PI + 0.5);
x = cos(*Angle2 * M_PI / 1800.0);
y = sin(*Angle2 * M_PI / 1800.0);
t = x * TransMat[0][0] + y * TransMat[0][1];
y = x * TransMat[1][0] + y * TransMat[1][1];
x = t;
*Angle2 = (int) (atan2(y, x) * 1800.0 / M_PI + 0.5);
NORMALIZE_ANGLE(*Angle1);
NORMALIZE_ANGLE(*Angle2);
if (*Angle2 < *Angle1) *Angle2 += 3600;
if (*Angle2 - *Angle1 > 1800)
{ /* Need to swap the two angles. */
Angle = (*Angle1);
*Angle1 = (*Angle2);
*Angle2 = Angle;
NORMALIZE_ANGLE(*Angle1);
NORMALIZE_ANGLE(*Angle2);
if (*Angle2 < *Angle1) *Angle2 += 3600;
swap = TRUE;
}
if ( Delta >= 1800 )
{
*Angle1 +=1;
*Angle2 -=1;
}
return swap;
}
/*****************************************************************************
* Routine to display an outline version of given library entry. *
* This routine is applied by the PlaceLibItem routine above. *
*****************************************************************************/
void DrawingLibInGhost(WinEDA_DrawPanel * panel, wxDC * DC,
EDA_LibComponentStruct *LibEntry,
EDA_SchComponentStruct *DrawLibItem, int PartX, int PartY,
int multi, int convert, int Color, bool DrawPinText)
{
int DrawMode = g_XorMode;
DrawLibPartAux(panel, DC, DrawLibItem, LibEntry, wxPoint(PartX, PartY),
DrawLibItem->m_Transform,
multi, convert, DrawMode, Color, DrawPinText);
}
/************************************************************/
/* Routine to draw One LibraryDrawStruct at given position, */
/* matrice de transformation 1 0 0 -1 (normale) */
/* DrawMode = GrXOR, GrOR .. */
/************************************************************/
/* Utilise en LibEdit et Lib Browse */
void DrawLibraryDrawStruct(WinEDA_DrawPanel * panel, wxDC * DC,
EDA_LibComponentStruct *LibEntry,
int PartX, int PartY,
LibEDA_BaseStruct *DrawItem, int Multi,
int DrawMode, int Color)
{
int i, x1, y1, x2, y2, t1, t2, orient;
int CharColor;
int TransMat[2][2];
int fill_option;
#undef GETCOLOR
#define GETCOLOR(l) Color < 0 ? ReturnLayerColor(l) : Color;
Multi = 0; /* unused */
/* Trace de la structure */
CharColor = GETCOLOR(LAYER_DEVICE);
GRSetDrawMode(DC, DrawMode);
TransMat[0][0] = 1;
TransMat[0][1] = TransMat[1][0] = 0;
TransMat[1][1] = -1;
switch (DrawItem->m_StructType)
{
case COMPONENT_ARC_DRAW_TYPE:
{
int xc,yc, x2,y2;
LibDrawArc * Arc = (LibDrawArc *) DrawItem;
t1 = Arc->t1; t2 = Arc->t2;
bool swap = MapAngles(&t1, &t2, TransMat);
xc = PartX + Arc->m_Pos.x;
yc = PartY - Arc->m_Pos.y;
x2 = PartX + Arc->m_Start.x;
y2 = PartY - Arc->m_Start.y;
x1 = PartX + Arc->m_End.x;
y1 = PartY - Arc->m_End.y;
if ( swap ) { EXCHG(x1,x2); EXCHG(y1, y2)}
fill_option = Arc->m_Fill & (~g_PrintFillMask);
if ( (Arc->m_Fill == FILLED_WITH_BG_BODYCOLOR) && ! g_IsPrinting )
GRFilledArc(&panel->m_ClipBox, DC, xc, yc, t1, t2,
Arc->m_Rayon, CharColor,
ReturnLayerColor(LAYER_DEVICE_BACKGROUND));
else if ( Arc->m_Fill == FILLED_SHAPE)
GRFilledArc(&panel->m_ClipBox, DC, xc, yc, t1, t2,
Arc->m_Rayon, CharColor, CharColor);
#ifdef DRAW_ARC_WITH_ANGLE
else GRArc(&panel->m_ClipBox, DC, xc, yc, t1, t2,
Arc->m_Rayon, CharColor);
#else
else GRArc1(&panel->m_ClipBox, DC, x1, y1, x2, y2,
xc, yc, CharColor);
#endif
}
break;
case COMPONENT_CIRCLE_DRAW_TYPE:
{
LibDrawCircle * Circle = (LibDrawCircle *) DrawItem;
x1 = PartX + Circle->m_Pos.x;
y1 = PartY - Circle->m_Pos.y;
fill_option = Circle->m_Fill & (~g_PrintFillMask);
if ( (fill_option == FILLED_WITH_BG_BODYCOLOR) && ! g_IsPrinting )
GRFilledCircle(&panel->m_ClipBox, DC, x1, y1,
Circle->m_Rayon, CharColor,
ReturnLayerColor(LAYER_DEVICE_BACKGROUND));
else if ( fill_option == FILLED_SHAPE)
GRFilledCircle(&panel->m_ClipBox, DC, x1, y1,
Circle->m_Rayon, CharColor, CharColor);
else GRCircle(&panel->m_ClipBox, DC, x1, y1,
Circle->m_Rayon, CharColor);
}
break;
case COMPONENT_GRAPHIC_TEXT_DRAW_TYPE:
{
LibDrawText * Text = (LibDrawText *) DrawItem;
x1 = PartX + Text->m_Pos.x;
y1 = PartY - Text->m_Pos.y;
PutTextInfo(panel, DC, Text->m_Horiz, wxPoint(x1, y1),
Text->m_Size, Text->m_Text,
DrawMode,CharColor);
}
break;
case COMPONENT_RECT_DRAW_TYPE:
{
LibDrawSquare * Square = (LibDrawSquare *) DrawItem;
x1 = PartX + Square->m_Start.x;
y1 = PartY - Square->m_Start.y;
x2 = PartX + Square->m_End.x;
y2 = PartY - Square->m_End.y;
fill_option = Square->m_Fill & (~g_PrintFillMask);
if ( (fill_option == FILLED_WITH_BG_BODYCOLOR) && ! g_IsPrinting )
GRFilledRect(&panel->m_ClipBox, DC, x1, y1, x2, y2,
CharColor,
ReturnLayerColor(LAYER_DEVICE_BACKGROUND));
else if ( fill_option == FILLED_SHAPE)
GRFilledRect(&panel->m_ClipBox, DC, x1, y1, x2, y2,
CharColor, CharColor);
else GRRect(&panel->m_ClipBox, DC, x1, y1, x2, y2,
CharColor);
}
break;
case COMPONENT_PIN_DRAW_TYPE: /* Trace des Pins */
{
LibDrawPin * Pin = (LibDrawPin *) DrawItem;
x2 = PartX + Pin->m_Pos.x;
y2 = PartY - Pin->m_Pos.y;
/* Compute the real pin orientation, i.e. pin orient + component orient */
orient = Pin->ReturnPinDrawOrient(TransMat);
/* Dessin de la pin et du symbole special associe */
if( Pin->m_Attributs & PINNOTDRAW) CharColor = DARKGRAY;
else CharColor = -1;
DrawPinSymbol(panel, DC, x2, y2, Pin->m_PinLen, orient,
Pin->m_PinShape, DrawMode);
wxPoint pinpos(x2,y2);
Pin->DrawPinTexts(panel, DC, pinpos, orient,
LibEntry->m_TextInside,
LibEntry->m_DrawPinNum,LibEntry->m_DrawPinName,
CharColor, DrawMode);
}
break;
case COMPONENT_POLYLINE_DRAW_TYPE:
{
LibDrawPolyline * polyline = (LibDrawPolyline *) DrawItem;
if ( Buf_Poly_Drawings == NULL )
{
Buf_Poly_Size = polyline->n;
Buf_Poly_Drawings = (int *) MyMalloc(sizeof(int) * 2 * Buf_Poly_Size);
}
else if ( Buf_Poly_Size < polyline->n )
{
Buf_Poly_Size = polyline->n;
Buf_Poly_Drawings = (int *) realloc(Buf_Poly_Drawings,
sizeof(int) * 2 * Buf_Poly_Size);
}
for (i = 0; i < polyline->n; i++)
{
Buf_Poly_Drawings[i * 2] = PartX + polyline->PolyList[i * 2];
Buf_Poly_Drawings[i * 2 + 1] = PartY - polyline->PolyList[i * 2 + 1];
}
fill_option = polyline->m_Fill & (~g_PrintFillMask);
if ( (fill_option == FILLED_WITH_BG_BODYCOLOR) && ! g_IsPrinting )
GRPoly(&panel->m_ClipBox, DC, polyline->n,
Buf_Poly_Drawings, 1, CharColor,
ReturnLayerColor(LAYER_DEVICE_BACKGROUND));
else if ( fill_option == FILLED_SHAPE)
GRPoly(&panel->m_ClipBox, DC, polyline->n,
Buf_Poly_Drawings, 1, CharColor, CharColor);
else GRPoly(&panel->m_ClipBox, DC, polyline->n,
Buf_Poly_Drawings, 0, CharColor, CharColor);
break;
}
}
}
Reference in New Issue View Git Blame Copy Permalink