haskal
/
kicad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

EDA_BaseStruct::m_StructType is now type KICAD_T

This commit is contained in:
dickelbeck 2007-08-24 15:10:46 +00:00
parent 908f6d936b
commit f3c324d535
32 changed files with 4536 additions and 3984 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
3d-viewer/3d_class.cpp
View File

@ -26,7 +26,7 @@ S3D_Vertex::S3D_Vertex(void)
/**************************************************************************/
S3D_Material::S3D_Material( Struct3D_Master * father, const wxString & name ):
EDA_BaseStruct( father, -1)
EDA_BaseStruct( father, NOT_USED )
/**************************************************************************/
{
m_DiffuseColor.x = m_DiffuseColor.y = m_DiffuseColor.z = 1.0;
@ -67,7 +67,7 @@ void Struct3D_Master::Copy(Struct3D_Master * pattern)
/***************************************************************/
Struct3D_Master::Struct3D_Master(EDA_BaseStruct * StructFather):
EDA_BaseStruct( StructFather, -1)
EDA_BaseStruct( StructFather, NOT_USED )
/***************************************************************/
{
m_MatScale.x = m_MatScale.y = m_MatScale.z = 1.0;
@ -100,7 +100,7 @@ S3D_Material * nextmat;
/***************************************************************/
Struct3D_Shape::Struct3D_Shape(EDA_BaseStruct * StructFather):
EDA_BaseStruct( StructFather, -1)
EDA_BaseStruct( StructFather, NOT_USED )
/***************************************************************/
{
m_3D_Coord = NULL;

15
change_log.txt
View File

@ -5,6 +5,18 @@ Please add newer entries at the top, list the date and your name with
email address.
2007-Aug-23 UPDATE Dick Hollenbeck <dick@softplc.com>
================================================================================
+ eeschema & pcbnew
* Removed class EDA_BaseLineStruct, which brought no behavioral advantage, only data.
Classes which were based on got its data members added and their initializers.
* Changed type of EDA_BaseStruct::m_StructType from int to KICAD_T which is an
enum. This makes debugging easier since gdb will show the name of the
KICAD_T rather than simply a number. Added NOT_USED = -1 to KICAD_T enum for
3d which was using -1.
* More beautification using latest uncrustify and the committed uncrustify.cfg
2007-Aug-24 UPDATE Geoff Harland <gharlandau@yahoo.com.au>
================================================================================
+ pcbnew
@ -27,9 +39,6 @@ email address.
tomorrow I will add a new class COLLECTORS_GUIDE which can be used by a
COLLECTOR to control its operation. It adds the concept of layer
locking, even though PCBNEW does not support that in the UI yet.
@todo:
add constructor initializers for classes that were derived from
EDA_BaseLineStruct but are now not. Its late, will do tomorrow.
2007-Aug-22 UPDATE Dick Hollenbeck <dick@softplc.com>

20
common/base_struct.cpp
View File

@ -17,8 +17,8 @@
#include "macros.h"
// DrawStructureType names for error messages only:
static wxString DrawStructureTypeName[MAX_STRUCT_TYPE_ID + 1] = {
// KICAD_T names for error messages only:
static wxString KICAD_TName[MAX_STRUCT_TYPE_ID + 1] = {
wxT( "Not init" ),
wxT( "Pcb" ),
@ -74,7 +74,7 @@ enum textbox {
/******************************************************************************/
EDA_BaseStruct::EDA_BaseStruct( EDA_BaseStruct* parent, int idType )
EDA_BaseStruct::EDA_BaseStruct( EDA_BaseStruct* parent, KICAD_T idType )
/******************************************************************************/
{
InitVars();
@ -84,7 +84,7 @@ EDA_BaseStruct::EDA_BaseStruct( EDA_BaseStruct* parent, int idType )
/********************************************/
EDA_BaseStruct::EDA_BaseStruct( int idType )
EDA_BaseStruct::EDA_BaseStruct( KICAD_T idType )
/********************************************/
{
InitVars();
@ -183,7 +183,7 @@ wxString EDA_BaseStruct::ReturnClassName() const
if( (ii < 0) || (ii > MAX_STRUCT_TYPE_ID) )
ii = MAX_STRUCT_TYPE_ID;
classname = DrawStructureTypeName[ii];
classname = KICAD_TName[ii];
return classname;
}
@ -287,16 +287,6 @@ std::ostream& EDA_BaseStruct::NestedSpace( int nestLevel, std::ostream& os )
/**********************************************************************************************/
EDA_BaseLineStruct::EDA_BaseLineStruct( EDA_BaseStruct* StructFather, DrawStructureType idtype ) :
EDA_BaseStruct( StructFather, idtype )
/**********************************************************************************************/
{
m_Layer = 0;
m_Width = 0; // 0 = line, > 0 = tracks, bus ...
};
/*********************************************************/
/* EDA_TextStruct (classe de base, non utilis<69> seule */
/*********************************************************/

93
eeschema/affiche.cpp
View File

@ -23,11 +23,13 @@ void DrawSheetStruct::Display_Infos(WinEDA_DrawFrame * frame)
Affiche_1_Parametre( frame, 30, _( "FileName" ), m_FileName, BROWN );
}
/***************************************************************/
void EDA_SchComponentStruct::Display_Infos( WinEDA_DrawFrame* frame )
/***************************************************************/
{
EDA_LibComponentStruct* Entry = FindLibPart( m_ChipName.GetData(), wxEmptyString, FIND_ROOT );;
wxString msg;
frame->MsgPanel->EraseMsgBox();
@ -37,7 +39,8 @@ wxString msg;
if( Entry && Entry->m_Options == ENTRY_POWER )
msg = _( "Pwr Symb" );
else msg = _("Val");
else
msg = _( "Val" );
Affiche_1_Parametre( frame, 10, msg, m_Field[VALUE].m_Text, DARKCYAN );
Affiche_1_Parametre( frame, 28, _( "RefLib" ), m_ChipName.GetData(), BROWN );
@ -53,10 +56,10 @@ wxString msg;
}
/*******************************************************/
void LibDrawPin::Display_Infos( WinEDA_DrawFrame* frame )
/*******************************************************/
/* Affiche en bas d'ecran les caracteristiques de la pin
*/
{
@ -69,8 +72,10 @@ int ii;
Affiche_1_Parametre( frame, 24, _( "PinName" ), m_PinName, DARKCYAN );
/* Affichage du numero */
if(m_PinNum == 0) Text = wxT("?" );
else ReturnPinStringNum(Text);
if( m_PinNum == 0 )
Text = wxT( "?" );
else
ReturnPinStringNum( Text );
Affiche_1_Parametre( frame, 40, _( "PinNum" ), Text, DARKCYAN );
@ -80,8 +85,10 @@ int ii;
/* Affichage de la visiblite */
ii = m_Attributs;
if( ii & 1 ) Text = _("no");
else Text = _("yes");
if( ii & 1 )
Text = _( "no" );
else
Text = _( "yes" );
Affiche_1_Parametre( frame, 58, _( "Display" ), Text, DARKGREEN );
/* Affichage de la longueur */
@ -91,11 +98,20 @@ int ii;
/* Affichage de l'orientation */
switch( m_Orient )
{
case PIN_UP: Text = _("Up"); break;
case PIN_DOWN: Text = _("Down"); break;
case PIN_LEFT: Text = _("Left"); break;
case PIN_RIGHT: Text = _("Right"); break;
default: Text = wxT("??"); break;
case PIN_UP:
Text = _( "Up" ); break;
case PIN_DOWN:
Text = _( "Down" ); break;
case PIN_LEFT:
Text = _( "Left" ); break;
case PIN_RIGHT:
Text = _( "Right" ); break;
default:
Text = wxT( "??" ); break;
}
Affiche_1_Parametre( frame, 72, _( "Orient" ), Text, MAGENTA );
@ -105,6 +121,7 @@ int ii;
/***********************************************************************/
void LibEDA_BaseStruct::Display_Infos_DrawEntry( WinEDA_DrawFrame* frame )
/***********************************************************************/
/* Affiche en bas d'ecran les caracteristiques de l'element
*/
{
@ -114,37 +131,59 @@ wxString msg;
/* affichage du type */
msg = wxT( "??" );
switch( m_StructType )
{
case COMPONENT_ARC_DRAW_TYPE: msg = wxT("Arc"); break;
case COMPONENT_CIRCLE_DRAW_TYPE: msg = wxT("Circle"); break;
case COMPONENT_GRAPHIC_TEXT_DRAW_TYPE: msg = wxT("Text"); break;
case COMPONENT_RECT_DRAW_TYPE: msg = wxT("Rect"); break;
case COMPONENT_POLYLINE_DRAW_TYPE: msg = wxT("PolyLine"); break;
case COMPONENT_LINE_DRAW_TYPE: msg = wxT("Segment"); break;
case COMPONENT_ARC_DRAW_TYPE:
msg = wxT( "Arc" ); break;
case COMPONENT_CIRCLE_DRAW_TYPE:
msg = wxT( "Circle" ); break;
case COMPONENT_GRAPHIC_TEXT_DRAW_TYPE:
msg = wxT( "Text" ); break;
case COMPONENT_RECT_DRAW_TYPE:
msg = wxT( "Rect" ); break;
case COMPONENT_POLYLINE_DRAW_TYPE:
msg = wxT( "PolyLine" ); break;
case COMPONENT_LINE_DRAW_TYPE:
msg = wxT( "Segment" ); break;
case COMPONENT_PIN_DRAW_TYPE:
( (LibDrawPin*) this )->Display_Infos( frame );
msg = wxT( "Pin" );
break;
default:
;
}
Affiche_1_Parametre( frame, 1, wxT( "Type" ), msg, CYAN );
/* Affichage de l'appartenance */
if( m_Unit == 0 ) msg = _("All");
else msg.Printf( wxT("%d"), m_Unit );
if( m_Unit == 0 )
msg = _( "All" );
else
msg.Printf( wxT( "%d" ), m_Unit );
Affiche_1_Parametre( frame, 10, _( "Unit" ), msg, BROWN );
if( m_Convert == 0 ) msg = _("All" );
else if( m_Convert == 1 ) msg = _("no");
else if( m_Convert == 2 ) msg = _("yes");
else msg = wxT("?");
if( m_Convert == 0 )
msg = _( "All" );
else if( m_Convert == 1 )
msg = _( "no" );
else if( m_Convert == 2 )
msg = _( "yes" );
else
msg = wxT( "?" );
Affiche_1_Parametre( frame, 16, _( "Convert" ), msg, BROWN );
if ( m_Width ) valeur_param(m_Width, msg);
else msg = _("default");
if( m_Width )
valeur_param( m_Width, msg );
else
msg = _( "default" );
Affiche_1_Parametre( frame, 24, _( "Width" ), msg, BLUE );
}

3
eeschema/block.cpp
View File

@ -841,6 +841,9 @@ static EDA_BaseStruct* CopyStruct( WinEDA_DrawPanel* panel, wxDC* DC, BASE_SCREE
sheet->m_FileName = sheet->m_SheetName + wxT( ".sch" );
break;
}
default:
;
}
SetStructFather( Struct, screen );

6
eeschema/block_libedit.cpp
View File

@ -594,6 +594,9 @@ void MoveMarkedItems( EDA_LibComponentStruct* LibEntry, wxPoint offset )
( (LibDrawText*) item )->m_Pos.x += offset.x;
( (LibDrawText*) item )->m_Pos.y += offset.y;
break;
default:
;
}
item->m_Flags = item->m_Selected = 0;
@ -701,6 +704,9 @@ void MirrorMarkedItems( EDA_LibComponentStruct* LibEntry, wxPoint offset )
case COMPONENT_GRAPHIC_TEXT_DRAW_TYPE:
SETMIRROR( ( (LibDrawText*) item )->m_Pos.x );
break;
default:
;
}
item->m_Flags = item->m_Selected = 0;

2
eeschema/cmpclass.cpp
View File

@ -148,7 +148,7 @@ wxString DrawMarkerStruct::GetComment( void )
/***************************/
EDA_DrawLineStruct::EDA_DrawLineStruct( const wxPoint& pos, int layer ) :
EDA_BaseLineStruct( NULL, DRAW_SEGMENT_STRUCT_TYPE )
EDA_BaseStruct( NULL, DRAW_SEGMENT_STRUCT_TYPE )
{
m_Start = pos;
m_End = pos;

2
eeschema/component_class.cpp
View File

@ -23,7 +23,7 @@
/***************************/
/***********************************************************************************/
DrawPartStruct::DrawPartStruct( DrawStructureType struct_type, const wxPoint & pos):
DrawPartStruct::DrawPartStruct( KICAD_T struct_type, const wxPoint & pos):
EDA_BaseStruct(struct_type)
/***********************************************************************************/
{

2
eeschema/component_class.h
View File

@ -70,7 +70,7 @@ public:
wxPoint m_Pos; /* Exact position of part. */
public:
DrawPartStruct( DrawStructureType struct_type, const wxPoint & pos);
DrawPartStruct( KICAD_T struct_type, const wxPoint & pos);
~DrawPartStruct(void);
};

157
eeschema/dangling_ends.cpp
View File

@ -12,8 +12,7 @@
#include "netlist.h" /* Definitions generales liees au calcul de netliste */
#include "protos.h"
enum End_Type
{
enum End_Type {
UNKNOWN = 0,
WIRE_START_END,
WIRE_END_END,
@ -34,8 +33,7 @@ public:
int m_Type;
DanglingEndHandle* m_Pnext;
DanglingEndHandle(int type)
{
DanglingEndHandle( int type ) {
m_Item = NULL;
m_Type = type;
m_Pnext = NULL;
@ -54,8 +52,9 @@ DanglingEndHandle * RebuildEndList(EDA_BaseStruct *DrawList);
bool SegmentIntersect( int Sx1, int Sy1, int Sx2, int Sy2,
int Px1, int Py1 )
/**********************************************************/
/* Retourne TRUE si le point P est sur le segment S.
Le segment est suppose horizontal ou vertical.
* Le segment est suppose horizontal ou vertical.
*/
{
int Sxmin, Sxmax, Symin, Symax;
@ -63,26 +62,32 @@ int Sxmin, Sxmax, Symin, Symax;
if( Sx1 == Sx2 ) /* Line S is vertical. */
{
Symin = MIN( Sy1, Sy2 ); Symax = MAX( Sy1, Sy2 );
if (Px1 != Sx1) return FALSE;
if (Py1 >= Symin && Py1 <= Symax) return TRUE;
else return FALSE;
if( Px1 != Sx1 )
return FALSE;
if( Py1 >= Symin && Py1 <= Symax )
return TRUE;
else
return FALSE;
}
else if( Sy1 == Sy2 ) /* Line S is horizontal. */
{
Sxmin = MIN( Sx1, Sx2 ); Sxmax = MAX( Sx1, Sx2 );
if (Py1 != Sy1) return FALSE;
if (Px1 >= Sxmin && Px1 <= Sxmax) return TRUE;
else return FALSE;
if( Py1 != Sy1 )
return FALSE;
if( Px1 >= Sxmin && Px1 <= Sxmax )
return TRUE;
else
return FALSE;
}
else return FALSE; // Segments quelconques
else
return FALSE; // Segments quelconques
}
/******************************************************************************/
void WinEDA_SchematicFrame::TestDanglingEnds( EDA_BaseStruct* DrawList, wxDC* DC )
/******************************************************************************/
/* Met a jour les membres m_Dangling des wires, bus, labels
*/
{
@ -97,6 +102,7 @@ const DanglingEndHandle * DanglingItem, * nextitem;
}
ItemList = RebuildEndList( DrawList );
// Controle des elements
for( DrawItem = DrawList; DrawItem != NULL; DrawItem = DrawItem->Pnext )
{
@ -118,7 +124,8 @@ const DanglingEndHandle * DanglingItem, * nextitem;
TestWireForDangling( STRUCT, this, DC );
break;
}
if( STRUCT->m_Layer == LAYER_NOTES) break;
if( STRUCT->m_Layer == LAYER_NOTES )
break;
if( STRUCT->m_Layer == LAYER_BUS )
{
STRUCT->m_StartIsDangling =
@ -126,17 +133,22 @@ const DanglingEndHandle * DanglingItem, * nextitem;
break;
}
break;
default:
;
}
}
}
/********************************************************************/
LibDrawPin* WinEDA_SchematicFrame::LocatePinEnd( EDA_BaseStruct* DrawList,
const wxPoint& pos )
/********************************************************************/
/* Teste si le point de coordonnées pos est sur l'extrémité d'une PIN
retourne un pointeur sur la pin
NULL sinon
* retourne un pointeur sur la pin
* NULL sinon
*/
{
EDA_SchComponentStruct* DrawLibItem;
@ -144,11 +156,13 @@ LibDrawPin * Pin;
wxPoint pinpos;
Pin = LocateAnyPin( DrawList, pos, &DrawLibItem );
if( ! Pin ) return NULL;
if( !Pin )
return NULL;
pinpos = Pin->m_Pos;
if(DrawLibItem == NULL ) pinpos.y = -pinpos.y;
if( DrawLibItem == NULL )
pinpos.y = -pinpos.y;
else
{
@ -159,7 +173,8 @@ wxPoint pinpos;
+ DrawLibItem->m_Transform[1][1] * y1;
}
if( (pos.x == pinpos.x) && (pos.y == pinpos.y) ) return Pin;
if( (pos.x == pinpos.x) && (pos.y == pinpos.y) )
return Pin;
return NULL;
}
@ -175,22 +190,23 @@ bool Sdangstate = TRUE, Edangstate = TRUE;
for( terminal_item = ItemList; terminal_item != NULL;
terminal_item = terminal_item->m_Pnext )
{
if ( terminal_item->m_Item == DrawRef ) continue;
if( terminal_item->m_Item == DrawRef )
continue;
if ( (DrawRef->m_Start.x == terminal_item->m_Pos.x) &&
(DrawRef->m_Start.y == terminal_item->m_Pos.y) )
if( (DrawRef->m_Start.x == terminal_item->m_Pos.x)
&& (DrawRef->m_Start.y == terminal_item->m_Pos.y) )
Sdangstate = FALSE;
if ( (DrawRef->m_End.x == terminal_item->m_Pos.x) &&
(DrawRef->m_End.y == terminal_item->m_Pos.y) )
if( (DrawRef->m_End.x == terminal_item->m_Pos.x)
&& (DrawRef->m_End.y == terminal_item->m_Pos.y) )
Edangstate = FALSE;
if( (Sdangstate == FALSE) && (Edangstate == FALSE) )
break;
}
if ( (Sdangstate != DrawRef->m_StartIsDangling) ||
(Edangstate != DrawRef->m_EndIsDangling) )
if( (Sdangstate != DrawRef->m_StartIsDangling)
|| (Edangstate != DrawRef->m_EndIsDangling) )
{
if( DC )
RedrawOneStruct( frame->DrawPanel, DC, DrawRef, g_XorMode );
@ -201,6 +217,7 @@ bool Sdangstate = TRUE, Edangstate = TRUE;
}
}
/********************************************************/
void TestLabelForDangling( DrawTextStruct* label,
WinEDA_SchematicFrame* frame, wxDC* DC )
@ -212,14 +229,16 @@ bool dangstate = TRUE;
for( terminal_item = ItemList; terminal_item != NULL;
terminal_item = terminal_item->m_Pnext )
{
if ( terminal_item->m_Item == label ) continue;
if( terminal_item->m_Item == label )
continue;
switch( terminal_item->m_Type )
{
case PIN_END:
case LABEL_END:
case SHEET_LABEL_END:
if ( (label->m_Pos.x == terminal_item->m_Pos.x) &&
(label->m_Pos.y == terminal_item->m_Pos.y) )
if( (label->m_Pos.x == terminal_item->m_Pos.x)
&& (label->m_Pos.y == terminal_item->m_Pos.y) )
dangstate = FALSE;
break;
@ -241,7 +260,8 @@ bool dangstate = TRUE;
break;
}
if (dangstate == FALSE) break;
if( dangstate == FALSE )
break;
}
if( dangstate != label->m_IsDangling )
@ -259,12 +279,14 @@ bool dangstate = TRUE;
wxPoint ReturnPinPhysicalPosition( LibDrawPin* Pin,
EDA_SchComponentStruct* DrawLibItem )
/****************************************************/
/* Retourne la position physique de la pin, qui dépend de l'orientation
du composant */
* du composant */
{
wxPoint PinPos = Pin->m_Pos;
if(DrawLibItem == NULL ) PinPos.y = -PinPos.y;
if( DrawLibItem == NULL )
PinPos.y = -PinPos.y;
else
{
@ -297,28 +319,36 @@ EDA_BaseStruct * DrawItem;
#undef STRUCT
#define STRUCT ( (DrawGlobalLabelStruct*) DrawItem )
item = new DanglingEndHandle( LABEL_END );
item->m_Item = DrawItem;
item->m_Pos = STRUCT->m_Pos;
if ( lastitem ) lastitem->m_Pnext = item;
else StartList = item;
if( lastitem )
lastitem->m_Pnext = item;
else
StartList = item;
lastitem = item;
break;
case DRAW_SEGMENT_STRUCT_TYPE:
#undef STRUCT
#define STRUCT ( (EDA_DrawLineStruct*) DrawItem )
if( STRUCT->m_Layer == LAYER_NOTES ) break;
if( STRUCT->m_Layer == LAYER_NOTES )
break;
if( (STRUCT->m_Layer == LAYER_BUS) || (STRUCT->m_Layer == LAYER_WIRE) )
{
item = new DanglingEndHandle( (STRUCT->m_Layer == LAYER_BUS) ?
BUS_START_END : WIRE_START_END );
item->m_Item = DrawItem;
item->m_Pos = STRUCT->m_Start;
if ( lastitem ) lastitem->m_Pnext = item;
else StartList = item;
if( lastitem )
lastitem->m_Pnext = item;
else
StartList = item;
lastitem = item;
item = new DanglingEndHandle( (STRUCT->m_Layer == LAYER_BUS) ?
BUS_END_END : WIRE_END_END );
item->m_Item = DrawItem;
item->m_Pos = STRUCT->m_End;
lastitem->m_Pnext = item;
@ -330,10 +360,13 @@ EDA_BaseStruct * DrawItem;
#undef STRUCT
#define STRUCT ( (DrawJunctionStruct*) DrawItem )
item = new DanglingEndHandle( JUNCTION_END );
item->m_Item = DrawItem;
item->m_Pos = STRUCT->m_Pos;
if ( lastitem ) lastitem->m_Pnext = item;
else StartList = item;
if( lastitem )
lastitem->m_Pnext = item;
else
StartList = item;
lastitem = item;
break;
@ -341,12 +374,16 @@ EDA_BaseStruct * DrawItem;
#undef STRUCT
#define STRUCT ( (DrawBusEntryStruct*) DrawItem )
item = new DanglingEndHandle( ENTRY_END );
item->m_Item = DrawItem;
item->m_Pos = STRUCT->m_Pos;
if ( lastitem ) lastitem->m_Pnext = item;
else StartList = item;
if( lastitem )
lastitem->m_Pnext = item;
else
StartList = item;
lastitem = item;
item = new DanglingEndHandle( ENTRY_END );
item->m_Item = DrawItem;
item->m_Pos = STRUCT->m_End();
lastitem->m_Pnext = item;
@ -359,31 +396,37 @@ EDA_BaseStruct * DrawItem;
#define STRUCT ( (EDA_SchComponentStruct*) DrawItem )
EDA_LibComponentStruct* Entry;
Entry = FindLibPart( STRUCT->m_ChipName, wxEmptyString, FIND_ROOT );
if( Entry == NULL ) break;
if( Entry == NULL )
break;
LibEDA_BaseStruct* DrawLibItem = Entry->m_Drawings;
for( ; DrawLibItem != NULL; DrawLibItem = DrawLibItem->Next() )
{
if(DrawLibItem->m_StructType != COMPONENT_PIN_DRAW_TYPE) continue;
if( DrawLibItem->m_StructType != COMPONENT_PIN_DRAW_TYPE )
continue;
LibDrawPin* Pin = (LibDrawPin*) DrawLibItem;
if( Pin->m_Unit && DrawLibItem->m_Unit &&
(DrawLibItem->m_Unit != Pin->m_Unit) )
if( Pin->m_Unit && DrawLibItem->m_Unit
&& (DrawLibItem->m_Unit != Pin->m_Unit) )
continue;
if( Pin->m_Convert && DrawLibItem->m_Convert &&
(DrawLibItem->m_Convert != Pin->m_Convert) )
if( Pin->m_Convert && DrawLibItem->m_Convert
&& (DrawLibItem->m_Convert != Pin->m_Convert) )
continue;
item = new DanglingEndHandle( PIN_END );
item->m_Item = Pin;
item->m_Pos = ReturnPinPhysicalPosition( Pin, STRUCT );
if ( lastitem ) lastitem->m_Pnext = item;
else StartList = item;
if( lastitem )
lastitem->m_Pnext = item;
else
StartList = item;
lastitem = item;
}
break;
break;
}
case DRAW_SHEET_STRUCT_TYPE:
@ -394,16 +437,24 @@ EDA_BaseStruct * DrawItem;
while( pinsheet )
{
item = new DanglingEndHandle( SHEET_LABEL_END );
item->m_Item = pinsheet;
item->m_Pos = pinsheet->m_Pos;
if ( lastitem ) lastitem->m_Pnext = item;
else StartList = item;
if( lastitem )
lastitem->m_Pnext = item;
else
StartList = item;
lastitem = item;
pinsheet = (DrawSheetLabelStruct*) pinsheet->Pnext;
}
break;
}
default:
;
}
}
return StartList;
}

310
eeschema/eelibs_draw_components.cpp
View File

@ -21,17 +21,18 @@
/* Fonctions locales */
/* Descr component <DUMMY> used when a component is not found in library,
to draw a dummy shape*/
* 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
* 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 int s_ItemSelectColor = BROWN;
@ -53,11 +54,13 @@ static void CreateDummyCmp(void)
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( "??" );
@ -73,15 +76,16 @@ void DrawLibEntry(WinEDA_DrawPanel * panel,wxDC * DC,
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
* 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;
@ -99,24 +103,29 @@ wxPoint text_pos;
convert, DrawMode, Color );
/* Trace des 2 champs ref et value (Attention aux coord: la matrice
de transformation change de signe les coord Y */
* 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;
if( Color >= 0 )
color = Color;
else
color = UNVISIBLE_COLOR;
}
else {
if( Color >= 0) color = Color;
else color = ReturnLayerColor(LAYER_REFERENCEPART);
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("?");
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;
@ -130,13 +139,17 @@ int LineWidth = MAX(LibEntry->m_Prefix.m_Width, g_DrawMinimunLineWidth);
if( LibEntry->m_Name.m_Attributs & TEXT_NO_VISIBLE )
{
if( Color >= 0) color = Color;
else color = UNVISIBLE_COLOR;
if( Color >= 0 )
color = Color;
else
color = UNVISIBLE_COLOR;
}
else {
if( Color >= 0 ) color = Color;
else color = ReturnLayerColor(LAYER_VALUEPART);
else
{
if( Color >= 0 )
color = Color;
else
color = ReturnLayerColor( LAYER_VALUEPART );
}
text_pos.x = LibEntry->m_Name.m_Pos.x + posX;
@ -151,17 +164,23 @@ int LineWidth = MAX(LibEntry->m_Prefix.m_Width, g_DrawMinimunLineWidth);
for( Field = LibEntry->Fields; Field != NULL; Field = (LibDrawField*) Field->Pnext )
{
if( Field->m_Text.IsEmpty() ) return;
if ( (Field->m_Flags & IS_MOVED) != 0 ) continue;
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 = UNVISIBLE_COLOR;
if( Color >= 0 )
color = Color;
else
color = UNVISIBLE_COLOR;
}
else
{
if( Color >= 0) color = Color;
else color = ReturnLayerColor(LAYER_FIELDS);
if( Color >= 0 )
color = Color;
else
color = ReturnLayerColor( LAYER_FIELDS );
}
text_pos.x = Field->m_Pos.x + posX;
@ -178,9 +197,9 @@ int LineWidth = MAX(LibEntry->m_Prefix.m_Width, g_DrawMinimunLineWidth);
int len = 3 * panel->GetZoom();
GRLine( &panel->m_ClipBox, DC, posX, posY - len, posX, posY + len, 0, color );
GRLine( &panel->m_ClipBox, DC, posX - len, posY, posX + len, posY, 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... *
@ -195,7 +214,8 @@ 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();
if( DummyCmp == NULL )
CreateDummyCmp();
Entry = DummyCmp;
}
@ -206,7 +226,7 @@ bool dummy = FALSE;
DrawMode );
/* Trace des champs, avec placement et orientation selon orient. du
composant
* composant
*/
if( ( (m_Field[REFERENCE].m_Attributs & TEXT_NO_VISIBLE) == 0 )
@ -220,21 +240,24 @@ bool dummy = FALSE;
for( ii = VALUE; ii < NUMBER_OF_FIELDS; ii++ )
{
if (m_Field[ii].m_Flags & IS_MOVED) continue;
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
* 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;
@ -243,8 +266,10 @@ EDA_SchComponentStruct *DrawLibItem = (EDA_SchComponentStruct *) Field->m_Parent
int hjustify, vjustify;
int LineWidth = MAX( Field->m_Width, g_DrawMinimunLineWidth );
if( Field->m_Attributs & TEXT_NO_VISIBLE ) return;
if( Field->IsVoid() ) return;
if( Field->m_Attributs & TEXT_NO_VISIBLE )
return;
if( Field->IsVoid() )
return;
GRSetDrawMode( DC, DrawMode );
@ -261,15 +286,20 @@ int LineWidth = MAX(Field->m_Width, g_DrawMinimunLineWidth);
/* 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;
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;
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)*/
{
/* 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 )
@ -280,7 +310,8 @@ int LineWidth = MAX(Field->m_Width, g_DrawMinimunLineWidth);
color = ReturnLayerColor( LAYER_REFERENCEPART );
else if( Field->m_FieldId == VALUE )
color = ReturnLayerColor( LAYER_VALUEPART );
else color = ReturnLayerColor(LAYER_FIELDS);
else
color = ReturnLayerColor( LAYER_FIELDS );
if( !IsMulti || (Field->m_FieldId != REFERENCE) )
{
DrawGraphicText( panel, DC, pos, color, Field->m_Text.GetData(),
@ -288,9 +319,9 @@ int LineWidth = MAX(Field->m_Width, g_DrawMinimunLineWidth);
Field->m_Size,
hjustify, vjustify, LineWidth );
}
else /* Le champ est la reference, et il y a plusieurs parts par boitier */
{/* On ajoute alors A ou B ... a la reference */
{
/* 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(),
@ -304,18 +335,21 @@ int LineWidth = MAX(Field->m_Width, g_DrawMinimunLineWidth);
/********************************************************************************/
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
* 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. */
@ -333,7 +367,8 @@ LibraryStruct *Lib = g_LibraryList;
Lib = Lib->m_Pnext; continue;
}
}
if( Lib == NULL ) break;
if( Lib == NULL )
break;
Entry = (EDA_LibComponentStruct*) PQFind( Lib->m_Entries, &DummyEntry );
if( Entry != NULL )
{
@ -351,9 +386,10 @@ LibraryStruct *Lib = g_LibraryList;
Lib->m_Name, FIND_ROOT );
}
return (Entry);
return Entry;
}
/*****************************************************************************
* Routine to draw the given part at given position, transformed/mirror as
* specified, and in the given drawing mode.
@ -375,22 +411,28 @@ int CharColor;
int fill_option;
int SetHightColor;
int LineWidth;
//#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;
//#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( 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
if( DEntry->m_Flags & IS_MOVED )
continue; // Element en deplacement non trace
SetHightColor = (DEntry->m_Selected & IS_SELECTED) ? HIGHT_LIGHT_FLAG : 0;
LineWidth = MAX( DEntry->m_Width, g_DrawMinimunLineWidth );
switch( DEntry->m_StructType )
{
case COMPONENT_ARC_DRAW_TYPE:
@ -412,7 +454,10 @@ int LineWidth;
TransMat[1][1] * Arc->m_ArcEnd.y;
t1 = Arc->t1; t2 = Arc->t2;
bool swap = MapAngles( &t1, &t2, TransMat );
if ( swap ) { EXCHG(x1,x2); EXCHG(y1, y2) }
if( swap )
{
EXCHG( x1, x2 ); EXCHG( y1, y2 )
}
fill_option = Arc->m_Fill & (~g_PrintFillMask);
if( Color < 0 ) // Normal Color Layer
{
@ -424,18 +469,22 @@ int LineWidth;
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,
else
GRArc( &panel->m_ClipBox, DC, xc, yc, t1, t2,
Arc->m_Rayon, LineWidth, CharColor );
#else
else GRArc1(&panel->m_ClipBox, DC, x1, y1, x2, y2,
else
GRArc1( &panel->m_ClipBox, DC, x1, y1, x2, y2,
xc, yc, LineWidth, CharColor );
#endif
}
#ifdef DRAW_ARC_WITH_ANGLE
else GRArc(&panel->m_ClipBox, DC, xc, yc, t1, t2,
else
GRArc( &panel->m_ClipBox, DC, xc, yc, t1, t2,
Arc->m_Rayon, Circle->m_Width, CharColor );
#else
else GRArc1(&panel->m_ClipBox, DC, x1, y1, x2, y2,
else
GRArc1( &panel->m_ClipBox, DC, x1, y1, x2, y2,
xc, yc, Arc->m_Width, CharColor );
#endif
}
@ -459,10 +508,12 @@ int LineWidth;
else if( fill_option == FILLED_SHAPE )
GRFilledCircle( &panel->m_ClipBox, DC, x1, y1,
Circle->m_Rayon, 0, CharColor, CharColor );
else GRCircle(&panel->m_ClipBox, DC, x1, y1,
else
GRCircle( &panel->m_ClipBox, DC, x1, y1,
Circle->m_Rayon, LineWidth, CharColor );
}
else GRCircle(&panel->m_ClipBox, DC, x1, y1,
else
GRCircle( &panel->m_ClipBox, DC, x1, y1,
Circle->m_Rayon, LineWidth, CharColor );
}
break;
@ -473,7 +524,7 @@ int LineWidth;
CharColor = GETCOLOR( LAYER_DEVICE );
/* The text orientation may need to be flipped if the
transformation matrix cuases xy axes to be flipped. */
* 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;
@ -509,10 +560,12 @@ int LineWidth;
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,
else
GRRect( &panel->m_ClipBox, DC, x1, y1, x2, y2,
LineWidth, CharColor );
}
else GRRect(&panel->m_ClipBox, DC, x1, y1, x2, y2,
else
GRRect( &panel->m_ClipBox, DC, x1, y1, x2, y2,
LineWidth, CharColor );
}
break;
@ -522,8 +575,8 @@ int LineWidth;
LibDrawPin* Pin = (LibDrawPin*) DEntry;
if( Pin->m_Attributs & PINNOTDRAW )
{
if( (ActiveScreen->m_Type == SCHEMATIC_FRAME) &&
!g_ShowAllPins )
if( (ActiveScreen->m_Type == SCHEMATIC_FRAME)
&& !g_ShowAllPins )
break;
}
/* Calcul de l'orientation reelle de la Pin */
@ -542,6 +595,7 @@ int LineWidth;
if( DrawPinText )
{
wxPoint pinpos( x2, y2 );
CharColor = SetHightColor ? s_ItemSelectColor : Color;
Pin->DrawPinTexts( panel, DC, pinpos, orient,
Entry->m_TextInside,
@ -575,6 +629,7 @@ int LineWidth;
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 )
{
@ -585,10 +640,12 @@ int LineWidth;
else if( fill_option == FILLED_SHAPE )
GRPoly( &panel->m_ClipBox, DC, polyline->n,
Buf_Poly_Drawings, 1, LineWidth, CharColor, CharColor );
else GRPoly(&panel->m_ClipBox, DC, polyline->n,
else
GRPoly( &panel->m_ClipBox, DC, polyline->n,
Buf_Poly_Drawings, 0, LineWidth, CharColor, CharColor );
}
else GRPoly(&panel->m_ClipBox, DC, polyline->n,
else
GRPoly( &panel->m_ClipBox, DC, polyline->n,
Buf_Poly_Drawings, 0, LineWidth, CharColor, CharColor );
}
break;
@ -596,13 +653,19 @@ int LineWidth;
default:
wxBell();
break;
} /* Fin Switch */
} /* Fin Boucle de dessin */
}
/* 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);
if( Component )
BoundaryBox = Component->GetBoundaryBox();
else
BoundaryBox = Entry->GetBoundaryBox( Multi, convert );
x1 = BoundaryBox.GetX();
y1 = BoundaryBox.GetY();
x2 = BoundaryBox.GetRight();
@ -630,7 +693,7 @@ void LibDrawPin::DrawPinSymbol(WinEDA_DrawPanel * panel, wxDC * DC,
/*******************************************************************************/
/* Draw the pin symbol (without texts)
if Color != 0 draw with Color, eles with the normal pin color
* if Color != 0 draw with Color, eles with the normal pin color
*/
{
int MapX1, MapY1, x1, y1;
@ -639,23 +702,29 @@ int width = MAX(m_Width, g_DrawMinimunLineWidth);
int posX = pin_pos.x, posY = pin_pos.y, len = m_PinLen;
if( Color >= 0) color = Color;
else color = ReturnLayerColor(LAYER_PIN);
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;
@ -671,7 +740,6 @@ int posX = pin_pos.x, posY = pin_pos.y, len = m_PinLen;
MapY1 * INVERT_PIN_RADIUS * 2 + y1 );
GRLineTo( &panel->m_ClipBox, DC, posX, posY, width, color );
}
else
{
GRMoveTo( x1, y1 );
@ -718,12 +786,22 @@ int posX = pin_pos.x, posY = pin_pos.y, len = m_PinLen;
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, width, color);
GRLineTo( &panel->m_ClipBox,
DC,
x1 + MapX1 * IEEE_SYMBOL_PIN_DIM * 2,
y1,
width,
color );
}
else /* MapX1 = 0 */
{
GRMoveTo( x1 - IEEE_SYMBOL_PIN_DIM, y1 );
GRLineTo(&panel->m_ClipBox, DC, x1 , y1 + MapY1 * IEEE_SYMBOL_PIN_DIM*2, width, color);
GRLineTo( &panel->m_ClipBox,
DC,
x1,
y1 + MapY1 * IEEE_SYMBOL_PIN_DIM * 2,
width,
color );
}
}
@ -773,7 +851,8 @@ bool swap = FALSE;
NORMALIZE_ANGLE( *Angle1 );
NORMALIZE_ANGLE( *Angle2 );
if (*Angle2 < *Angle1) *Angle2 += 3600;
if( *Angle2 < *Angle1 )
*Angle2 += 3600;
if( *Angle2 - *Angle1 > 1800 )
{ /* Need to swap the two angles. */
@ -783,7 +862,8 @@ bool swap = FALSE;
NORMALIZE_ANGLE( *Angle1 );
NORMALIZE_ANGLE( *Angle2 );
if (*Angle2 < *Angle1) *Angle2 += 3600;
if( *Angle2 < *Angle1 )
*Angle2 += 3600;
swap = TRUE;
}
@ -811,9 +891,9 @@ 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) */
@ -860,7 +940,10 @@ int fill_option;
x1 = PartX + Arc->m_ArcEnd.x;
y1 = PartY - Arc->m_ArcEnd.y;
if ( swap ) { EXCHG(x1,x2); EXCHG(y1, y2)}
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,
@ -870,10 +953,12 @@ int fill_option;
GRFilledArc( &panel->m_ClipBox, DC, xc, yc, t1, t2,
Arc->m_Rayon, LineWidth, CharColor, CharColor );
#ifdef DRAW_ARC_WITH_ANGLE
else GRArc(&panel->m_ClipBox, DC, xc, yc, t1, t2,
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,
else
GRArc1( &panel->m_ClipBox, DC, x1, y1, x2, y2,
xc, yc, LineWidth, CharColor );
#endif
}
@ -892,7 +977,8 @@ int fill_option;
else if( fill_option == FILLED_SHAPE )
GRFilledCircle( &panel->m_ClipBox, DC, x1, y1,
Circle->m_Rayon, 0, CharColor, CharColor );
else GRCircle(&panel->m_ClipBox, DC, x1, y1,
else
GRCircle( &panel->m_ClipBox, DC, x1, y1,
Circle->m_Rayon, LineWidth, CharColor );
}
break;
@ -924,7 +1010,8 @@ int fill_option;
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, LineWidth,
else
GRRect( &panel->m_ClipBox, DC, x1, y1, x2, y2, LineWidth,
CharColor );
}
break;
@ -938,11 +1025,14 @@ int fill_option;
orient = Pin->ReturnPinDrawOrient( TransMat );
/* Dessin de la pin et du symbole special associe */
if( Pin->m_Attributs & PINNOTDRAW) CharColor = DARKGRAY;
else CharColor = -1;
if( Pin->m_Attributs & PINNOTDRAW )
CharColor = DARKGRAY;
else
CharColor = -1;
Pin->DrawPinSymbol( panel, DC, wxPoint( x2, y2 ), orient, DrawMode );
wxPoint pinpos( x2, y2 );
Pin->DrawPinTexts( panel, DC, pinpos, orient,
LibEntry->m_TextInside,
LibEntry->m_DrawPinNum, LibEntry->m_DrawPinName,
@ -969,6 +1059,7 @@ int fill_option;
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,
@ -977,10 +1068,13 @@ int fill_option;
else if( fill_option == FILLED_SHAPE )
GRPoly( &panel->m_ClipBox, DC, polyline->n,
Buf_Poly_Drawings, 1, LineWidth, CharColor, CharColor );
else GRPoly(&panel->m_ClipBox, DC, polyline->n,
else
GRPoly( &panel->m_ClipBox, DC, polyline->n,
Buf_Poly_Drawings, 0, LineWidth, CharColor, CharColor );
break;
}
}
}
default:
;
}
}

