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

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

@ -25,8 +25,8 @@ S3D_Vertex::S3D_Vertex(void)
/**************************************************************************/
S3D_Material::S3D_Material(Struct3D_Master * father, const wxString & name):
EDA_BaseStruct( father, -1)
S3D_Material::S3D_Material( Struct3D_Master * father, const wxString & name ):
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 */
/*********************************************************/

177
eeschema/affiche.cpp
View File

@ -1,8 +1,8 @@
/**********************************************************/
/* Routines d'affichage de parametres et caracteristiques */
/**********************************************************/
/**********************************************************/
/* Routines d'affichage de parametres et caracteristiques */
/**********************************************************/
/* Fichier AFFICHE.CPP */
/* Fichier AFFICHE.CPP */
#include "fctsys.h"
#include "gr_basic.h"
@ -15,136 +15,175 @@
/***********************************************************/
void DrawSheetStruct::Display_Infos(WinEDA_DrawFrame * frame)
void DrawSheetStruct::Display_Infos( WinEDA_DrawFrame* frame )
/************************************************************/
{
frame->MsgPanel->EraseMsgBox();
Affiche_1_Parametre(frame, 1, _("Name"), m_SheetName, CYAN);
Affiche_1_Parametre(frame, 30, _("FileName"), m_FileName, BROWN);
Affiche_1_Parametre( frame, 1, _( "Name" ), m_SheetName, CYAN );
Affiche_1_Parametre( frame, 30, _( "FileName" ), m_FileName, BROWN );
}
/***************************************************************/
void EDA_SchComponentStruct::Display_Infos(WinEDA_DrawFrame * frame)
void EDA_SchComponentStruct::Display_Infos( WinEDA_DrawFrame* frame )
/***************************************************************/
{
EDA_LibComponentStruct * Entry = FindLibPart(m_ChipName.GetData(),wxEmptyString,FIND_ROOT);;
wxString msg;
EDA_LibComponentStruct* Entry = FindLibPart( m_ChipName.GetData(), wxEmptyString, FIND_ROOT );;
wxString msg;
frame->MsgPanel->EraseMsgBox();
Affiche_1_Parametre(frame, 1, _("Ref"),
m_Field[REFERENCE].m_Text, DARKCYAN);
Affiche_1_Parametre( frame, 1, _( "Ref" ),
m_Field[REFERENCE].m_Text, DARKCYAN );
if (Entry && Entry->m_Options == ENTRY_POWER)
msg = _("Pwr Symb");
else msg = _("Val");
Affiche_1_Parametre(frame, 10, msg, m_Field[VALUE].m_Text, DARKCYAN);
if( Entry && Entry->m_Options == ENTRY_POWER )
msg = _( "Pwr Symb" );
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);
Affiche_1_Parametre( frame, 28, _( "RefLib" ), m_ChipName.GetData(), BROWN );
msg = FindLibName;
Affiche_1_Parametre(frame, 40, _("Lib"), msg, DARKRED);
Affiche_1_Parametre( frame, 40, _( "Lib" ), msg, DARKRED );
if( Entry )
{
Affiche_1_Parametre(frame, 52, Entry->m_Doc, wxEmptyString, DARKCYAN);
Affiche_1_Parametre(frame, 52, wxEmptyString, Entry->m_KeyWord, DARKGREEN);
Affiche_1_Parametre( frame, 52, Entry->m_Doc, wxEmptyString, DARKCYAN );
Affiche_1_Parametre( frame, 52, wxEmptyString, Entry->m_KeyWord, DARKGREEN );
}
}
/*******************************************************/
void LibDrawPin::Display_Infos( WinEDA_DrawFrame* frame )
/*******************************************************/
/*******************************************************/
void LibDrawPin::Display_Infos(WinEDA_DrawFrame * frame)
/*******************************************************/
/* Affiche en bas d'ecran les caracteristiques de la pin
*/
*/
{
wxString Text;
int ii;
wxString Text;
int ii;
frame->MsgPanel->EraseMsgBox();
/* Affichage du nom */
Affiche_1_Parametre(frame, 24, _("PinName"), m_PinName, DARKCYAN);
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);
Affiche_1_Parametre( frame, 40, _( "PinNum" ), Text, DARKCYAN );
/* Affichage du type */
ii = m_PinType;
Affiche_1_Parametre(frame, 48, _("PinType"), MsgPinElectricType[ii], RED);
Affiche_1_Parametre( frame, 48, _( "PinType" ), MsgPinElectricType[ii], RED );
/* Affichage de la visiblite */
ii = m_Attributs;
if( ii & 1 ) Text = _("no");
else Text = _("yes");
Affiche_1_Parametre(frame, 58, _("Display"), Text, DARKGREEN);
if( ii & 1 )
Text = _( "no" );
else
Text = _( "yes" );
Affiche_1_Parametre( frame, 58, _( "Display" ), Text, DARKGREEN );
/* Affichage de la longueur */
Text.Printf( wxT("%d"), m_PinLen);
Affiche_1_Parametre(frame, 66, _("Lengh"), Text, MAGENTA);
Text.Printf( wxT( "%d" ), m_PinLen );
Affiche_1_Parametre( frame, 66, _( "Lengh" ), Text, MAGENTA );
/* Affichage de l'orientation */
switch(m_Orient)
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);
Affiche_1_Parametre( frame, 72, _( "Orient" ), Text, MAGENTA );
}
/***********************************************************************/
void LibEDA_BaseStruct::Display_Infos_DrawEntry(WinEDA_DrawFrame * frame)
void LibEDA_BaseStruct::Display_Infos_DrawEntry( WinEDA_DrawFrame* frame )
/***********************************************************************/
/* Affiche en bas d'ecran les caracteristiques de l'element
*/
*/
{
wxString msg;
wxString msg;
frame->MsgPanel->EraseMsgBox();
/* affichage du type */
msg = wxT("??");
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");
( (LibDrawPin*) this )->Display_Infos( frame );
msg = wxT( "Pin" );
break;
default:
;
}
Affiche_1_Parametre(frame, 1, wxT("Type"), msg, CYAN);
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 );
Affiche_1_Parametre(frame, 10, _("Unit"), msg, BROWN);
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("?");
Affiche_1_Parametre(frame, 16, _("Convert"), 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( "?" );
Affiche_1_Parametre( frame, 16, _( "Convert" ), msg, BROWN );
if ( m_Width ) valeur_param(m_Width, msg);
else msg = _("default");
Affiche_1_Parametre(frame, 24, _("Width"), msg, BLUE);
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);
};

381
eeschema/dangling_ends.cpp
View File

