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

651 lines
21 KiB
C++
Raw Blame History

/****************************************/
/* Modules to handle component drawing. */
/****************************************/
#include "fctsys.h"
#include "gr_basic.h"
#include "common.h"
#include "class_drawpanel.h"
#include "drawtxt.h"
#include "program.h"
#include "libcmp.h"
#include "component_class.h"
#include "general.h"
#include "trigo.h"
#include "protos.h"
//#define DRAW_ARC_WITH_ANGLE // Used to select function to draw arcs
/* Local functions */
/* Descr component <DUMMY> used when a component is not found in library,
* to draw a dummy shape
* This component is a 400 mils square with the text ??
* 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 void CreateDummyCmp();
static void DrawLibPartAux( WinEDA_DrawPanel * panel, wxDC * DC,
SCH_COMPONENT * Component,
EDA_LibComponentStruct * Entry,
const wxPoint &Pos,
const int TransMat[2][2],
int Multi, int convert,
int DrawMode, int Color = -1, bool DrawPinText = TRUE );
/* Local variables */
static EDA_LibComponentStruct* DummyCmp;
/***************************************************************************/
wxPoint TransformCoordinate( const int aTransformMatrix[2][2], const wxPoint& aPosition )
/***************************************************************************/
/** Function TransformCoordinate
* Calculate the wew coordinate from the old one, according to the transform matrix.
* @param aTransformMatrix = rotation, mirror .. matrix
* @param aPosition = the position to transform
* @return the new coordinate
*/
{
wxPoint new_pos;
new_pos.x = (aTransformMatrix[0][0] * aPosition.x) + (aTransformMatrix[0][1] * aPosition.y);
new_pos.y = (aTransformMatrix[1][0] * aPosition.x) + (aTransformMatrix[1][1] * aPosition.y);
return new_pos;
}
/******************************/
void CreateDummyCmp()
/******************************/
{
DummyCmp = new EDA_LibComponentStruct( NULL );
LibDrawSquare* Square = new LibDrawSquare();
Square->m_Pos = 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->SetNext( Text );
}
/*************************************************************/
void DrawLibEntry( WinEDA_DrawPanel* panel, wxDC* DC,
EDA_LibComponentStruct* LibEntry,
const wxPoint & aOffset,
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;
wxString Prefix;
LibDrawField* Field;
wxPoint text_pos;
DrawLibPartAux( panel, DC, NULL, LibEntry, aOffset,
DefaultTransformMatrix, 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 = g_InvisibleItemColor;
}
else color = Color;
if( LibEntry->m_UnitCount > 1 )
#if defined(KICAD_GOST)
Prefix.Printf( wxT( "%s?.%c" ), LibEntry->m_Prefix.m_Text.GetData(), Multi + '1' - 1);
#else
Prefix.Printf( wxT( "%s?%c" ), LibEntry->m_Prefix.m_Text.GetData(), Multi + 'A' - 1 );
#endif
else
Prefix = LibEntry->m_Prefix.m_Text + wxT( "?" );
if( (LibEntry->m_Prefix.m_Flags & IS_MOVED) == 0 )
LibEntry->m_Prefix.Draw( panel, DC, aOffset, color, DrawMode, &Prefix, DefaultTransformMatrix );
if( LibEntry->m_Name.m_Attributs & TEXT_NO_VISIBLE )
{
if( Color >= 0 )
color = Color;
else
color = g_InvisibleItemColor;
}
else color = Color;
if( (LibEntry->m_Name.m_Flags & IS_MOVED) == 0 )
LibEntry->m_Name.Draw( panel, DC, aOffset, color, DrawMode, NULL, DefaultTransformMatrix );
for( Field = LibEntry->m_Fields; Field != NULL; Field = Field->Next() )
{
if( Field->m_Text.IsEmpty() )
return;
if( (Field->m_Flags & IS_MOVED) != 0 )
continue;
if( Field->m_Attributs & TEXT_NO_VISIBLE )
{
if( Color >= 0 )
color = Color;
else
color = g_InvisibleItemColor;
}
else color = Color;
Field->Draw( panel, DC, aOffset, color, DrawMode, NULL, DefaultTransformMatrix );
}
// Trace de l'ancre
int len = panel->GetScreen()->Unscale( 3 );
GRLine( &panel->m_ClipBox, DC, aOffset.x, aOffset.y - len, aOffset.x, aOffset.y + len, 0, color );
GRLine( &panel->m_ClipBox, DC, aOffset.x - len, aOffset.y, aOffset.x + len, aOffset.y, 0, 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 SCH_COMPONENT::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 trouve, 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
*/
SCH_CMP_FIELD* field = GetField( REFERENCE );
if( ( (field->m_Attributs & TEXT_NO_VISIBLE) == 0 )
&& !(field->m_Flags & IS_MOVED) )
{
if( Entry->m_UnitCount > 1 )
{
field->m_AddExtraText = true;
field->Draw( panel, DC, offset, DrawMode );
}
else
{
field->m_AddExtraText = false;
field->Draw( panel, DC, offset, DrawMode );
}
}
for( ii = VALUE; ii < GetFieldCount(); ii++ )
{
field = GetField( ii );
if( field->m_Flags & IS_MOVED )
continue;
field->Draw( panel, DC, offset, DrawMode );
}
}
/***********************************************************/
void SCH_CMP_FIELD::Draw( WinEDA_DrawPanel* panel,
wxDC* DC,
const wxPoint& offset,
int DrawMode,
int Color )
/***********************************************************/
/* Routine de trace des textes type Field du composant.
* entree:
* DrawMode: mode de trace
*/
{
int orient;
EDA_Colors color;
wxPoint pos; /* Position des textes */
SCH_COMPONENT* DrawLibItem = (SCH_COMPONENT*) m_Parent;
GRTextHorizJustifyType hjustify;
GRTextVertJustifyType vjustify;
int LineWidth = MAX( m_Width, g_DrawMinimunLineWidth );
if( m_Attributs & TEXT_NO_VISIBLE )
return;
if( IsVoid() )
return;
GRSetDrawMode( DC, DrawMode );
/* Calcul de la position des textes, selon orientation du composant */
orient = m_Orient;
hjustify = m_HJustify; vjustify = m_VJustify;
pos = m_Pos - DrawLibItem->m_Pos;
pos = DrawLibItem->GetScreenCoord( pos );
pos += DrawLibItem->m_Pos;
/* 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)*/
GRTextHorizJustifyType tmp = hjustify;
hjustify = (GRTextHorizJustifyType) vjustify;
vjustify = (GRTextVertJustifyType) tmp;
if( DrawLibItem->m_Transform[1][0] < 0 )
switch ( vjustify )
{
case GR_TEXT_VJUSTIFY_BOTTOM:
vjustify = GR_TEXT_VJUSTIFY_TOP;
break;
case GR_TEXT_VJUSTIFY_TOP:
vjustify = GR_TEXT_VJUSTIFY_BOTTOM;
break;
default:
break;
}
if( DrawLibItem->m_Transform[1][0] > 0 )
switch ( hjustify )
{
case GR_TEXT_HJUSTIFY_LEFT:
hjustify = GR_TEXT_HJUSTIFY_RIGHT;
break;
case GR_TEXT_HJUSTIFY_RIGHT:
hjustify = GR_TEXT_HJUSTIFY_LEFT;
break;
default:
break;
}
}
else
{
/* Texte horizontal: Y a t-il miroir (pour les justifications)*/
if( DrawLibItem->m_Transform[0][0] < 0 )
switch ( hjustify )
{
case GR_TEXT_HJUSTIFY_LEFT:
hjustify = GR_TEXT_HJUSTIFY_RIGHT;
break;
case GR_TEXT_HJUSTIFY_RIGHT:
hjustify = GR_TEXT_HJUSTIFY_LEFT;
break;
default:
break;
}
if( DrawLibItem->m_Transform[1][1] > 0 )
switch ( vjustify )
{
case GR_TEXT_VJUSTIFY_BOTTOM:
vjustify = GR_TEXT_VJUSTIFY_TOP;
break;
case GR_TEXT_VJUSTIFY_TOP:
vjustify = GR_TEXT_VJUSTIFY_BOTTOM;
break;
default:
break;
}
}
if( m_FieldId == REFERENCE )
color = ReturnLayerColor( LAYER_REFERENCEPART );
else if( m_FieldId == VALUE )
color = ReturnLayerColor( LAYER_VALUEPART );
else
color = ReturnLayerColor( LAYER_FIELDS );
if( !m_AddExtraText || (m_FieldId != REFERENCE) )
{
DrawGraphicText( panel, DC, pos, color, m_Text,
orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ,
m_Size,
hjustify, vjustify, LineWidth, m_Italic );
}
else // For more than one part per package, we must add the part selection to the reference )
{
/* Adding A ou B ... or .1 .2 ... to the reference */
wxString fulltext = m_Text;
#if defined(KICAD_GOST)
fulltext.Append( '.');
fulltext.Append( '1' - 1 + DrawLibItem->m_Multi );
#else
fulltext.Append( 'A' - 1 + DrawLibItem->m_Multi );
#endif
DrawGraphicText( panel, DC, pos, color, fulltext,
orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ,
m_Size,
hjustify, vjustify, LineWidth, m_Italic );
}
}
/********************************************************************************/
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,
SCH_COMPONENT* Component,
EDA_LibComponentStruct* Entry,
const wxPoint& Pos,
const int TransMat[2][2],
int Multi, int convert, int DrawMode,
int Color, bool DrawPinText )
{
wxPoint pos1, pos2;
LibEDA_BaseStruct* DEntry;
bool force_nofill;
if( Entry->m_Drawings == NULL )
return;
GRSetDrawMode( DC, DrawMode );
for( DEntry = Entry->m_Drawings; DEntry != NULL; DEntry = DEntry->Next() )
{
/* Do not draw items not attached to the current part */
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; // Do do draw here an item while moving (the cursor handler does that)
force_nofill = false;
switch( DEntry->Type() )
{
case COMPONENT_PIN_DRAW_TYPE:
{
DrawPinPrms prms( Entry, DrawPinText );
DEntry->Draw( panel, DC, Pos, Color, DrawMode, &prms, TransMat );
}
break;
case COMPONENT_ARC_DRAW_TYPE:
case COMPONENT_CIRCLE_DRAW_TYPE:
case COMPONENT_GRAPHIC_TEXT_DRAW_TYPE:
case COMPONENT_RECT_DRAW_TYPE:
case COMPONENT_POLYLINE_DRAW_TYPE:
default:
if( g_IsPrinting && DEntry->m_Fill == FILLED_WITH_BG_BODYCOLOR
&& GetGRForceBlackPenState() )
force_nofill = true;
DEntry->Draw( panel, DC, Pos, Color, DrawMode, (void*) force_nofill, TransMat );
break;
}
}
if( g_DebugLevel > 4 ) /* Draw the component boundary box */
{
EDA_Rect BoundaryBox;
if( Component )
BoundaryBox = Component->GetBoundaryBox();
else
BoundaryBox = Entry->GetBoundaryBox( Multi, convert );
int x1 = BoundaryBox.GetX();
int y1 = BoundaryBox.GetY();
int x2 = BoundaryBox.GetRight();
int y2 = BoundaryBox.GetBottom();
GRRect( &panel->m_ClipBox, DC, x1, y1, x2, y2, BROWN );
BoundaryBox = Component->GetField( 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->GetField( VALUE )->GetBoundaryBox();
x1 = BoundaryBox.GetX();
y1 = BoundaryBox.GetY();
x2 = BoundaryBox.GetRight();
y2 = BoundaryBox.GetBottom();
GRRect( &panel->m_ClipBox, DC, x1, y1, x2, y2, BROWN );
}
}
/*****************************************************************************
* 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, const 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,
SCH_COMPONENT* 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* aPanel, wxDC* aDC,
EDA_LibComponentStruct* aLibEntry,
wxPoint aPosition,
LibEDA_BaseStruct* aDrawItem,
int aDrawMode, int aColor )
{
int TransMat[2][2];
bool no_fill;
GRSetDrawMode( aDC, aDrawMode );
TransMat[0][0] = 1;
TransMat[0][1] = TransMat[1][0] = 0;
TransMat[1][1] = -1;
no_fill = false;
switch( aDrawItem->Type() )
{
case COMPONENT_PIN_DRAW_TYPE: /* Trace des Pins */
{
DrawPinPrms prms( aLibEntry, true );
aDrawItem->Draw( aPanel, aDC, aPosition, aColor, aDrawMode, &prms, TransMat );
}
break;
case COMPONENT_ARC_DRAW_TYPE:
case COMPONENT_CIRCLE_DRAW_TYPE:
case COMPONENT_GRAPHIC_TEXT_DRAW_TYPE:
case COMPONENT_RECT_DRAW_TYPE:
case COMPONENT_POLYLINE_DRAW_TYPE:
default:
if( g_IsPrinting && aDrawItem->m_Fill == FILLED_WITH_BG_BODYCOLOR
&& GetGRForceBlackPenState() )
no_fill = true;
aDrawItem->Draw( aPanel, aDC, aPosition, aColor, aDrawMode, (void*) no_fill, TransMat );
break;
}
}
Reference in New Issue View Git Blame Copy Permalink