357
eeschema/eelibs_read_libraryfiles.cpp
View File

@ -69,17 +69,21 @@ wxString FullFileName;
}
NewLib = new LibraryStruct( LIBRARY_TYPE_EESCHEMA, LibName, FullLibName );
Entries = LoadLibraryAux( frame, NewLib, f, &NumOfParts );
if( Entries != NULL )
{
NewLib->m_Entries = Entries;
NewLib->m_NumOfParts = NumOfParts;
if ( g_LibraryList == NULL ) g_LibraryList = NewLib;
if( g_LibraryList == NULL )
g_LibraryList = NewLib;
else
{
LibraryStruct* tmplib = g_LibraryList;
while ( tmplib->m_Pnext ) tmplib = tmplib->m_Pnext;
while( tmplib->m_Pnext )
tmplib = tmplib->m_Pnext;
tmplib->m_Pnext = NewLib;
}
@ -87,7 +91,8 @@ wxString FullFileName;
ChangeFileNameExt( FullFileName, DOC_EXT );
LoadDocLib( frame, FullFileName, NewLib->m_Name );
}
else delete NewLib;
else
delete NewLib;
fclose( f );
return NewLib;
@ -97,8 +102,9 @@ wxString FullFileName;
/******************************************/
void LoadLibraries( WinEDA_DrawFrame* frame )
/******************************************/
/* Delete toutes les librairies chargees et recree toutes les librairies
donnes dans la liste g_LibName_List
* donnes dans la liste g_LibName_List
*/
{
wxString FullLibName, msg;
@ -112,13 +118,15 @@ LibraryStruct *nextlib, *lib = g_LibraryList;
for( ; lib != NULL; lib = nextlib )
{
nextlib = lib->m_Pnext;
if ( lib->m_IsLibCache ) continue;
if( lib->m_IsLibCache )
continue;
wxString libname = lib->m_Name;
// is this library in "wanted list" g_LibName_List ?
int test = g_LibName_List.Index( libname );
if ( test == wxNOT_FOUND ) FreeCmpLibrary(frame, libname);
if( test == wxNOT_FOUND )
FreeCmpLibrary( frame, libname );
}
// Load missing libraries (if any)
@ -126,7 +134,8 @@ LibraryStruct *nextlib, *lib = g_LibraryList;
{
LibName = g_LibName_List[ii];
if( LibName.IsEmpty() ) continue;
if( LibName.IsEmpty() )
continue;
FullLibName = MakeFileName( g_RealLibDirBuffer, LibName, g_LibExtBuffer );
msg = wxT( "Loading " ) + FullLibName;
if( LoadLibraryName( frame, FullLibName, LibName ) )
@ -143,7 +152,9 @@ LibraryStruct *nextlib, *lib = g_LibraryList;
lib->m_Flags = 0;
NumOfLibs++;
}
if ( NumOfLibs == 0 ) return;
if( NumOfLibs == 0 )
return;
LibraryStruct** libs =
(LibraryStruct**) MyZMalloc( sizeof(LibraryStruct *) * (NumOfLibs + 2) );
@ -151,7 +162,8 @@ LibraryStruct *nextlib, *lib = g_LibraryList;
int jj = 0;
for( ii = 0; ii < g_LibName_List.GetCount(); ii++ )
{
if ( jj >= NumOfLibs ) break;
if( jj >= NumOfLibs )
break;
lib = FindLibrary( g_LibName_List[ii] );
if( lib )
{
@ -159,11 +171,14 @@ LibraryStruct *nextlib, *lib = g_LibraryList;
libs[jj++] = lib;
}
}
/* Put lib cache at end of list */
for( lib = g_LibraryList; lib != NULL; lib = lib->m_Pnext )
{
if ( lib->m_Flags == 0 ) libs[jj++] = lib;
if( lib->m_Flags == 0 )
libs[jj++] = lib;
}
libs[jj] = NULL;
/* Change the linked list pointers */
@ -178,6 +193,7 @@ LibraryStruct *nextlib, *lib = g_LibraryList;
lib->m_Flags = 0;
}
/*****************************************************************************
* Routine to free a library from the current loaded libraries. *
*****************************************************************************/
@ -195,29 +211,37 @@ LibraryStruct *Lib, *TempLib;
/* Search for this library name: */
for( Lib = g_LibraryList; Lib != NULL; Lib = Lib->m_Pnext )
{
if (LibName == Lib->m_Name) break;
if( LibName == Lib->m_Name )
break;
}
if (Lib == NULL) return;
if( Lib == NULL )
return;
if ( Lib == g_LibraryList) g_LibraryList = Lib->m_Pnext;
if( Lib == g_LibraryList )
g_LibraryList = Lib->m_Pnext;
else
{
for( TempLib = g_LibraryList; TempLib->m_Pnext != Lib; TempLib=TempLib->m_Pnext);
for( TempLib = g_LibraryList; TempLib->m_Pnext != Lib; TempLib = TempLib->m_Pnext )
;
TempLib->m_Pnext = TempLib->m_Pnext->m_Pnext;
}
delete Lib;
/* La librairie supprimee est peut etre celle selectee dans libedit */
if ( Lib == CurrentLib ) CurrentLib = NULL;
if( Lib == CurrentLib )
CurrentLib = NULL;
}
/******************************/
const wxChar** GetLibNames( void )
/******************************/
/* Routine to return pointers to all library names.
User is responsible to deallocate memory
* User is responsible to deallocate memory
*/
{
int ii, NumOfLibs = NumOfLibraries();
@ -229,6 +253,7 @@ LibraryStruct *Lib;
{
Names[ii] = Lib->m_Name.GetData();
}
Names[ii] = NULL;
return Names;
@ -244,10 +269,12 @@ int LibraryEntryCompare(EDA_LibComponentStruct *LE1, EDA_LibComponentStruct *LE2
return LE1->m_Name.m_Text.CmpNoCase( LE2->m_Name.m_Text );
}
/*****************************************************************************
* Routine to load a library from given open file. *
*****************************************************************************/
PriorQue *LoadLibraryAux(WinEDA_DrawFrame * frame, LibraryStruct * Library, FILE *libfile, int *NumOfParts)
PriorQue* LoadLibraryAux( WinEDA_DrawFrame* frame, LibraryStruct* Library, FILE* libfile,
int* NumOfParts )
{
int LineNum = 0;
char Line[1024];
@ -273,7 +300,8 @@ wxBusyCursor ShowWait; // Display a Busy Cursor..
return NULL;
}
if ( Library ) Library->m_Header = CONV_FROM_UTF8(Line);
if( Library )
Library->m_Header = CONV_FROM_UTF8( Line );
PQInit( &PQ );
PQCompFunc( (PQCompFuncType) LibraryEntryCompare );
@ -315,6 +343,7 @@ wxBusyCursor ShowWait; // Display a Busy Cursor..
EDA_LibComponentStruct* Read_Component_Definition( WinEDA_DrawFrame* frame, char* Line,
FILE* f, int* LineNum )
/*********************************************************************************************/
/* Routine to Read a DEF/ENDDEF part entry from given open file.
*/
{
@ -337,36 +366,38 @@ wxString Msg;
char drawnum = 0, drawname = 0;
LibEntry = new EDA_LibComponentStruct( NULL );
if ((Name = strtok(NULL, " \t\n")) == NULL || /* Part name: */
(Prefix = strtok(NULL, " \t\n")) == NULL || /* Prefix name: */
(p = strtok(NULL, " \t\n")) == NULL || /* NumOfPins: */
sscanf(p, "%d", &unused) != 1 ||
(p = strtok(NULL, " \t\n")) == NULL || /* TextInside: */
sscanf(p, "%d", &LibEntry->m_TextInside) != 1 ||
(p = strtok(NULL, " \t\n")) == NULL || /* DrawNums: */
sscanf(p, "%c", &drawnum) != 1 ||
(p = strtok(NULL, " \t\n")) == NULL || /* DrawNums: */
sscanf(p, "%c", &drawname) != 1 ||
(p = strtok(NULL, " \t\n")) == NULL || /* m_UnitCount: */
sscanf(p, "%d", &LibEntry->m_UnitCount) != 1 )
if( ( Name = strtok( NULL, " \t\n" ) ) == NULL /* Part name: */
|| ( Prefix = strtok( NULL, " \t\n" ) ) == NULL /* Prefix name: */
|| ( p = strtok( NULL, " \t\n" ) ) == NULL /* NumOfPins: */
|| sscanf( p, "%d", &unused ) != 1
|| ( p = strtok( NULL, " \t\n" ) ) == NULL /* TextInside: */
|| sscanf( p, "%d", &LibEntry->m_TextInside ) != 1
|| ( p = strtok( NULL, " \t\n" ) ) == NULL /* DrawNums: */
|| sscanf( p, "%c", &drawnum ) != 1
|| ( p = strtok( NULL, " \t\n" ) ) == NULL /* DrawNums: */
|| sscanf( p, "%c", &drawname ) != 1
|| ( p = strtok( NULL, " \t\n" ) ) == NULL /* m_UnitCount: */
|| sscanf( p, "%d", &LibEntry->m_UnitCount ) != 1 )
{
Msg.Printf( wxT( "Wrong DEF format in line %d, skipped." ), *LineNum );
DisplayError( frame, Msg );
while( GetLine( f, Line, LineNum, 1024 ) )
{
p = strtok( Line, " \t\n" );
if (stricmp(p, "ENDDEF") == 0) break;
}
return NULL;
if( stricmp( p, "ENDDEF" ) == 0 )
break;
}
return NULL;
}
else /* Mise a jour des infos de la ligne "DEF" */
{
LibEntry->m_DrawPinNum = (drawnum == 'N') ? FALSE : TRUE;
LibEntry->m_DrawPinName = (drawname == 'N') ? FALSE : TRUE;
/* Copy part name and prefix. */
strupper( Name );
if(Name[0] != '~') LibEntry->m_Name.m_Text = CONV_FROM_UTF8(Name);
if( Name[0] != '~' )
LibEntry->m_Name.m_Text = CONV_FROM_UTF8( Name );
else
{
LibEntry->m_Name.m_Text = CONV_FROM_UTF8( &Name[1] );
@ -378,16 +409,19 @@ wxString Msg;
LibEntry->m_Prefix.m_Text.Empty();
LibEntry->m_Prefix.m_Attributs |= TEXT_NO_VISIBLE;
}
else LibEntry->m_Prefix.m_Text = CONV_FROM_UTF8(Prefix);
else
LibEntry->m_Prefix.m_Text = CONV_FROM_UTF8( Prefix );
// Copy optional infos
if( ( p = strtok( NULL, " \t\n" ) ) != NULL ) // m_UnitSelectionLocked param
{
if ( *p == 'L') LibEntry->m_UnitSelectionLocked = TRUE;
if( *p == 'L' )
LibEntry->m_UnitSelectionLocked = TRUE;
}
if( ( p = strtok( NULL, " \t\n" ) ) != NULL ) /* Type Of Component */
{
if ( *p == 'P') LibEntry->m_Options = ENTRY_POWER;
if( *p == 'P' )
LibEntry->m_Options = ENTRY_POWER;
}
}
@ -401,33 +435,27 @@ wxString Msg;
{
Res = ReadLibEntryDateAndTime( LibEntry, Line );
}
else if( Line[0] == 'F' )
{
Res = GetLibEntryField( LibEntry, Line );
}
else if( strcmp( p, "ENDDEF" ) == 0 )
{
break;
}
else if( strcmp( p, "DRAW" ) == 0 )
{
LibEntry->m_Drawings = GetDrawEntry( frame, f, Line, LineNum );
}
else if( strncmp( p, "ALIAS", 5 ) == 0 )
{
p = strtok( NULL, "\r\n" );
Res = AddAliasNames( LibEntry, p );
}
else if( strncmp( p, "$FPLIST", 5 ) == 0 )
{
Res = AddFootprintFilterList( LibEntry, f, Line, LineNum );
}
else
{
Msg.Printf( wxT( "Undefined command \"%s\" in line %d, skipped." ), p, *LineNum );
@ -450,7 +478,6 @@ wxString Msg;
}
/*****************************************************************************
* Routine to load a DRAW definition from given file. Note "DRAW" line has *
* been read already. Reads upto and include ENDDRAW, or an error (NULL ret). *
@ -489,16 +516,20 @@ LibEDA_BaseStruct *Tail = NULL,
{
int startx, starty, endx, endy;
LibDrawArc* Arc = new LibDrawArc();
New = Arc;
ll = 0;
int nbarg = sscanf( &Line[2], "%d %d %d %d %d %d %d %d %s %d %d %d %d",
&Arc->m_Pos.x, &Arc->m_Pos.y, &Arc->m_Rayon,
&Arc->t1, &Arc->t2, &Unit, &Convert,
&Arc->m_Width, chartmp, &startx, &starty, &endx, &endy );
if ( nbarg < 8 ) Error = TRUE;
if( nbarg < 8 )
Error = TRUE;
Arc->m_Unit = Unit; Arc->m_Convert = Convert;
if ( chartmp[0] == 'F') Arc->m_Fill = FILLED_SHAPE;
if ( chartmp[0] == 'f') Arc->m_Fill = FILLED_WITH_BG_BODYCOLOR;
if( chartmp[0] == 'F' )
Arc->m_Fill = FILLED_SHAPE;
if( chartmp[0] == 'f' )
Arc->m_Fill = FILLED_WITH_BG_BODYCOLOR;
NORMALIZE_ANGLE( Arc->t1 );
NORMALIZE_ANGLE( Arc->t2 );
@ -523,20 +554,24 @@ LibEDA_BaseStruct *Tail = NULL,
case 'C': /* Circle */
{
LibDrawCircle* Circle = new LibDrawCircle();
New = Circle; ll = 0;
Error = sscanf( &Line[2], "%d %d %d %d %d %d %s",
&Circle->m_Pos.x, &Circle->m_Pos.y, &Circle->m_Rayon,
&Unit, &Convert, &Circle->m_Width, chartmp ) < 6;
Circle->m_Unit = Unit;
Circle->m_Convert = Convert;
if ( chartmp[0] == 'F') Circle->m_Fill = FILLED_SHAPE;
if ( chartmp[0] == 'f') Circle->m_Fill = FILLED_WITH_BG_BODYCOLOR;
if( chartmp[0] == 'F' )
Circle->m_Fill = FILLED_SHAPE;
if( chartmp[0] == 'f' )
Circle->m_Fill = FILLED_WITH_BG_BODYCOLOR;
}
break;
case 'T': /* Text */
{
LibDrawText* Text = new LibDrawText();
New = Text;
Buffer[0] = 0;
Error = sscanf( &Line[2], "%d %d %d %d %d %d %d %s",
@ -558,14 +593,17 @@ LibEDA_BaseStruct *Tail = NULL,
case 'S': /* Square */
{
LibDrawSquare* Square = new LibDrawSquare();
New = Square; ll = 0;
Error = sscanf( &Line[2], "%d %d %d %d %d %d %d %s",
&Square->m_Pos.x, &Square->m_Pos.y,
&Square->m_End.x, &Square->m_End.y,
&Unit, &Convert, &Square->m_Width, chartmp ) < 7;
Square->m_Unit = Unit; Square->m_Convert = Convert;
if ( chartmp[0] == 'F') Square->m_Fill = FILLED_SHAPE;
if ( chartmp[0] == 'f') Square->m_Fill = FILLED_WITH_BG_BODYCOLOR;
if( chartmp[0] == 'F' )
Square->m_Fill = FILLED_SHAPE;
if( chartmp[0] == 'f' )
Square->m_Fill = FILLED_WITH_BG_BODYCOLOR;
}
break;
@ -573,6 +611,7 @@ LibEDA_BaseStruct *Tail = NULL,
{
*Buffer = 0;
LibDrawPin* Pin = new LibDrawPin();
New = Pin;
i = sscanf( Line + 2, "%s %s %d %d %d %s %d %d %d %d %s %s",
BufName, PinNum,
@ -593,62 +632,88 @@ LibEDA_BaseStruct *Tail = NULL,
Pin->m_PinName = CONV_FROM_UTF8( BufName );
jj = *chartmp & 255;
switch( jj )
{
case 'I':
Pin->m_PinType = PIN_INPUT; break;
case 'O':
Pin->m_PinType = PIN_OUTPUT; break;
case 'B':
Pin->m_PinType = PIN_BIDI; break;
case 'T':
Pin->m_PinType = PIN_TRISTATE; break;
case 'P':
Pin->m_PinType = PIN_PASSIVE; break;
case 'U':
Pin->m_PinType = PIN_UNSPECIFIED; break;
case 'W':
Pin->m_PinType = PIN_POWER_IN; break;
case 'w':
Pin->m_PinType = PIN_POWER_OUT; break;
case 'C':
Pin->m_PinType = PIN_OPENCOLLECTOR; break;
case 'E':
Pin->m_PinType = PIN_OPENEMITTER; break;
default:
MsgLine.Printf( wxT( "Unknown Pin Type [%c] line %d" ),
jj, *LineNum );
DisplayError( frame, MsgLine );
}
if( i == 12 ) /* Special Symbole defined */
for( jj = strlen( Buffer ); jj > 0; )
{
switch( Buffer[--jj] )
{
case '~': break;
case 'N': Pin->m_Attributs |= PINNOTDRAW; break;
case 'I': Pin->m_PinShape |= INVERT; break;
case 'C': Pin->m_PinShape |= CLOCK; break;
case 'L': Pin->m_PinShape |= LOWLEVEL_IN; break;
case 'V': Pin->m_PinShape |= LOWLEVEL_OUT; break;
case '~':
break;
case 'N':
Pin->m_Attributs |= PINNOTDRAW; break;
case 'I':
Pin->m_PinShape |= INVERT; break;
case 'C':
Pin->m_PinShape |= CLOCK; break;
case 'L':
Pin->m_PinShape |= LOWLEVEL_IN; break;
case 'V':
Pin->m_PinShape |= LOWLEVEL_OUT; break;
default:
MsgLine.Printf( wxT( "Unknown Pin Shape [%c] line %d" ),
Buffer[jj], *LineNum );
DisplayError( frame, MsgLine ); break;
}
}
}
break;
case 'P': /* Polyline */
{
LibDrawPolyline* Polyl = new LibDrawPolyline();
New = Polyl;
if( sscanf( &Line[2], "%d %d %d %d",
&Polyl->n, &Unit, &Convert,
&Polyl->m_Width) == 4 &&
Polyl->n > 0)
&Polyl->m_Width ) == 4
&& Polyl->n > 0 )
{
Polyl->m_Unit = Unit; Polyl->m_Convert = Convert;
@ -665,16 +730,18 @@ LibEDA_BaseStruct *Tail = NULL,
p = strtok( NULL, " \t\n" );
Error = sscanf( p, "%d", &Polyl->PolyList[i] ) != 1;
}
Polyl->m_Fill = NO_FILL;
if( ( p = strtok( NULL, " \t\n" ) ) != NULL )
{
if ( p[0] == 'F') Polyl->m_Fill = FILLED_SHAPE;
if( p[0] == 'F' )
Polyl->m_Fill = FILLED_SHAPE;
if( p[0] == 'f' )
Polyl->m_Fill = FILLED_WITH_BG_BODYCOLOR;
}
}
else Error = TRUE;
else
Error = TRUE;
}
break;
@ -691,6 +758,7 @@ LibEDA_BaseStruct *Tail = NULL,
Line[0], *LineNum );
DisplayError( frame, MsgLine );
delete New;
/* FLush till end of draw: */
do {
if( GetLine( f, Line, LineNum, 1024 ) == NULL )
@ -699,12 +767,13 @@ LibEDA_BaseStruct *Tail = NULL,
return Head;
}
} while( strncmp( Line, "ENDDRAW", 7 ) != 0 );
return (Head);
}
return Head;
}
else
{
if (Head == NULL) Head = Tail = New;
if( Head == NULL )
Head = Tail = New;
else
{
Tail->Pnext = New; Tail = New;
@ -725,12 +794,15 @@ LibraryStruct *Lib = g_LibraryList;
while( Lib )
{
if (Lib->m_Name == Name ) return Lib;
if( Lib->m_Name == Name )
return Lib;
Lib = Lib->m_Pnext;
}
return NULL;
}
/*****************************************************************************
* Routine to find the number of libraries currently loaded. *
*****************************************************************************/
@ -739,7 +811,9 @@ int NumOfLibraries(void)
int ii;
LibraryStruct* Lib = g_LibraryList;
for (ii = 0; Lib != NULL; Lib = Lib->m_Pnext) ii++;
for( ii = 0; Lib != NULL; Lib = Lib->m_Pnext )
ii++;
return ii;
}
@ -747,9 +821,10 @@ LibraryStruct *Lib = g_LibraryList;
/*****************************************************************************/
static bool GetLibEntryField( EDA_LibComponentStruct* LibEntry, char* line )
/*****************************************************************************/
/* Analyse la ligne de description du champ de la forme:
Fn "CA3130" 150 -200 50 H V
ou n = 0 (REFERENCE), 1 (VALUE) , 2 .. 11 = autres champs, facultatifs
* Fn "CA3130" 150 -200 50 H V
* ou n = 0 (REFERENCE), 1 (VALUE) , 2 .. 11 = autres champs, facultatifs
*/
{
int posx, posy, size, orient, hjustify, vjustify;
@ -761,36 +836,53 @@ char *Text,
int NumOfField, nbparam;
LibDrawField* Field = NULL;
if( sscanf(line+1, "%d", &NumOfField) != 1) return(0);
if( sscanf( line + 1, "%d", &NumOfField ) != 1 )
return 0;
/* Recherche du debut des donnees (debut du texte suivant) */
while(*line != 0) line++;
while(*line == 0) line++;
while( *line != 0 )
line++;
while( *line == 0 )
line++;
/* recherche du texte */
while ( *line && (*line != '"') ) line++;
if ( *line == 0 ) return(0);
while( *line && (*line != '"') )
line++;
if( *line == 0 )
return 0;
line++; Text = line;
/* recherche fin de texte */
while ( *line && (*line != '"') ) line++;
if ( *line == 0 ) return(0);
while( *line && (*line != '"') )
line++;
if( *line == 0 )
return 0;
*line = 0; line++;
FieldUserName[0] = 0;
nbparam = sscanf( line, " %d %d %d %c %c %c %c",
&posx, &posy, &size, Char1, Char2, Char3, Char4 );
orient = TEXT_ORIENT_HORIZ; if(Char1[0] == 'V') orient = TEXT_ORIENT_VERT;
draw = TRUE; if(Char2[0] == 'I') draw = FALSE;
orient = TEXT_ORIENT_HORIZ; if( Char1[0] == 'V' )
orient = TEXT_ORIENT_VERT;
draw = TRUE; if( Char2[0] == 'I' )
draw = FALSE;
hjustify = GR_TEXT_HJUSTIFY_CENTER;
vjustify = GR_TEXT_VJUSTIFY_CENTER;
if( nbparam >= 6 )
{
if ( *Char3 == 'L' ) hjustify = GR_TEXT_HJUSTIFY_LEFT;
else if ( *Char3 == 'R' ) hjustify = GR_TEXT_HJUSTIFY_RIGHT;
if ( *Char4 == 'B' ) vjustify = GR_TEXT_VJUSTIFY_BOTTOM;
else if ( *Char4 == 'T' ) vjustify = GR_TEXT_VJUSTIFY_TOP;
if( *Char3 == 'L' )
hjustify = GR_TEXT_HJUSTIFY_LEFT;
else if( *Char3 == 'R' )
hjustify = GR_TEXT_HJUSTIFY_RIGHT;
if( *Char4 == 'B' )
vjustify = GR_TEXT_VJUSTIFY_BOTTOM;
else if( *Char4 == 'T' )
vjustify = GR_TEXT_VJUSTIFY_TOP;
}
switch( NumOfField )
{
case REFERENCE:
@ -804,18 +896,22 @@ LibDrawField * Field = NULL;
break;
default:
if(NumOfField >= NUMBER_OF_FIELDS ) break;
if( NumOfField >= NUMBER_OF_FIELDS )
break;
Field = new LibDrawField( NumOfField );
Field->Pnext = LibEntry->Fields;
LibEntry->Fields = Field;
break;
}
if ( Field == NULL ) return FALSE;
if( Field == NULL )
return FALSE;
Field->m_Pos.x = posx; Field->m_Pos.y = posy;
Field->m_Orient = orient;
if( draw == FALSE ) Field->m_Attributs |= TEXT_NO_VISIBLE;
if( draw == FALSE )
Field->m_Attributs |= TEXT_NO_VISIBLE;
Field->m_Size.x = Field->m_Size.y = size;
Field->m_Text = CONV_FROM_UTF8( Text );
if( NumOfField >= FIELD1 )
@ -825,19 +921,21 @@ LibDrawField * Field = NULL;
}
Field->m_HJustify = hjustify;
Field->m_VJustify = vjustify;
return(TRUE);
return TRUE;
}
/********************************************************************/
static bool AddAliasNames( EDA_LibComponentStruct* LibEntry, char* line )
/********************************************************************/
/* Read the alias names (in buffer line) and add them in alias list
names are separated by spaces
* names are separated by spaces
*/
{
char* text;
wxString name;
text = strtok( line, " \t\r\n" );
while( text )
@ -846,9 +944,11 @@ wxString name;
LibEntry->m_AliasList.Add( name );
text = strtok( NULL, " \t\r\n" );
}
return( TRUE );
return TRUE;
}
/********************************************************************/
static void InsertAlias( PriorQue** PQ, EDA_LibComponentStruct* LibEntry,
int* NumOfParts )
@ -865,11 +965,13 @@ unsigned ii;
{
AliasEntry = new EDA_LibCmpAliasStruct( LibEntry->m_AliasList[ii],
LibEntry->m_Name.m_Text.GetData() );
++ * NumOfParts;
PQInsert( PQ, AliasEntry );
}
}
/*******************************************************/
/* Routines de lecture des Documentation de composants */
/*******************************************************/
@ -886,7 +988,8 @@ FILE * f;
wxString msg;
f = wxFopen( FullDocLibName, wxT( "rt" ) );
if (f == NULL) return(0);
if( f == NULL )
return 0;
if( GetLine( f, Line, &LineNum, sizeof(Line) ) == NULL )
{ /* pas de lignes utiles */
@ -917,24 +1020,30 @@ wxString msg;
Entry = FindLibPart( cmpname.GetData(), Libname, FIND_ALIAS );
while( GetLine( f, Line, &LineNum, sizeof(Line) ) )
{
if( strncmp(Line, "$ENDCMP",7) == 0) break;
if( strncmp( Line, "$ENDCMP", 7 ) == 0 )
break;
Text = strtok( Line + 2, "\n\r" );
switch( Line[0] )
{
case 'D':
if(Entry) Entry->m_Doc = CONV_FROM_UTF8(Text);
if( Entry )
Entry->m_Doc = CONV_FROM_UTF8( Text );
break;
case 'K':
if(Entry) Entry->m_KeyWord = CONV_FROM_UTF8(Text);
if( Entry )
Entry->m_KeyWord = CONV_FROM_UTF8( Text );
break;
case 'F':
if(Entry) Entry->m_DocFile = CONV_FROM_UTF8(Text);
if( Entry )
Entry->m_DocFile = CONV_FROM_UTF8( Text );
break;
}
}
}
fclose( f );
return 1;
}
@ -943,8 +1052,9 @@ wxString msg;
/*********************************************************************************/
static bool ReadLibEntryDateAndTime( EDA_LibComponentStruct* LibEntry, char* Line )
/*********************************************************************************/
/* lit date et time de modif composant sous le format:
"Ti yy/mm/jj hh:mm:ss"
* "Ti yy/mm/jj hh:mm:ss"
*/
{
int year, mon, day, hour, min, sec;
@ -966,22 +1076,27 @@ char * text;
return TRUE;
}
/*******************************************/
static int SortItemsFct( const void* ref, const void* item );
void EDA_LibComponentStruct::SortDrawItems( void )
/*******************************************/
/* Trie les éléments graphiques d'un composant lib pour améliorer
le tracé:
items remplis en premier, pins en dernier
En cas de superposition d'items, c'est plus lisible
* le tracé:
* items remplis en premier, pins en dernier
* En cas de superposition d'items, c'est plus lisible
*/
{
LibEDA_BaseStruct** Bufentry, ** BufentryBase, * Entry = m_Drawings;
int ii, nbitems;
if(Entry == NULL ) return; /* Pas d'alias pour ce composant */
if( Entry == NULL )
return; /* Pas d'alias pour ce composant */
/* calcul du nombre d'items */
for( nbitems = 0; Entry != NULL; Entry = Entry->Next()) nbitems++;
for( nbitems = 0; Entry != NULL; Entry = Entry->Next() )
nbitems++;
BufentryBase =
(LibEDA_BaseStruct**) MyZMalloc( (nbitems + 1) * sizeof(LibEDA_BaseStruct *) );
@ -993,7 +1108,7 @@ int ii, nbitems;
qsort( BufentryBase, nbitems, sizeof(LibEDA_BaseStruct *), SortItemsFct );
/* Mise a jour du chainage. Remarque:
le dernier element de BufEntryBase (BufEntryBase[nbitems]) est NULL*/
* le dernier element de BufEntryBase (BufEntryBase[nbitems]) est NULL*/
m_Drawings = *BufentryBase;
Bufentry = BufentryBase;
for( ii = 0; ii < nbitems; ii++ )
@ -1005,6 +1120,7 @@ int ii, nbitems;
MyFree( BufentryBase );
}
int SortItemsFct( const void* ref, const void* item )
{
#define Ref ( *(LibEDA_BaseStruct**) (ref) )
@ -1045,8 +1161,10 @@ int fill_ref = 0, fill_item = 0;
}
case COMPONENT_GRAPHIC_TEXT_DRAW_TYPE:
if ( Item->m_StructType == COMPONENT_PIN_DRAW_TYPE ) return BEFORE;
if ( Item->m_StructType == COMPONENT_GRAPHIC_TEXT_DRAW_TYPE ) return 0;
if( Item->m_StructType == COMPONENT_PIN_DRAW_TYPE )
return BEFORE;
if( Item->m_StructType == COMPONENT_GRAPHIC_TEXT_DRAW_TYPE )
return 0;
return 1;
break;
@ -1054,23 +1172,30 @@ int fill_ref = 0, fill_item = 0;
if( Item->m_StructType == COMPONENT_PIN_DRAW_TYPE )
{
int ii;
// We sort the pins by orientation
ii = ( (LibDrawPin*) Ref )->m_Orient - ( (LibDrawPin*) Item )->m_Orient;
if ( ii ) return ii;
if( ii )
return ii;
/* We sort the pins by position (x or y).
note: at this point, most of pins have same x pos or y pos,
because they are sorted by orientation and generally are vertically or
horizontally aligned */
* note: at this point, most of pins have same x pos or y pos,
* because they are sorted by orientation and generally are vertically or
* horizontally aligned */
wxPoint pos_ref, pos_tst;
pos_ref = ( (LibDrawPin*) Ref )->m_Pos;
pos_tst = ( (LibDrawPin*) Item )->m_Pos;
if ( (ii = pos_ref.x - pos_tst.x) ) return ii;
if( (ii = pos_ref.x - pos_tst.x) )
return ii;
ii = pos_ref.y - pos_tst.y;
return ii;
}
else return AFTER;
else
return AFTER;
break;
default:
;
}
/* Test de l'item */
@ -1111,10 +1236,15 @@ int fill_ref = 0, fill_item = 0;
case COMPONENT_PIN_DRAW_TYPE:
return BEFORE;
break;
default:
;
}
if ( fill_ref & fill_item ) return 0;
if ( fill_ref ) return BEFORE;
if( fill_ref & fill_item )
return 0;
if( fill_ref )
return BEFORE;
return AFTER;
}
@ -1123,10 +1253,11 @@ int fill_ref = 0, fill_item = 0;
int AddFootprintFilterList( EDA_LibComponentStruct* LibEntryLibEntry, FILE* f,
char* Line, int* LineNum )
/******************************************************************************/
/* read the FootprintFilter List stating with:
FPLIST
and ending with:
ENDFPLIST
* FPLIST
* and ending with:
* ENDFPLIST
*/
{
for( ; ; )

2
eeschema/hotkeys.cpp
View File

@ -212,6 +212,8 @@ wxPoint MousePos = m_CurrentScreen->m_MousePosition;
}
ChangeTextOrient( (DrawTextStruct*)DrawStruct, DC);
break;
default:;
}
break;