@ -1,6 +1,6 @@
/*********************/
/* dangling_ends.cpp */
/*********************/
/*********************/
/* dangling_ends.cpp */
/*********************/
#include "fctsys.h"
#include "gr_basic.h"
@ -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,
@ -29,126 +28,141 @@ enum End_Type
class DanglingEndHandle
{
public:
const void * m_Item;
const void* m_Item;
wxPoint m_Pos;
int m_Type;
DanglingEndHandle * m_Pnext;
DanglingEndHandle* m_Pnext;
DanglingEndHandle(int type)
{
DanglingEndHandle( int type ) {
m_Item = NULL;
m_Type = type;
m_Pnext = NULL;
}
};
DanglingEndHandle * ItemList;
DanglingEndHandle* ItemList;
static void TestWireForDangling(EDA_DrawLineStruct * DrawRef,
WinEDA_SchematicFrame * frame, wxDC * DC);
void TestLabelForDangling(DrawTextStruct * label,
WinEDA_SchematicFrame * frame, wxDC * DC);
DanglingEndHandle * RebuildEndList(EDA_BaseStruct *DrawList);
static void TestWireForDangling( EDA_DrawLineStruct* DrawRef,
WinEDA_SchematicFrame* frame, wxDC* DC );
void TestLabelForDangling( DrawTextStruct* label,
WinEDA_SchematicFrame* frame, wxDC* DC );
DanglingEndHandle* RebuildEndList( EDA_BaseStruct* DrawList );
/**********************************************************/
bool SegmentIntersect(int Sx1, int Sy1, int Sx2, int Sy2,
int Px1, int Py1)
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;
int Sxmin, Sxmax, Symin, Symax;
if (Sx1 == Sx2) /* Line S is vertical. */
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;
Symin = MIN( Sy1, Sy2 ); Symax = MAX( Sy1, Sy2 );
if( Px1 != Sx1 )
return FALSE;
if( Py1 >= Symin && Py1 <= Symax )
return TRUE;
else
return FALSE;
}
else if (Sy1 == Sy2) /* Line S is horizontal. */
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;
Sxmin = MIN( Sx1, Sx2 ); Sxmax = MAX( Sx1, Sx2 );
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 )
/******************************************************************************/
/******************************************************************************/
void WinEDA_SchematicFrame::TestDanglingEnds(EDA_BaseStruct *DrawList, wxDC *DC)
/******************************************************************************/
/* Met a jour les membres m_Dangling des wires, bus, labels
*/
*/
{
EDA_BaseStruct * DrawItem;
const DanglingEndHandle * DanglingItem, * nextitem;
EDA_BaseStruct* DrawItem;
const DanglingEndHandle* DanglingItem, * nextitem;
if ( ItemList )
for ( DanglingItem = ItemList; DanglingItem != NULL; DanglingItem = nextitem)
if( ItemList )
for( DanglingItem = ItemList; DanglingItem != NULL; DanglingItem = nextitem )
{
nextitem = DanglingItem->m_Pnext;
delete DanglingItem;
}
ItemList = RebuildEndList(DrawList);
ItemList = RebuildEndList( DrawList );
// Controle des elements
for ( DrawItem = DrawList; DrawItem != NULL; DrawItem= DrawItem->Pnext)
for( DrawItem = DrawList; DrawItem != NULL; DrawItem = DrawItem->Pnext )
{
switch( DrawItem->m_StructType )
{
case DRAW_GLOBAL_LABEL_STRUCT_TYPE:
case DRAW_LABEL_STRUCT_TYPE:
#undef STRUCT
#define STRUCT ((DrawLabelStruct*)DrawItem)
TestLabelForDangling(STRUCT, this, DC);
#define STRUCT ( (DrawLabelStruct*) DrawItem )
TestLabelForDangling( STRUCT, this, DC );
break;
break;
case DRAW_SEGMENT_STRUCT_TYPE:
#undef STRUCT
#define STRUCT ((EDA_DrawLineStruct*)DrawItem)
if( STRUCT->m_Layer == LAYER_WIRE)
#define STRUCT ( (EDA_DrawLineStruct*) DrawItem )
if( STRUCT->m_Layer == LAYER_WIRE )
{
TestWireForDangling(STRUCT, this, DC);
TestWireForDangling( STRUCT, this, DC );
break;
}
if( STRUCT->m_Layer == LAYER_NOTES) break;
if( STRUCT->m_Layer == LAYER_BUS)
if( STRUCT->m_Layer == LAYER_NOTES )
break;
if( STRUCT->m_Layer == LAYER_BUS )
{
STRUCT->m_StartIsDangling =
STRUCT->m_EndIsDangling = FALSE;
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
*/
{
EDA_SchComponentStruct * DrawLibItem;
LibDrawPin * Pin;
wxPoint pinpos;
Pin = LocateAnyPin(DrawList,pos, &DrawLibItem);
if( ! Pin ) return NULL;
/********************************************************************/
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
*/
{
EDA_SchComponentStruct* DrawLibItem;
LibDrawPin* Pin;
wxPoint pinpos;
Pin = LocateAnyPin( DrawList, pos, &DrawLibItem );
if( !Pin )
return NULL;
pinpos = Pin->m_Pos;
if(DrawLibItem == NULL ) pinpos.y = -pinpos.y;
if( DrawLibItem == NULL )
pinpos.y = -pinpos.y;
else
{
@ -159,77 +173,82 @@ 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;
}
/****************************************************************************/
void TestWireForDangling(EDA_DrawLineStruct * DrawRef,
WinEDA_SchematicFrame * frame, wxDC * DC)
void TestWireForDangling( EDA_DrawLineStruct* DrawRef,
WinEDA_SchematicFrame* frame, wxDC* DC )
/****************************************************************************/
{
DanglingEndHandle * terminal_item;
bool Sdangstate = TRUE, Edangstate = TRUE;
DanglingEndHandle* terminal_item;
bool Sdangstate = TRUE, Edangstate = TRUE;
for ( terminal_item = ItemList; terminal_item != NULL;
terminal_item = terminal_item->m_Pnext)
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) )
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);
if( DC )
RedrawOneStruct( frame->DrawPanel, DC, DrawRef, g_XorMode );
DrawRef->m_StartIsDangling = Sdangstate;
DrawRef->m_EndIsDangling = Edangstate;
if ( DC )
RedrawOneStruct(frame->DrawPanel,DC, DrawRef, GR_DEFAULT_DRAWMODE);
if( DC )
RedrawOneStruct( frame->DrawPanel, DC, DrawRef, GR_DEFAULT_DRAWMODE );
}
}
/********************************************************/
void TestLabelForDangling(DrawTextStruct * label,
WinEDA_SchematicFrame * frame, wxDC * DC)
void TestLabelForDangling( DrawTextStruct* label,
WinEDA_SchematicFrame* frame, wxDC* DC )
/********************************************************/
{
DanglingEndHandle * terminal_item;
bool dangstate = TRUE;
DanglingEndHandle* terminal_item;
bool dangstate = TRUE;
for ( terminal_item = ItemList; terminal_item != NULL;
terminal_item = terminal_item->m_Pnext)
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;
case WIRE_START_END:
case BUS_START_END:
dangstate = ! SegmentIntersect(terminal_item->m_Pos.x,
dangstate = !SegmentIntersect( terminal_item->m_Pos.x,
terminal_item->m_Pos.y,
terminal_item->m_Pnext->m_Pos.x,
terminal_item->m_Pnext->m_Pos.y,
label->m_Pos.x, label->m_Pos.y);
label->m_Pos.x, label->m_Pos.y );
terminal_item = terminal_item->m_Pnext;
break;
@ -241,30 +260,33 @@ bool dangstate = TRUE;
break;
}
if (dangstate == FALSE) break;
if( dangstate == FALSE )
break;
}
if ( dangstate != label->m_IsDangling )
if( dangstate != label->m_IsDangling )
{
if ( DC )
RedrawOneStruct(frame->DrawPanel,DC, label, g_XorMode);
if( DC )
RedrawOneStruct( frame->DrawPanel, DC, label, g_XorMode );
label->m_IsDangling = dangstate;
if ( DC )
RedrawOneStruct(frame->DrawPanel,DC, label, GR_DEFAULT_DRAWMODE);
if( DC )
RedrawOneStruct( frame->DrawPanel, DC, label, GR_DEFAULT_DRAWMODE );
}
}
/****************************************************/
wxPoint ReturnPinPhysicalPosition( LibDrawPin * Pin,
EDA_SchComponentStruct * DrawLibItem)
wxPoint ReturnPinPhysicalPosition( LibDrawPin* Pin,
EDA_SchComponentStruct* DrawLibItem )
/****************************************************/
/* Retourne la position physique de la pin, qui dépend de l'orientation
du composant */
{
wxPoint PinPos = Pin->m_Pos;
if(DrawLibItem == NULL ) PinPos.y = -PinPos.y;
/* Retourne la position physique de la pin, qui dépend de l'orientation
* du composant */
{
wxPoint PinPos = Pin->m_Pos;
if( DrawLibItem == NULL )
PinPos.y = -PinPos.y;
else
{
@ -280,13 +302,13 @@ wxPoint PinPos = Pin->m_Pos;
/***********************************************************/
DanglingEndHandle * RebuildEndList(EDA_BaseStruct *DrawList)
DanglingEndHandle* RebuildEndList( EDA_BaseStruct* DrawList )
/***********************************************************/
{
DanglingEndHandle * StartList = NULL, *item, *lastitem = NULL;
EDA_BaseStruct * DrawItem;
DanglingEndHandle* StartList = NULL, * item, * lastitem = NULL;
EDA_BaseStruct* DrawItem;
for ( DrawItem = DrawList; DrawItem != NULL; DrawItem = DrawItem->Pnext)
for( DrawItem = DrawList; DrawItem != NULL; DrawItem = DrawItem->Pnext )
{
switch( DrawItem->m_StructType )
{
@ -295,30 +317,38 @@ EDA_BaseStruct * DrawItem;
case DRAW_GLOBAL_LABEL_STRUCT_TYPE:
#undef STRUCT
#define STRUCT ((DrawGlobalLabelStruct*)DrawItem)
item = new DanglingEndHandle(LABEL_END);
#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;
#define STRUCT ( (EDA_DrawLineStruct*) DrawItem )
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 = 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 = 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;
@ -328,25 +358,32 @@ EDA_BaseStruct * DrawItem;
case DRAW_JUNCTION_STRUCT_TYPE:
#undef STRUCT
#define STRUCT ((DrawJunctionStruct*)DrawItem)
item = new DanglingEndHandle(JUNCTION_END);
#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;
case DRAW_BUSENTRY_STRUCT_TYPE:
#undef STRUCT
#define STRUCT ((DrawBusEntryStruct*)DrawItem)
item = new DanglingEndHandle(ENTRY_END);
#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 = new DanglingEndHandle( ENTRY_END );
item->m_Item = DrawItem;
item->m_Pos = STRUCT->m_End();
lastitem->m_Pnext = item;
@ -356,54 +393,68 @@ EDA_BaseStruct * DrawItem;
case DRAW_LIB_ITEM_STRUCT_TYPE:
{
#undef STRUCT
#define STRUCT ((EDA_SchComponentStruct*)DrawItem)
EDA_LibComponentStruct * Entry;
Entry = FindLibPart( STRUCT->m_ChipName, wxEmptyString, FIND_ROOT);
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;
LibDrawPin * Pin = (LibDrawPin *) DrawLibItem;
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) )
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;
lastitem = item;
}
#define STRUCT ( (EDA_SchComponentStruct*) DrawItem )
EDA_LibComponentStruct* Entry;
Entry = FindLibPart( STRUCT->m_ChipName, wxEmptyString, FIND_ROOT );
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;
LibDrawPin* Pin = (LibDrawPin*) DrawLibItem;
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) )
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;
lastitem = item;
}
break;
}
case DRAW_SHEET_STRUCT_TYPE:
{
#undef STRUCT
#define STRUCT ((DrawSheetStruct*)DrawItem)
DrawSheetLabelStruct * pinsheet = STRUCT->m_Label;
while(pinsheet)
#define STRUCT ( (DrawSheetStruct*) DrawItem )
DrawSheetLabelStruct* pinsheet = STRUCT->m_Label;
while( pinsheet )
{
item = new DanglingEndHandle(SHEET_LABEL_END);
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;
pinsheet = (DrawSheetLabelStruct*) pinsheet->Pnext;
}
break;
}
default:
;
}
}
return StartList;
}

950
eeschema/eelibs_draw_components.cpp
View File

File diff suppressed because it is too large Load Diff

1157
eeschema/eelibs_read_libraryfiles.cpp
View File

File diff suppressed because it is too large Load Diff

2
eeschema/hotkeys.cpp
View File

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

575
eeschema/libclass.cpp
View File

@ -13,12 +13,12 @@
#include "protos.h"
/*******************************************************/
/* Methodes relatives a la manipulation des librairies */
/*******************************************************/
/*******************************************************/
/* Methodes relatives a la manipulation des librairies */
/*******************************************************/
/***************************************************************************************/
LibraryStruct::LibraryStruct(int type, const wxString & name, const wxString & fullname)
LibraryStruct::LibraryStruct( int type, const wxString& name, const wxString& fullname )
/***************************************************************************************/
{
m_Type = type; /* type indicator */
@ -31,129 +31,147 @@ LibraryStruct::LibraryStruct(int type, const wxString & name, const wxString & f
m_TimeStamp = 0;
m_Flags = 0;
m_IsLibCache = FALSE;
}
/*****************************************/
void FreeLibraryEntry(LibCmpEntry * Entry)
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)
bool LibraryStruct::WriteHeader( FILE* file )
/*******************************************/
/* Ecrit l'entete du fichier librairie
*/
{
char BufLine[1024];
bool succes = TRUE;
DateAndTime(BufLine);
if ( fprintf(file,"%s %d.%d Date: %s\n", LIBFILE_IDENT,
/* Ecrit l'entete du fichier librairie
*/
{
char BufLine[1024];
bool succes = TRUE;
DateAndTime( BufLine );
if( fprintf( file, "%s %d.%d Date: %s\n", LIBFILE_IDENT,
LIB_VERSION_MAJOR, LIB_VERSION_MINOR,
BufLine) != 5 )
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
*/
{
char Line[1024], * text, * data;
while (GetLine(libfile, Line, LineNum, sizeof(Line)) )
/***********************************************************/
bool LibraryStruct::ReadHeader( FILE* libfile, int* LineNum )
/***********************************************************/
/* Ecrit l'entete du fichier librairie
*/
{
char Line[1024], * text, * data;
while( GetLine( libfile, Line, LineNum, sizeof(Line) ) )
{
text = strtok(Line, " \t\r\n");
data = strtok(NULL, " \t\r\n");
if ( stricmp(text, "TimeStamp") == 0 )
m_TimeStamp = atol(data);
if ( stricmp(text,"$ENDHEADER") == 0 ) return TRUE;
text = strtok( Line, " \t\r\n" );
data = strtok( NULL, " \t\r\n" );
if( stricmp( text, "TimeStamp" ) == 0 )
m_TimeStamp = atol( data );
if( stricmp( text, "$ENDHEADER" ) == 0 )
return TRUE;
}
return FALSE;
}
/*********************/
/* class LibCmpEntry */
/*********************/
/*********************/
/* 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
*/
/********************************************************************/
LibCmpEntry::LibCmpEntry(LibrEntryType CmpType, const wxChar * CmpName):
EDA_BaseStruct(LIBCOMPONENT_STRUCT_TYPE)
LibCmpEntry::LibCmpEntry( LibrEntryType CmpType, const wxChar* CmpName ) :
EDA_BaseStruct( LIBCOMPONENT_STRUCT_TYPE )
/********************************************************************/
{
Type = CmpType;
m_Name.m_FieldId = VALUE;
if ( CmpName ) m_Name.m_Text = CmpName;
if( CmpName )
m_Name.m_Text = CmpName;
}
/******************************/
LibCmpEntry::~LibCmpEntry(void)
LibCmpEntry::~LibCmpEntry( void )
/******************************/
{
}
/*******************************/
/* class EDA_LibCmpAliasStruct */
/*******************************/
/*******************************/
/* class EDA_LibCmpAliasStruct */
/*******************************/
/* 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)
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)
EDA_LibCmpAliasStruct::~EDA_LibCmpAliasStruct( void )
{
}
/********************************/
/* class EDA_LibComponentStruct */
/********************************/
/********************************/
/* class EDA_LibComponentStruct */
/********************************/
/* This is a standard component (in library)
*/
EDA_LibComponentStruct:: EDA_LibComponentStruct( const wxChar * CmpName):
LibCmpEntry(ROOT, CmpName)
*/
EDA_LibComponentStruct:: EDA_LibComponentStruct( const wxChar* CmpName ) :
LibCmpEntry( ROOT, CmpName )
{
m_Drawings = NULL;
m_LastDate = 0;
@ -167,23 +185,24 @@ EDA_LibComponentStruct:: EDA_LibComponentStruct( const wxChar * CmpName):
m_Prefix.m_FieldId = REFERENCE;
}
/******************************************************/
EDA_LibComponentStruct::~EDA_LibComponentStruct( void )
/******************************************************/
{
LibEDA_BaseStruct * DrawItem, * NextDrawItem;
LibDrawField *TempField, *field;
LibEDA_BaseStruct* DrawItem, * NextDrawItem;
LibDrawField* TempField, * field;
field = Fields; Fields = NULL;
while (field)
while( field )
{
TempField = field; field = (LibDrawField *) field->Pnext;
TempField = field; field = (LibDrawField*) field->Pnext;
delete TempField;
}
/* suppression des elements dependants */
DrawItem = m_Drawings; m_Drawings = NULL;
while(DrawItem)
while( DrawItem )
{
NextDrawItem = DrawItem->Next();
delete DrawItem;
@ -193,109 +212,121 @@ LibDrawField *TempField, *field;
/**********************************************************************/
EDA_Rect EDA_LibComponentStruct::GetBoundaryBox( int Unit, int Convert)
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;
int * pt, ii;
LibEDA_BaseStruct * DrawEntry;
EDA_Rect BoundaryBox;
int xmin, xmax, ymin, ymax, x1, y1;
int* pt, ii;
LibEDA_BaseStruct* DrawEntry;
EDA_Rect BoundaryBox;
DrawEntry = m_Drawings;
if ( DrawEntry )
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() )
for( ; DrawEntry != NULL; DrawEntry = DrawEntry->Next() )
{
if ( DrawEntry->m_Unit > 0 ) // The item is non common to units
if ( (m_UnitCount > 1 ) && (Unit > 0) && (Unit != DrawEntry->m_Unit) )
if( DrawEntry->m_Unit > 0 ) // The item is non common to units
if( (m_UnitCount > 1 ) && (Unit > 0) && (Unit != DrawEntry->m_Unit) )
continue;
if ( DrawEntry->m_Convert > 0 ) //The item is not common to alls convert
if ( (Convert > 0) && (Convert != DrawEntry->m_Convert) )
if( DrawEntry->m_Convert > 0 ) //The item is not common to alls convert
if( (Convert > 0) && (Convert != DrawEntry->m_Convert) )
continue;
switch ( DrawEntry->m_StructType)
switch( DrawEntry->m_StructType )
{
case COMPONENT_ARC_DRAW_TYPE:
{
// Arc is reduced to a line from m_Start to m_End.
// TO DO better.
LibDrawArc * Arc = (LibDrawArc *) DrawEntry;
LibDrawArc* Arc = (LibDrawArc*) DrawEntry;
x1 = Arc->m_ArcStart.x;
y1 = Arc->m_ArcStart.y;
xmin = MIN(xmin, x1);
ymin = MIN(ymin, y1);
xmax = MAX(xmax, x1);
ymax = MAX(ymax, y1);
xmin = MIN( xmin, x1 );
ymin = MIN( ymin, y1 );
xmax = MAX( xmax, x1 );
ymax = MAX( ymax, y1 );
x1 = Arc->m_ArcEnd.x;
y1 = Arc->m_ArcEnd.y;
xmin = MIN(xmin, x1);
ymin = MIN(ymin, y1);
xmax = MAX(xmax, x1);
ymax = MAX(ymax, y1);
xmin = MIN( xmin, x1 );
ymin = MIN( ymin, y1 );
xmax = MAX( xmax, x1 );
ymax = MAX( ymax, y1 );
}
break;
case COMPONENT_CIRCLE_DRAW_TYPE:
{
LibDrawCircle * Circle = (LibDrawCircle *) DrawEntry;
LibDrawCircle* Circle = (LibDrawCircle*) DrawEntry;
x1 = Circle->m_Pos.x - Circle->m_Rayon;
y1 = Circle->m_Pos.y - Circle->m_Rayon;
xmin = MIN(xmin, x1);
ymin = MIN(ymin, y1);
xmin = MIN( xmin, x1 );
ymin = MIN( ymin, y1 );
x1 = Circle->m_Pos.x + Circle->m_Rayon;
y1 = Circle->m_Pos.y + Circle->m_Rayon;
xmax = MAX(xmax, x1);
ymax = MAX(ymax, y1);
xmax = MAX( xmax, x1 );
ymax = MAX( ymax, y1 );
}
break;
case COMPONENT_RECT_DRAW_TYPE:
{
LibDrawSquare * Square = (LibDrawSquare *) DrawEntry;
xmin = MIN(xmin, Square->m_Pos.x);
xmin = MIN(xmin, Square->m_End.x);
xmax = MAX(xmax, Square->m_Pos.x);
xmax = MAX(xmax, Square->m_End.x);
ymin = MIN(ymin, Square->m_Pos.y);
ymin = MIN(ymin, Square->m_End.y);
ymax = MAX(ymax, Square->m_Pos.y);
ymax = MAX(ymax, Square->m_End.y);
LibDrawSquare* Square = (LibDrawSquare*) DrawEntry;
xmin = MIN( xmin, Square->m_Pos.x );
xmin = MIN( xmin, Square->m_End.x );
xmax = MAX( xmax, Square->m_Pos.x );
xmax = MAX( xmax, Square->m_End.x );
ymin = MIN( ymin, Square->m_Pos.y );
ymin = MIN( ymin, Square->m_End.y );
ymax = MAX( ymax, Square->m_Pos.y );
ymax = MAX( ymax, Square->m_End.y );
}
break;
case COMPONENT_PIN_DRAW_TYPE:
{
LibDrawPin * Pin = (LibDrawPin *) DrawEntry;
LibDrawPin* Pin = (LibDrawPin*) DrawEntry;
x1 = Pin->m_Pos.x;
y1 = Pin->m_Pos.y;
xmin = MIN(xmin, x1);
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
switch ( Pin->Orient )
xmin = MIN( xmin, x1 );
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
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);
ymax = MAX(ymax, y1);
xmin = MIN( xmin, x1 );
xmax = MAX( xmax, x1 );
ymin = MIN( ymin, y1 );
ymax = MAX( ymax, y1 );
#endif
}
break;
@ -305,52 +336,64 @@ EDA_Rect BoundaryBox;
case COMPONENT_POLYLINE_DRAW_TYPE:
{
LibDrawPolyline * polyline = (LibDrawPolyline *) DrawEntry;
LibDrawPolyline* polyline = (LibDrawPolyline*) DrawEntry;
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
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 );
BoundaryBox.SetX(xmin); BoundaryBox.SetWidth(xmax-xmin);
BoundaryBox.SetY(ymin); BoundaryBox.SetHeight(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 );
return 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.
/***************************/
/* class LibraryFieldEntry */
/***************************/
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)
/* 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,21 +402,25 @@ LibDrawField::LibDrawField(int idfield) : LibEDA_BaseStruct(COMPONENT_FIELD_DRAW
m_VJustify = GR_TEXT_VJUSTIFY_CENTER; /* Horizontal and vertical text justification */
}
LibDrawField::~LibDrawField(void)
LibDrawField::~LibDrawField( void )
{
}
// Creation et Duplication d'un field
LibDrawField * LibDrawField::GenCopy(void)
// Creation et Duplication d'un field
LibDrawField* LibDrawField::GenCopy( void )
{
LibDrawField * newfield = new LibDrawField(m_FieldId);
Copy(newfield);
LibDrawField* newfield = new LibDrawField( m_FieldId );
Copy( newfield );
return newfield;
}
// copie du field dans le field Target
void LibDrawField::Copy(LibDrawField * Target)
// copie du field dans le field Target
void LibDrawField::Copy( LibDrawField* Target )
{
Target->m_Pos = m_Pos;
Target->m_Size = m_Size;
@ -386,19 +433,21 @@ void LibDrawField::Copy(LibDrawField * Target)
Target->m_VJustify = m_VJustify;
}
/* Elements Graphiques */
LibEDA_BaseStruct::LibEDA_BaseStruct(int struct_type):
EDA_BaseStruct(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)
LibDrawPin::LibDrawPin( void ) : LibEDA_BaseStruct( COMPONENT_PIN_DRAW_TYPE )
/***************************************************************/
{
m_PinLen = 300; /* default Pin len */
@ -410,58 +459,80 @@ 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
}
/******************************************/
wxPoint LibDrawPin::ReturnPinEndPoint(void)
wxPoint LibDrawPin::ReturnPinEndPoint( void )
/******************************************/
/* return the pin end position, for a component in normal orient
*/
*/
{
wxPoint pos = m_Pos;
switch ( m_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
*/
{
int orient;
int x1 = 0, y1 = 0;
int t1, t2;
switch ( m_Orient )
/********************************************************/
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
*/
{
int orient;
int x1 = 0, y1 = 0;
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;
@ -469,45 +540,52 @@ int t1, t2;
/****************************************************/
void LibDrawPin::ReturnPinStringNum(wxString & buffer)
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];
char ascii_buf[5];
strncpy(ascii_buf, (char*)&m_PinNum,4);
ascii_buf[4]=0;
strncpy( ascii_buf, (char*) &m_PinNum, 4 );
ascii_buf[4] = 0;
buffer = CONV_FROM_UTF8(ascii_buf);
buffer = CONV_FROM_UTF8( ascii_buf );
}
/****************************************************/
void LibDrawPin::SetPinNumFromString(wxString & buffer)
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();
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;
for ( ii = 0; ii < len; ii ++ )
if( len > 4 )
len = 4;
for( ii = 0; ii < len; ii++ )
{
ascii_buf[ii] = buffer.GetChar(ii) & 0xFF;
ascii_buf[ii] = buffer.GetChar( ii ) & 0xFF;
}
strncpy((char*)&m_PinNum, ascii_buf, 4);
strncpy( (char*) &m_PinNum, ascii_buf, 4 );
}
/*************************************/
LibDrawPin * LibDrawPin::GenCopy(void)
LibDrawPin* LibDrawPin::GenCopy( void )
/*************************************/
{
LibDrawPin * newpin = new LibDrawPin();
LibDrawPin* newpin = new LibDrawPin();
newpin->m_Pos = m_Pos;
newpin->m_PinLen = m_PinLen;
@ -528,8 +606,9 @@ LibDrawPin * newpin = new LibDrawPin();
return newpin;
}
/**************************************************************/
LibDrawArc::LibDrawArc(void) : LibEDA_BaseStruct(COMPONENT_ARC_DRAW_TYPE)
LibDrawArc::LibDrawArc( void ) : LibEDA_BaseStruct( COMPONENT_ARC_DRAW_TYPE )
/**************************************************************/
{
m_Rayon = 0;
@ -540,10 +619,10 @@ LibDrawArc::LibDrawArc(void) : LibEDA_BaseStruct(COMPONENT_ARC_DRAW_TYPE)
/************************************/
LibDrawArc * LibDrawArc::GenCopy(void)
LibDrawArc* LibDrawArc::GenCopy( void )
/************************************/
{
LibDrawArc * newitem = new LibDrawArc();
LibDrawArc* newitem = new LibDrawArc();
newitem->m_Pos = m_Pos;
newitem->m_ArcStart = m_ArcStart;
@ -561,18 +640,19 @@ LibDrawArc * newitem = new LibDrawArc();
/**********************************************************************/
LibDrawCircle::LibDrawCircle(void) : LibEDA_BaseStruct(COMPONENT_CIRCLE_DRAW_TYPE)
LibDrawCircle::LibDrawCircle( void ) : LibEDA_BaseStruct( COMPONENT_CIRCLE_DRAW_TYPE )
/**********************************************************************/
{
m_Rayon = 0;
m_Fill = NO_FILL;
}
/*******************************************/
LibDrawCircle * LibDrawCircle::GenCopy(void)
LibDrawCircle* LibDrawCircle::GenCopy( void )
/*******************************************/
{
LibDrawCircle * newitem = new LibDrawCircle();
LibDrawCircle* newitem = new LibDrawCircle();
newitem->m_Pos = m_Pos;
newitem->m_Rayon = m_Rayon;
@ -586,20 +666,21 @@ LibDrawCircle * newitem = new LibDrawCircle();
/*****************************************************************/
LibDrawText::LibDrawText(void) : LibEDA_BaseStruct(COMPONENT_GRAPHIC_TEXT_DRAW_TYPE)
LibDrawText::LibDrawText( void ) : LibEDA_BaseStruct( COMPONENT_GRAPHIC_TEXT_DRAW_TYPE )
/*****************************************************************/
{
m_Horiz = TEXT_ORIENT_HORIZ;
m_Size = wxSize(50,50);
m_Size = wxSize( 50, 50 );
m_Type = 0;
m_Width = 0;
}
/***************************************/
LibDrawText * LibDrawText::GenCopy(void)
LibDrawText* LibDrawText::GenCopy( void )
/***************************************/
{
LibDrawText * newitem = new LibDrawText();
LibDrawText* newitem = new LibDrawText();
newitem->m_Pos = m_Pos;
newitem->m_Horiz = m_Horiz;
@ -614,16 +695,16 @@ LibDrawText * newitem = new LibDrawText();
}
LibDrawSquare::LibDrawSquare(void) : LibEDA_BaseStruct(COMPONENT_RECT_DRAW_TYPE)
LibDrawSquare::LibDrawSquare( void ) : LibEDA_BaseStruct( COMPONENT_RECT_DRAW_TYPE )
{
m_Width = 0;
m_Fill = NO_FILL;
}
LibDrawSquare * LibDrawSquare::GenCopy(void)
LibDrawSquare* LibDrawSquare::GenCopy( void )
{
LibDrawSquare * newitem = new LibDrawSquare();
LibDrawSquare* newitem = new LibDrawSquare();
newitem->m_Pos = m_Pos;
newitem->m_End = m_End;
@ -635,14 +716,16 @@ LibDrawSquare * newitem = new LibDrawSquare();
return newitem;
}
LibDrawSegment::LibDrawSegment(void) : LibEDA_BaseStruct(COMPONENT_LINE_DRAW_TYPE)
LibDrawSegment::LibDrawSegment( void ) : LibEDA_BaseStruct( COMPONENT_LINE_DRAW_TYPE )
{
m_Width = 0;
}
LibDrawSegment * LibDrawSegment::GenCopy(void)
LibDrawSegment* LibDrawSegment::GenCopy( void )
{
LibDrawSegment * newitem = new LibDrawSegment();
LibDrawSegment* newitem = new LibDrawSegment();
newitem->m_Pos = m_Pos;
newitem->m_End = m_End;
@ -654,7 +737,7 @@ LibDrawSegment * newitem = new LibDrawSegment();
}
LibDrawPolyline::LibDrawPolyline(void) : LibEDA_BaseStruct(COMPONENT_POLYLINE_DRAW_TYPE)
LibDrawPolyline::LibDrawPolyline( void ) : LibEDA_BaseStruct( COMPONENT_POLYLINE_DRAW_TYPE )
{
n = 0;
PolyList = NULL;
@ -662,19 +745,21 @@ LibDrawPolyline::LibDrawPolyline(void) : LibEDA_BaseStruct(COMPONENT_POLYLINE_DR
m_Width = 0;
}
/************************************************/
LibDrawPolyline * LibDrawPolyline::GenCopy(void)
LibDrawPolyline* LibDrawPolyline::GenCopy( void )
/************************************************/
{
LibDrawPolyline * newitem = new LibDrawPolyline();
int size;
LibDrawPolyline* newitem = new LibDrawPolyline();
int size;
newitem->n = n;
size = sizeof(int) * 2 * n;
if( size )
{
newitem->PolyList = (int*)MyMalloc(size);
memcpy(newitem->PolyList, PolyList, size);
newitem->PolyList = (int*) MyMalloc( size );
memcpy( newitem->PolyList, PolyList, size );
}
newitem->m_Pos = m_Pos;
newitem->m_Width = m_Width;
@ -685,23 +770,23 @@ int size;
return newitem;
}
/***************************************************/
void LibDrawPolyline::AddPoint(const wxPoint & point)
void LibDrawPolyline::AddPoint( const wxPoint& point )
/***************************************************/
/* add a point to the polyline coordinate list, and realloc the memory
*/
*/
{
int allocsize;
int allocsize;
n++;
allocsize = 2 * sizeof(int) * n;
if (PolyList == NULL)
PolyList = (int*)MyMalloc( allocsize );
if( PolyList == NULL )
PolyList = (int*) MyMalloc( allocsize );
else
PolyList = (int*)realloc(PolyList, allocsize );
PolyList = (int*) realloc( PolyList, allocsize );
PolyList[(n*2) - 2] = point.x;
PolyList[(n*2) - 1] = - point.y;
PolyList[(n * 2) - 2] = point.x;
PolyList[(n * 2) - 1] = -point.y;
}

234
eeschema/libcmp.h
View File

@ -15,7 +15,7 @@
#define LIB_VERSION_MINOR 3
#define LIBFILE_IDENT "EESchema-LIBRARY Version" /* Must be at the lib file start. */
#define DOCFILE_IDENT "EESchema-DOCLIB Version 2.0" /* Must be at the doc file start. */
#define DOC_EXT wxT(".dcm") /* extension des fichiers de documentation */
#define DOC_EXT wxT( ".dcm" ) /* extension des fichiers de documentation */
#define TARGET_PIN_DIAM 12 /* Diam cercle des extremites des pins */
@ -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 {
@ -90,23 +90,25 @@ typedef enum { /* Type des Pins. si modif: modifier tableau des mgs suivant */
} ElectricPinType;
/* Messages d'affichage du type electrique */
eda_global wxChar * MsgPinElectricType[]
eda_global wxChar* MsgPinElectricType[]
#ifdef MAIN
= {
wxT("input"),
wxT("output"),
wxT("BiDi"),
wxT("3state"),
wxT("passive"),
wxT("unspc"),
wxT("power_in"),
wxT("power_out"),
wxT("openCol"),
wxT("openEm"),
wxT("?????")
}
= {
wxT( "input" ),
wxT( "output" ),
wxT( "BiDi" ),
wxT( "3state" ),
wxT( "passive" ),
wxT( "unspc" ),
wxT( "power_in" ),
wxT( "power_out" ),
wxT( "openCol" ),
wxT( "openEm" ),
wxT( "?????" )
}
#endif
;
;
/* Autres bits: bits du membre .Flag des Pins */
#define PINNOTDRAW 1 /* si 1: pin invisible */
@ -117,14 +119,14 @@ typedef enum { /* Forme des Pins */
CLOCK = 2,
LOWLEVEL_IN = 4,
LOWLEVEL_OUT = 8
} DrawPinShape;
} DrawPinShape;
typedef enum { /* Orientation des Pins */
PIN_RIGHT = 'R',
PIN_LEFT = 'L',
PIN_UP = 'U',
PIN_DOWN = 'D',
} DrawPinOrient;
} DrawPinOrient;
/*************************************/
/* Classe representant une librairie */
@ -138,8 +140,8 @@ public:
wxString m_FullFileName; /* Full File Name (with path) of library loaded. */
wxString m_Header; /* first line of library loaded. */
int m_NumOfParts; /* Number of parts this library has. */
PriorQue * m_Entries; /* Parts themselves are saved here. */
LibraryStruct * m_Pnext; /* Point on next lib in chain. */
PriorQue* m_Entries; /* Parts themselves are saved here. */
LibraryStruct* m_Pnext; /* Point on next lib in chain. */
int m_Modified; /* flag indicateur d'edition */
int m_Size; // Size in bytes (for statistics)
unsigned long m_TimeStamp; // Signature temporelle
@ -148,10 +150,10 @@ public:
// True for the library cache
public:
LibraryStruct(int type, const wxString & name, const wxString & fullname);
LibraryStruct( int type, const wxString &name, const wxString &fullname );
~LibraryStruct();
bool WriteHeader(FILE * file);
bool ReadHeader(FILE * file, int * LineNum);
bool WriteHeader( FILE* file );
bool ReadHeader( FILE* file, int* LineNum );
};
@ -161,24 +163,27 @@ 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);
virtual ~LibEDA_BaseStruct(void){}
void Display_Infos_DrawEntry(WinEDA_DrawFrame * frame);
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,30 +196,32 @@ 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 */
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:
LibDrawPin(void);
~LibDrawPin(void) {}
LibDrawPin * GenCopy(void);
bool WriteDescr( FILE * File );
void Display_Infos(WinEDA_DrawFrame * frame);
wxPoint ReturnPinEndPoint(void);
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,
int DrawMode, int Color = -1);
LibDrawPin( void );
~LibDrawPin( void ) { }
LibDrawPin* GenCopy( void );
bool WriteDescr( FILE* File );
void Display_Infos( WinEDA_DrawFrame* frame );
wxPoint ReturnPinEndPoint( void );
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,
int DrawMode, int Color = -1 );
void DrawPinTexts(WinEDA_DrawPanel * panel, wxDC * DC,
wxPoint & pin_pos, int orient,
void DrawPinTexts( WinEDA_DrawPanel* panel, wxDC* DC,
wxPoint& pin_pos, int orient,
int TextInside, bool DrawPinNum, bool DrawPinName,
int Color, int DrawMode);
void PlotPinTexts(wxPoint & pin_pos, int orient,
int TextInside, bool DrawPinNum, bool DrawPinName);
int Color, int DrawMode );
void PlotPinTexts( wxPoint& pin_pos, int orient,
int TextInside, bool DrawPinNum, bool DrawPinName );
};
@ -227,10 +234,10 @@ public:
wxPoint m_ArcStart, m_ArcEnd; /* position des 2 extremites de l'arc en coord reelles*/
public:
LibDrawArc(void);
~LibDrawArc(void){}
LibDrawArc * GenCopy(void);
bool WriteDescr( FILE * File );
LibDrawArc( void );
~LibDrawArc( void ) { }
LibDrawArc* GenCopy( void );
bool WriteDescr( FILE* File );
};
class LibDrawCircle : public LibEDA_BaseStruct
@ -240,10 +247,10 @@ public:
int m_Fill;
public:
LibDrawCircle(void);
~LibDrawCircle(void){}
LibDrawCircle * GenCopy(void);
bool WriteDescr( FILE * File );
LibDrawCircle( void );
~LibDrawCircle( void ) { }
LibDrawCircle* GenCopy( void );
bool WriteDescr( FILE* File );
};
class LibDrawText : public LibEDA_BaseStruct
@ -255,10 +262,10 @@ public:
wxString m_Text;
public:
LibDrawText(void);
~LibDrawText(void){}
LibDrawText * GenCopy(void);
bool WriteDescr( FILE * File );
LibDrawText( void );
~LibDrawText( void ) { }
LibDrawText* GenCopy( void );
bool WriteDescr( FILE* File );
};
class LibDrawSquare : public LibEDA_BaseStruct
@ -268,10 +275,10 @@ public:
int m_Fill;
public:
LibDrawSquare(void);
~LibDrawSquare(void){}
LibDrawSquare * GenCopy(void);
bool WriteDescr( FILE * File );
LibDrawSquare( void );
~LibDrawSquare( void ) { }
LibDrawSquare* GenCopy( void );
bool WriteDescr( FILE* File );
};
class LibDrawSegment : public LibEDA_BaseStruct
@ -280,28 +287,31 @@ public:
wxPoint m_End;
public:
LibDrawSegment(void);
~LibDrawSegment(void){}
LibDrawSegment * GenCopy(void);
bool WriteDescr( FILE * File );
LibDrawSegment( void );
~LibDrawSegment( void ) { }
LibDrawSegment* GenCopy( void );
bool WriteDescr( FILE* File );
};
class LibDrawPolyline : public LibEDA_BaseStruct
{
public:
int n, *PolyList;
int n, * PolyList;
int m_Fill;
public:
LibDrawPolyline(void);
~LibDrawPolyline(void){ if ( PolyList ) free(PolyList);}
LibDrawPolyline * GenCopy(void);
void AddPoint(const wxPoint & point);
bool WriteDescr( FILE * File );
LibDrawPolyline( void );
~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:
@ -316,12 +326,12 @@ public:
wxString m_Name; /* Field Name */
public:
LibDrawField(int idfield = 2);
~LibDrawField(void);
LibDrawField( int idfield = 2 );
~LibDrawField( void );
LibDrawField * GenCopy(void);
void Copy(LibDrawField * Target);
bool WriteDescr( FILE * File );
LibDrawField* GenCopy( void );
void Copy( LibDrawField* Target );
bool WriteDescr( FILE* File );
};
@ -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 */
@ -338,12 +348,12 @@ public:
LibrEntryOptions m_Options; // special features (i.e. Entry is a POWER)
public:
LibCmpEntry(LibrEntryType CmpType, const wxChar * CmpName);
virtual ~LibCmpEntry(void);
bool WriteDescr( FILE * File );
LibCmpEntry( LibrEntryType CmpType, const wxChar * CmpName );
virtual ~LibCmpEntry( void );
bool WriteDescr( FILE* File );
};
class EDA_LibComponentStruct: public LibCmpEntry /* composant "racine" */
class EDA_LibComponentStruct : public LibCmpEntry /* composant "racine" */
{
public:
LibDrawField m_Prefix; /* Prefix ( U, IC ... ) = REFERENCE */
@ -352,61 +362,61 @@ public:
int m_UnitCount; /* Units (or sections) per package */
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 */
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 */
bool m_DrawPinNum;
bool m_DrawPinName;
LibDrawField *Fields; /* Auxiliairy Field list (id = 2 a 11*/
LibEDA_BaseStruct * m_Drawings; /* How to draw this part */
LibDrawField* Fields; /* Auxiliairy Field list (id = 2 a 11*/
LibEDA_BaseStruct* m_Drawings; /* How to draw this part */
long m_LastDate; // Last change Date
public:
EDA_LibComponentStruct( const wxChar * CmpName);
EDA_Rect GetBoundaryBox( int Unit, int Convert); /* return Box around the part. */
EDA_LibComponentStruct( const wxChar * CmpName );
EDA_Rect GetBoundaryBox( int Unit, int Convert );/* return Box around the part. */
~EDA_LibComponentStruct( void );
void SortDrawItems(void);
void SortDrawItems( void );
};
class EDA_LibCmpAliasStruct: public LibCmpEntry
class EDA_LibCmpAliasStruct : public LibCmpEntry
{
public:
wxString m_RootName; /* Part name pour le composant de reference */
public:
EDA_LibCmpAliasStruct( const wxChar * CmpName, const wxChar * CmpRootName);
~EDA_LibCmpAliasStruct(void);
EDA_LibCmpAliasStruct( const wxChar * CmpName, const wxChar * CmpRootName );
~EDA_LibCmpAliasStruct( void );
};
/* Variables */
extern LibraryStruct *LibraryList; /* All part libs are saved here. */
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..;) */
eda_global LibraryStruct *CurrentLib; /* Pointeur sur la librairie du
composant en cours d'edition */
eda_global EDA_LibComponentStruct *CurrentLibEntry; /* pointeur sur le composant en
cours d'edition */
eda_global LibEDA_BaseStruct * CurrentDrawItem; /* pointeur sur les
elements de dessin du comp. en edition */
eda_global LibEDA_BaseStruct* LibItemToRepeat;/* pointeur sur l'élément que l'on
* peut répéter (Pin..;) */
eda_global LibraryStruct* CurrentLib; /* Pointeur sur la librairie du
* composant en cours d'edition */
eda_global EDA_LibComponentStruct* CurrentLibEntry; /* pointeur sur le composant en
* cours d'edition */
eda_global LibEDA_BaseStruct* CurrentDrawItem;/* pointeur sur les
* elements de dessin du comp. en edition */
eda_global wxString CurrentAliasName; // Nom de l'alias selectionné
eda_global bool g_AsDeMorgan; // Pour libedit:
eda_global int CurrentUnit
#ifdef MAIN
= 1
= 1
#endif
;
eda_global int CurrentConvert /* Convert = 1 .. 255 */
#ifdef MAIN
= 1
= 1
#endif
;
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 */