223
eeschema/libclass.cpp
View File

@ -31,29 +31,33 @@ LibraryStruct::LibraryStruct(int type, const wxString & name, const wxString & f
m_TimeStamp = 0;
m_Flags = 0;
m_IsLibCache = FALSE;
}
/*****************************************/
void FreeLibraryEntry( LibCmpEntry* Entry )
/*****************************************/
/* Used by PQFreeFunc() to delete all entries
*/
{
delete Entry;
}
/******************************/
LibraryStruct::~LibraryStruct()
/******************************/
{
if ( m_Entries ) PQFreeFunc(m_Entries, (void(*)(void *))FreeLibraryEntry);
if( m_Entries )
PQFreeFunc( m_Entries, ( void( * ) ( void* ) )FreeLibraryEntry );
}
/*******************************************/
bool LibraryStruct::WriteHeader( FILE* file )
/*******************************************/
/* Ecrit l'entete du fichier librairie
*/
{
@ -66,17 +70,23 @@ bool succes = TRUE;
BufLine ) != 5 )
succes = FALSE;
#if 0
if ( fprintf(file,"$HEADER\n") != 1 ) succes = FALSE;
if ( fprintf(file,"TimeStamp %8.8lX\n", m_TimeStamp) != 2 ) succes = FALSE;
if ( fprintf(file,"Parts %d\n", m_NumOfParts) != 2 ) succes = FALSE;
if ( fprintf(file,"$ENDHEADER\n") != 1 ) succes = FALSE;
if( fprintf( file, "$HEADER\n" ) != 1 )
succes = FALSE;
if( fprintf( file, "TimeStamp %8.8lX\n", m_TimeStamp ) != 2 )
succes = FALSE;
if( fprintf( file, "Parts %d\n", m_NumOfParts ) != 2 )
succes = FALSE;
if( fprintf( file, "$ENDHEADER\n" ) != 1 )
succes = FALSE;
#endif
return (succes);
return succes;
}
/***********************************************************/
bool LibraryStruct::ReadHeader( FILE* libfile, int* LineNum )
/***********************************************************/
/* Ecrit l'entete du fichier librairie
*/
{
@ -88,8 +98,10 @@ char Line[1024], * text, * data;
data = strtok( NULL, " \t\r\n" );
if( stricmp( text, "TimeStamp" ) == 0 )
m_TimeStamp = atol( data );
if ( stricmp(text,"$ENDHEADER") == 0 ) return TRUE;
if( stricmp( text, "$ENDHEADER" ) == 0 )
return TRUE;
}
return FALSE;
}
@ -97,11 +109,12 @@ char Line[1024], * text, * data;
/*********************/
/* class LibCmpEntry */
/*********************/
/* Basic class for librarty oomponent description
Not directly used
Used to create the 2 derived classes :
- EDA_LibCmpAliasStruct
- EDA_LibComponentStruct
* Not directly used
* Used to create the 2 derived classes :
* - EDA_LibCmpAliasStruct
* - EDA_LibComponentStruct
*/
/********************************************************************/
@ -111,9 +124,11 @@ LibCmpEntry::LibCmpEntry(LibrEntryType CmpType, const wxChar * CmpName):
{
Type = CmpType;
m_Name.m_FieldId = VALUE;
if ( CmpName ) m_Name.m_Text = CmpName;
if( CmpName )
m_Name.m_Text = CmpName;
}
/******************************/
LibCmpEntry::~LibCmpEntry( void )
/******************************/
@ -126,21 +141,24 @@ LibCmpEntry::~LibCmpEntry(void)
/*******************************/
/* Class to define an alias of a component
An alias uses the component defintion (graphic, pins...)
but has its own name and documentation.
Therefore, when the component is modified, alias of this component are modified.
This is a simple method to create components with differs very few
(like 74LS00, 74HC00 ... and many op amps )
* An alias uses the component defintion (graphic, pins...)
* but has its own name and documentation.
* Therefore, when the component is modified, alias of this component are modified.
* This is a simple method to create components with differs very few
* (like 74LS00, 74HC00 ... and many op amps )
*/
EDA_LibCmpAliasStruct:: EDA_LibCmpAliasStruct( const wxChar* CmpName,
const wxChar* CmpRootName ) :
LibCmpEntry( ALIAS, CmpName )
{
if ( CmpRootName == NULL) m_RootName.Empty();
else m_RootName = CmpRootName;
if( CmpRootName == NULL )
m_RootName.Empty();
else
m_RootName = CmpRootName;
}
EDA_LibCmpAliasStruct::~EDA_LibCmpAliasStruct( void )
{
}
@ -167,6 +185,7 @@ EDA_LibComponentStruct:: EDA_LibComponentStruct( const wxChar * CmpName):
m_Prefix.m_FieldId = REFERENCE;
}
/******************************************************/
EDA_LibComponentStruct::~EDA_LibComponentStruct( void )
/******************************************************/
@ -195,10 +214,11 @@ LibDrawField *TempField, *field;
/**********************************************************************/
EDA_Rect EDA_LibComponentStruct::GetBoundaryBox( int Unit, int Convert )
/**********************************************************************/
/* Return the componenty boundary box ( in user coordinates )
The unit Unit, and the shape Convert are considered.
If Unit == 0, Unit is not used
if Convert == 0 Convert is non used
* The unit Unit, and the shape Convert are considered.
* If Unit == 0, Unit is not used
* if Convert == 0 Convert is non used
**/
{
int xmin, xmax, ymin, ymax, x1, y1;
@ -209,11 +229,13 @@ EDA_Rect BoundaryBox;
DrawEntry = m_Drawings;
if( DrawEntry )
{
xmin = ymin = 0x7FFFFFFF; xmax = ymax = 0x80000000;
xmin = ymin = 0x7FFFFFFF;
xmax = ymax = 0x80000000;
}
else
{
xmin = ymin = -50; xmax = ymax = 50; // Min size in 1/1000 inch
xmin = ymin = -50;
xmax = ymax = 50; // Min size in 1/1000 inch
}
for( ; DrawEntry != NULL; DrawEntry = DrawEntry->Next() )
@ -284,14 +306,23 @@ EDA_Rect BoundaryBox;
xmax = MAX( xmax, x1 );
ymin = MIN( ymin, y1 );
ymax = MAX( ymax, y1 );
#if 0 // 0 pour englober le point origine de la pin, 1 pour englober toute la pin
#if 0 \
// 0 pour englober le point origine de la pin, 1 pour englober toute la pin
switch( Pin->Orient )
{
case PIN_UP: y1 += Pin->Len; break;
case PIN_DOWN: y1 -= Pin->Len; break;
case PIN_LEFT: x1 -= Pin->Len; break;
case PIN_RIGHT: x1 += Pin->Len; break;
case PIN_UP:
y1 += Pin->Len; break;
case PIN_DOWN:
y1 -= Pin->Len; break;
case PIN_LEFT:
x1 -= Pin->Len; break;
case PIN_RIGHT:
x1 += Pin->Len; break;
}
xmin = MIN( xmin, x1 );
xmax = MAX( xmax, x1 );
ymin = MIN( ymin, y1 );
@ -309,23 +340,32 @@ EDA_Rect BoundaryBox;
pt = polyline->PolyList;
for( ii = 0; ii < polyline->n; ii++ )
{
if( xmin > *pt ) xmin = *pt;
if( xmax < *pt ) xmax = *pt;
if( xmin > *pt )
xmin = *pt;
if( xmax < *pt )
xmax = *pt;
pt++;
if( ymin > *pt ) ymin = *pt;
if( ymax < *pt ) ymax = *pt;
if( ymin > *pt )
ymin = *pt;
if( ymax < *pt )
ymax = *pt;
pt++;
}
}
break;
default:
;
}
}
// Update the BoundaryBox. Remenber the fact the screen Y axis is the reverse */
ymax = -ymax; ymin = -ymin; // Y is is screen axis sense
// Ensure w and H > 0 (wxRect assume it)
if ( xmax < xmin ) EXCHG( xmax, xmin );
if ( ymax < ymin ) EXCHG( ymax, ymin );
if( xmax < xmin )
EXCHG( xmax, xmin );
if( ymax < ymin )
EXCHG( ymax, ymin );
BoundaryBox.SetX( xmin ); BoundaryBox.SetWidth( xmax - xmin );
BoundaryBox.SetY( ymin ); BoundaryBox.SetHeight( ymax - ymin );
@ -336,21 +376,24 @@ EDA_Rect BoundaryBox;
/***************************/
/* class LibraryFieldEntry */
/***************************/
/* a Field is a string linked to a component.
Unlike a pure graphic text, fields can be used in netlist generation
and other things.
4 fields have a special meaning:
REFERENCE
VALUE
FOOTPRINT NAME
SCHEMATIC LINK (reserved but not used in kicad)
/* a Field is a string linked to a component.
* Unlike a pure graphic text, fields can be used in netlist generation
* and other things.
*
* 4 fields have a special meaning:
* REFERENCE
* VALUE
* FOOTPRINT NAME
* SCHEMATIC LINK (reserved but not used in kicad)
*/
LibDrawField::LibDrawField( int idfield ) : LibEDA_BaseStruct( COMPONENT_FIELD_DRAW_TYPE )
{
m_FieldId = idfield; /* 0 a 11, 0 = REFERENCE, 1 = VALUE*/
if ( m_FieldId < 0 ) m_FieldId = 0;
if ( m_FieldId >= NUMBER_OF_FIELDS ) m_FieldId = NUMBER_OF_FIELDS - 1;
if( m_FieldId < 0 )
m_FieldId = 0;
if( m_FieldId >= NUMBER_OF_FIELDS )
m_FieldId = NUMBER_OF_FIELDS - 1;
m_Size.x = m_Size.y = DEFAULT_SIZE_TEXT;
m_Orient = 0; /* Orientation */
m_Attributs = 0; /* Attributs = unvisible ... */
@ -359,19 +402,23 @@ LibDrawField::LibDrawField(int idfield) : LibEDA_BaseStruct(COMPONENT_FIELD_DRAW
m_VJustify = GR_TEXT_VJUSTIFY_CENTER; /* Horizontal and vertical text justification */
}
LibDrawField::~LibDrawField( void )
{
}
// Creation et Duplication d'un field
LibDrawField* LibDrawField::GenCopy( void )
{
LibDrawField* newfield = new LibDrawField( m_FieldId );
Copy( newfield );
return newfield;
}
// copie du field dans le field Target
void LibDrawField::Copy( LibDrawField* Target )
{
@ -386,17 +433,19 @@ void LibDrawField::Copy(LibDrawField * Target)
Target->m_VJustify = m_VJustify;
}
/* Elements Graphiques */
LibEDA_BaseStruct::LibEDA_BaseStruct(int struct_type):
LibEDA_BaseStruct::LibEDA_BaseStruct( KICAD_T struct_type ) :
EDA_BaseStruct( struct_type )
{
m_Unit = 0; /* Unit identification (for multi part per package)
0 if the item is common to all units */
* 0 if the item is common to all units */
m_Convert = 0; /* Shape identification (for parts which have a convert shape)
0 if the item is common to all shapes */
* 0 if the item is common to all shapes */
m_Width = 0; /* Default value to draw lines or arc ... */
}
/***************************************************************/
LibDrawPin::LibDrawPin( void ) : LibEDA_BaseStruct( COMPONENT_PIN_DRAW_TYPE )
/***************************************************************/
@ -410,6 +459,7 @@ LibDrawPin::LibDrawPin(void) : LibEDA_BaseStruct(COMPONENT_PIN_DRAW_TYPE)
m_PinNumSize = 50;
m_PinNameSize = 50; /* Default size for pin name and num */
m_Width = 0;
// m_PinNumWidth = m_PinNameWidth = 0; // Unused
}
@ -417,27 +467,38 @@ LibDrawPin::LibDrawPin(void) : LibEDA_BaseStruct(COMPONENT_PIN_DRAW_TYPE)
/******************************************/
wxPoint LibDrawPin::ReturnPinEndPoint( void )
/******************************************/
/* return the pin end position, for a component in normal orient
*/
{
wxPoint pos = m_Pos;
switch( m_Orient )
{
case PIN_UP: pos.y += m_PinLen; break;
case PIN_DOWN: pos.y -= m_PinLen; break;
case PIN_LEFT: pos.x -= m_PinLen; break;
case PIN_RIGHT: pos.x += m_PinLen; break;
case PIN_UP:
pos.y += m_PinLen; break;
case PIN_DOWN:
pos.y -= m_PinLen; break;
case PIN_LEFT:
pos.x -= m_PinLen; break;
case PIN_RIGHT:
pos.x += m_PinLen; break;
}
return pos;
}
/********************************************************/
int LibDrawPin::ReturnPinDrawOrient( int TransMat[2][2] )
/********************************************************/
/* Return the pin real orientation (PIN_UP, PIN_DOWN, PIN_RIGHT, PIN_LEFT),
according to its orientation,
AND the matrix transform (rot, mirror) TransMat
* according to its orientation,
* AND the matrix transform (rot, mirror) TransMat
*/
{
int orient;
@ -446,22 +507,32 @@ int t1, t2;
switch( m_Orient )
{
case PIN_UP: y1 = 1; break;
case PIN_DOWN: y1 = -1; break;
case PIN_LEFT: x1 = -1; break;
case PIN_RIGHT: x1 = 1; break;
case PIN_UP:
y1 = 1; break;
case PIN_DOWN:
y1 = -1; break;
case PIN_LEFT:
x1 = -1; break;
case PIN_RIGHT:
x1 = 1; break;
}
t1 = TransMat[0][0] * x1 + TransMat[0][1] * y1;
t2 = TransMat[1][0] * x1 + TransMat[1][1] * y1;
orient = PIN_UP;
if( t1 == 0 )
{
if ( t2 > 0 ) orient = PIN_DOWN;
if( t2 > 0 )
orient = PIN_DOWN;
}
else
{
orient = PIN_RIGHT;
if ( t1 < 0 ) orient = PIN_LEFT;
if( t1 < 0 )
orient = PIN_LEFT;
}
return orient;
@ -471,9 +542,10 @@ int t1, t2;
/****************************************************/
void LibDrawPin::ReturnPinStringNum( wxString& buffer )
/****************************************************/
/* fill the buffer with pin num as a wxString
Pin num is coded as a long
Used to print/draw the pin num
* Pin num is coded as a long
* Used to print/draw the pin num
*/
{
char ascii_buf[5];
@ -483,26 +555,32 @@ char ascii_buf[5];
buffer = CONV_FROM_UTF8( ascii_buf );
}
/****************************************************/
void LibDrawPin::SetPinNumFromString( wxString& buffer )
/****************************************************/
/* fill the buffer with pin num as a wxString
Pin num is coded as a long
Used to print/draw the pin num
* Pin num is coded as a long
* Used to print/draw the pin num
*/
{
char ascii_buf[4];
unsigned ii, len = buffer.Len();
ascii_buf[0] = ascii_buf[1] = ascii_buf[2] = ascii_buf[3] = 0;
if ( len > 4 ) len = 4;
if( len > 4 )
len = 4;
for( ii = 0; ii < len; ii++ )
{
ascii_buf[ii] = buffer.GetChar( ii ) & 0xFF;
}
strncpy( (char*) &m_PinNum, ascii_buf, 4 );
}
/*************************************/
LibDrawPin* LibDrawPin::GenCopy( void )
/*************************************/
@ -528,6 +606,7 @@ LibDrawPin * newpin = new LibDrawPin();
return newpin;
}
/**************************************************************/
LibDrawArc::LibDrawArc( void ) : LibEDA_BaseStruct( COMPONENT_ARC_DRAW_TYPE )
/**************************************************************/
@ -568,6 +647,7 @@ LibDrawCircle::LibDrawCircle(void) : LibEDA_BaseStruct(COMPONENT_CIRCLE_DRAW_TYP
m_Fill = NO_FILL;
}
/*******************************************/
LibDrawCircle* LibDrawCircle::GenCopy( void )
/*******************************************/
@ -595,6 +675,7 @@ LibDrawText::LibDrawText(void) : LibEDA_BaseStruct(COMPONENT_GRAPHIC_TEXT_DRAW_T
m_Width = 0;
}
/***************************************/
LibDrawText* LibDrawText::GenCopy( void )
/***************************************/
@ -614,13 +695,13 @@ LibDrawText * newitem = new LibDrawText();
}
LibDrawSquare::LibDrawSquare( void ) : LibEDA_BaseStruct( COMPONENT_RECT_DRAW_TYPE )
{
m_Width = 0;
m_Fill = NO_FILL;
}
LibDrawSquare* LibDrawSquare::GenCopy( void )
{
LibDrawSquare* newitem = new LibDrawSquare();
@ -635,11 +716,13 @@ LibDrawSquare * newitem = new LibDrawSquare();
return newitem;
}
LibDrawSegment::LibDrawSegment( void ) : LibEDA_BaseStruct( COMPONENT_LINE_DRAW_TYPE )
{
m_Width = 0;
}
LibDrawSegment* LibDrawSegment::GenCopy( void )
{
LibDrawSegment* newitem = new LibDrawSegment();
@ -662,11 +745,13 @@ LibDrawPolyline::LibDrawPolyline(void) : LibEDA_BaseStruct(COMPONENT_POLYLINE_DR
m_Width = 0;
}
/************************************************/
LibDrawPolyline* LibDrawPolyline::GenCopy( void )
/************************************************/
{
LibDrawPolyline* newitem = new LibDrawPolyline();
int size;
newitem->n = n;
@ -685,9 +770,11 @@ int size;
return newitem;
}
/***************************************************/
void LibDrawPolyline::AddPoint( const wxPoint& point )
/***************************************************/
/* add a point to the polyline coordinate list, and realloc the memory
*/
{
@ -703,5 +790,3 @@ int allocsize;
PolyList[(n * 2) - 2] = point.x;
PolyList[(n * 2) - 1] = -point.y;
}

50
eeschema/libcmp.h
View File

@ -56,9 +56,9 @@ typedef enum {
/* flags utilises dans FindLibPart() : */
#define FIND_ROOT 0 /* indique la recherche du composant racine si
meme si le composant specifie est un alias */
* meme si le composant specifie est un alias */
#define FIND_ALIAS 1 /* indique la recherche du composant specifie
(alias ou racine) */
* (alias ou racine) */
/* definition des types des structures d'elements de librairie */
typedef enum {
@ -105,6 +105,8 @@ eda_global wxChar * MsgPinElectricType[]
wxT( "openEm" ),
wxT( "?????" )
}
#endif
;
@ -161,22 +163,25 @@ public:
/* class LibEDA_BaseStruct : Basic class for items used in a library component
(graphic shapes, texts, fields, pins)
* (graphic shapes, texts, fields, pins)
*/
class LibEDA_BaseStruct : public EDA_BaseStruct
{
public:
int m_Unit; /* Unit identification (for multi part per parkage)
0 if the item is common to all units */
* 0 if the item is common to all units */
int m_Convert; /* Shape identification (for parts which have a convert shape)
0 if the item is common to all shapes */
* 0 if the item is common to all shapes */
wxPoint m_Pos; /* Position or centre (Arc and Circle) or start point (segments) */
int m_Width; /* Width of draw lines */
public:
LibEDA_BaseStruct * Next(void) {return (LibEDA_BaseStruct *) Pnext;}
LibEDA_BaseStruct(int struct_type);
LibEDA_BaseStruct* Next( void )
{
return (LibEDA_BaseStruct*) Pnext;
}
LibEDA_BaseStruct( KICAD_T struct_type );
virtual ~LibEDA_BaseStruct( void ) { }
void Display_Infos_DrawEntry( WinEDA_DrawFrame* frame );
};
@ -191,9 +196,10 @@ public:
int m_PinType; /* Electrical pin properties */
int m_Attributs; /* bit 0 != 0: pin invisible */
long m_PinNum; /* Pin number: 4 Ascii code like "12" or "anod" or "G6"
"12" is really "12\0\0"*/
* "12" is really "12\0\0"*/
wxString m_PinName;
int m_PinNumSize, m_PinNameSize;/* Pin num and Pin name sizes */
// short m_PinNumWidth, m_PinNameWidth; /* (Unused) Pin num and Pin name text width */
public:
@ -206,7 +212,8 @@ public:
int ReturnPinDrawOrient( int TransMat[2][2] );
void ReturnPinStringNum( wxString& buffer );
void SetPinNumFromString( wxString& buffer );
void DrawPinSymbol(WinEDA_DrawPanel * panel, wxDC * DC, const wxPoint & pin_pos, int orient,
void DrawPinSymbol( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& pin_pos,
int orient,
int DrawMode, int Color = -1 );
void DrawPinTexts( WinEDA_DrawPanel* panel, wxDC* DC,
@ -294,14 +301,17 @@ public:
public:
LibDrawPolyline( void );
~LibDrawPolyline(void){ if ( PolyList ) free(PolyList);}
~LibDrawPolyline( void ) {
if( PolyList )
free( PolyList );
}
LibDrawPolyline* GenCopy( void );
void AddPoint( const wxPoint& point );
bool WriteDescr( FILE* File );
};
/* Fields identiques aux fields des composants, pouvant etre predefinis en lib
2 Fields sont toujours presents : Prefix (U, IC..) et Name (74LS00..)*/
* 2 Fields sont toujours presents : Prefix (U, IC..) et Name (74LS00..)*/
class LibDrawField : public LibEDA_BaseStruct
{
public:
@ -330,7 +340,7 @@ class LibCmpEntry : public EDA_BaseStruct
{
public:
LibrEntryType Type; /* Type = ROOT;
= ALIAS pour struct LibraryAliasType */
* = ALIAS pour struct LibraryAliasType */
LibDrawField m_Name; // name (74LS00 ..) in lib ( = VALUE )
wxString m_Doc; /* ligne de documentation */
wxString m_KeyWord; /* liste des mots cles */
@ -353,8 +363,8 @@ public:
bool m_UnitSelectionLocked; // True if units are differents and their selection is locked
// (i.e. if part A cannot be automatically changed in part B
int m_TextInside;/* if 0: pin name drawn on the pin itself
if > 0 pin name drawn inside the component,
with a distance of m_TextInside in mils */
* if > 0 pin name drawn inside the component,
* with a distance of m_TextInside in mils */
bool m_DrawPinNum;
bool m_DrawPinName;
LibDrawField* Fields; /* Auxiliairy Field list (id = 2 a 11*/
@ -364,6 +374,7 @@ public:
public:
EDA_LibComponentStruct( const wxChar * CmpName );
EDA_Rect GetBoundaryBox( int Unit, int Convert );/* return Box around the part. */
~EDA_LibComponentStruct( void );
void SortDrawItems( void );
};
@ -383,13 +394,13 @@ extern LibraryStruct *LibraryList; /* All part libs are saved here. */
/* Variables Utiles pour les editions de composants en librairie */
eda_global LibEDA_BaseStruct* LibItemToRepeat;/* pointeur sur l'élément que l'on
peut répéter (Pin..;) */
* peut répéter (Pin..;) */
eda_global LibraryStruct* CurrentLib; /* Pointeur sur la librairie du
composant en cours d'edition */
* composant en cours d'edition */
eda_global EDA_LibComponentStruct* CurrentLibEntry; /* pointeur sur le composant en
cours d'edition */
* cours d'edition */
eda_global LibEDA_BaseStruct* CurrentDrawItem;/* pointeur sur les
elements de dessin du comp. en edition */
* elements de dessin du comp. en edition */
eda_global wxString CurrentAliasName; // Nom de l'alias selectionné
eda_global bool g_AsDeMorgan; // Pour libedit:
@ -406,7 +417,6 @@ eda_global int CurrentConvert /* Convert = 1 .. 255 */
eda_global wxString FindLibName; /* nom de la librairie ou a ete trouve le
dernier composant recherche par FindLibPart() */
* dernier composant recherche par FindLibPart() */
#endif // LIBCMP_H

1
eeschema/libframe.cpp
View File

@ -543,6 +543,7 @@ wxClientDC dc(DrawPanel);
case COMPONENT_GRAPHIC_TEXT_DRAW_TYPE:
EditSymbolText(&dc, CurrentDrawItem);
break;
default:;
}
DrawPanel->CursorOn(&dc);
}

3
eeschema/locate.cpp
View File

@ -839,6 +839,9 @@ int seuil;
return(DrawItem); /* Texte trouve */
}
break;
default:
;
}
}
return(NULL);

3
eeschema/plot.cpp
View File

@ -290,6 +290,9 @@ wxPoint pos;
MyFree(Poly);
}
break;
default:;
} /* Fin Switch */
Plume('U');
} /* Fin Boucle de dessin */

65
eeschema/program.h
View File

@ -55,22 +55,36 @@ extern const wxChar * NameMarqueurType[];
/* Forward declarations */
class DrawSheetStruct;
class EDA_DrawLineStruct: public EDA_BaseLineStruct /* Segment decription
base class to describe items which have 2 end points (track, wire, draw line ...) */
/**
* Class EDA_DrawLineStruct
* is a segment decription base class to describe items which have 2 end
* points (track, wire, draw line ...)
*/
class EDA_DrawLineStruct : public EDA_BaseStruct
{
public:
bool m_StartIsDangling, m_EndIsDangling; // TRUE si Start ou End not connected (wires, tracks...)
int m_Layer; // Layer number
int m_Width; // 0 = line, > 0 = tracks, bus ...
wxPoint m_Start; // Line start point
wxPoint m_End; // Line end point
bool m_StartIsDangling;
bool m_EndIsDangling; // TRUE si Start ou End not connected (wires, tracks...)
public:
EDA_DrawLineStruct( const wxPoint &pos, int layer );
~EDA_DrawLineStruct( void ) { }
bool IsOneEndPointAt( const wxPoint& pos );
EDA_DrawLineStruct* GenCopy( void );
bool IsNull( void )
{
return (m_Start == m_End);
return m_Start == m_End;
}
virtual void Draw(WinEDA_DrawPanel * panel, wxDC * DC, const wxPoint & offset, int draw_mode, int Color = -1);
virtual void Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset, int draw_mode,
int Color = -1 );
};
@ -87,9 +101,11 @@ public:
~DrawMarkerStruct( void );
DrawMarkerStruct* GenCopy( void );
wxString GetComment( void );
virtual void Draw(WinEDA_DrawPanel * panel, wxDC * DC, const wxPoint & offset, int draw_mode, int Color = -1);
virtual void Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset,
int draw_mode, int Color = -1 );
};
class DrawNoConnectStruct : public EDA_BaseStruct /* Symboles de non connexion */
{
public:
@ -99,11 +115,16 @@ public:
DrawNoConnectStruct( const wxPoint &pos );
~DrawNoConnectStruct( void ) { }
DrawNoConnectStruct* GenCopy( void );
virtual void Draw(WinEDA_DrawPanel * panel, wxDC * DC, const wxPoint & offset, int draw_mode, int Color = -1);
virtual void Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset,
int draw_mode, int Color = -1 );
};
class DrawBusEntryStruct: public EDA_BaseStruct /* Struct de descr 1 raccord
a 45 degres de BUS ou WIRE */
/**
* Class DrawBusEntryStruct
* Struct de descr 1 raccord a 45 degres de BUS ou WIRE
*/
class DrawBusEntryStruct : public EDA_BaseStruct
{
public:
int m_Layer;
@ -116,7 +137,8 @@ public:
~DrawBusEntryStruct( void ) { }
DrawBusEntryStruct* GenCopy( void );
wxPoint m_End( void ); // retourne la coord de fin du raccord
virtual void Draw(WinEDA_DrawPanel * panel, wxDC * DC, const wxPoint & offset, int draw_mode, int Color = -1);
virtual void Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset,
int draw_mode, int Color = -1 );
};
class DrawPolylineStruct : public EDA_BaseStruct/* Polyligne (serie de segments) */
@ -131,7 +153,8 @@ public:
DrawPolylineStruct( int layer );
~DrawPolylineStruct( void );
DrawPolylineStruct* GenCopy( void );
virtual void Draw(WinEDA_DrawPanel * panel, wxDC * DC, const wxPoint & offset, int draw_mode, int Color = -1);
virtual void Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset,
int draw_mode, int Color = -1 );
};
class DrawJunctionStruct : public EDA_BaseStruct
@ -144,7 +167,8 @@ public:
DrawJunctionStruct( const wxPoint &pos );
~DrawJunctionStruct( void ) { }
DrawJunctionStruct* GenCopy( void );
virtual void Draw(WinEDA_DrawPanel * panel, wxDC * DC, const wxPoint & offset, int draw_mode, int Color = -1);
virtual void Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset,
int draw_mode, int Color = -1 );
};
class DrawTextStruct : public EDA_BaseStruct, public EDA_TextStruct
@ -158,13 +182,18 @@ public:
DrawTextStruct( const wxPoint& pos = wxPoint( 0, 0 ), const wxString& text = wxEmptyString );
~DrawTextStruct( void ) { }
DrawTextStruct* GenCopy( void );
virtual void Draw(WinEDA_DrawPanel * panel, wxDC * DC, const wxPoint & offset, int draw_mode, int Color = -1);
virtual void Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset, int draw_mode,
int Color = -1 );
void SwapData( DrawTextStruct* copyitem );
virtual void Place( WinEDA_DrawFrame* frame, wxDC* DC );
private:
void DrawAsText(WinEDA_DrawPanel * panel, wxDC * DC, const wxPoint & offset, int draw_mode, int Color);
void DrawAsLabel(WinEDA_DrawPanel * panel, wxDC * DC, const wxPoint & offset, int draw_mode, int Color);
void DrawAsGlobalLabel(WinEDA_DrawPanel * panel, wxDC * DC, const wxPoint & offset, int draw_mode, int Color);
void DrawAsText( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset,
int draw_mode, int Color );
void DrawAsLabel( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset,
int draw_mode, int Color );
void DrawAsGlobalLabel( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset,
int draw_mode, int Color );
};
@ -179,7 +208,8 @@ public:
class DrawGlobalLabelStruct : public DrawTextStruct
{
public:
DrawGlobalLabelStruct(const wxPoint & pos = wxPoint(0,0), const wxString & text = wxEmptyString);
DrawGlobalLabelStruct( const wxPoint& pos = wxPoint( 0, 0 ),
const wxString& text = wxEmptyString );
~DrawGlobalLabelStruct( void ) { }
};
@ -200,4 +230,3 @@ public:
#endif /* PROGRAM_H */