171
eeschema/program.h
View File

@ -1,6 +1,6 @@
/********************************************/
/* Definitions for the EESchema program: */
/********************************************/
/********************************************/
/* Definitions for the EESchema program: */
/********************************************/
#ifndef PROGRAM_H
#define PROGRAM_H
@ -39,42 +39,56 @@ typedef enum { /* Type des Marqueurs */
/* Messages correspondants aux types des marqueurs */
#ifdef MAIN
const wxChar * NameMarqueurType[] =
{
wxT(""),
wxT("ERC"),
wxT("PCB"),
wxT("SIMUL"),
wxT("?????")
};
const wxChar* NameMarqueurType[] =
{
wxT( "" ),
wxT( "ERC" ),
wxT( "PCB" ),
wxT( "SIMUL" ),
wxT( "?????" )
};
#else
extern const wxChar * NameMarqueurType[];
extern const wxChar* NameMarqueurType[];
#endif
/* 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)
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 );
};
class DrawMarkerStruct: public EDA_BaseStruct /* marqueurs */
class DrawMarkerStruct : public EDA_BaseStruct /* marqueurs */
{
public:
wxPoint m_Pos; /* XY coordinates of marker. */
@ -83,27 +97,34 @@ public:
wxString m_Comment; /* Texte (commentaireassocie eventuel */
public:
DrawMarkerStruct(const wxPoint & pos, const wxString & text);
~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);
DrawMarkerStruct( const wxPoint &pos, const wxString &text );
~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 );
};
class DrawNoConnectStruct: public EDA_BaseStruct /* Symboles de non connexion */
class DrawNoConnectStruct : public EDA_BaseStruct /* Symboles de non connexion */
{
public:
wxPoint m_Pos; /* XY coordinates of NoConnect. */
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);
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 );
};
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;
@ -112,42 +133,45 @@ public:
wxSize m_Size;
public:
DrawBusEntryStruct(const wxPoint & pos, int shape, int id );
~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);
DrawBusEntryStruct( const wxPoint &pos, int shape, int id );
~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 );
};
class DrawPolylineStruct: public EDA_BaseStruct /* Polyligne (serie de segments) */
class DrawPolylineStruct : public EDA_BaseStruct/* Polyligne (serie de segments) */
{
public:
int m_Layer;
int m_Width;
int m_NumOfPoints; /* Number of XY pairs in Points array. */
int *m_Points; /* XY pairs that forms the polyline. */
int* m_Points; /* XY pairs that forms the polyline. */
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);
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 );
};
class DrawJunctionStruct: public EDA_BaseStruct
class DrawJunctionStruct : public EDA_BaseStruct
{
public:
int m_Layer;
wxPoint m_Pos; /* XY coordinates of connection. */
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);
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 );
};
class DrawTextStruct: public EDA_BaseStruct, public EDA_TextStruct
class DrawTextStruct : public EDA_BaseStruct, public EDA_TextStruct
{
public:
int m_Layer;
@ -155,32 +179,38 @@ public:
bool m_IsDangling; // TRUE si non connecté
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);
void SwapData(DrawTextStruct * copyitem);
virtual void Place(WinEDA_DrawFrame * frame, wxDC * DC);
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 );
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 );
};
class DrawLabelStruct: public DrawTextStruct
class DrawLabelStruct : public DrawTextStruct
{
public:
DrawLabelStruct(const wxPoint & pos = wxPoint(0,0), const wxString & text = wxEmptyString);
~DrawLabelStruct(void) {}
DrawLabelStruct( const wxPoint& pos = wxPoint( 0, 0 ), const wxString& text = wxEmptyString );
~DrawLabelStruct( void ) { }
};
class DrawGlobalLabelStruct: public DrawTextStruct
class DrawGlobalLabelStruct : public DrawTextStruct
{
public:
DrawGlobalLabelStruct(const wxPoint & pos = wxPoint(0,0), const wxString & text = wxEmptyString);
~DrawGlobalLabelStruct(void) {}
DrawGlobalLabelStruct( const wxPoint& pos = wxPoint( 0, 0 ),
const wxString& text = wxEmptyString );
~DrawGlobalLabelStruct( void ) { }
};
@ -188,9 +218,9 @@ public:
class LayerStruct
{
public:
char LayerNames[MAX_LAYERS+1][8];
int LayerColor[MAX_LAYERS+1];
char LayerStatus[MAX_LAYERS+1];
char LayerNames[MAX_LAYERS + 1][8];
int LayerColor[MAX_LAYERS + 1];
char LayerStatus[MAX_LAYERS + 1];
int NumberOfLayers;
int CurrentLayer;
int CurrentWidth;
@ -200,4 +230,3 @@ public:
#endif /* PROGRAM_H */

631
eeschema/symbdraw.cpp
View File

File diff suppressed because it is too large Load Diff

402
eeschema/symbedit.cpp
View File

@ -1,11 +1,11 @@
/*************************************************/
/* Functions to Load from file and save to file */
/* the graphic shapes used to draw a component */
/* When using the import/export symbol options */
/* files are the *.sym files */
/*************************************************/
/*************************************************/
/* Functions to Load from file and save to file */
/* the graphic shapes used to draw a component */
/* When using the import/export symbol options */
/* files are the *.sym files */
/*************************************************/
/* fichier symbedit.cpp */
/* fichier symbedit.cpp */
#include "fctsys.h"
#include "gr_basic.h"
@ -19,36 +19,37 @@
/* Routines locales */
static bool CompareSymbols(LibEDA_BaseStruct *DEntryRef,
LibEDA_BaseStruct *DEntryCompare);
static bool CompareSymbols( LibEDA_BaseStruct* DEntryRef,
LibEDA_BaseStruct* DEntryCompare );
/* Variables locales */
/***************************************************/
void WinEDA_LibeditFrame::LoadOneSymbol(wxDC * DC)
void WinEDA_LibeditFrame::LoadOneSymbol( wxDC* DC )
/***************************************************/
/* Read a component shape file and add data (graphic items) to the current
component.
*/
* component.
*/
{
int NumOfParts;
PriorQue *Entries;
EDA_LibComponentStruct *LibEntry = NULL;
LibEDA_BaseStruct *DrawEntry;
wxString FullFileName, mask;
FILE * ImportFile;
wxString msg;
int NumOfParts;
PriorQue* Entries;
EDA_LibComponentStruct* LibEntry = NULL;
LibEDA_BaseStruct* DrawEntry;
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;
mask = wxT("*") + g_SymbolExtBuffer;
FullFileName = EDA_FileSelector( _("Import symbol drawings:"),
mask = wxT( "*" ) + g_SymbolExtBuffer;
FullFileName = EDA_FileSelector( _( "Import symbol drawings:" ),
g_RealLibDirBuffer, /* Chemin par defaut */
wxEmptyString, /* nom fichier par defaut */
g_SymbolExtBuffer, /* extension par defaut */
@ -58,47 +59,51 @@ wxString msg;
TRUE
);
GetScreen()->m_Curseur = wxPoint(0,0);
GetScreen()->m_Curseur = wxPoint( 0, 0 );
DrawPanel->MouseToCursorSchema();
DrawPanel->m_IgnoreMouseEvents = FALSE;
if ( FullFileName.IsEmpty() ) return;
if( FullFileName.IsEmpty() )
return;
/* Load data */
ImportFile = wxFopen(FullFileName, wxT("rt"));
if (ImportFile == NULL)
ImportFile = wxFopen( FullFileName, wxT( "rt" ) );
if( ImportFile == NULL )
{
msg.Printf( _("Failed to open Symbol File <%s>"), FullFileName.GetData());
DisplayError(this, msg, 20);
msg.Printf( _( "Failed to open Symbol File <%s>" ), FullFileName.GetData() );
DisplayError( this, msg, 20 );
return;
}
Entries = LoadLibraryAux(this, NULL, ImportFile, &NumOfParts);
fclose(ImportFile);
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);
if( NumOfParts > 1 )
DisplayError( this, _( "Warning: more than 1 part in Symbol File" ), 20 );
LibEntry = (EDA_LibComponentStruct *)PQFirst(&Entries,FALSE);
LibEntry = (EDA_LibComponentStruct*) PQFirst( &Entries, FALSE );
if(LibEntry == NULL )
DisplayError(this, _("Symbol File is void"), 20);
if( LibEntry == NULL )
DisplayError( this, _( "Symbol File is void" ), 20 );
else /* add data to the current symbol */
{
DrawEntry = LibEntry->m_Drawings;
while(DrawEntry)
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;
if(DrawEntry->Pnext == NULL)
if( DrawEntry->Pnext == NULL )
{ /* Fin de liste trouvee */
DrawEntry->Pnext = CurrentLibEntry->m_Drawings;
CurrentLibEntry->m_Drawings = LibEntry->m_Drawings;
@ -107,39 +112,43 @@ wxString msg;
}
DrawEntry = DrawEntry->Next();
}
SuppressDuplicateDrawItem(CurrentLibEntry);
SuppressDuplicateDrawItem( CurrentLibEntry );
m_CurrentScreen->SetModify();
// Move (and place ) the new draw items:
HandleBlockBegin(DC, -1, GetScreen()->m_Curseur);
HandleBlockEnd(DC);
RedrawActiveWindow( DC,TRUE);
HandleBlockBegin( DC, -1, GetScreen()->m_Curseur );
HandleBlockEnd( DC );
RedrawActiveWindow( DC, TRUE );
}
PQFreeFunc(Entries, (void(*)(void*))FreeLibraryEntry);
PQFreeFunc( Entries, ( void( * ) ( void* ) )FreeLibraryEntry );
}
/********************************************/
void WinEDA_LibeditFrame::SaveOneSymbol(void)
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
*/
{
EDA_LibComponentStruct *LibEntry = CurrentLibEntry;
int Unit = CurrentUnit, convert = CurrentConvert;
int SymbUnit, SymbConvert;
LibEDA_BaseStruct *DrawEntry;
wxString FullFileName, mask;
wxString msg;
FILE * ExportFile;
if( LibEntry->m_Drawings == NULL ) return;
/* Save in file the current symbol
* file format is like the standard libraries, but there is only one symbol
* Invisible pins are not saved
*/
{
EDA_LibComponentStruct* LibEntry = CurrentLibEntry;
int Unit = CurrentUnit, convert = CurrentConvert;
int SymbUnit, SymbConvert;
LibEDA_BaseStruct* DrawEntry;
wxString FullFileName, mask;
wxString msg;
FILE* ExportFile;
if( LibEntry->m_Drawings == NULL )
return;
/* Creation du fichier symbole */
mask = wxT("*") + g_SymbolExtBuffer;
FullFileName = EDA_FileSelector( _("Export symbol drawings:"),
mask = wxT( "*" ) + g_SymbolExtBuffer;
FullFileName = EDA_FileSelector( _( "Export symbol drawings:" ),
g_RealLibDirBuffer, /* Chemin par defaut */
wxEmptyString, /* nom fichier par defaut */
g_SymbolExtBuffer, /* extension par defaut */
@ -148,51 +157,53 @@ FILE * ExportFile;
wxFD_SAVE,
TRUE
);
if ( FullFileName.IsEmpty() ) return;
if( FullFileName.IsEmpty() )
return;
ExportFile = wxFopen(FullFileName, wxT("wt") );
if ( ExportFile == NULL )
ExportFile = wxFopen( FullFileName, wxT( "wt" ) );
if( ExportFile == NULL )
{
msg.Printf(_("Unable to create <%s>"), FullFileName.GetData());
DisplayError(this, msg);
msg.Printf( _( "Unable to create <%s>" ), FullFileName.GetData() );
DisplayError( this, msg );
return;
}
msg.Printf(_("Save Symbol in [%s]"), FullFileName.GetData());
Affiche_Message(msg);
msg.Printf( _( "Save Symbol in [%s]" ), FullFileName.GetData() );
Affiche_Message( msg );
/* Creation de l'entete de la librairie */
char Line[256];
fprintf(ExportFile,"%s %d.%d %s Date: %s\n",LIBFILE_IDENT,
fprintf( ExportFile, "%s %d.%d %s Date: %s\n", LIBFILE_IDENT,
LIB_VERSION_MAJOR, LIB_VERSION_MINOR,
"SYMBOL",DateAndTime(Line));
"SYMBOL", DateAndTime( Line ) );
/* Creation du commentaire donnant le nom du composant */
fprintf(ExportFile,"# SYMBOL %s\n#\n",
(const char*) LibEntry->m_Name.m_Text.GetData());
fprintf( ExportFile, "# SYMBOL %s\n#\n",
(const char*) LibEntry->m_Name.m_Text.GetData() );
/* Generation des lignes utiles */
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," ~");
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, " ~" );
fprintf(ExportFile," %d %d %c %c %d %d %c\n",
fprintf( ExportFile, " %d %d %c %c %d %d %c\n",
0, /* unused */
LibEntry->m_TextInside,
LibEntry->m_DrawPinNum ? 'Y' : 'N',
LibEntry->m_DrawPinName ? 'Y' : 'N',
1, 0 /* unused */, 'N');
1, 0 /* unused */, 'N' );
/* Position / orientation / visibilite des champs */
LibEntry->m_Prefix.WriteDescr( ExportFile );
LibEntry->m_Name.WriteDescr( ExportFile );
DrawEntry = LibEntry->m_Drawings;
if(DrawEntry)
if( DrawEntry )
{
fprintf(ExportFile,"DRAW\n");
for( ; DrawEntry != NULL ; DrawEntry = DrawEntry->Next())
fprintf( ExportFile, "DRAW\n" );
for( ; DrawEntry != NULL; DrawEntry = DrawEntry->Next() )
{
/* Elimination des elements non relatifs a l'unite */
if( Unit && DrawEntry->m_Unit && (DrawEntry->m_Unit != Unit) )
@ -201,178 +212,211 @@ 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;
switch( DrawEntry->m_StructType)
if( SymbConvert > 1 )
SymbConvert = 1;
switch( DrawEntry->m_StructType )
{
case COMPONENT_ARC_DRAW_TYPE:
#define DRAWSTRUCT ((LibDrawArc *) DrawEntry)
#define DRAWSTRUCT ( (LibDrawArc*) DrawEntry )
DRAWSTRUCT->WriteDescr( ExportFile );
break;
case COMPONENT_CIRCLE_DRAW_TYPE:
#undef DRAWSTRUCT
#define DRAWSTRUCT ((LibDrawCircle *) DrawEntry)
#define DRAWSTRUCT ( (LibDrawCircle*) DrawEntry )
DRAWSTRUCT->WriteDescr( ExportFile );
break;
case COMPONENT_GRAPHIC_TEXT_DRAW_TYPE:
#undef DRAWSTRUCT
#define DRAWSTRUCT ((LibDrawText *) DrawEntry)
#define DRAWSTRUCT ( (LibDrawText*) DrawEntry )
DRAWSTRUCT->WriteDescr( ExportFile );
break;
case COMPONENT_RECT_DRAW_TYPE:
#undef DRAWSTRUCT
#define DRAWSTRUCT ((LibDrawSquare *) DrawEntry)
#define DRAWSTRUCT ( (LibDrawSquare*) DrawEntry )
DRAWSTRUCT->WriteDescr( ExportFile );
break;
case COMPONENT_PIN_DRAW_TYPE:
#undef DRAWSTRUCT
#define DRAWSTRUCT ((LibDrawPin *) DrawEntry)
if(DRAWSTRUCT->m_Attributs & PINNOTDRAW) break;
#define DRAWSTRUCT ( (LibDrawPin*) DrawEntry )
if( DRAWSTRUCT->m_Attributs & PINNOTDRAW )
break;
DRAWSTRUCT->WriteDescr( ExportFile );
break;
case COMPONENT_POLYLINE_DRAW_TYPE:
#undef DRAWSTRUCT
#define DRAWSTRUCT ((LibDrawPolyline *) DrawEntry)
#define DRAWSTRUCT ( (LibDrawPolyline*) DrawEntry )
DRAWSTRUCT->WriteDescr( ExportFile );
break;
default:
;
}
}
fprintf(ExportFile,"ENDDRAW\n");
fprintf( ExportFile, "ENDDRAW\n" );
}
fprintf(ExportFile,"ENDDEF\n");
fclose(ExportFile);
fprintf( ExportFile, "ENDDEF\n" );
fclose( ExportFile );
}
/*****************************************************************/
void SuppressDuplicateDrawItem( EDA_LibComponentStruct* LibEntry )
/*****************************************************************/
/*****************************************************************/
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;
bool deleted;
wxDC * DC = NULL;
LibEDA_BaseStruct* DEntryRef, * DEntryCompare;
bool deleted;
wxDC* DC = NULL;
DEntryRef = LibEntry->m_Drawings;
while( DEntryRef)
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 )
{
if( CompareSymbols(DEntryRef,DEntryCompare) == TRUE)
if( CompareSymbols( DEntryRef, DEntryCompare ) == TRUE )
{
DeleteOneLibraryDrawStruct(NULL, DC, LibEntry,DEntryRef, 1);
DeleteOneLibraryDrawStruct( NULL, DC, LibEntry, DEntryRef, 1 );
deleted = TRUE;
break;
}
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)
/********************************************************************/
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;
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)
switch( DEntryRef->m_StructType )
{
case COMPONENT_ARC_DRAW_TYPE:
#undef REFSTRUCT
#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);
#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;
break;
case COMPONENT_CIRCLE_DRAW_TYPE:
#undef REFSTRUCT
#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);
#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;
break;
case COMPONENT_GRAPHIC_TEXT_DRAW_TYPE:
#undef REFSTRUCT
#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);
#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_Text != CMPSTRUCT->m_Text )
return(FALSE);
return FALSE;
break;
case COMPONENT_RECT_DRAW_TYPE:
#undef REFSTRUCT
#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);
#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;
break;
case COMPONENT_PIN_DRAW_TYPE:
#undef REFSTRUCT
#undef CMPSTRUCT
#define REFSTRUCT ((LibDrawPin *) DEntryRef)
#define CMPSTRUCT ((LibDrawPin *) DEntryCompare)
if( REFSTRUCT->m_Pos != CMPSTRUCT->m_Pos) return(FALSE);
#define REFSTRUCT ( (LibDrawPin*) DEntryRef )
#define CMPSTRUCT ( (LibDrawPin*) DEntryCompare )
if( REFSTRUCT->m_Pos != CMPSTRUCT->m_Pos )
return FALSE;
break;
case COMPONENT_POLYLINE_DRAW_TYPE:
#undef REFSTRUCT
#undef CMPSTRUCT
#define REFSTRUCT ((LibDrawPolyline *) DEntryRef)
#define CMPSTRUCT ((LibDrawPolyline *) DEntryCompare)
if( REFSTRUCT->n != CMPSTRUCT->n) return(FALSE);
#define REFSTRUCT ( (LibDrawPolyline*) DEntryRef )
#define CMPSTRUCT ( (LibDrawPolyline*) DEntryCompare )
if( REFSTRUCT->n != CMPSTRUCT->n )
return FALSE;
ptref = REFSTRUCT->PolyList;
ptcomp = CMPSTRUCT->PolyList;
for( ii = 2 * REFSTRUCT->n ; ii > 0; ii-- )
for( ii = 2 * REFSTRUCT->n; ii > 0; ii-- )
{
if( *ptref != *ptcomp) return(FALSE);
if( *ptref != *ptcomp )
return FALSE;
ptref++; ptcomp++;
}
break;
}
return(TRUE);
}
break;
default:
;
}
return TRUE;
}
/***************************************************************************/
@ -383,18 +427,19 @@ int * ptref, *ptcomp;
/* d'ancrage ( coord 0,0 ). */
/***************************************************************************/
void WinEDA_LibeditFrame::PlaceAncre(void)
void WinEDA_LibeditFrame::PlaceAncre( void )
{
int ii, *ptsegm;
int dx, dy; /* Offsets de deplacement */
EDA_LibComponentStruct * LibEntry;
LibEDA_BaseStruct * DrawEntry;
int ii, * ptsegm;
int dx, dy; /* Offsets de deplacement */
EDA_LibComponentStruct* LibEntry;
LibEDA_BaseStruct* DrawEntry;
dx = - m_CurrentScreen->m_Curseur.x;
dx = -m_CurrentScreen->m_Curseur.x;
dy = m_CurrentScreen->m_Curseur.y;
LibEntry = CurrentLibEntry;
if( LibEntry == NULL ) return;
if( LibEntry == NULL )
return;
m_CurrentScreen->SetModify();
@ -402,13 +447,13 @@ LibEDA_BaseStruct * DrawEntry;
LibEntry->m_Prefix.m_Pos.x += dx; LibEntry->m_Prefix.m_Pos.y += dy;
DrawEntry = LibEntry->m_Drawings;
while(DrawEntry)
while( DrawEntry )
{
switch(DrawEntry->m_StructType)
switch( DrawEntry->m_StructType )
{
case COMPONENT_ARC_DRAW_TYPE:
#undef STRUCT
#define STRUCT ((LibDrawArc *) DrawEntry)
#define STRUCT ( (LibDrawArc*) DrawEntry )
STRUCT->m_Pos.x += dx;
STRUCT->m_Pos.y += dy;
STRUCT->m_ArcStart.x += dx;
@ -419,21 +464,21 @@ LibEDA_BaseStruct * DrawEntry;
case COMPONENT_CIRCLE_DRAW_TYPE:
#undef STRUCT
#define STRUCT ((LibDrawCircle *) DrawEntry)
#define STRUCT ( (LibDrawCircle*) DrawEntry )
STRUCT->m_Pos.x += dx;
STRUCT->m_Pos.y += dy;
break;
case COMPONENT_GRAPHIC_TEXT_DRAW_TYPE:
#undef STRUCT
#define STRUCT ((LibDrawText *) DrawEntry)
#define STRUCT ( (LibDrawText*) DrawEntry )
STRUCT->m_Pos.x += dx;
STRUCT->m_Pos.y += dy;
break;
case COMPONENT_RECT_DRAW_TYPE:
#undef STRUCT
#define STRUCT ((LibDrawSquare *) DrawEntry)
#define STRUCT ( (LibDrawSquare*) DrawEntry )
STRUCT->m_Pos.x += dx;
STRUCT->m_Pos.y += dy;
STRUCT->m_End.x += dx;
@ -442,27 +487,30 @@ LibEDA_BaseStruct * DrawEntry;
case COMPONENT_PIN_DRAW_TYPE:
#undef STRUCT
#define STRUCT ((LibDrawPin *) DrawEntry)
#define STRUCT ( (LibDrawPin*) DrawEntry )
STRUCT->m_Pos.x += dx;
STRUCT->m_Pos.y += dy;
break;
case COMPONENT_POLYLINE_DRAW_TYPE:
#undef STRUCT
#define STRUCT ((LibDrawPolyline *) DrawEntry)
#define STRUCT ( (LibDrawPolyline*) DrawEntry )
ptsegm = STRUCT->PolyList;
for( ii = STRUCT->n ; ii > 0; ii-- )
for( ii = STRUCT->n; ii > 0; ii-- )
{
*ptsegm += dx; ptsegm++;
*ptsegm += dy;ptsegm++;
*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);
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 )