143
eeschema/symbdraw.cpp
View File

@ -40,6 +40,7 @@ static int FlSymbol_Fill = NO_FILL;
void WinEDA_bodygraphics_PropertiesFrame::
bodygraphics_PropertiesAccept( wxCommandEvent& event )
/************************************************************/
/* Update the current draw item
*/
{
@ -54,15 +55,20 @@ void WinEDA_bodygraphics_PropertiesFrame::
if( !(CurrentDrawItem->m_Flags & IS_NEW) ) // if IS_NEW, copy for undo is done before place
m_Parent->SaveCopyInUndoList( CurrentLibEntry );
wxClientDC dc( m_Parent->DrawPanel );
m_Parent->DrawPanel->PrepareGraphicContext( &dc );
DrawLibraryDrawStruct( m_Parent->DrawPanel, &dc, CurrentLibEntry, 0, 0,
CurrentDrawItem, CurrentUnit, g_XorMode );
if( g_FlDrawSpecificUnit ) CurrentDrawItem->m_Unit = CurrentUnit;
else CurrentDrawItem->m_Unit = 0;
if( g_FlDrawSpecificConvert ) CurrentDrawItem->m_Convert = CurrentConvert;
else CurrentDrawItem->m_Convert = 0;
if( g_FlDrawSpecificUnit )
CurrentDrawItem->m_Unit = CurrentUnit;
else
CurrentDrawItem->m_Unit = 0;
if( g_FlDrawSpecificConvert )
CurrentDrawItem->m_Convert = CurrentConvert;
else
CurrentDrawItem->m_Convert = 0;
if( m_Filled )
{
switch( CurrentDrawItem->m_StructType )
@ -84,10 +90,12 @@ void WinEDA_bodygraphics_PropertiesFrame::
case COMPONENT_POLYLINE_DRAW_TYPE:
( (LibDrawPolyline*) CurrentDrawItem )->m_Fill = FlSymbol_Fill;
((LibDrawPolyline*)CurrentDrawItem)->m_Width = m_GraphicShapeWidthCtrl->GetValue();
( (LibDrawPolyline*) CurrentDrawItem )->m_Width = m_GraphicShapeWidthCtrl->
GetValue();
break;
default: break;
default:
break;
}
}
CurrentLibEntry->SortDrawItems();
@ -105,17 +113,20 @@ void WinEDA_bodygraphics_PropertiesFrame::
m_Parent->ReDrawPanel();
}
/**********************************************************/
void WinEDA_LibeditFrame::EditGraphicSymbol( wxDC* DC,
LibEDA_BaseStruct* DrawItem )
/**********************************************************/
/* Install the dialog box for editing a graphical item properties
*/
{
if ( DrawItem == NULL ) return;
if( DrawItem == NULL )
return;
WinEDA_bodygraphics_PropertiesFrame* frame = new WinEDA_bodygraphics_PropertiesFrame( this );
WinEDA_bodygraphics_PropertiesFrame * frame = new
WinEDA_bodygraphics_PropertiesFrame(this);
frame->ShowModal(); frame->Destroy();
}
@ -124,11 +135,11 @@ void WinEDA_LibeditFrame::EditGraphicSymbol(wxDC * DC,
static void AbortSymbolTraceOn( WinEDA_DrawPanel* Panel, wxDC* DC )
/****************************************************************/
{
StateDrawArc = 0;
Panel->ManageCurseur = NULL;
Panel->ForceCloseManageCurseur = NULL;
if(CurrentDrawItem == NULL) return;
if( CurrentDrawItem == NULL )
return;
if( CurrentDrawItem->m_Flags & IS_NEW )
{
@ -136,11 +147,11 @@ static void AbortSymbolTraceOn(WinEDA_DrawPanel * Panel, wxDC * DC)
{
Panel->m_Parent->RedrawActiveWindow( DC, TRUE );
}
else DrawLibraryDrawStruct(Panel, DC, CurrentLibEntry, 0 , 0,
else
DrawLibraryDrawStruct( Panel, DC, CurrentLibEntry, 0, 0,
CurrentDrawItem, CurrentUnit, g_XorMode );
delete CurrentDrawItem;
}
else
{
wxPoint curpos;
@ -158,23 +169,25 @@ static void AbortSymbolTraceOn(WinEDA_DrawPanel * Panel, wxDC * DC)
}
/*********************************************************************/
LibEDA_BaseStruct* WinEDA_LibeditFrame::CreateGraphicItem( wxDC* DC )
/*********************************************************************/
/* Routine de creation d'un nouvel element type LibraryDrawStruct
POLYLINE
ARC
CIRCLE
RECTANGLE
* POLYLINE
* ARC
* CIRCLE
* RECTANGLE
*/
{
int DrawType;
int* ptpoly;
if(CurrentDrawItem) return NULL;
if( CurrentDrawItem )
return NULL;
DrawPanel->m_IgnoreMouseEvents = TRUE;
// Creation du nouvel element
switch( m_ID_current_state )
{
@ -211,6 +224,7 @@ int * ptpoly;
case COMPONENT_ARC_DRAW_TYPE:
{
LibDrawArc* Arc = new LibDrawArc();
CurrentDrawItem = Arc;
ArcStartX = ArcEndX = m_CurrentScreen->m_Curseur.x;
ArcStartY = ArcEndY = -m_CurrentScreen->m_Curseur.y;
@ -223,6 +237,7 @@ int * ptpoly;
case COMPONENT_CIRCLE_DRAW_TYPE:
{
LibDrawCircle* Circle = new LibDrawCircle();
CurrentDrawItem = Circle;
Circle->m_Pos.x = m_CurrentScreen->m_Curseur.x;
Circle->m_Pos.y = -m_CurrentScreen->m_Curseur.y;
@ -234,6 +249,7 @@ int * ptpoly;
case COMPONENT_RECT_DRAW_TYPE:
{
LibDrawSquare* Square = new LibDrawSquare();
CurrentDrawItem = Square;
Square->m_Pos.x = m_CurrentScreen->m_Curseur.x;
Square->m_Pos.y = -m_CurrentScreen->m_Curseur.y;
@ -246,6 +262,7 @@ int * ptpoly;
case COMPONENT_POLYLINE_DRAW_TYPE:
{
LibDrawPolyline* polyline = new LibDrawPolyline();
CurrentDrawItem = polyline;
polyline->n = 2;
ptpoly = (int*) MyZMalloc( 4 * sizeof(int) );
@ -260,6 +277,7 @@ int * ptpoly;
case COMPONENT_LINE_DRAW_TYPE:
{
LibDrawSegment* Segment = new LibDrawSegment();
CurrentDrawItem = Segment;
Segment->m_Pos.x = m_CurrentScreen->m_Curseur.x;
Segment->m_Pos.y = -m_CurrentScreen->m_Curseur.y;
@ -271,6 +289,7 @@ int * ptpoly;
case COMPONENT_GRAPHIC_TEXT_DRAW_TYPE:
{
LibDrawText* Text = new LibDrawText();
CurrentDrawItem = Text;
Text->m_Size.x = Text->m_Size.y = g_LastTextSize;
Text->m_Horiz = g_LastTextOrient;
@ -297,8 +316,10 @@ int * ptpoly;
if( CurrentDrawItem )
{
CurrentDrawItem->m_Flags |= IS_NEW;
if(g_FlDrawSpecificUnit) CurrentDrawItem->m_Unit = CurrentUnit;
if(g_FlDrawSpecificConvert) CurrentDrawItem->m_Convert = CurrentConvert;
if( g_FlDrawSpecificUnit )
CurrentDrawItem->m_Unit = CurrentUnit;
if( g_FlDrawSpecificConvert )
CurrentDrawItem->m_Convert = CurrentConvert;
}
DrawPanel->MouseToCursorSchema();
@ -311,10 +332,12 @@ int * ptpoly;
/********************************************************/
void WinEDA_LibeditFrame::GraphicItemBeginDraw( wxDC* DC )
/********************************************************/
/* Routine de creation d'un nouvel element type LibraryDrawStruct
*/
{
if(CurrentDrawItem == NULL) return;
if( CurrentDrawItem == NULL )
return;
switch( CurrentDrawItem->m_StructType )
{
@ -348,13 +371,17 @@ void WinEDA_LibeditFrame::GraphicItemBeginDraw(wxDC * DC)
case COMPONENT_LINE_DRAW_TYPE:
break;
default:
;
}
}
}
/**************************************************************************/
static void RedrawWhileMovingCursor( WinEDA_DrawPanel* panel, wxDC* DC, bool erase )
/**************************************************************************/
/* Redraw the graphoc shape while moving
*/
{
@ -380,7 +407,6 @@ int mx, my;
}
/*****************************************************************/
void MoveLibDrawItemAt( LibEDA_BaseStruct* DrawItem, wxPoint newpos )
/*****************************************************************/
@ -440,14 +466,19 @@ wxSize size;
( (LibDrawText*) CurrentDrawItem )->m_Pos.x = mx;
( (LibDrawText*) CurrentDrawItem )->m_Pos.y = -my;
break;
default:
;
}
}
/************************************************************/
void WinEDA_LibeditFrame::StartMoveDrawSymbol( wxDC* DC )
/************************************************************/
{
if(CurrentDrawItem == NULL) return;
if( CurrentDrawItem == NULL )
return;
SetCursor( wxCURSOR_HAND );
@ -479,6 +510,9 @@ void WinEDA_LibeditFrame::StartMoveDrawSymbol(wxDC * DC)
case COMPONENT_GRAPHIC_TEXT_DRAW_TYPE:
InitPosition = ( (LibDrawText*) CurrentDrawItem )->m_Pos;
break;
default:
;
}
ItemPreviousPos = m_CurrentScreen->m_Curseur;
@ -488,7 +522,6 @@ void WinEDA_LibeditFrame::StartMoveDrawSymbol(wxDC * DC)
}
/****************************************************************/
/* Routine de Gestion des evenements souris lors de la creation */
/* d'un nouvel element type LibraryDrawStruct */
@ -573,6 +606,9 @@ int mx = Screen->m_Curseur.x,
case COMPONENT_GRAPHIC_TEXT_DRAW_TYPE: /* Traite par des routines specifiques */
break;
default:
;
}
if( StateDrawArc == 1 )
@ -603,15 +639,18 @@ int mx = Screen->m_Curseur.x,
/******************************************************/
void WinEDA_LibeditFrame::EndDrawGraphicItem( wxDC* DC )
/******************************************************/
/* Place la structure courante en liste des structures du composant
courant, si elle existe et redessine toujours celle ci
Parametres: (tous globaux)
CurrentDrawItem
CurrentLibEntry
* courant, si elle existe et redessine toujours celle ci
* Parametres: (tous globaux)
* CurrentDrawItem
* CurrentLibEntry
*/
{
if(CurrentLibEntry == NULL) return;
if(CurrentDrawItem == NULL) return;
if( CurrentLibEntry == NULL )
return;
if( CurrentDrawItem == NULL )
return;
if( CurrentDrawItem->m_StructType == COMPONENT_ARC_DRAW_TYPE )
{
@ -633,6 +672,7 @@ void WinEDA_LibeditFrame::EndDrawGraphicItem(wxDC * DC)
SaveCopyInUndoList( CurrentLibEntry );
CurrentDrawItem->Pnext = CurrentLibEntry->m_Drawings;
CurrentLibEntry->m_Drawings = CurrentDrawItem;
switch( CurrentDrawItem->m_StructType )
{
case COMPONENT_ARC_DRAW_TYPE:
@ -655,12 +695,18 @@ void WinEDA_LibeditFrame::EndDrawGraphicItem(wxDC * DC)
case COMPONENT_LINE_DRAW_TYPE:
case COMPONENT_GRAPHIC_TEXT_DRAW_TYPE:
break;
default:
;
}
CurrentLibEntry->SortDrawItems();
}
if ( m_ID_current_state ) SetCursor(wxCURSOR_PENCIL);
else SetCursor(wxCURSOR_ARROW);
if( m_ID_current_state )
SetCursor( wxCURSOR_PENCIL );
else
SetCursor( wxCURSOR_ARROW );
if( (CurrentDrawItem->m_Flags & IS_MOVED) )
{
@ -683,15 +729,15 @@ void WinEDA_LibeditFrame::EndDrawGraphicItem(wxDC * DC)
}
/***************************************************************/
static void ComputeArc( LibDrawArc* DrawItem, wxPoint ArcCentre )
/***************************************************************/
/* routine d'ajustage des parametres de l'arc en cours de trace
calcule le centre, rayon, angles pour que l'arc en cours
passe par les points ArcStartX,Y et ArcEndX,Y avec le centre le plus proche
de la pos souris
Remarque: le centre n'est evidemment pas sur la grille
* calcule le centre, rayon, angles pour que l'arc en cours
* passe par les points ArcStartX,Y et ArcEndX,Y avec le centre le plus proche
* de la pos souris
* Remarque: le centre n'est evidemment pas sur la grille
*/
{
int dx, dy;
@ -739,8 +785,10 @@ int angle;
// limitation val abs a < 1800 (1/2 cercle) pour eviter Pbs d'affichage en miroir
// car en trace on suppose que l'arc fait moins de 180 deg pour trouver
// son orientation apres rot, miroir...
if ( (DrawItem->t2 - DrawItem->t1) > 1800 ) DrawItem->t2 -= 3600;
else if ( (DrawItem->t2 - DrawItem->t1) <= -1800 ) DrawItem->t2 += 3600;
if( (DrawItem->t2 - DrawItem->t1) > 1800 )
DrawItem->t2 -= 3600;
else if( (DrawItem->t2 - DrawItem->t1) <= -1800 )
DrawItem->t2 += 3600;
wxString msg;
angle = DrawItem->t2 - DrawItem->t1;
@ -752,6 +800,7 @@ wxString msg;
DrawItem->t2--;
DrawItem->t1++;
}
while( (DrawItem->t1 - DrawItem->t2) >= 1800 )
{
DrawItem->t2++;
@ -760,17 +809,18 @@ wxString msg;
NORMALIZE_ANGLE( DrawItem->t1 );
NORMALIZE_ANGLE( DrawItem->t2 );
}
/***************************************************/
void WinEDA_LibeditFrame::DeleteDrawPoly( wxDC* DC )
/**************************************************/
/* Used for deleting last entered segment while creating a Polyline
*/
{
if ( CurrentDrawItem == NULL ) return;
if( CurrentDrawItem == NULL )
return;
if( CurrentDrawItem->m_StructType != COMPONENT_POLYLINE_DRAW_TYPE )
return;
@ -784,8 +834,8 @@ LibDrawPolyline * Poly = (LibDrawPolyline*)CurrentDrawItem;
{
Poly->n--;
ptpoly = Poly->PolyList + ( 2 * (Poly->n - 1) );
if ( (ptpoly[0] != m_CurrentScreen->m_Curseur.x) ||
(ptpoly[1] != - m_CurrentScreen->m_Curseur.y) )
if( (ptpoly[0] != m_CurrentScreen->m_Curseur.x)
|| (ptpoly[1] != -m_CurrentScreen->m_Curseur.y) )
{
ptpoly[0] = m_CurrentScreen->m_Curseur.x;
ptpoly[1] = -m_CurrentScreen->m_Curseur.y;
@ -799,4 +849,3 @@ LibDrawPolyline * Poly = (LibDrawPolyline*)CurrentDrawItem;
DrawLibraryDrawStruct( DrawPanel, DC, CurrentLibEntry, 0, 0,
CurrentDrawItem, CurrentUnit, g_XorMode );
}

148
eeschema/symbedit.cpp
View File

@ -25,13 +25,12 @@ static bool CompareSymbols(LibEDA_BaseStruct *DEntryRef,
/* Variables locales */
/***************************************************/
void WinEDA_LibeditFrame::LoadOneSymbol( wxDC* DC )
/***************************************************/
/* Read a component shape file and add data (graphic items) to the current
component.
* component.
*/
{
int NumOfParts;
@ -42,8 +41,10 @@ wxString FullFileName, mask;
FILE* ImportFile;
wxString msg;
if(CurrentDrawItem) return;
if( CurrentLibEntry == NULL) return;
if( CurrentDrawItem )
return;
if( CurrentLibEntry == NULL )
return;
DrawPanel->m_IgnoreMouseEvents = TRUE;
@ -62,7 +63,8 @@ wxString msg;
DrawPanel->MouseToCursorSchema();
DrawPanel->m_IgnoreMouseEvents = FALSE;
if ( FullFileName.IsEmpty() ) return;
if( FullFileName.IsEmpty() )
return;
/* Load data */
@ -78,7 +80,8 @@ wxString msg;
Entries = LoadLibraryAux( this, NULL, ImportFile, &NumOfParts );
fclose( ImportFile );
if( Entries == NULL) return;
if( Entries == NULL )
return;
if( NumOfParts > 1 )
DisplayError( this, _( "Warning: more than 1 part in Symbol File" ), 20 );
@ -93,8 +96,10 @@ wxString msg;
DrawEntry = LibEntry->m_Drawings;
while( DrawEntry )
{
if(DrawEntry->m_Unit) DrawEntry->m_Unit = CurrentUnit;
if(DrawEntry->m_Convert) DrawEntry->m_Convert = CurrentConvert;
if( DrawEntry->m_Unit )
DrawEntry->m_Unit = CurrentUnit;
if( DrawEntry->m_Convert )
DrawEntry->m_Convert = CurrentConvert;
DrawEntry->m_Flags = IS_NEW;
DrawEntry->m_Selected = IS_SELECTED;
@ -107,8 +112,10 @@ wxString msg;
}
DrawEntry = DrawEntry->Next();
}
SuppressDuplicateDrawItem( CurrentLibEntry );
m_CurrentScreen->SetModify();
// Move (and place ) the new draw items:
HandleBlockBegin( DC, -1, GetScreen()->m_Curseur );
HandleBlockEnd( DC );
@ -122,9 +129,10 @@ wxString msg;
/********************************************/
void WinEDA_LibeditFrame::SaveOneSymbol( void )
/********************************************/
/* Save in file the current symbol
file format is like the standard libraries, but there is only one symbol
Invisible pins are not saved
* file format is like the standard libraries, but there is only one symbol
* Invisible pins are not saved
*/
{
EDA_LibComponentStruct* LibEntry = CurrentLibEntry;
@ -135,7 +143,8 @@ wxString FullFileName, mask;
wxString msg;
FILE* ExportFile;
if( LibEntry->m_Drawings == NULL ) return;
if( LibEntry->m_Drawings == NULL )
return;
/* Creation du fichier symbole */
mask = wxT( "*" ) + g_SymbolExtBuffer;
@ -148,7 +157,8 @@ FILE * ExportFile;
wxFD_SAVE,
TRUE
);
if ( FullFileName.IsEmpty() ) return;
if( FullFileName.IsEmpty() )
return;
ExportFile = wxFopen( FullFileName, wxT( "wt" ) );
if( ExportFile == NULL )
@ -175,7 +185,8 @@ FILE * ExportFile;
fprintf( ExportFile, "DEF %s", (const char*) LibEntry->m_Name.m_Text.GetData() );
if( !LibEntry->m_Prefix.m_Text.IsEmpty() )
fprintf( ExportFile, " %s", (const char*) LibEntry->m_Prefix.m_Text.GetData() );
else fprintf(ExportFile," ~");
else
fprintf( ExportFile, " ~" );
fprintf( ExportFile, " %d %d %c %c %d %d %c\n",
0, /* unused */
@ -201,9 +212,12 @@ FILE * ExportFile;
continue;
/* .Unit , . Convert est laisse a 0 ou mis a 1 */
SymbUnit = DrawEntry->m_Unit; if ( SymbUnit > 1) SymbUnit = 1;
SymbUnit = DrawEntry->m_Unit; if( SymbUnit > 1 )
SymbUnit = 1;
SymbConvert = DrawEntry->m_Convert;
if ( SymbConvert > 1) SymbConvert = 1;
if( SymbConvert > 1 )
SymbConvert = 1;
switch( DrawEntry->m_StructType )
{
case COMPONENT_ARC_DRAW_TYPE:
@ -232,7 +246,8 @@ FILE * ExportFile;
case COMPONENT_PIN_DRAW_TYPE:
#undef DRAWSTRUCT
#define DRAWSTRUCT ( (LibDrawPin*) DrawEntry )
if(DRAWSTRUCT->m_Attributs & PINNOTDRAW) break;
if( DRAWSTRUCT->m_Attributs & PINNOTDRAW )
break;
DRAWSTRUCT->WriteDescr( ExportFile );
break;
@ -241,6 +256,9 @@ FILE * ExportFile;
#define DRAWSTRUCT ( (LibDrawPolyline*) DrawEntry )
DRAWSTRUCT->WriteDescr( ExportFile );
break;
default:
;
}
}
fprintf( ExportFile, "ENDDRAW\n" );
@ -250,13 +268,13 @@ FILE * ExportFile;
}
/*****************************************************************/
void SuppressDuplicateDrawItem( EDA_LibComponentStruct* LibEntry )
/*****************************************************************/
/* Delete redundant graphic items.
Useful after loading asymbole from a file symbol, because some graphic items
can be duplicated.
* Useful after loading asymbole from a file symbol, because some graphic items
* can be duplicated.
*/
{
LibEDA_BaseStruct* DEntryRef, * DEntryCompare;
@ -266,9 +284,11 @@ wxDC * DC = NULL;
DEntryRef = LibEntry->m_Drawings;
while( DEntryRef )
{
if( DEntryRef->Pnext == NULL ) return;
if( DEntryRef->Pnext == NULL )
return;
DEntryCompare = DEntryRef->Next();
if( DEntryCompare == NULL ) return;
if( DEntryCompare == NULL )
return;
deleted = 0;
while( DEntryCompare )
{
@ -280,29 +300,35 @@ wxDC * DC = NULL;
}
DEntryCompare = DEntryCompare->Next();
}
if ( ! deleted ) DEntryRef = DEntryRef->Next();
else DEntryRef = LibEntry->m_Drawings;
}
}
if( !deleted )
DEntryRef = DEntryRef->Next();
else
DEntryRef = LibEntry->m_Drawings;
}
}
/********************************************************************/
static bool CompareSymbols( LibEDA_BaseStruct* DEntryRef,
LibEDA_BaseStruct* DEntryCompare )
/********************************************************************/
/* Compare 2 graphic items (arc, lines ...).
return FALSE si different
TRUE si they are identical, and therefore redundant
* return FALSE si different
* TRUE si they are identical, and therefore redundant
*/
{
int ii;
int* ptref, * ptcomp;
/* Comparaison des proprietes generales */
if( DEntryRef->m_StructType != DEntryCompare->m_StructType) return(FALSE);
if( DEntryRef->m_Unit != DEntryCompare->m_Unit) return(FALSE);
if( DEntryRef->m_Convert != DEntryCompare->m_Convert) return(FALSE);
if( DEntryRef->m_StructType != DEntryCompare->m_StructType )
return FALSE;
if( DEntryRef->m_Unit != DEntryCompare->m_Unit )
return FALSE;
if( DEntryRef->m_Convert != DEntryCompare->m_Convert )
return FALSE;
switch( DEntryRef->m_StructType )
{
@ -311,10 +337,14 @@ int * ptref, *ptcomp;
#undef CMPSTRUCT
#define REFSTRUCT ( (LibDrawArc*) DEntryRef )
#define CMPSTRUCT ( (LibDrawArc*) DEntryCompare )
if( REFSTRUCT->m_Pos.x != CMPSTRUCT->m_Pos.x) return(FALSE);
if( REFSTRUCT->m_Pos.y != CMPSTRUCT->m_Pos.y) return(FALSE);
if( REFSTRUCT->t1 != CMPSTRUCT->t1) return(FALSE);
if( REFSTRUCT->t2 != CMPSTRUCT->t2) return(FALSE);
if( REFSTRUCT->m_Pos.x != CMPSTRUCT->m_Pos.x )
return FALSE;
if( REFSTRUCT->m_Pos.y != CMPSTRUCT->m_Pos.y )
return FALSE;
if( REFSTRUCT->t1 != CMPSTRUCT->t1 )
return FALSE;
if( REFSTRUCT->t2 != CMPSTRUCT->t2 )
return FALSE;
break;
case COMPONENT_CIRCLE_DRAW_TYPE:
@ -322,9 +352,12 @@ int * ptref, *ptcomp;
#undef CMPSTRUCT
#define REFSTRUCT ( (LibDrawCircle*) DEntryRef )
#define CMPSTRUCT ( (LibDrawCircle*) DEntryCompare )
if( REFSTRUCT->m_Pos.x != CMPSTRUCT->m_Pos.x) return(FALSE);
if( REFSTRUCT->m_Pos.y != CMPSTRUCT->m_Pos.y) return(FALSE);
if( REFSTRUCT->m_Rayon != CMPSTRUCT->m_Rayon) return(FALSE);
if( REFSTRUCT->m_Pos.x != CMPSTRUCT->m_Pos.x )
return FALSE;
if( REFSTRUCT->m_Pos.y != CMPSTRUCT->m_Pos.y )
return FALSE;
if( REFSTRUCT->m_Rayon != CMPSTRUCT->m_Rayon )
return FALSE;
break;
case COMPONENT_GRAPHIC_TEXT_DRAW_TYPE:
@ -332,10 +365,12 @@ int * ptref, *ptcomp;
#undef CMPSTRUCT
#define REFSTRUCT ( (LibDrawText*) DEntryRef )
#define CMPSTRUCT ( (LibDrawText*) DEntryCompare )
if( REFSTRUCT->m_Pos != CMPSTRUCT->m_Pos) return(FALSE);
if( REFSTRUCT->m_Size != CMPSTRUCT->m_Size) return(FALSE);
if( REFSTRUCT->m_Pos != CMPSTRUCT->m_Pos )
return FALSE;
if( REFSTRUCT->m_Size != CMPSTRUCT->m_Size )
return FALSE;
if( REFSTRUCT->m_Text != CMPSTRUCT->m_Text )
return(FALSE);
return FALSE;
break;
case COMPONENT_RECT_DRAW_TYPE:
@ -343,8 +378,10 @@ int * ptref, *ptcomp;
#undef CMPSTRUCT
#define REFSTRUCT ( (LibDrawSquare*) DEntryRef )
#define CMPSTRUCT ( (LibDrawSquare*) DEntryCompare )
if( REFSTRUCT->m_Pos != CMPSTRUCT->m_Pos) return(FALSE);
if( REFSTRUCT->m_End != CMPSTRUCT->m_End) return(FALSE);
if( REFSTRUCT->m_Pos != CMPSTRUCT->m_Pos )
return FALSE;
if( REFSTRUCT->m_End != CMPSTRUCT->m_End )
return FALSE;
break;
case COMPONENT_PIN_DRAW_TYPE:
@ -352,7 +389,8 @@ int * ptref, *ptcomp;
#undef CMPSTRUCT
#define REFSTRUCT ( (LibDrawPin*) DEntryRef )
#define CMPSTRUCT ( (LibDrawPin*) DEntryCompare )
if( REFSTRUCT->m_Pos != CMPSTRUCT->m_Pos) return(FALSE);
if( REFSTRUCT->m_Pos != CMPSTRUCT->m_Pos )
return FALSE;
break;
case COMPONENT_POLYLINE_DRAW_TYPE:
@ -360,19 +398,25 @@ int * ptref, *ptcomp;
#undef CMPSTRUCT
#define REFSTRUCT ( (LibDrawPolyline*) DEntryRef )
#define CMPSTRUCT ( (LibDrawPolyline*) DEntryCompare )
if( REFSTRUCT->n != CMPSTRUCT->n) return(FALSE);
if( REFSTRUCT->n != CMPSTRUCT->n )
return FALSE;
ptref = REFSTRUCT->PolyList;
ptcomp = CMPSTRUCT->PolyList;
for( ii = 2 * REFSTRUCT->n; ii > 0; ii-- )
{
if( *ptref != *ptcomp) return(FALSE);
if( *ptref != *ptcomp )
return FALSE;
ptref++; ptcomp++;
}
break;
}
return(TRUE);
default:
;
}
return TRUE;
}
/***************************************************************************/
@ -394,7 +438,8 @@ LibEDA_BaseStruct * DrawEntry;
dy = m_CurrentScreen->m_Curseur.y;
LibEntry = CurrentLibEntry;
if( LibEntry == NULL ) return;
if( LibEntry == NULL )
return;
m_CurrentScreen->SetModify();
@ -457,12 +502,15 @@ LibEDA_BaseStruct * DrawEntry;
*ptsegm += dy; ptsegm++;
}
break;
default:
;
}
DrawEntry = DrawEntry->Next();
}
/* Redraw the symbol */
m_CurrentScreen->m_Curseur.x = m_CurrentScreen->m_Curseur.y = 0;
Recadre_Trace( TRUE );
m_CurrentScreen->SetRefreshReq();
}

31
include/base_struct.h
View File

@ -14,7 +14,9 @@ extern std::ostream& operator<<( std::ostream& out, const wxPoint& pt );
/* Id for class identification, at run time */
enum DrawStructureType {
enum KICAD_T {
NOT_USED = -1, // the 3d code uses this value
EOT = 0, // search types array terminator (End Of Types)
@ -80,7 +82,6 @@ enum SEARCH_RESULT {
SEARCH_CONTINUE
};
typedef DrawStructureType KICAD_T; // shorter name
class EDA_BaseStruct;
class WinEDA_DrawFrame;
@ -126,7 +127,7 @@ public:
class EDA_BaseStruct /* Basic class, not directly used */
{
public:
int m_StructType; /* Struct ident for run time identification */
KICAD_T m_StructType; /* Struct ident for run time identification */
EDA_BaseStruct* Pnext; /* Linked list: Link (next struct) */
EDA_BaseStruct* Pback; /* Linked list: Link (previous struct) */
EDA_BaseStruct* m_Parent; /* Linked list: Link (parent struct) */
@ -163,11 +164,11 @@ private:
public:
EDA_BaseStruct( EDA_BaseStruct* parent, int idType );
EDA_BaseStruct( int struct_type );
EDA_BaseStruct( EDA_BaseStruct* parent, KICAD_T idType );
EDA_BaseStruct( KICAD_T struct_type );
virtual ~EDA_BaseStruct() { };
EDA_BaseStruct* Next( void ) { return Pnext; }
EDA_BaseStruct* Next() { return Pnext; }
/* Gestion de l'etat (status) de la structure (active, deleted..) */
int GetState( int type );
@ -381,7 +382,7 @@ protected:
public:
BOARD_ITEM( BOARD_ITEM* StructFather, DrawStructureType idtype ) :
BOARD_ITEM( BOARD_ITEM* StructFather, KICAD_T idtype ) :
EDA_BaseStruct( StructFather, idtype ),
m_Layer(0)
{
@ -450,22 +451,6 @@ public:
};
/* Base class for building items like lines, which have 1 start point and 1 end point.
* Arc and circles can use this class.
*/
class EDA_BaseLineStruct : public EDA_BaseStruct
{
public:
int m_Layer; // Layer number
int m_Width; // 0 = line, > 0 = tracks, bus ...
wxPoint m_Start; // Line start point
wxPoint m_End; // Line end point
public:
EDA_BaseLineStruct( EDA_BaseStruct* StructFather, DrawStructureType idtype );
};
/**************************/
/* class DrawPickedStruct */
/**************************/

2
include/pcbstruct.h
View File

@ -358,7 +358,7 @@ public:
int m_Angle; // pour les arcs: "longueur" de l'arc en 1/10 deg
public:
DRAWSEGMENT( BOARD_ITEM* StructFather, DrawStructureType idtype = TYPEDRAWSEGMENT );
DRAWSEGMENT( BOARD_ITEM* StructFather, KICAD_T idtype = TYPEDRAWSEGMENT );
~DRAWSEGMENT( void );
// Read/write data

2
include/wxstruct.h
View File

@ -501,7 +501,7 @@ public:
virtual void SwitchLayer( wxDC* DC, int layer );
// divers
void AddHistory( int value, DrawStructureType type ); // Add value in data list history
void AddHistory( int value, KICAD_T type ); // Add value in data list history
void InstallGridFrame( const wxPoint& pos );
};

9
pcbnew/block_module_editor.cpp
View File

@ -502,6 +502,9 @@ void MoveMarkedItems( MODULE* module, wxPoint offset )
( (EDGE_MODULE*) item )->m_End0.x += offset.x;
( (EDGE_MODULE*) item )->m_End0.y += offset.y;
break;
default:
;
}
item->m_Flags = item->m_Selected = 0;
@ -588,6 +591,9 @@ void MirrorMarkedItems( MODULE* module, wxPoint offset )
SETMIRROR( ( (TEXTE_MODULE*) item )->m_Pos.x );
( (TEXTE_MODULE*) item )->m_Pos0.x = ( (TEXTE_MODULE*) item )->m_Pos.x;
break;
default:
;
}
item->m_Flags = item->m_Selected = 0;
@ -639,6 +645,9 @@ void RotateMarkedItems( MODULE* module, wxPoint offset )
( (TEXTE_MODULE*) item )->m_Pos0 = ( (TEXTE_MODULE*) item )->m_Pos;
( (TEXTE_MODULE*) item )->m_Orient += 900;
break;
default:
;
}
item->m_Flags = item->m_Selected = 0;

1
pcbnew/class_edge_mod.cpp
View File

@ -31,6 +31,7 @@
EDGE_MODULE::EDGE_MODULE( MODULE* parent ) :
BOARD_ITEM( parent, TYPEEDGEMODULE )
{
m_Width = 0;
m_Shape = S_SEGMENT;
m_Angle = 0;
m_Width = 120;

3
pcbnew/class_track.cpp
View File

@ -22,9 +22,10 @@
/* Constructeur des classes type pistes, vias et zones */
TRACK::TRACK( BOARD_ITEM* StructFather, DrawStructureType idtype ) :
TRACK::TRACK( BOARD_ITEM* StructFather, KICAD_T idtype ) :
BOARD_ITEM( StructFather, idtype )
{
m_Width = 0;
m_Shape = S_SEGMENT;
start = end = NULL;
m_NetCode = 0;

2
pcbnew/class_track.h
View File

@ -40,7 +40,7 @@ public:
int m_Param; // Auxiliary variable ( used in some computations )
public:
TRACK( BOARD_ITEM* StructFather, DrawStructureType idtype = TYPETRACK );
TRACK( BOARD_ITEM* StructFather, KICAD_T idtype = TYPETRACK );
TRACK( const TRACK& track );
TRACK* Next() { return (TRACK*) Pnext; }

4
pcbnew/classpcb.cpp
View File

@ -52,10 +52,10 @@ EDGE_ZONE:: ~EDGE_ZONE( void )
/**********************/
/* Classe DRAWSEGMENT: constructeur */
DRAWSEGMENT::DRAWSEGMENT( BOARD_ITEM* StructFather, DrawStructureType idtype ) :
DRAWSEGMENT::DRAWSEGMENT( BOARD_ITEM* StructFather, KICAD_T idtype ) :
BOARD_ITEM( StructFather, idtype )
{
m_Flags = m_Shape = m_Type = m_Angle = 0;
m_Width = m_Flags = m_Shape = m_Type = m_Angle = 0;
}

2
pcbnew/classtrc.cpp
View File

@ -19,7 +19,7 @@
/* Constructeur des classes type pistes, vias et zones */
TRACK::TRACK( EDA_BaseStruct* StructFather, DrawStructureType idtype ) :
TRACK::TRACK( EDA_BaseStruct* StructFather, KICAD_T idtype ) :
SEGDRAW_Struct( StructFather, idtype )
{
m_Shape = S_SEGMENT;

2
pcbnew/dialog_track_options.cpp
View File

@ -281,7 +281,7 @@ void WinEDA_PcbTracksDialog::AcceptPcbOptions(wxCommandEvent& event)
/*********************************************************************/
void WinEDA_BasePcbFrame::AddHistory(int value, DrawStructureType type)
void WinEDA_BasePcbFrame::AddHistory(int value, KICAD_T type)
/**********************************************************************/
// Mise a jour des listes des dernieres epaisseurs de via et track utilisées
{

3
pcbnew/ratsnest.cpp
View File

@ -1254,6 +1254,9 @@ int* WinEDA_BasePcbFrame::build_ratsnest_pad( EDA_BaseStruct* ref,
conn_number = track_ref->m_Sous_Netcode;
break;
}
default:
;
}
if( current_net_code <= 0 )