Skip to content

K
kicad-source-mirror
Commit f3c324d5 authored by dickelbeck's avatar dickelbeck
Browse files
Options

EDA_BaseStruct::m_StructType is now type KICAD_T

parent 908f6d93
Show whitespace changes
Inline Side-by-side
Showing with 4866 additions and 4314 deletions
3d-viewer/3d_class.cpp
View file @ f3c324d5
......@@ -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;
......
change_log.txt
View file @ f3c324d5
......@@ -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>
......
common/base_struct.cpp
View file @ f3c324d5
......@@ -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� seule */
/*********************************************************/
......
eeschema/affiche.cpp
View file @ f3c324d5
/**********************************************************/
/* 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_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_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_Width )
valeur_param( m_Width, msg );
else
msg = _( "default" );
Affiche_1_Parametre( frame, 24, _( "Width" ), msg, BLUE );
}
eeschema/block.cpp
View file @ f3c324d5
......@@ -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 );
......
eeschema/block_libedit.cpp
View file @ f3c324d5
......@@ -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;
......
eeschema/cmpclass.cpp
View file @ f3c324d5
......@@ -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;
......
eeschema/component_class.cpp
View file @ f3c324d5
......@@ -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)
/***********************************************************************************/
{
......
eeschema/component_class.h
View file @ f3c324d5
......@@ -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);
};
......
eeschema/dangling_ends.cpp
View file @ f3c324d5
/*********************/
/* 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)
LibDrawPin* WinEDA_SchematicFrame::LocatePinEnd( EDA_BaseStruct* DrawList,
const wxPoint& pos )
/********************************************************************/
/* Teste si le point de coordonnes pos est sur l'extrmit d'une PIN
retourne un pointeur sur la pin
NULL sinon
*/
* retourne un pointeur sur la pin
* NULL sinon
*/
{
EDA_SchComponentStruct * DrawLibItem;
LibDrawPin * Pin;
wxPoint pinpos;
EDA_SchComponentStruct* DrawLibItem;
LibDrawPin* Pin;
wxPoint pinpos;
Pin = LocateAnyPin(DrawList,pos, &DrawLibItem);
if( ! Pin ) return NULL;
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 dpend de l'orientation
du composant */
* du composant */
{
wxPoint PinPos = Pin->m_Pos;
wxPoint PinPos = Pin->m_Pos;
if(DrawLibItem == NULL ) PinPos.y = -PinPos.y;
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())
#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;
if( DrawLibItem->m_StructType != COMPONENT_PIN_DRAW_TYPE )
continue;
LibDrawPin * Pin = (LibDrawPin *) DrawLibItem;
LibDrawPin* Pin = (LibDrawPin*) DrawLibItem;
if( Pin->m_Unit && DrawLibItem->m_Unit &&
(DrawLibItem->m_Unit != Pin->m_Unit) )
if( Pin->m_Unit && DrawLibItem->m_Unit
&& (DrawLibItem->m_Unit != Pin->m_Unit) )
continue;
if( Pin->m_Convert && DrawLibItem->m_Convert &&
(DrawLibItem->m_Convert != Pin->m_Convert) )
if( Pin->m_Convert && DrawLibItem->m_Convert
&& (DrawLibItem->m_Convert != Pin->m_Convert) )
continue;
item = new DanglingEndHandle(PIN_END);
item = new DanglingEndHandle( PIN_END );
item->m_Item = Pin;
item->m_Pos = ReturnPinPhysicalPosition( Pin,STRUCT);
if ( lastitem ) lastitem->m_Pnext = item;
else StartList = item;
item->m_Pos = ReturnPinPhysicalPosition( Pin, STRUCT );
if( lastitem )
lastitem->m_Pnext = item;
else
StartList = item;
lastitem = item;
}
break;
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;
}
eeschema/eelibs_draw_components.cpp
View file @ f3c324d5
/****************************************/
/* Modules to handle component drawing. */
/****************************************/
/****************************************/
/* Modules to handle component drawing. */
/****************************************/
#include "fctsys.h"
#include "gr_basic.h"
......@@ -21,45 +21,48 @@
/* Fonctions locales */
/* Descr component <DUMMY> used when a component is not found in library,
to draw a dummy shape*/
* to draw a dummy shape*/
/*
This component is a 400 mils square with the text ??
DEF DUMMY U 0 40 Y Y 1 0 N
F0 "U" 0 -350 60 H V
F1 "DUMMY" 0 350 60 H V
DRAW
T 0 0 0 150 0 0 0 ??
S -200 200 200 -200 0 1 0
ENDDRAW
ENDDEF
*/
* This component is a 400 mils square with the text ??
* DEF DUMMY U 0 40 Y Y 1 0 N
* F0 "U" 0 -350 60 H V
* F1 "DUMMY" 0 350 60 H V
* DRAW
* T 0 0 0 150 0 0 0 ??
* S -200 200 200 -200 0 1 0
* ENDDRAW
* ENDDEF
*/
static int s_ItemSelectColor = BROWN;
static EDA_LibComponentStruct * DummyCmp;
static int * Buf_Poly_Drawings, Buf_Poly_Size; // Used fo polyline drawings
static void DrawLibPartAux(WinEDA_DrawPanel * panel, wxDC * DC,
EDA_SchComponentStruct *Component,
EDA_LibComponentStruct *Entry,
const wxPoint & Pos,
static EDA_LibComponentStruct* DummyCmp;
static int* Buf_Poly_Drawings, Buf_Poly_Size; // Used fo polyline drawings
static void DrawLibPartAux( WinEDA_DrawPanel* panel, wxDC* DC,
EDA_SchComponentStruct* Component,
EDA_LibComponentStruct* Entry,
const wxPoint& Pos,
int TransMat[2][2],
int Multi, int convert,
int DrawMode, int Color = -1, bool DrawPinText = TRUE);
int DrawMode, int Color = -1, bool DrawPinText = TRUE );
/******************************/
static void CreateDummyCmp(void)
static void CreateDummyCmp( void )
/******************************/
{
DummyCmp = new EDA_LibComponentStruct( NULL);
DummyCmp = new EDA_LibComponentStruct( NULL );
LibDrawSquare* Square = new LibDrawSquare();
LibDrawSquare * Square = new LibDrawSquare();
Square->m_Pos = wxPoint(- 200,200);
Square->m_End = wxPoint(200, - 200);
Square->m_Pos = wxPoint( -200, 200 );
Square->m_End = wxPoint( 200, -200 );
Square->m_Width = 4;
LibDrawText * Text = new LibDrawText();
LibDrawText* Text = new LibDrawText();
Text->m_Size.x = Text->m_Size.y = 150;
Text->m_Text = wxT("??");
Text->m_Text = wxT( "??" );
DummyCmp->m_Drawings = Square;
Square->Pnext = Text;
......@@ -67,186 +70,208 @@ static void CreateDummyCmp(void)
/*************************************************************/
void DrawLibEntry(WinEDA_DrawPanel * panel,wxDC * DC,
EDA_LibComponentStruct *LibEntry,
void DrawLibEntry( WinEDA_DrawPanel* panel, wxDC* DC,
EDA_LibComponentStruct* LibEntry,
int posX, int posY,
int Multi, int convert,
int DrawMode, int Color)
int DrawMode, int Color )
/**************************************************************/
/* Routine de dessin d'un composant d'une librairie
LibEntry = pointeur sur la description en librairie
posX, posY = position du composant
DrawMode = GrOR ..
Color = 0 : dessin en vraies couleurs, sinon couleur = Color
Une croix symbolise le point d'accrochage (ref position) du composant
Le composant est toujours trace avec orientation 0
*/
/* Routine de dessin d'un composant d'une librairie
* LibEntry = pointeur sur la description en librairie
* posX, posY = position du composant
* DrawMode = GrOR ..
* Color = 0 : dessin en vraies couleurs, sinon couleur = Color
*
* Une croix symbolise le point d'accrochage (ref position) du composant
*
* Le composant est toujours trace avec orientation 0
*/
{
int color;
int TransMat[2][2];
wxString Prefix;
LibDrawField * Field;
wxPoint text_pos;
int color;
int TransMat[2][2];
wxString Prefix;
LibDrawField* Field;
wxPoint text_pos;
/* Orientation normale */
TransMat[0][0] = 1; TransMat[1][1] = -1;
TransMat[1][0] = TransMat[0][1] = 0;
DrawLibPartAux(panel, DC, NULL, LibEntry, wxPoint(posX, posY),
DrawLibPartAux( panel, DC, NULL, LibEntry, wxPoint( posX, posY ),
TransMat, Multi,
convert, DrawMode, Color);
convert, DrawMode, Color );
/* Trace des 2 champs ref et value (Attention aux coord: la matrice
de transformation change de signe les coord Y */
* de transformation change de signe les coord Y */
GRSetDrawMode(DC, DrawMode);
GRSetDrawMode( DC, DrawMode );
if( LibEntry->m_Prefix.m_Attributs & TEXT_NO_VISIBLE )
{
if( Color >= 0 ) color = Color;
else color = UNVISIBLE_COLOR;
if( Color >= 0 )
color = Color;
else
color = UNVISIBLE_COLOR;
}
else {
if( Color >= 0) color = Color;
else color = ReturnLayerColor(LAYER_REFERENCEPART);
else
{
if( Color >= 0 )
color = Color;
else
color = ReturnLayerColor( LAYER_REFERENCEPART );
}
if (LibEntry->m_UnitCount > 1)
Prefix.Printf( wxT("%s?%c"),LibEntry->m_Prefix.m_Text.GetData(),Multi + 'A' - 1);
else Prefix = LibEntry->m_Prefix.m_Text + wxT("?");
if( LibEntry->m_UnitCount > 1 )
Prefix.Printf( wxT( "%s?%c" ), LibEntry->m_Prefix.m_Text.GetData(), Multi + 'A' - 1 );
else
Prefix = LibEntry->m_Prefix.m_Text + wxT( "?" );
text_pos.x = LibEntry->m_Prefix.m_Pos.x + posX;
text_pos.y = posY - LibEntry->m_Prefix.m_Pos.y;
int LineWidth = MAX(LibEntry->m_Prefix.m_Width, g_DrawMinimunLineWidth);
if ( (LibEntry->m_Prefix.m_Flags & IS_MOVED) == 0 )
DrawGraphicText(panel, DC, text_pos,
color,LibEntry->m_Prefix.m_Text.GetData(),
int LineWidth = MAX( LibEntry->m_Prefix.m_Width, g_DrawMinimunLineWidth );
if( (LibEntry->m_Prefix.m_Flags & IS_MOVED) == 0 )
DrawGraphicText( panel, DC, text_pos,
color, LibEntry->m_Prefix.m_Text.GetData(),
LibEntry->m_Prefix.m_Orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ,
LibEntry->m_Prefix.m_Size,
LibEntry->m_Prefix.m_HJustify, LibEntry->m_Prefix.m_VJustify, LineWidth);
LibEntry->m_Prefix.m_HJustify, LibEntry->m_Prefix.m_VJustify, LineWidth );
if( LibEntry->m_Name.m_Attributs & TEXT_NO_VISIBLE )
{
if( Color >= 0) color = Color;
else color = UNVISIBLE_COLOR;
if( Color >= 0 )
color = Color;
else
color = UNVISIBLE_COLOR;
}
else {
if( Color >= 0 ) color = Color;
else color = ReturnLayerColor(LAYER_VALUEPART);
else
{
if( Color >= 0 )
color = Color;
else
color = ReturnLayerColor( LAYER_VALUEPART );
}
text_pos.x = LibEntry->m_Name.m_Pos.x + posX;
text_pos.y = posY - LibEntry->m_Name.m_Pos.y;
LineWidth = MAX(LibEntry->m_Name.m_Width, g_DrawMinimunLineWidth);
if ( (LibEntry->m_Name.m_Flags & IS_MOVED) == 0 )
DrawGraphicText(panel, DC, text_pos,
LineWidth = MAX( LibEntry->m_Name.m_Width, g_DrawMinimunLineWidth );
if( (LibEntry->m_Name.m_Flags & IS_MOVED) == 0 )
DrawGraphicText( panel, DC, text_pos,
color, LibEntry->m_Name.m_Text.GetData(),
LibEntry->m_Name.m_Orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ,
LibEntry->m_Name.m_Size,
LibEntry->m_Name.m_HJustify, LibEntry->m_Name.m_VJustify, LineWidth);
LibEntry->m_Name.m_HJustify, LibEntry->m_Name.m_VJustify, LineWidth );
for( Field = LibEntry->Fields; Field != NULL; Field = (LibDrawField *)Field->Pnext )
for( Field = LibEntry->Fields; Field != NULL; Field = (LibDrawField*) Field->Pnext )
{
if( Field->m_Text.IsEmpty() ) return;
if ( (Field->m_Flags & IS_MOVED) != 0 ) continue;
if( Field->m_Text.IsEmpty() )
return;
if( (Field->m_Flags & IS_MOVED) != 0 )
continue;
if( Field->m_Attributs & TEXT_NO_VISIBLE )
{
if( Color >= 0) color = Color;
else color = UNVISIBLE_COLOR;
if( Color >= 0 )
color = Color;
else
color = UNVISIBLE_COLOR;
}
else
{
if( Color >= 0) color = Color;
else color = ReturnLayerColor(LAYER_FIELDS);
if( Color >= 0 )
color = Color;
else
color = ReturnLayerColor( LAYER_FIELDS );
}
text_pos.x = Field->m_Pos.x + posX;
text_pos.y = posY - Field->m_Pos.y;
LineWidth = MAX(Field->m_Width, g_DrawMinimunLineWidth);
DrawGraphicText(panel, DC, text_pos,
LineWidth = MAX( Field->m_Width, g_DrawMinimunLineWidth );
DrawGraphicText( panel, DC, text_pos,
color, Field->m_Text,
Field->m_Orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ,
Field->m_Size,
Field->m_HJustify, Field->m_VJustify, LineWidth);
Field->m_HJustify, Field->m_VJustify, LineWidth );
}
// Trac de l'ancre
int len = 3 * panel->GetZoom();
GRLine(&panel->m_ClipBox, DC, posX, posY - len, posX, posY + len, 0, color);
GRLine(&panel->m_ClipBox, DC, posX - len, posY, posX + len, posY, 0, color);
GRLine( &panel->m_ClipBox, DC, posX, posY - len, posX, posY + len, 0, color );
GRLine( &panel->m_ClipBox, DC, posX - len, posY, posX + len, posY, 0, color );
}
/*****************************************************************************
* Routine to draw the given part at given position, transformed/mirror as *
* specified, and in the given drawing mode. Only this one is visible... *
*****************************************************************************/
void EDA_SchComponentStruct::Draw(WinEDA_DrawPanel * panel,wxDC * DC,
const wxPoint & offset, int DrawMode, int Color)
void EDA_SchComponentStruct::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
const wxPoint& offset, int DrawMode, int Color )
{
EDA_LibComponentStruct *Entry;
int ii;
bool dummy = FALSE;
EDA_LibComponentStruct* Entry;
int ii;
bool dummy = FALSE;
if( (Entry = FindLibPart(m_ChipName.GetData(),wxEmptyString,FIND_ROOT)) == NULL)
if( ( Entry = FindLibPart( m_ChipName.GetData(), wxEmptyString, FIND_ROOT ) ) == NULL )
{ /* composant non trouv, on affiche un composant "dummy" */
dummy = TRUE;
if( DummyCmp == NULL ) CreateDummyCmp();
if( DummyCmp == NULL )
CreateDummyCmp();
Entry = DummyCmp;
}
DrawLibPartAux(panel, DC, this, Entry, m_Pos + offset,
DrawLibPartAux( panel, DC, this, Entry, m_Pos + offset,
m_Transform,
dummy ? 0 : m_Multi,
dummy ? 0 : m_Convert,
DrawMode);
DrawMode );
/* Trace des champs, avec placement et orientation selon orient. du
composant
* composant
*/
if( ((m_Field[REFERENCE].m_Attributs & TEXT_NO_VISIBLE) == 0)
&& ! (m_Field[REFERENCE].m_Flags & IS_MOVED) )
if( ( (m_Field[REFERENCE].m_Attributs & TEXT_NO_VISIBLE) == 0 )
&& !(m_Field[REFERENCE].m_Flags & IS_MOVED) )
{
if ( Entry->m_UnitCount > 1 )
DrawTextField(panel, DC, &m_Field[REFERENCE],1,DrawMode);
if( Entry->m_UnitCount > 1 )
DrawTextField( panel, DC, &m_Field[REFERENCE], 1, DrawMode );
else
DrawTextField(panel, DC, &m_Field[REFERENCE],0,DrawMode);
DrawTextField( panel, DC, &m_Field[REFERENCE], 0, DrawMode );
}
for( ii = VALUE; ii < NUMBER_OF_FIELDS; ii++ )
{
if (m_Field[ii].m_Flags & IS_MOVED) continue;
DrawTextField(panel, DC, &m_Field[ii],0,DrawMode);
if( m_Field[ii].m_Flags & IS_MOVED )
continue;
DrawTextField( panel, DC, &m_Field[ii], 0, DrawMode );
}
}
/***********************************************************/
void DrawTextField(WinEDA_DrawPanel * panel,wxDC * DC,
PartTextStruct * Field, int IsMulti, int DrawMode)
void DrawTextField( WinEDA_DrawPanel* panel, wxDC* DC,
PartTextStruct* Field, int IsMulti, int DrawMode )
/***********************************************************/
/* Routine de trace des textes type Field du composant.
entree:
IsMulti: flag Non Null si il y a plusieurs parts par boitier.
n'est utile que pour le champ reference pour ajouter a celui ci
l'identification de la part ( A, B ... )
DrawMode: mode de trace
*/
* entree:
* IsMulti: flag Non Null si il y a plusieurs parts par boitier.
* n'est utile que pour le champ reference pour ajouter a celui ci
* l'identification de la part ( A, B ... )
* DrawMode: mode de trace
*/
{
int orient, color;
wxPoint pos; /* Position des textes */
EDA_SchComponentStruct *DrawLibItem = (EDA_SchComponentStruct *) Field->m_Parent;
int hjustify, vjustify;
int LineWidth = MAX(Field->m_Width, g_DrawMinimunLineWidth);
int orient, color;
wxPoint pos; /* Position des textes */
EDA_SchComponentStruct* DrawLibItem = (EDA_SchComponentStruct*) Field->m_Parent;
int hjustify, vjustify;
int LineWidth = MAX( Field->m_Width, g_DrawMinimunLineWidth );
if( Field->m_Attributs & TEXT_NO_VISIBLE ) return;
if( Field->IsVoid() ) return;
if( Field->m_Attributs & TEXT_NO_VISIBLE )
return;
if( Field->IsVoid() )
return;
GRSetDrawMode(DC, DrawMode);
GRSetDrawMode( DC, DrawMode );
/* Calcul de la position des textes, selon orientation du composant */
orient = Field->m_Orient;
......@@ -254,88 +279,98 @@ int LineWidth = MAX(Field->m_Width, g_DrawMinimunLineWidth);
pos.x = Field->m_Pos.x - DrawLibItem->m_Pos.x;
pos.y = Field->m_Pos.y - DrawLibItem->m_Pos.y;
pos = DrawLibItem->GetScreenCoord(pos);
pos = DrawLibItem->GetScreenCoord( pos );
pos.x += DrawLibItem->m_Pos.x;
pos.y += DrawLibItem->m_Pos.y;
/* Y a t-il rotation (pour l'orientation, la justification)*/
if(DrawLibItem->m_Transform[0][1]) // Rotation du composant de 90deg
if( DrawLibItem->m_Transform[0][1] ) // Rotation du composant de 90deg
{
if ( orient == TEXT_ORIENT_HORIZ) orient = TEXT_ORIENT_VERT;
else orient = TEXT_ORIENT_HORIZ;
if( orient == TEXT_ORIENT_HORIZ )
orient = TEXT_ORIENT_VERT;
else
orient = TEXT_ORIENT_HORIZ;
/* Y a t-il rotation, miroir (pour les justifications)*/
EXCHG(hjustify, vjustify);
if (DrawLibItem->m_Transform[1][0] < 0 ) vjustify = - vjustify;
if (DrawLibItem->m_Transform[1][0] > 0 ) hjustify = - hjustify;
EXCHG( hjustify, vjustify );
if( DrawLibItem->m_Transform[1][0] < 0 )
vjustify = -vjustify;
if( DrawLibItem->m_Transform[1][0] > 0 )
hjustify = -hjustify;
}
else
{ /* Texte horizontal: Y a t-il miroir (pour les justifications)*/
if (DrawLibItem->m_Transform[0][0] < 0 )
hjustify = - hjustify;
if (DrawLibItem->m_Transform[1][1] > 0 )
vjustify = - vjustify;
{
/* Texte horizontal: Y a t-il miroir (pour les justifications)*/
if( DrawLibItem->m_Transform[0][0] < 0 )
hjustify = -hjustify;
if( DrawLibItem->m_Transform[1][1] > 0 )
vjustify = -vjustify;
}
if( Field->m_FieldId == REFERENCE )
color = ReturnLayerColor(LAYER_REFERENCEPART);
color = ReturnLayerColor( LAYER_REFERENCEPART );
else if( Field->m_FieldId == VALUE )
color = ReturnLayerColor(LAYER_VALUEPART);
else color = ReturnLayerColor(LAYER_FIELDS);
color = ReturnLayerColor( LAYER_VALUEPART );
else
color = ReturnLayerColor( LAYER_FIELDS );
if( !IsMulti || (Field->m_FieldId != REFERENCE) )
{
DrawGraphicText(panel, DC, pos, color, Field->m_Text.GetData(),
DrawGraphicText( panel, DC, pos, color, Field->m_Text.GetData(),
orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ,
Field->m_Size,
hjustify, vjustify, LineWidth);
hjustify, vjustify, LineWidth );
}
else /* Le champ est la reference, et il y a plusieurs parts par boitier */
{/* On ajoute alors A ou B ... a la reference */
{
/* On ajoute alors A ou B ... a la reference */
wxString fulltext = Field->m_Text;
fulltext.Append('A' - 1 + DrawLibItem->m_Multi);
DrawGraphicText(panel, DC, pos, color, fulltext.GetData(),
fulltext.Append( 'A' - 1 + DrawLibItem->m_Multi );
DrawGraphicText( panel, DC, pos, color, fulltext.GetData(),
orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ,
Field->m_Size,
hjustify, vjustify, LineWidth);
hjustify, vjustify, LineWidth );
}
}
/********************************************************************************/
EDA_LibComponentStruct *FindLibPart(const wxChar *Name, const wxString & LibName, int Alias)
EDA_LibComponentStruct* FindLibPart( const wxChar* Name, const wxString& LibName, int Alias )
/********************************************************************************/
/*
Routine to find a part in one of the libraries given its name.
Name = Name of part.
LibName = Name of Lib; if "": seach in all libs
Alias = Flag: si flag != 0, retourne un pointeur sur une part ou un alias
si flag = 0, retourne un pointeur sur une part meme si le nom
correspond a un alias
Alias = FIND_ROOT, ou Alias = FIND_ALIAS
*/
* Routine to find a part in one of the libraries given its name.
* Name = Name of part.
* LibName = Name of Lib; if "": seach in all libs
* Alias = Flag: si flag != 0, retourne un pointeur sur une part ou un alias
* si flag = 0, retourne un pointeur sur une part meme si le nom
* correspond a un alias
* Alias = FIND_ROOT, ou Alias = FIND_ALIAS
*/
{
EDA_LibComponentStruct *Entry;
static EDA_LibComponentStruct DummyEntry(wxEmptyString); /* Used only to call PQFind. */
LibraryStruct *Lib = g_LibraryList;
EDA_LibComponentStruct* Entry;
static EDA_LibComponentStruct DummyEntry( wxEmptyString );/* Used only to call PQFind. */
DummyEntry.m_Drawings = NULL; /* Used only to call PQFind. */
LibraryStruct* Lib = g_LibraryList;
DummyEntry.m_Drawings = NULL;/* Used only to call PQFind. */
DummyEntry.m_Name.m_Text = Name;
PQCompFunc((PQCompFuncType) LibraryEntryCompare);
PQCompFunc( (PQCompFuncType) LibraryEntryCompare );
Entry = NULL; FindLibName.Empty();
while (Lib)
while( Lib )
{
if( ! LibName.IsEmpty() )
if( !LibName.IsEmpty() )
{
if( Lib->m_Name != LibName )
{
Lib = Lib->m_Pnext; continue ;
Lib = Lib->m_Pnext; continue;
}
}
if( Lib == NULL ) break;
Entry = (EDA_LibComponentStruct*)PQFind(Lib->m_Entries, &DummyEntry);
if( Entry != NULL)
if( Lib == NULL )
break;
Entry = (EDA_LibComponentStruct*) PQFind( Lib->m_Entries, &DummyEntry );
if( Entry != NULL )
{
FindLibName = Lib->m_Name;
break;
......@@ -347,13 +382,14 @@ LibraryStruct *Lib = g_LibraryList;
if( Entry )
{
if( (Entry->Type != ROOT ) && (Alias == FIND_ROOT) )
Entry = FindLibPart( ((EDA_LibCmpAliasStruct*)Entry)->m_RootName.GetData() ,
Lib->m_Name, FIND_ROOT);
Entry = FindLibPart( ( (EDA_LibCmpAliasStruct*) Entry )->m_RootName.GetData(),
Lib->m_Name, FIND_ROOT );
}
return (Entry);
return Entry;
}
/*****************************************************************************
* Routine to draw the given part at given position, transformed/mirror as
* specified, and in the given drawing mode.
......@@ -361,43 +397,49 @@ LibraryStruct *Lib = g_LibraryList;
* else draw in color = Color
*****************************************************************************/
/* DrawMode = GrXOR, GrOR ..*/
void DrawLibPartAux(WinEDA_DrawPanel * panel,wxDC * DC,
EDA_SchComponentStruct *Component,
EDA_LibComponentStruct *Entry,
const wxPoint & Pos,
void DrawLibPartAux( WinEDA_DrawPanel* panel, wxDC* DC,
EDA_SchComponentStruct* Component,
EDA_LibComponentStruct* Entry,
const wxPoint& Pos,
int TransMat[2][2],
int Multi, int convert, int DrawMode,
int Color, bool DrawPinText)
int Color, bool DrawPinText )
{
int i, x1, y1, x2, y2, t1, t2, orient;
LibEDA_BaseStruct *DEntry = NULL;
int CharColor;
int fill_option;
int SetHightColor;
int LineWidth;
int i, x1, y1, x2, y2, t1, t2, orient;
LibEDA_BaseStruct* DEntry = NULL;
int CharColor;
int fill_option;
int SetHightColor;
int LineWidth;
//#define GETCOLOR(l) Color < 0 ? (ReturnLayerColor(l)| SetHightColor) : Color;
#define GETCOLOR(l) Color < 0 ? SetHightColor ? s_ItemSelectColor : (ReturnLayerColor(l)| SetHightColor) : Color;
#define GETCOLOR( l ) Color < 0 ? SetHightColor ?\
s_ItemSelectColor : (ReturnLayerColor( l ) | SetHightColor) : Color;
if (Entry->m_Drawings == NULL) return;
GRSetDrawMode(DC, DrawMode);
if( Entry->m_Drawings == NULL )
return;
GRSetDrawMode( DC, DrawMode );
for( DEntry = Entry->m_Drawings; DEntry != NULL;DEntry = DEntry->Next())
for( DEntry = Entry->m_Drawings; DEntry != NULL; DEntry = DEntry->Next() )
{
/* Elimination des elements non relatifs a l'unite */
if( Multi && DEntry->m_Unit && (DEntry->m_Unit != Multi) ) continue;
if( Multi && DEntry->m_Unit && (DEntry->m_Unit != Multi) )
continue;
if( convert && DEntry->m_Convert && (DEntry->m_Convert != convert) )
continue;
if ( DEntry->m_Flags & IS_MOVED ) continue; // Element en deplacement non trace
if( DEntry->m_Flags & IS_MOVED )
continue; // Element en deplacement non trace
SetHightColor = (DEntry->m_Selected & IS_SELECTED) ? HIGHT_LIGHT_FLAG : 0;
LineWidth = MAX(DEntry->m_Width, g_DrawMinimunLineWidth);
switch (DEntry->m_StructType)
LineWidth = MAX( DEntry->m_Width, g_DrawMinimunLineWidth );
switch( DEntry->m_StructType )
{
case COMPONENT_ARC_DRAW_TYPE:
{
int xc,yc, x2, y2;
LibDrawArc * Arc = (LibDrawArc *) DEntry;
CharColor = GETCOLOR(LAYER_DEVICE);
int xc, yc, x2, y2;
LibDrawArc* Arc = (LibDrawArc*) DEntry;
CharColor = GETCOLOR( LAYER_DEVICE );
xc = Pos.x + TransMat[0][0] * Arc->m_Pos.x +
TransMat[0][1] * Arc->m_Pos.y;
yc = Pos.y + TransMat[1][0] * Arc->m_Pos.x +
......@@ -411,85 +453,94 @@ int LineWidth;
y1 = Pos.y + TransMat[1][0] * Arc->m_ArcEnd.x +
TransMat[1][1] * Arc->m_ArcEnd.y;
t1 = Arc->t1; t2 = Arc->t2;
bool swap = MapAngles(&t1, &t2, TransMat);
if ( swap ) { EXCHG(x1,x2); EXCHG(y1, y2) }
bool swap = MapAngles( &t1, &t2, TransMat );
if( swap )
{
EXCHG( x1, x2 ); EXCHG( y1, y2 )
}
fill_option = Arc->m_Fill & (~g_PrintFillMask);
if ( Color < 0 ) // Normal Color Layer
if( Color < 0 ) // Normal Color Layer
{
if ( (fill_option == FILLED_WITH_BG_BODYCOLOR) && ! g_IsPrinting )
GRFilledArc(&panel->m_ClipBox, DC, xc, yc, t1, t2,
if( (fill_option == FILLED_WITH_BG_BODYCOLOR) && !g_IsPrinting )
GRFilledArc( &panel->m_ClipBox, DC, xc, yc, t1, t2,
Arc->m_Rayon, Arc->m_Width, CharColor,
ReturnLayerColor(LAYER_DEVICE_BACKGROUND));
else if ( fill_option == FILLED_SHAPE)
GRFilledArc(&panel->m_ClipBox, DC, xc, yc, t1, t2,
Arc->m_Rayon, CharColor, CharColor);
ReturnLayerColor( LAYER_DEVICE_BACKGROUND ) );
else if( fill_option == FILLED_SHAPE )
GRFilledArc( &panel->m_ClipBox, DC, xc, yc, t1, t2,
Arc->m_Rayon, CharColor, CharColor );
#ifdef DRAW_ARC_WITH_ANGLE
else GRArc(&panel->m_ClipBox, DC, xc, yc, t1, t2,
Arc->m_Rayon, LineWidth, CharColor);
else
GRArc( &panel->m_ClipBox, DC, xc, yc, t1, t2,
Arc->m_Rayon, LineWidth, CharColor );
#else
else GRArc1(&panel->m_ClipBox, DC, x1, y1, x2, y2,
xc, yc, LineWidth, CharColor);
else
GRArc1( &panel->m_ClipBox, DC, x1, y1, x2, y2,
xc, yc, LineWidth, CharColor );
#endif
}
#ifdef DRAW_ARC_WITH_ANGLE
else GRArc(&panel->m_ClipBox, DC, xc, yc, t1, t2,
Arc->m_Rayon, Circle->m_Width, CharColor);
else
GRArc( &panel->m_ClipBox, DC, xc, yc, t1, t2,
Arc->m_Rayon, Circle->m_Width, CharColor );
#else
else GRArc1(&panel->m_ClipBox, DC, x1, y1, x2, y2,
xc, yc, Arc->m_Width, CharColor);
else
GRArc1( &panel->m_ClipBox, DC, x1, y1, x2, y2,
xc, yc, Arc->m_Width, CharColor );
#endif
}
break;
case COMPONENT_CIRCLE_DRAW_TYPE:
{
LibDrawCircle * Circle = (LibDrawCircle *) DEntry;
CharColor = GETCOLOR(LAYER_DEVICE);
LibDrawCircle* Circle = (LibDrawCircle*) DEntry;
CharColor = GETCOLOR( LAYER_DEVICE );
x1 = Pos.x + TransMat[0][0] * Circle->m_Pos.x +
TransMat[0][1] * Circle->m_Pos.y;
y1 = Pos.y + TransMat[1][0] * Circle->m_Pos.x +
TransMat[1][1] * Circle->m_Pos.y;
fill_option = Circle->m_Fill & (~g_PrintFillMask);
if ( Color < 0 )
if( Color < 0 )
{
if ( (fill_option == FILLED_WITH_BG_BODYCOLOR) && ! g_IsPrinting )
GRFilledCircle(&panel->m_ClipBox, DC, x1, y1,
if( (fill_option == FILLED_WITH_BG_BODYCOLOR) && !g_IsPrinting )
GRFilledCircle( &panel->m_ClipBox, DC, x1, y1,
Circle->m_Rayon, LineWidth, CharColor,
ReturnLayerColor(LAYER_DEVICE_BACKGROUND));
else if ( fill_option == FILLED_SHAPE)
GRFilledCircle(&panel->m_ClipBox, DC, x1, y1,
Circle->m_Rayon, 0, CharColor, CharColor);
else GRCircle(&panel->m_ClipBox, DC, x1, y1,
Circle->m_Rayon, LineWidth, CharColor);
ReturnLayerColor( LAYER_DEVICE_BACKGROUND ) );
else if( fill_option == FILLED_SHAPE )
GRFilledCircle( &panel->m_ClipBox, DC, x1, y1,
Circle->m_Rayon, 0, CharColor, CharColor );
else
GRCircle( &panel->m_ClipBox, DC, x1, y1,
Circle->m_Rayon, LineWidth, CharColor );
}
else GRCircle(&panel->m_ClipBox, DC, x1, y1,
Circle->m_Rayon, LineWidth, CharColor);
else
GRCircle( &panel->m_ClipBox, DC, x1, y1,
Circle->m_Rayon, LineWidth, CharColor );
}
break;
case COMPONENT_GRAPHIC_TEXT_DRAW_TYPE:
{
LibDrawText * Text = (LibDrawText *) DEntry;
CharColor = GETCOLOR(LAYER_DEVICE);
LibDrawText* Text = (LibDrawText*) DEntry;
CharColor = GETCOLOR( LAYER_DEVICE );
/* The text orientation may need to be flipped if the
transformation matrix cuases xy axes to be flipped. */
* transformation matrix cuases xy axes to be flipped. */
t1 = (TransMat[0][0] != 0) ^ (Text->m_Horiz != 0);
x1 = Pos.x + TransMat[0][0] * Text->m_Pos.x
+ TransMat[0][1] * Text->m_Pos.y;
y1 = Pos.y + TransMat[1][0] * Text->m_Pos.x
+ TransMat[1][1] * Text->m_Pos.y;
DrawGraphicText(panel, DC, wxPoint(x1, y1), CharColor, Text->m_Text,
DrawGraphicText( panel, DC, wxPoint( x1, y1 ), CharColor, Text->m_Text,
t1 ? TEXT_ORIENT_HORIZ : TEXT_ORIENT_VERT,
Text->m_Size,
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER, LineWidth);
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER, LineWidth );
}
break;
case COMPONENT_RECT_DRAW_TYPE:
{
LibDrawSquare * Square = (LibDrawSquare *) DEntry;
CharColor = GETCOLOR(LAYER_DEVICE);
LibDrawSquare* Square = (LibDrawSquare*) DEntry;
CharColor = GETCOLOR( LAYER_DEVICE );
x1 = Pos.x + TransMat[0][0] * Square->m_Pos.x
+ TransMat[0][1] * Square->m_Pos.y;
......@@ -500,34 +551,36 @@ int LineWidth;
y2 = Pos.y + TransMat[1][0] * Square->m_End.x
+ TransMat[1][1] * Square->m_End.y;
fill_option = Square->m_Fill & (~g_PrintFillMask);
if ( Color < 0 )
if( Color < 0 )
{
if ( (fill_option == FILLED_WITH_BG_BODYCOLOR) && ! g_IsPrinting )
GRFilledRect(&panel->m_ClipBox, DC, x1, y1, x2, y2,
if( (fill_option == FILLED_WITH_BG_BODYCOLOR) && !g_IsPrinting )
GRFilledRect( &panel->m_ClipBox, DC, x1, y1, x2, y2,
CharColor, LineWidth,
ReturnLayerColor(LAYER_DEVICE_BACKGROUND));
else if ( fill_option == FILLED_SHAPE)
GRFilledRect(&panel->m_ClipBox, DC, x1, y1, x2, y2,
CharColor, CharColor);
else GRRect(&panel->m_ClipBox, DC, x1, y1, x2, y2,
LineWidth, CharColor);
ReturnLayerColor( LAYER_DEVICE_BACKGROUND ) );
else if( fill_option == FILLED_SHAPE )
GRFilledRect( &panel->m_ClipBox, DC, x1, y1, x2, y2,
CharColor, CharColor );
else
GRRect( &panel->m_ClipBox, DC, x1, y1, x2, y2,
LineWidth, CharColor );
}
else GRRect(&panel->m_ClipBox, DC, x1, y1, x2, y2,
LineWidth, CharColor);
else
GRRect( &panel->m_ClipBox, DC, x1, y1, x2, y2,
LineWidth, CharColor );
}
break;
case COMPONENT_PIN_DRAW_TYPE: /* Trace des Pins */
{
LibDrawPin * Pin = (LibDrawPin *) DEntry;
if(Pin->m_Attributs & PINNOTDRAW)
LibDrawPin* Pin = (LibDrawPin*) DEntry;
if( Pin->m_Attributs & PINNOTDRAW )
{
if( (ActiveScreen->m_Type == SCHEMATIC_FRAME) &&
!g_ShowAllPins )
if( (ActiveScreen->m_Type == SCHEMATIC_FRAME)
&& !g_ShowAllPins )
break;
}
/* Calcul de l'orientation reelle de la Pin */
orient = Pin->ReturnPinDrawOrient(TransMat);
orient = Pin->ReturnPinDrawOrient( TransMat );
/* Calcul de la position du point de reference */
x2 = Pos.x + (TransMat[0][0] * Pin->m_Pos.x)
......@@ -536,37 +589,38 @@ int LineWidth;
+ (TransMat[1][1] * Pin->m_Pos.y);
/* Dessin de la pin et du symbole special associe */
CharColor = GETCOLOR(LAYER_PIN);
Pin->DrawPinSymbol(panel, DC, wxPoint(x2, y2) , orient, DrawMode, CharColor );
CharColor = GETCOLOR( LAYER_PIN );
Pin->DrawPinSymbol( panel, DC, wxPoint( x2, y2 ), orient, DrawMode, CharColor );
if ( DrawPinText )
if( DrawPinText )
{
wxPoint pinpos(x2,y2);
wxPoint pinpos( x2, y2 );
CharColor = SetHightColor ? s_ItemSelectColor : Color;
Pin->DrawPinTexts(panel, DC, pinpos, orient,
Pin->DrawPinTexts( panel, DC, pinpos, orient,
Entry->m_TextInside,
Entry->m_DrawPinNum,Entry->m_DrawPinName,
CharColor, DrawMode);
Entry->m_DrawPinNum, Entry->m_DrawPinName,
CharColor, DrawMode );
}
}
break;
case COMPONENT_POLYLINE_DRAW_TYPE:
{
LibDrawPolyline * polyline = (LibDrawPolyline *) DEntry;
CharColor = GETCOLOR(LAYER_DEVICE);
if ( Buf_Poly_Drawings == NULL )
LibDrawPolyline* polyline = (LibDrawPolyline*) DEntry;
CharColor = GETCOLOR( LAYER_DEVICE );
if( Buf_Poly_Drawings == NULL )
{
Buf_Poly_Size = polyline->n;
Buf_Poly_Drawings = (int *) MyMalloc(sizeof(int) * 2 * Buf_Poly_Size);
Buf_Poly_Drawings = (int*) MyMalloc( sizeof(int) * 2 * Buf_Poly_Size );
}
else if ( Buf_Poly_Size < polyline->n )
else if( Buf_Poly_Size < polyline->n )
{
Buf_Poly_Size = polyline->n;
Buf_Poly_Drawings = (int *) realloc(Buf_Poly_Drawings,
sizeof(int) * 2 * Buf_Poly_Size);
Buf_Poly_Drawings = (int*) realloc( Buf_Poly_Drawings,
sizeof(int) * 2 * Buf_Poly_Size );
}
for (i = 0; i < polyline->n; i++)
for( i = 0; i < polyline->n; i++ )
{
Buf_Poly_Drawings[i * 2] = Pos.x +
TransMat[0][0] * polyline->PolyList[i * 2] +
......@@ -575,161 +629,185 @@ int LineWidth;
TransMat[1][0] * polyline->PolyList[i * 2] +
TransMat[1][1] * polyline->PolyList[i * 2 + 1];
}
fill_option = polyline->m_Fill & (~g_PrintFillMask);
if ( Color < 0 )
if( Color < 0 )
{
if ( (fill_option == FILLED_WITH_BG_BODYCOLOR) && ! g_IsPrinting )
GRPoly(&panel->m_ClipBox, DC, polyline->n,
if( (fill_option == FILLED_WITH_BG_BODYCOLOR) && !g_IsPrinting )
GRPoly( &panel->m_ClipBox, DC, polyline->n,
Buf_Poly_Drawings, 1, LineWidth, CharColor,
ReturnLayerColor(LAYER_DEVICE_BACKGROUND));
else if ( fill_option == FILLED_SHAPE )
GRPoly(&panel->m_ClipBox, DC, polyline->n,
Buf_Poly_Drawings, 1, LineWidth, CharColor, CharColor);
else GRPoly(&panel->m_ClipBox, DC, polyline->n,
Buf_Poly_Drawings, 0, LineWidth, CharColor, CharColor);
ReturnLayerColor( LAYER_DEVICE_BACKGROUND ) );
else if( fill_option == FILLED_SHAPE )
GRPoly( &panel->m_ClipBox, DC, polyline->n,
Buf_Poly_Drawings, 1, LineWidth, CharColor, CharColor );
else
GRPoly( &panel->m_ClipBox, DC, polyline->n,
Buf_Poly_Drawings, 0, LineWidth, CharColor, CharColor );
}
else GRPoly(&panel->m_ClipBox, DC, polyline->n,
Buf_Poly_Drawings, 0, LineWidth, CharColor, CharColor);
else
GRPoly( &panel->m_ClipBox, DC, polyline->n,
Buf_Poly_Drawings, 0, LineWidth, CharColor, CharColor );
}
break;
default:
wxBell();
break;
} /* Fin Switch */
} /* Fin Boucle de dessin */
if ( g_DebugLevel > 4 ) /* Draw the component boundary box */
}
/* Fin Switch */
}
/* Fin Boucle de dessin */
if( g_DebugLevel > 4 ) /* Draw the component boundary box */
{
EDA_Rect BoundaryBox;
if ( Component ) BoundaryBox = Component->GetBoundaryBox();
else BoundaryBox = Entry->GetBoundaryBox(Multi, convert);
if( Component )
BoundaryBox = Component->GetBoundaryBox();
else
BoundaryBox = Entry->GetBoundaryBox( Multi, convert );
x1 = BoundaryBox.GetX();
y1 = BoundaryBox.GetY();
x2 = BoundaryBox.GetRight();
y2 = BoundaryBox.GetBottom();
GRRect(&panel->m_ClipBox, DC, x1, y1, x2, y2, BROWN);
GRRect( &panel->m_ClipBox, DC, x1, y1, x2, y2, BROWN );
BoundaryBox = Component->m_Field[REFERENCE].GetBoundaryBox();
x1 = BoundaryBox.GetX();
y1 = BoundaryBox.GetY();
x2 = BoundaryBox.GetRight();
y2 = BoundaryBox.GetBottom();
GRRect(&panel->m_ClipBox, DC, x1, y1, x2, y2, BROWN);
GRRect( &panel->m_ClipBox, DC, x1, y1, x2, y2, BROWN );
BoundaryBox = Component->m_Field[VALUE].GetBoundaryBox();
x1 = BoundaryBox.GetX();
y1 = BoundaryBox.GetY();
x2 = BoundaryBox.GetRight();
y2 = BoundaryBox.GetBottom();
GRRect(&panel->m_ClipBox, DC, x1, y1, x2, y2, BROWN);
GRRect( &panel->m_ClipBox, DC, x1, y1, x2, y2, BROWN );
}
}
/********************************************************************************/
void LibDrawPin::DrawPinSymbol(WinEDA_DrawPanel * panel, wxDC * DC,
const wxPoint & pin_pos, int orient, int DrawMode, int Color)
void LibDrawPin::DrawPinSymbol( WinEDA_DrawPanel* panel, wxDC* DC,
const wxPoint& pin_pos, int orient, int DrawMode, int Color )
/*******************************************************************************/
/* Draw the pin symbol (without texts)
if Color != 0 draw with Color, eles with the normal pin color
*/
* if Color != 0 draw with Color, eles with the normal pin color
*/
{
int MapX1, MapY1, x1, y1;
int color;
int width = MAX(m_Width, g_DrawMinimunLineWidth);
int posX = pin_pos.x, posY = pin_pos.y, len = m_PinLen;
int MapX1, MapY1, x1, y1;
int color;
int width = MAX( m_Width, g_DrawMinimunLineWidth );
int posX = pin_pos.x, posY = pin_pos.y, len = m_PinLen;
if( Color >= 0) color = Color;
else color = ReturnLayerColor(LAYER_PIN);
GRSetDrawMode(DC, DrawMode);
if( Color >= 0 )
color = Color;
else
color = ReturnLayerColor( LAYER_PIN );
GRSetDrawMode( DC, DrawMode );
MapX1 = MapY1 = 0; x1 = posX; y1 = posY;
switch ( orient )
switch( orient )
{
case PIN_UP:
y1 = posY - len; MapY1 = 1;
break;
case PIN_DOWN:
y1 = posY + len; MapY1 = -1;
break;
case PIN_LEFT:
x1 = posX - len, MapX1 = 1;
break;
case PIN_RIGHT:
x1 = posX + len; MapX1 = -1;
break;
}
if( m_PinShape & INVERT)
if( m_PinShape & INVERT )
{
GRCircle(&panel->m_ClipBox, DC, MapX1 * INVERT_PIN_RADIUS + x1,
GRCircle( &panel->m_ClipBox, DC, MapX1 * INVERT_PIN_RADIUS + x1,
MapY1 * INVERT_PIN_RADIUS + y1,
INVERT_PIN_RADIUS, width, color);
INVERT_PIN_RADIUS, width, color );
GRMoveTo(MapX1 * INVERT_PIN_RADIUS * 2 + x1,
MapY1 * INVERT_PIN_RADIUS * 2 + y1);
GRLineTo(&panel->m_ClipBox, DC, posX, posY, width, color);
GRMoveTo( MapX1 * INVERT_PIN_RADIUS * 2 + x1,
MapY1 * INVERT_PIN_RADIUS * 2 + y1 );
GRLineTo( &panel->m_ClipBox, DC, posX, posY, width, color );
}
else
{
GRMoveTo(x1, y1);
GRLineTo(&panel->m_ClipBox, DC, posX, posY, width, color);
GRMoveTo( x1, y1 );
GRLineTo( &panel->m_ClipBox, DC, posX, posY, width, color );
}
if(m_PinShape & CLOCK)
if( m_PinShape & CLOCK )
{
if(MapY1 == 0 ) /* MapX1 = +- 1 */
if( MapY1 == 0 ) /* MapX1 = +- 1 */
{
GRMoveTo(x1, y1 + CLOCK_PIN_DIM);
GRLineTo(&panel->m_ClipBox, DC, x1 - MapX1 * CLOCK_PIN_DIM, y1, width, color);
GRLineTo(&panel->m_ClipBox, DC, x1, y1 - CLOCK_PIN_DIM, width, color);
GRMoveTo( x1, y1 + CLOCK_PIN_DIM );
GRLineTo( &panel->m_ClipBox, DC, x1 - MapX1 * CLOCK_PIN_DIM, y1, width, color );
GRLineTo( &panel->m_ClipBox, DC, x1, y1 - CLOCK_PIN_DIM, width, color );
}
else /* MapX1 = 0 */
{
GRMoveTo(x1 + CLOCK_PIN_DIM, y1 );
GRLineTo(&panel->m_ClipBox, DC, x1, y1 - MapY1 * CLOCK_PIN_DIM, width, color);
GRLineTo(&panel->m_ClipBox, DC, x1 - CLOCK_PIN_DIM, y1, width, color);
GRMoveTo( x1 + CLOCK_PIN_DIM, y1 );
GRLineTo( &panel->m_ClipBox, DC, x1, y1 - MapY1 * CLOCK_PIN_DIM, width, color );
GRLineTo( &panel->m_ClipBox, DC, x1 - CLOCK_PIN_DIM, y1, width, color );
}
}
if(m_PinShape & LOWLEVEL_IN) /* IEEE symbol "Active Low Input" */
if( m_PinShape & LOWLEVEL_IN ) /* IEEE symbol "Active Low Input" */
{
if(MapY1 == 0 ) /* MapX1 = +- 1 */
if( MapY1 == 0 ) /* MapX1 = +- 1 */
{
GRMoveTo(x1 + MapX1 * IEEE_SYMBOL_PIN_DIM*2, y1);
GRLineTo(&panel->m_ClipBox, DC, x1 + MapX1 * IEEE_SYMBOL_PIN_DIM*2,
y1 - IEEE_SYMBOL_PIN_DIM, width, color);
GRLineTo(&panel->m_ClipBox, DC, x1, y1, width, color);
GRMoveTo( x1 + MapX1 * IEEE_SYMBOL_PIN_DIM * 2, y1 );
GRLineTo( &panel->m_ClipBox, DC, x1 + MapX1 * IEEE_SYMBOL_PIN_DIM * 2,
y1 - IEEE_SYMBOL_PIN_DIM, width, color );
GRLineTo( &panel->m_ClipBox, DC, x1, y1, width, color );
}
else /* MapX1 = 0 */
{
GRMoveTo(x1, y1 + MapY1 * IEEE_SYMBOL_PIN_DIM*2);
GRLineTo(&panel->m_ClipBox, DC, x1 - IEEE_SYMBOL_PIN_DIM,
y1 + MapY1 * IEEE_SYMBOL_PIN_DIM*2, width, color);
GRLineTo(&panel->m_ClipBox, DC, x1 , y1, width, color);
GRMoveTo( x1, y1 + MapY1 * IEEE_SYMBOL_PIN_DIM * 2 );
GRLineTo( &panel->m_ClipBox, DC, x1 - IEEE_SYMBOL_PIN_DIM,
y1 + MapY1 * IEEE_SYMBOL_PIN_DIM * 2, width, color );
GRLineTo( &panel->m_ClipBox, DC, x1, y1, width, color );
}
}
if(m_PinShape & LOWLEVEL_OUT) /* IEEE symbol "Active Low Output" */
if( m_PinShape & LOWLEVEL_OUT ) /* IEEE symbol "Active Low Output" */
{
if(MapY1 == 0 ) /* MapX1 = +- 1 */
if( MapY1 == 0 ) /* MapX1 = +- 1 */
{
GRMoveTo(x1, y1 - IEEE_SYMBOL_PIN_DIM);
GRLineTo(&panel->m_ClipBox, DC, x1 + MapX1 * IEEE_SYMBOL_PIN_DIM*2, y1, width, color);
GRMoveTo( x1, y1 - IEEE_SYMBOL_PIN_DIM );
GRLineTo( &panel->m_ClipBox,
DC,
x1 + MapX1 * IEEE_SYMBOL_PIN_DIM * 2,
y1,
width,
color );
}
else /* MapX1 = 0 */
{
GRMoveTo(x1 - IEEE_SYMBOL_PIN_DIM, y1);
GRLineTo(&panel->m_ClipBox, DC, x1 , y1 + MapY1 * IEEE_SYMBOL_PIN_DIM*2, width, color);
GRMoveTo( x1 - IEEE_SYMBOL_PIN_DIM, y1 );
GRLineTo( &panel->m_ClipBox,
DC,
x1,
y1 + MapY1 * IEEE_SYMBOL_PIN_DIM * 2,
width,
color );
}
}
/* Draw the pin end target (active end of the pin) */
if ( ! g_IsPrinting ) // Draw but do not print the pin end target 1 pixel width */
GRCircle(&panel->m_ClipBox, DC, posX,posY,TARGET_PIN_DIAM, 0, color);
if( !g_IsPrinting ) // Draw but do not print the pin end target 1 pixel width */
GRCircle( &panel->m_ClipBox, DC, posX, posY, TARGET_PIN_DIAM, 0, color );
}
......@@ -744,53 +822,55 @@ int posX = pin_pos.x, posY = pin_pos.y, len = m_PinLen;
* transform (only mirror and rotate so it remains on the unit circle) to *
* a new point which is used to detect new angle. *
*****************************************************************************/
bool MapAngles(int *Angle1, int *Angle2, int TransMat[2][2])
bool MapAngles( int* Angle1, int* Angle2, int TransMat[2][2] )
{
int Angle, Delta;
double x, y, t;
bool swap = FALSE;
int Angle, Delta;
double x, y, t;
bool swap = FALSE;
Delta = *Angle2 - *Angle1;
if ( Delta >= 1800 )
if( Delta >= 1800 )
{
*Angle1 -=1;
*Angle2 +=1;
*Angle1 -= 1;
*Angle2 += 1;
}
x = cos(*Angle1 * M_PI / 1800.0);
y = sin(*Angle1 * M_PI / 1800.0);
x = cos( *Angle1 * M_PI / 1800.0 );
y = sin( *Angle1 * M_PI / 1800.0 );
t = x * TransMat[0][0] + y * TransMat[0][1];
y = x * TransMat[1][0] + y * TransMat[1][1];
x = t;
*Angle1 = (int) (atan2(y, x) * 1800.0 / M_PI + 0.5);
*Angle1 = (int) (atan2( y, x ) * 1800.0 / M_PI + 0.5);
x = cos(*Angle2 * M_PI / 1800.0);
y = sin(*Angle2 * M_PI / 1800.0);
x = cos( *Angle2 * M_PI / 1800.0 );
y = sin( *Angle2 * M_PI / 1800.0 );
t = x * TransMat[0][0] + y * TransMat[0][1];
y = x * TransMat[1][0] + y * TransMat[1][1];
x = t;
*Angle2 = (int) (atan2(y, x) * 1800.0 / M_PI + 0.5);
*Angle2 = (int) (atan2( y, x ) * 1800.0 / M_PI + 0.5);
NORMALIZE_ANGLE(*Angle1);
NORMALIZE_ANGLE(*Angle2);
if (*Angle2 < *Angle1) *Angle2 += 3600;
NORMALIZE_ANGLE( *Angle1 );
NORMALIZE_ANGLE( *Angle2 );
if( *Angle2 < *Angle1 )
*Angle2 += 3600;
if (*Angle2 - *Angle1 > 1800)
if( *Angle2 - *Angle1 > 1800 )
{ /* Need to swap the two angles. */
Angle = (*Angle1);
*Angle1 = (*Angle2);
*Angle2 = Angle;
NORMALIZE_ANGLE(*Angle1);
NORMALIZE_ANGLE(*Angle2);
if (*Angle2 < *Angle1) *Angle2 += 3600;
NORMALIZE_ANGLE( *Angle1 );
NORMALIZE_ANGLE( *Angle2 );
if( *Angle2 < *Angle1 )
*Angle2 += 3600;
swap = TRUE;
}
if ( Delta >= 1800 )
if( Delta >= 1800 )
{
*Angle1 +=1;
*Angle2 -=1;
*Angle1 += 1;
*Angle2 -= 1;
}
return swap;
......@@ -801,58 +881,58 @@ bool swap = FALSE;
* Routine to display an outline version of given library entry. *
* This routine is applied by the PlaceLibItem routine above. *
*****************************************************************************/
void DrawingLibInGhost(WinEDA_DrawPanel * panel, wxDC * DC,
EDA_LibComponentStruct *LibEntry,
EDA_SchComponentStruct *DrawLibItem, int PartX, int PartY,
int multi, int convert, int Color, bool DrawPinText)
void DrawingLibInGhost( WinEDA_DrawPanel* panel, wxDC* DC,
EDA_LibComponentStruct* LibEntry,
EDA_SchComponentStruct* DrawLibItem, int PartX, int PartY,
int multi, int convert, int Color, bool DrawPinText )
{
int DrawMode = g_XorMode;
int DrawMode = g_XorMode;
DrawLibPartAux(panel, DC, DrawLibItem, LibEntry, wxPoint(PartX, PartY),
DrawLibPartAux( panel, DC, DrawLibItem, LibEntry, wxPoint( PartX, PartY ),
DrawLibItem->m_Transform,
multi, convert, DrawMode, Color, DrawPinText);
multi, convert, DrawMode, Color, DrawPinText );
}
/************************************************************/
/* Routine to draw One LibraryDrawStruct at given position, */
/* matrice de transformation 1 0 0 -1 (normale) */
/* DrawMode = GrXOR, GrOR .. */
/************************************************************/
/* Utilise en LibEdit et Lib Browse */
void DrawLibraryDrawStruct(WinEDA_DrawPanel * panel, wxDC * DC,
EDA_LibComponentStruct *LibEntry,
void DrawLibraryDrawStruct( WinEDA_DrawPanel* panel, wxDC* DC,
EDA_LibComponentStruct* LibEntry,
int PartX, int PartY,
LibEDA_BaseStruct *DrawItem, int Multi,
int DrawMode, int Color)
LibEDA_BaseStruct* DrawItem, int Multi,
int DrawMode, int Color )
{
int i, x1, y1, x2, y2, t1, t2, orient;
int CharColor;
int TransMat[2][2];
int fill_option;
int i, x1, y1, x2, y2, t1, t2, orient;
int CharColor;
int TransMat[2][2];
int fill_option;
#undef GETCOLOR
#define GETCOLOR(l) Color < 0 ? ReturnLayerColor(l) : Color;
#define GETCOLOR( l ) Color < 0 ? ReturnLayerColor( l ) : Color;
Multi = 0; /* unused */
/* Trace de la structure */
CharColor = GETCOLOR(LAYER_DEVICE);
GRSetDrawMode(DC, DrawMode);
CharColor = GETCOLOR( LAYER_DEVICE );
GRSetDrawMode( DC, DrawMode );
TransMat[0][0] = 1;
TransMat[0][1] = TransMat[1][0] = 0;
TransMat[1][1] = -1;
int LineWidth = MAX(DrawItem->m_Width, g_DrawMinimunLineWidth);
int LineWidth = MAX( DrawItem->m_Width, g_DrawMinimunLineWidth );
switch (DrawItem->m_StructType)
switch( DrawItem->m_StructType )
{
case COMPONENT_ARC_DRAW_TYPE:
{
int xc,yc, x2,y2;
LibDrawArc * Arc = (LibDrawArc *) DrawItem;
int xc, yc, x2, y2;
LibDrawArc* Arc = (LibDrawArc*) DrawItem;
t1 = Arc->t1; t2 = Arc->t2;
bool swap = MapAngles(&t1, &t2, TransMat);
bool swap = MapAngles( &t1, &t2, TransMat );
xc = PartX + Arc->m_Pos.x;
yc = PartY - Arc->m_Pos.y;
x2 = PartX + Arc->m_ArcStart.x;
......@@ -860,127 +940,141 @@ int fill_option;
x1 = PartX + Arc->m_ArcEnd.x;
y1 = PartY - Arc->m_ArcEnd.y;
if ( swap ) { EXCHG(x1,x2); EXCHG(y1, y2)}
if( swap )
{
EXCHG( x1, x2 ); EXCHG( y1, y2 )
}
fill_option = Arc->m_Fill & (~g_PrintFillMask);
if ( (Arc->m_Fill == FILLED_WITH_BG_BODYCOLOR) && ! g_IsPrinting )
GRFilledArc(&panel->m_ClipBox, DC, xc, yc, t1, t2,
if( (Arc->m_Fill == FILLED_WITH_BG_BODYCOLOR) && !g_IsPrinting )
GRFilledArc( &panel->m_ClipBox, DC, xc, yc, t1, t2,
Arc->m_Rayon, CharColor,
ReturnLayerColor(LAYER_DEVICE_BACKGROUND));
else if ( Arc->m_Fill == FILLED_SHAPE)
GRFilledArc(&panel->m_ClipBox, DC, xc, yc, t1, t2,
Arc->m_Rayon, LineWidth, CharColor, CharColor);
ReturnLayerColor( LAYER_DEVICE_BACKGROUND ) );
else if( Arc->m_Fill == FILLED_SHAPE )
GRFilledArc( &panel->m_ClipBox, DC, xc, yc, t1, t2,
Arc->m_Rayon, LineWidth, CharColor, CharColor );
#ifdef DRAW_ARC_WITH_ANGLE
else GRArc(&panel->m_ClipBox, DC, xc, yc, t1, t2,
Arc->m_Rayon, CharColor);
else
GRArc( &panel->m_ClipBox, DC, xc, yc, t1, t2,
Arc->m_Rayon, CharColor );
#else
else GRArc1(&panel->m_ClipBox, DC, x1, y1, x2, y2,
xc, yc, LineWidth, CharColor);
else
GRArc1( &panel->m_ClipBox, DC, x1, y1, x2, y2,
xc, yc, LineWidth, CharColor );
#endif
}
break;
case COMPONENT_CIRCLE_DRAW_TYPE:
{
LibDrawCircle * Circle = (LibDrawCircle *) DrawItem;
LibDrawCircle* Circle = (LibDrawCircle*) DrawItem;
x1 = PartX + Circle->m_Pos.x;
y1 = PartY - Circle->m_Pos.y;
fill_option = Circle->m_Fill & (~g_PrintFillMask);
if ( (fill_option == FILLED_WITH_BG_BODYCOLOR) && ! g_IsPrinting )
GRFilledCircle(&panel->m_ClipBox, DC, x1, y1,
if( (fill_option == FILLED_WITH_BG_BODYCOLOR) && !g_IsPrinting )
GRFilledCircle( &panel->m_ClipBox, DC, x1, y1,
Circle->m_Rayon, LineWidth, CharColor,
ReturnLayerColor(LAYER_DEVICE_BACKGROUND));
else if ( fill_option == FILLED_SHAPE)
GRFilledCircle(&panel->m_ClipBox, DC, x1, y1,
Circle->m_Rayon, 0, CharColor, CharColor);
else GRCircle(&panel->m_ClipBox, DC, x1, y1,
Circle->m_Rayon, LineWidth, CharColor);
ReturnLayerColor( LAYER_DEVICE_BACKGROUND ) );
else if( fill_option == FILLED_SHAPE )
GRFilledCircle( &panel->m_ClipBox, DC, x1, y1,
Circle->m_Rayon, 0, CharColor, CharColor );
else
GRCircle( &panel->m_ClipBox, DC, x1, y1,
Circle->m_Rayon, LineWidth, CharColor );
}
break;
case COMPONENT_GRAPHIC_TEXT_DRAW_TYPE:
{
LibDrawText * Text = (LibDrawText *) DrawItem;
LibDrawText* Text = (LibDrawText*) DrawItem;
x1 = PartX + Text->m_Pos.x;
y1 = PartY - Text->m_Pos.y;
DrawGraphicText(panel, DC, wxPoint(x1, y1), CharColor, Text->m_Text,
DrawGraphicText( panel, DC, wxPoint( x1, y1 ), CharColor, Text->m_Text,
Text->m_Horiz,
Text->m_Size,
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER, LineWidth);
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER, LineWidth );
}
break;
case COMPONENT_RECT_DRAW_TYPE:
{
LibDrawSquare * Square = (LibDrawSquare *) DrawItem;
LibDrawSquare* Square = (LibDrawSquare*) DrawItem;
x1 = PartX + Square->m_Pos.x;
y1 = PartY - Square->m_Pos.y;
x2 = PartX + Square->m_End.x;
y2 = PartY - Square->m_End.y;
fill_option = Square->m_Fill & (~g_PrintFillMask);
if ( (fill_option == FILLED_WITH_BG_BODYCOLOR) && ! g_IsPrinting )
GRFilledRect(&panel->m_ClipBox, DC, x1, y1, x2, y2,
if( (fill_option == FILLED_WITH_BG_BODYCOLOR) && !g_IsPrinting )
GRFilledRect( &panel->m_ClipBox, DC, x1, y1, x2, y2,
CharColor, LineWidth,
ReturnLayerColor(LAYER_DEVICE_BACKGROUND));
else if ( fill_option == FILLED_SHAPE)
GRFilledRect(&panel->m_ClipBox, DC, x1, y1, x2, y2,
CharColor, CharColor);
else GRRect(&panel->m_ClipBox, DC, x1, y1, x2, y2, LineWidth,
CharColor);
ReturnLayerColor( LAYER_DEVICE_BACKGROUND ) );
else if( fill_option == FILLED_SHAPE )
GRFilledRect( &panel->m_ClipBox, DC, x1, y1, x2, y2,
CharColor, CharColor );
else
GRRect( &panel->m_ClipBox, DC, x1, y1, x2, y2, LineWidth,
CharColor );
}
break;
case COMPONENT_PIN_DRAW_TYPE: /* Trace des Pins */
{
LibDrawPin * Pin = (LibDrawPin *) DrawItem;
LibDrawPin* Pin = (LibDrawPin*) DrawItem;
x2 = PartX + Pin->m_Pos.x;
y2 = PartY - Pin->m_Pos.y;
/* Compute the real pin orientation, i.e. pin orient + component orient */
orient = Pin->ReturnPinDrawOrient(TransMat);
orient = Pin->ReturnPinDrawOrient( TransMat );
/* Dessin de la pin et du symbole special associe */
if( Pin->m_Attributs & PINNOTDRAW) CharColor = DARKGRAY;
else CharColor = -1;
if( Pin->m_Attributs & PINNOTDRAW )
CharColor = DARKGRAY;
else
CharColor = -1;
Pin->DrawPinSymbol( panel, DC, wxPoint( x2, y2 ), orient, DrawMode );
wxPoint pinpos( x2, y2 );
Pin->DrawPinSymbol(panel, DC, wxPoint(x2, y2), orient, DrawMode);
wxPoint pinpos(x2,y2);
Pin->DrawPinTexts(panel, DC, pinpos, orient,
Pin->DrawPinTexts( panel, DC, pinpos, orient,
LibEntry->m_TextInside,
LibEntry->m_DrawPinNum,LibEntry->m_DrawPinName,
CharColor, DrawMode);
LibEntry->m_DrawPinNum, LibEntry->m_DrawPinName,
CharColor, DrawMode );
}
break;
case COMPONENT_POLYLINE_DRAW_TYPE:
{
LibDrawPolyline * polyline = (LibDrawPolyline *) DrawItem;
if ( Buf_Poly_Drawings == NULL )
LibDrawPolyline* polyline = (LibDrawPolyline*) DrawItem;
if( Buf_Poly_Drawings == NULL )
{
Buf_Poly_Size = polyline->n;
Buf_Poly_Drawings = (int *) MyMalloc(sizeof(int) * 2 * Buf_Poly_Size);
Buf_Poly_Drawings = (int*) MyMalloc( sizeof(int) * 2 * Buf_Poly_Size );
}
else if ( Buf_Poly_Size < polyline->n )
else if( Buf_Poly_Size < polyline->n )
{
Buf_Poly_Size = polyline->n;
Buf_Poly_Drawings = (int *) realloc(Buf_Poly_Drawings,
sizeof(int) * 2 * Buf_Poly_Size);
Buf_Poly_Drawings = (int*) realloc( Buf_Poly_Drawings,
sizeof(int) * 2 * Buf_Poly_Size );
}
for (i = 0; i < polyline->n; i++)
for( i = 0; i < polyline->n; i++ )
{
Buf_Poly_Drawings[i * 2] = PartX + polyline->PolyList[i * 2];
Buf_Poly_Drawings[i * 2 + 1] = PartY - polyline->PolyList[i * 2 + 1];
}
fill_option = polyline->m_Fill & (~g_PrintFillMask);
if ( (fill_option == FILLED_WITH_BG_BODYCOLOR) && ! g_IsPrinting )
GRPoly(&panel->m_ClipBox, DC, polyline->n,
if( (fill_option == FILLED_WITH_BG_BODYCOLOR) && !g_IsPrinting )
GRPoly( &panel->m_ClipBox, DC, polyline->n,
Buf_Poly_Drawings, 1, LineWidth, CharColor,
ReturnLayerColor(LAYER_DEVICE_BACKGROUND));
else if ( fill_option == FILLED_SHAPE )
GRPoly(&panel->m_ClipBox, DC, polyline->n,
Buf_Poly_Drawings, 1, LineWidth, CharColor, CharColor);
else GRPoly(&panel->m_ClipBox, DC, polyline->n,
Buf_Poly_Drawings, 0, LineWidth, CharColor, CharColor);
ReturnLayerColor( LAYER_DEVICE_BACKGROUND ) );
else if( fill_option == FILLED_SHAPE )
GRPoly( &panel->m_ClipBox, DC, polyline->n,
Buf_Poly_Drawings, 1, LineWidth, CharColor, CharColor );
else
GRPoly( &panel->m_ClipBox, DC, polyline->n,
Buf_Poly_Drawings, 0, LineWidth, CharColor, CharColor );
break;
}
default:
;
}
}
eeschema/eelibs_read_libraryfiles.cpp
View file @ f3c324d5
......@@ -17,22 +17,22 @@
/* Fonctions locales */
/* pour librairies de composants */
static LibEDA_BaseStruct *GetDrawEntry(WinEDA_DrawFrame * frame, FILE *f,
char *Line, int *LineNum);
static bool GetLibEntryField(EDA_LibComponentStruct *LibEntry, char * line);
static bool AddAliasNames(EDA_LibComponentStruct *LibEntry, char * line);
static void InsertAlias(PriorQue ** PQ,
EDA_LibComponentStruct *LibEntry, int *NumOfParts);
static bool ReadLibEntryDateAndTime(EDA_LibComponentStruct * LibEntry, char * Line);
static int AddFootprintFilterList(EDA_LibComponentStruct *LibEntryLibEntry,
FILE * f, char * Line, int *LineNum);
static LibEDA_BaseStruct* GetDrawEntry( WinEDA_DrawFrame* frame, FILE* f,
char* Line, int* LineNum );
static bool GetLibEntryField( EDA_LibComponentStruct* LibEntry, char* line );
static bool AddAliasNames( EDA_LibComponentStruct* LibEntry, char* line );
static void InsertAlias( PriorQue** PQ,
EDA_LibComponentStruct* LibEntry, int* NumOfParts );
static bool ReadLibEntryDateAndTime( EDA_LibComponentStruct* LibEntry, char* Line );
static int AddFootprintFilterList( EDA_LibComponentStruct* LibEntryLibEntry,
FILE* f, char* Line, int* LineNum );
/* pour doc librairies */
/****************************************************/
/* Routines de lecture des librairies de composants */
/****************************************************/
/****************************************************/
/* Routines de lecture des librairies de composants */
/****************************************************/
/*****************************************************************************
......@@ -41,194 +41,219 @@ static int AddFootprintFilterList(EDA_LibComponentStruct *LibEntryLibEntry,
* IF library already exists, it is NOT reloaded. *
* return: new lib or NULL *
*****************************************************************************/
LibraryStruct * LoadLibraryName(WinEDA_DrawFrame * frame,
const wxString & FullLibName, const wxString & LibName)
LibraryStruct* LoadLibraryName( WinEDA_DrawFrame* frame,
const wxString& FullLibName, const wxString& LibName )
{
int NumOfParts;
FILE *f;
LibraryStruct *NewLib;
PriorQue *Entries;
wxString FullFileName;
int NumOfParts;
FILE* f;
LibraryStruct* NewLib;
PriorQue* Entries;
wxString FullFileName;
if ( (NewLib = FindLibrary(LibName)) != NULL)
if( ( NewLib = FindLibrary( LibName ) ) != NULL )
{
if ( NewLib->m_FullFileName == FullLibName )
if( NewLib->m_FullFileName == FullLibName )
return NewLib;
FreeCmpLibrary(frame, LibName);
FreeCmpLibrary( frame, LibName );
}
NewLib = NULL;
f = wxFopen(FullLibName, wxT("rt") );
if (f == NULL)
f = wxFopen( FullLibName, wxT( "rt" ) );
if( f == NULL )
{
wxString msg;
msg.Printf( _("Library <%s> not found"), FullLibName.GetData());
DisplayError(frame, msg);
msg.Printf( _( "Library <%s> not found" ), FullLibName.GetData() );
DisplayError( frame, msg );
return NULL;
}
NewLib = new LibraryStruct(LIBRARY_TYPE_EESCHEMA, LibName, FullLibName);
Entries = LoadLibraryAux(frame, NewLib, f, &NumOfParts);
if ( Entries != NULL)
NewLib = new LibraryStruct( LIBRARY_TYPE_EESCHEMA, LibName, FullLibName );
Entries = LoadLibraryAux( frame, NewLib, f, &NumOfParts );
if( Entries != NULL )
{
NewLib->m_Entries = Entries;
NewLib->m_NumOfParts = NumOfParts;
if ( g_LibraryList == NULL ) g_LibraryList = NewLib;
if( g_LibraryList == NULL )
g_LibraryList = NewLib;
else
{
LibraryStruct *tmplib = g_LibraryList;
while ( tmplib->m_Pnext ) tmplib = tmplib->m_Pnext;
LibraryStruct* tmplib = g_LibraryList;
while( tmplib->m_Pnext )
tmplib = tmplib->m_Pnext;
tmplib->m_Pnext = NewLib;
}
FullFileName = FullLibName;
ChangeFileNameExt(FullFileName, DOC_EXT);
LoadDocLib(frame, FullFileName, NewLib->m_Name);
ChangeFileNameExt( FullFileName, DOC_EXT );
LoadDocLib( frame, FullFileName, NewLib->m_Name );
}
else delete NewLib;
else
delete NewLib;
fclose(f);
fclose( f );
return NewLib;
}
/******************************************/
void LoadLibraries(WinEDA_DrawFrame * frame)
void LoadLibraries( WinEDA_DrawFrame* frame )
/******************************************/
/* Delete toutes les librairies chargees et recree toutes les librairies
donnes dans la liste g_LibName_List
*/
* donnes dans la liste g_LibName_List
*/
{
wxString FullLibName, msg;
wxString LibName;
unsigned ii, iimax = g_LibName_List.GetCount();
wxString FullLibName, msg;
wxString LibName;
unsigned ii, iimax = g_LibName_List.GetCount();
frame->PrintMsg( _("Start loading schematic libs"));
frame->PrintMsg( _( "Start loading schematic libs" ) );
// Free the unwanted libraries (i.e. not in list) but keep the .cache lib
LibraryStruct *nextlib, *lib = g_LibraryList;
for (; lib != NULL; lib = nextlib )
LibraryStruct* nextlib, * lib = g_LibraryList;
for( ; lib != NULL; lib = nextlib )
{
nextlib = lib->m_Pnext;
if ( lib->m_IsLibCache ) continue;
if( lib->m_IsLibCache )
continue;
wxString libname = lib->m_Name;
// is this library in "wanted list" g_LibName_List ?
int test = g_LibName_List.Index(libname);
if ( test == wxNOT_FOUND ) FreeCmpLibrary(frame, libname);
int test = g_LibName_List.Index( libname );
if( test == wxNOT_FOUND )
FreeCmpLibrary( frame, libname );
}
// Load missing libraries (if any)
for ( ii = 0 ; ii < iimax; ii++)
for( ii = 0; ii < iimax; ii++ )
{
LibName = g_LibName_List[ii];
if( LibName.IsEmpty() ) continue;
FullLibName = MakeFileName(g_RealLibDirBuffer, LibName, g_LibExtBuffer);
msg = wxT("Loading ") + FullLibName;
if ( LoadLibraryName(frame, FullLibName, LibName) )
msg += wxT(" OK");
if( LibName.IsEmpty() )
continue;
FullLibName = MakeFileName( g_RealLibDirBuffer, LibName, g_LibExtBuffer );
msg = wxT( "Loading " ) + FullLibName;
if( LoadLibraryName( frame, FullLibName, LibName ) )
msg += wxT( " OK" );
else
msg += wxT(" ->Error");
msg += wxT( " ->Error" );
frame->PrintMsg( msg );
}
// reorder the linked list to match the order filename list:
int NumOfLibs;
for (NumOfLibs = 0, lib = g_LibraryList; lib != NULL; lib = lib->m_Pnext)
for( NumOfLibs = 0, lib = g_LibraryList; lib != NULL; lib = lib->m_Pnext )
{
lib->m_Flags = 0;
NumOfLibs++;
}
if ( NumOfLibs == 0 ) return;
LibraryStruct ** libs =
(LibraryStruct **) MyZMalloc(sizeof(LibraryStruct *) * (NumOfLibs + 2));
if( NumOfLibs == 0 )
return;
LibraryStruct** libs =
(LibraryStruct**) MyZMalloc( sizeof(LibraryStruct *) * (NumOfLibs + 2) );
int jj = 0;
for (ii = 0; ii < g_LibName_List.GetCount(); ii++)
for( ii = 0; ii < g_LibName_List.GetCount(); ii++ )
{
if ( jj >= NumOfLibs ) break;
lib = FindLibrary(g_LibName_List[ii]);
if ( lib )
if( jj >= NumOfLibs )
break;
lib = FindLibrary( g_LibName_List[ii] );
if( lib )
{
lib->m_Flags = 1;
libs[jj++] = lib;
}
}
/* Put lib cache at end of list */
for (lib = g_LibraryList; lib != NULL; lib = lib->m_Pnext)
for( lib = g_LibraryList; lib != NULL; lib = lib->m_Pnext )
{
if ( lib->m_Flags == 0 ) libs[jj++] = lib;
if( lib->m_Flags == 0 )
libs[jj++] = lib;
}
libs[jj] = NULL;
/* Change the linked list pointers */
for (ii = 0; libs[ii] != NULL; ii++)
libs[ii]->m_Pnext = libs[ii+1];
for( ii = 0; libs[ii] != NULL; ii++ )
libs[ii]->m_Pnext = libs[ii + 1];
g_LibraryList = libs[0];
MyFree(libs);
MyFree( libs );
for (lib = g_LibraryList; lib != NULL; lib = lib->m_Pnext)
for( lib = g_LibraryList; lib != NULL; lib = lib->m_Pnext )
lib->m_Flags = 0;
}
/*****************************************************************************
* Routine to free a library from the current loaded libraries. *
*****************************************************************************/
void FreeCmpLibrary(wxWindow * frame, const wxString & LibName)
void FreeCmpLibrary( wxWindow* frame, const wxString& LibName )
{
int NumOfLibs = NumOfLibraries();
LibraryStruct *Lib, *TempLib;
int NumOfLibs = NumOfLibraries();
LibraryStruct* Lib, * TempLib;
if (NumOfLibs == 0)
if( NumOfLibs == 0 )
{
DisplayError(frame, wxT("No libraries are loaded"),20);
DisplayError( frame, wxT( "No libraries are loaded" ), 20 );
return;
}
/* Search for this library name: */
for (Lib = g_LibraryList; Lib != NULL; Lib = Lib->m_Pnext)
for( Lib = g_LibraryList; Lib != NULL; Lib = Lib->m_Pnext )
{
if (LibName == Lib->m_Name) break;
if( LibName == Lib->m_Name )
break;
}
if (Lib == NULL) return;
if( Lib == NULL )
return;
if ( Lib == g_LibraryList) g_LibraryList = Lib->m_Pnext;
if( Lib == g_LibraryList )
g_LibraryList = Lib->m_Pnext;
else
{
for( TempLib = g_LibraryList; TempLib->m_Pnext != Lib; TempLib=TempLib->m_Pnext);
for( TempLib = g_LibraryList; TempLib->m_Pnext != Lib; TempLib = TempLib->m_Pnext )
;
TempLib->m_Pnext = TempLib->m_Pnext->m_Pnext;
}
delete Lib;
/* La librairie supprimee est peut etre celle selectee dans libedit */
if ( Lib == CurrentLib ) CurrentLib = NULL;
if( Lib == CurrentLib )
CurrentLib = NULL;
}
/******************************/
const wxChar **GetLibNames(void)
const wxChar** GetLibNames( void )
/******************************/
/* Routine to return pointers to all library names.
User is responsible to deallocate memory
*/
* User is responsible to deallocate memory
*/
{
int ii, NumOfLibs = NumOfLibraries();
const wxChar **Names;
LibraryStruct *Lib;
int ii, NumOfLibs = NumOfLibraries();
const wxChar** Names;
LibraryStruct* Lib;
Names = (const wxChar **) MyZMalloc(sizeof(wxChar *) * (NumOfLibs + 1));
for (ii = 0, Lib = g_LibraryList; Lib != NULL; Lib = Lib->m_Pnext, ii++)
Names = (const wxChar**) MyZMalloc( sizeof(wxChar *) * (NumOfLibs + 1) );
for( ii = 0, Lib = g_LibraryList; Lib != NULL; Lib = Lib->m_Pnext, ii++ )
{
Names[ii] = Lib->m_Name.GetData();
}
Names[ii] = NULL;
return Names;
......@@ -239,70 +264,73 @@ LibraryStruct *Lib;
* Routine to compare two EDA_LibComponentStruct for the PriorQue module. *
* Comparison (insensitive case) is based on Part name. *
*****************************************************************************/
int LibraryEntryCompare(EDA_LibComponentStruct *LE1, EDA_LibComponentStruct *LE2)
int LibraryEntryCompare( EDA_LibComponentStruct* LE1, EDA_LibComponentStruct* LE2 )
{
return LE1->m_Name.m_Text.CmpNoCase(LE2->m_Name.m_Text);
return LE1->m_Name.m_Text.CmpNoCase( LE2->m_Name.m_Text );
}
/*****************************************************************************
* Routine to load a library from given open file. *
*****************************************************************************/
PriorQue *LoadLibraryAux(WinEDA_DrawFrame * frame, LibraryStruct * Library, FILE *libfile, int *NumOfParts)
PriorQue* LoadLibraryAux( WinEDA_DrawFrame* frame, LibraryStruct* Library, FILE* libfile,
int* NumOfParts )
{
int LineNum = 0;
char Line[1024];
PriorQue *PQ = NULL;
EDA_LibComponentStruct *LibEntry;
wxString msg;
int LineNum = 0;
char Line[1024];
PriorQue* PQ = NULL;
EDA_LibComponentStruct* LibEntry;
wxString msg;
wxBusyCursor ShowWait; // Display a Busy Cursor..
wxBusyCursor ShowWait; // Display a Busy Cursor..
*NumOfParts = 0;
if ( GetLine(libfile, Line, &LineNum, sizeof(Line) ) == NULL)
if( GetLine( libfile, Line, &LineNum, sizeof(Line) ) == NULL )
{
msg = _("File <") + Library->m_Name + _("> is empty!");
DisplayError(frame, msg);
msg = _( "File <" ) + Library->m_Name + _( "> is empty!" );
DisplayError( frame, msg );
return NULL;
}
if( strnicmp(Line, LIBFILE_IDENT, 10) != 0)
if( strnicmp( Line, LIBFILE_IDENT, 10 ) != 0 )
{
msg = _("File <") + Library->m_Name + _("> is NOT EESCHEMA library!");
DisplayError(frame, msg);
msg = _( "File <" ) + Library->m_Name + _( "> is NOT EESCHEMA library!" );
DisplayError( frame, msg );
return NULL;
}
if ( Library ) Library->m_Header = CONV_FROM_UTF8(Line);
if( Library )
Library->m_Header = CONV_FROM_UTF8( Line );
PQInit(&PQ);
PQCompFunc((PQCompFuncType) LibraryEntryCompare);
PQInit( &PQ );
PQCompFunc( (PQCompFuncType) LibraryEntryCompare );
while (GetLine(libfile, Line, &LineNum, sizeof(Line)) )
while( GetLine( libfile, Line, &LineNum, sizeof(Line) ) )
{
if (strnicmp(Line, "$HEADER", 7) == 0)
if( strnicmp( Line, "$HEADER", 7 ) == 0 )
{
if ( Library )
if( Library )
{
if ( ! Library->ReadHeader(libfile, &LineNum) )
if( !Library->ReadHeader( libfile, &LineNum ) )
{
msg = _("Library <") + Library->m_Name + _("> header read error");
DisplayError(frame, msg, 30);
msg = _( "Library <" ) + Library->m_Name + _( "> header read error" );
DisplayError( frame, msg, 30 );
}
}
continue;
}
if (strnicmp(Line, "DEF", 3) == 0)
if( strnicmp( Line, "DEF", 3 ) == 0 )
{
/* Read one DEF/ENDDEF part entry from library: */
LibEntry = Read_Component_Definition(frame, Line, libfile, &LineNum);
if ( LibEntry )
LibEntry = Read_Component_Definition( frame, Line, libfile, &LineNum );
if( LibEntry )
{
/* If we are here, this part is O.k. - put it in: */
++*NumOfParts;
PQInsert(&PQ, LibEntry);
InsertAlias(&PQ, LibEntry, NumOfParts);
++ * NumOfParts;
PQInsert( &PQ, LibEntry );
InsertAlias( &PQ, LibEntry, NumOfParts );
}
}
}
......@@ -312,133 +340,133 @@ wxBusyCursor ShowWait; // Display a Busy Cursor..
/*********************************************************************************************/
EDA_LibComponentStruct * Read_Component_Definition(WinEDA_DrawFrame * frame, char * Line,
FILE *f, int *LineNum)
EDA_LibComponentStruct* Read_Component_Definition( WinEDA_DrawFrame* frame, char* Line,
FILE* f, int* LineNum )
/*********************************************************************************************/
/* Routine to Read a DEF/ENDDEF part entry from given open file.
*/
*/
{
int unused;
char *p, *Name, *Prefix = NULL;
EDA_LibComponentStruct *LibEntry = NULL;
bool Res;
wxString Msg;
int unused;
char* p, * Name, * Prefix = NULL;
EDA_LibComponentStruct* LibEntry = NULL;
bool Res;
wxString Msg;
p = strtok(Line, " \t\r\n");
p = strtok( Line, " \t\r\n" );
if (strcmp(p, "DEF") != 0)
if( strcmp( p, "DEF" ) != 0 )
{
Msg.Printf( wxT("DEF command expected in line %d, aborted."), *LineNum);
DisplayError(frame, Msg);
Msg.Printf( wxT( "DEF command expected in line %d, aborted." ), *LineNum );
DisplayError( frame, Msg );
return NULL;
}
/* Read DEF line: */
char drawnum = 0, drawname = 0;
LibEntry = new EDA_LibComponentStruct( NULL);
if ((Name = strtok(NULL, " \t\n")) == NULL || /* Part name: */
(Prefix = strtok(NULL, " \t\n")) == NULL || /* Prefix name: */
(p = strtok(NULL, " \t\n")) == NULL || /* NumOfPins: */
sscanf(p, "%d", &unused) != 1 ||
(p = strtok(NULL, " \t\n")) == NULL || /* TextInside: */
sscanf(p, "%d", &LibEntry->m_TextInside) != 1 ||
(p = strtok(NULL, " \t\n")) == NULL || /* DrawNums: */
sscanf(p, "%c", &drawnum) != 1 ||
(p = strtok(NULL, " \t\n")) == NULL || /* DrawNums: */
sscanf(p, "%c", &drawname) != 1 ||
(p = strtok(NULL, " \t\n")) == NULL || /* m_UnitCount: */
sscanf(p, "%d", &LibEntry->m_UnitCount) != 1 )
{
Msg.Printf( wxT("Wrong DEF format in line %d, skipped."),*LineNum);
DisplayError(frame, Msg);
while (GetLine(f, Line, LineNum, 1024) )
{
p = strtok(Line, " \t\n");
if (stricmp(p, "ENDDEF") == 0) break;
LibEntry = new EDA_LibComponentStruct( NULL );
if( ( Name = strtok( NULL, " \t\n" ) ) == NULL /* Part name: */
|| ( Prefix = strtok( NULL, " \t\n" ) ) == NULL /* Prefix name: */
|| ( p = strtok( NULL, " \t\n" ) ) == NULL /* NumOfPins: */
|| sscanf( p, "%d", &unused ) != 1
|| ( p = strtok( NULL, " \t\n" ) ) == NULL /* TextInside: */
|| sscanf( p, "%d", &LibEntry->m_TextInside ) != 1
|| ( p = strtok( NULL, " \t\n" ) ) == NULL /* DrawNums: */
|| sscanf( p, "%c", &drawnum ) != 1
|| ( p = strtok( NULL, " \t\n" ) ) == NULL /* DrawNums: */
|| sscanf( p, "%c", &drawname ) != 1
|| ( p = strtok( NULL, " \t\n" ) ) == NULL /* m_UnitCount: */
|| sscanf( p, "%d", &LibEntry->m_UnitCount ) != 1 )
{
Msg.Printf( wxT( "Wrong DEF format in line %d, skipped." ), *LineNum );
DisplayError( frame, Msg );
while( GetLine( f, Line, LineNum, 1024 ) )
{
p = strtok( Line, " \t\n" );
if( stricmp( p, "ENDDEF" ) == 0 )
break;
}
return NULL;
}
else /* Mise a jour des infos de la ligne "DEF" */
{
LibEntry->m_DrawPinNum = (drawnum == 'N') ? FALSE : TRUE;
LibEntry->m_DrawPinName = (drawname == 'N') ? FALSE : TRUE;
/* Copy part name and prefix. */
strupper(Name);
if(Name[0] != '~') LibEntry->m_Name.m_Text = CONV_FROM_UTF8(Name);
strupper( Name );
if( Name[0] != '~' )
LibEntry->m_Name.m_Text = CONV_FROM_UTF8( Name );
else
{
LibEntry->m_Name.m_Text = CONV_FROM_UTF8(&Name[1]);
LibEntry->m_Name.m_Text = CONV_FROM_UTF8( &Name[1] );
LibEntry->m_Name.m_Attributs |= TEXT_NO_VISIBLE;
}
if (strcmp(Prefix, "~") == 0)
if( strcmp( Prefix, "~" ) == 0 )
{
LibEntry->m_Prefix.m_Text.Empty();
LibEntry->m_Prefix.m_Attributs |= TEXT_NO_VISIBLE;
}
else LibEntry->m_Prefix.m_Text = CONV_FROM_UTF8(Prefix);
else
LibEntry->m_Prefix.m_Text = CONV_FROM_UTF8( Prefix );
// Copy optional infos
if ( (p = strtok(NULL, " \t\n")) != NULL ) // m_UnitSelectionLocked param
if( ( p = strtok( NULL, " \t\n" ) ) != NULL ) // m_UnitSelectionLocked param
{
if ( *p == 'L') LibEntry->m_UnitSelectionLocked = TRUE;
if( *p == 'L' )
LibEntry->m_UnitSelectionLocked = TRUE;
}
if ( (p = strtok(NULL, " \t\n")) != NULL ) /* Type Of Component */
if( ( p = strtok( NULL, " \t\n" ) ) != NULL ) /* Type Of Component */
{
if ( *p == 'P') LibEntry->m_Options = ENTRY_POWER;
if( *p == 'P' )
LibEntry->m_Options = ENTRY_POWER;
}
}
/* Analyse lignes suivantes */
while (GetLine(f, Line, LineNum, 1024) )
while( GetLine( f, Line, LineNum, 1024 ) )
{
p = strtok(Line, " \t\n");
p = strtok( Line, " \t\n" );
Res = TRUE; /* Pour test d'erreur (Res = FALSE = erreur) */
if( (Line[0] == 'T') && (Line[1] == 'i') )
{
Res = ReadLibEntryDateAndTime(LibEntry, Line);
Res = ReadLibEntryDateAndTime( LibEntry, Line );
}
else if(Line[0] == 'F')
else if( Line[0] == 'F' )
{
Res = GetLibEntryField(LibEntry, Line);
Res = GetLibEntryField( LibEntry, Line );
}
else if (strcmp(p, "ENDDEF") == 0)
else if( strcmp( p, "ENDDEF" ) == 0 )
{
break;
}
else if (strcmp(p, "DRAW") == 0)
else if( strcmp( p, "DRAW" ) == 0 )
{
LibEntry->m_Drawings = GetDrawEntry(frame, f, Line, LineNum);
LibEntry->m_Drawings = GetDrawEntry( frame, f, Line, LineNum );
}
else if(strncmp(p, "ALIAS", 5) == 0 )
else if( strncmp( p, "ALIAS", 5 ) == 0 )
{
p = strtok(NULL, "\r\n");
Res = AddAliasNames(LibEntry, p);
p = strtok( NULL, "\r\n" );
Res = AddAliasNames( LibEntry, p );
}
else if(strncmp(p, "$FPLIST", 5) == 0 )
else if( strncmp( p, "$FPLIST", 5 ) == 0 )
{
Res = AddFootprintFilterList(LibEntry, f, Line, LineNum);
Res = AddFootprintFilterList( LibEntry, f, Line, LineNum );
}
else
{
Msg.Printf( wxT("Undefined command \"%s\" in line %d, skipped."), p, * LineNum);
frame->PrintMsg(Msg);
Msg.Printf( wxT( "Undefined command \"%s\" in line %d, skipped." ), p, *LineNum );
frame->PrintMsg( Msg );
}
/* Fin analyse de la ligne ou block: test de l'info lue */
if (!Res)
if( !Res )
{ /* Something went wrong there. */
Msg.Printf( wxT(" Error Line %d, Library not loaded"), *LineNum);
DisplayError(frame, Msg);
Msg.Printf( wxT( " Error Line %d, Library not loaded" ), *LineNum );
DisplayError( frame, Msg );
delete LibEntry;
return NULL;
}
......@@ -450,60 +478,63 @@ wxString Msg;
}
/*****************************************************************************
* Routine to load a DRAW definition from given file. Note "DRAW" line has *
* been read already. Reads upto and include ENDDRAW, or an error (NULL ret). *
*****************************************************************************/
static LibEDA_BaseStruct *GetDrawEntry(WinEDA_DrawFrame * frame, FILE *f, char *Line, int *LineNum)
static LibEDA_BaseStruct* GetDrawEntry( WinEDA_DrawFrame* frame, FILE* f, char* Line, int* LineNum )
{
int i = 0, jj, ll, Unit, Convert, size1, size2;
char *p, Buffer[1024], BufName[256],
int i = 0, jj, ll, Unit, Convert, size1, size2;
char* p, Buffer[1024], BufName[256],
PinNum[256],
chartmp[256], chartmp1[256];
wxString MsgLine;
bool Error = FALSE;
LibEDA_BaseStruct *Tail = NULL,
*New = NULL,
*Head = NULL;
wxString MsgLine;
bool Error = FALSE;
LibEDA_BaseStruct* Tail = NULL,
* New = NULL,
* Head = NULL;
while (TRUE)
while( TRUE )
{
if (GetLine(f, Line, LineNum, 1024 ) == NULL)
if( GetLine( f, Line, LineNum, 1024 ) == NULL )
{
DisplayError(frame, wxT("File ended prematurely"));
DisplayError( frame, wxT( "File ended prematurely" ) );
return Head;
}
if (strncmp(Line, "ENDDRAW", 7) == 0)
if( strncmp( Line, "ENDDRAW", 7 ) == 0 )
{
break;
}
New = NULL;
switch (Line[0])
switch( Line[0] )
{
case 'A': /* Arc */
{
int startx, starty, endx, endy;
LibDrawArc * Arc = new LibDrawArc();
LibDrawArc* Arc = new LibDrawArc();
New = Arc;
ll = 0;
int nbarg = sscanf(&Line[2], "%d %d %d %d %d %d %d %d %s %d %d %d %d",
int nbarg = sscanf( &Line[2], "%d %d %d %d %d %d %d %d %s %d %d %d %d",
&Arc->m_Pos.x, &Arc->m_Pos.y, &Arc->m_Rayon,
&Arc->t1, &Arc->t2, &Unit, &Convert,
&Arc->m_Width, chartmp, &startx, &starty, &endx, &endy);
if ( nbarg < 8 ) Error = TRUE;
&Arc->m_Width, chartmp, &startx, &starty, &endx, &endy );
if( nbarg < 8 )
Error = TRUE;
Arc->m_Unit = Unit; Arc->m_Convert = Convert;
if ( chartmp[0] == 'F') Arc->m_Fill = FILLED_SHAPE;
if ( chartmp[0] == 'f') Arc->m_Fill = FILLED_WITH_BG_BODYCOLOR;
if( chartmp[0] == 'F' )
Arc->m_Fill = FILLED_SHAPE;
if( chartmp[0] == 'f' )
Arc->m_Fill = FILLED_WITH_BG_BODYCOLOR;
NORMALIZE_ANGLE(Arc->t1);
NORMALIZE_ANGLE(Arc->t2);
NORMALIZE_ANGLE( Arc->t1 );
NORMALIZE_ANGLE( Arc->t2 );
if ( nbarg >= 13 ) // Coord reelles des extremites de l'arc lues
if( nbarg >= 13 ) // Coord reelles des extremites de l'arc lues
{
Arc->m_ArcStart.x = startx; Arc->m_ArcStart.y = starty;
Arc->m_ArcEnd.x = endx; Arc->m_ArcEnd.y = endy;
......@@ -512,74 +543,82 @@ LibEDA_BaseStruct *Tail = NULL,
{
Arc->m_ArcStart.x = Arc->m_Rayon; Arc->m_ArcStart.y = 0;
Arc->m_ArcEnd.x = Arc->m_Rayon; Arc->m_ArcEnd.y = 0;
RotatePoint( &Arc->m_ArcStart.x, &Arc->m_ArcStart.y, -Arc->t1);
Arc->m_ArcStart.x += Arc->m_Pos.x; Arc->m_ArcStart.y +=Arc->m_Pos.y;
RotatePoint( &Arc->m_ArcEnd.x, &Arc->m_ArcEnd.y, -Arc->t2);
Arc->m_ArcEnd.x += Arc->m_Pos.x; Arc->m_ArcEnd.y +=Arc->m_Pos.y;
RotatePoint( &Arc->m_ArcStart.x, &Arc->m_ArcStart.y, -Arc->t1 );
Arc->m_ArcStart.x += Arc->m_Pos.x; Arc->m_ArcStart.y += Arc->m_Pos.y;
RotatePoint( &Arc->m_ArcEnd.x, &Arc->m_ArcEnd.y, -Arc->t2 );
Arc->m_ArcEnd.x += Arc->m_Pos.x; Arc->m_ArcEnd.y += Arc->m_Pos.y;
}
}
break;
case 'C': /* Circle */
{
LibDrawCircle * Circle = new LibDrawCircle();
LibDrawCircle* Circle = new LibDrawCircle();
New = Circle; ll = 0;
Error = sscanf(&Line[2], "%d %d %d %d %d %d %s",
Error = sscanf( &Line[2], "%d %d %d %d %d %d %s",
&Circle->m_Pos.x, &Circle->m_Pos.y, &Circle->m_Rayon,
&Unit, &Convert,&Circle->m_Width, chartmp) < 6;
&Unit, &Convert, &Circle->m_Width, chartmp ) < 6;
Circle->m_Unit = Unit;
Circle->m_Convert = Convert;
if ( chartmp[0] == 'F') Circle->m_Fill = FILLED_SHAPE;
if ( chartmp[0] == 'f') Circle->m_Fill = FILLED_WITH_BG_BODYCOLOR;
if( chartmp[0] == 'F' )
Circle->m_Fill = FILLED_SHAPE;
if( chartmp[0] == 'f' )
Circle->m_Fill = FILLED_WITH_BG_BODYCOLOR;
}
break;
case 'T': /* Text */
{
LibDrawText * Text = new LibDrawText();
LibDrawText* Text = new LibDrawText();
New = Text;
Buffer[0] = 0;
Error = sscanf(&Line[2], "%d %d %d %d %d %d %d %s",
Error = sscanf( &Line[2], "%d %d %d %d %d %d %d %s",
&Text->m_Horiz,
&Text->m_Pos.x, &Text->m_Pos.y,
&Text->m_Size.x, &Text->m_Type,
&Unit, &Convert, Buffer) != 8;
&Unit, &Convert, Buffer ) != 8;
Text->m_Unit = Unit; Text->m_Convert = Convert;
Text->m_Size.y = Text->m_Size.x;
if (!Error)
if( !Error )
{ /* Convert '~' to spaces. */
Text->m_Text = CONV_FROM_UTF8(Buffer);
Text->m_Text.Replace(wxT("~"), wxT(" ")); // Les espaces sont restitus
Text->m_Text = CONV_FROM_UTF8( Buffer );
Text->m_Text.Replace( wxT( "~" ), wxT( " " ) ); // Les espaces sont restitus
}
}
break;
case 'S': /* Square */
{
LibDrawSquare * Square = new LibDrawSquare();
LibDrawSquare* Square = new LibDrawSquare();
New = Square; ll = 0;
Error = sscanf(&Line[2], "%d %d %d %d %d %d %d %s",
Error = sscanf( &Line[2], "%d %d %d %d %d %d %d %s",
&Square->m_Pos.x, &Square->m_Pos.y,
&Square->m_End.x, &Square->m_End.y,
&Unit, &Convert,&Square->m_Width, chartmp) < 7;
&Unit, &Convert, &Square->m_Width, chartmp ) < 7;
Square->m_Unit = Unit; Square->m_Convert = Convert;
if ( chartmp[0] == 'F') Square->m_Fill = FILLED_SHAPE;
if ( chartmp[0] == 'f') Square->m_Fill = FILLED_WITH_BG_BODYCOLOR;
if( chartmp[0] == 'F' )
Square->m_Fill = FILLED_SHAPE;
if( chartmp[0] == 'f' )
Square->m_Fill = FILLED_WITH_BG_BODYCOLOR;
}
break;
case 'X': /* Pin Description */
{
*Buffer = 0;
LibDrawPin * Pin = new LibDrawPin();
LibDrawPin* Pin = new LibDrawPin();
New = Pin;
i = sscanf(Line+2, "%s %s %d %d %d %s %d %d %d %d %s %s",
i = sscanf( Line + 2, "%s %s %d %d %d %s %d %d %d %d %s %s",
BufName, PinNum,
&Pin->m_Pos.x, &Pin->m_Pos.y,
&ll, chartmp1,
&size1, &size2,
&Unit, &Convert, chartmp, Buffer);
&Unit, &Convert, chartmp, Buffer );
Pin->m_PinNumSize = size1; /* Parametres type short */
Pin->m_PinNameSize = size2;
......@@ -587,124 +626,154 @@ LibEDA_BaseStruct *Tail = NULL,
Pin->m_Orient = chartmp1[0] & 255;
Pin->m_Unit = Unit; Pin->m_Convert = Convert;
strncpy((char*)&Pin->m_PinNum, PinNum, 4);
strncpy( (char*) &Pin->m_PinNum, PinNum, 4 );
Error = (i != 11 && i != 12);
Pin->m_PinName = CONV_FROM_UTF8(BufName);
Pin->m_PinName = CONV_FROM_UTF8( BufName );
jj = *chartmp & 255;
switch(jj)
switch( jj )
{
case 'I':
Pin->m_PinType = PIN_INPUT; break;
case 'O':
Pin->m_PinType = PIN_OUTPUT; break;
case 'B':
Pin->m_PinType = PIN_BIDI; break;
case 'T':
Pin->m_PinType = PIN_TRISTATE; break;
case 'P':
Pin->m_PinType = PIN_PASSIVE; break;
case 'U':
Pin->m_PinType = PIN_UNSPECIFIED; break;
case 'W':
Pin->m_PinType = PIN_POWER_IN; break;
case 'w':
Pin->m_PinType = PIN_POWER_OUT; break;
case 'C':
Pin->m_PinType = PIN_OPENCOLLECTOR; break;
case 'E':
Pin->m_PinType = PIN_OPENEMITTER; break;
default:
MsgLine.Printf( wxT("Unknown Pin Type [%c] line %d"),
jj, *LineNum);
DisplayError(frame, MsgLine);
MsgLine.Printf( wxT( "Unknown Pin Type [%c] line %d" ),
jj, *LineNum );
DisplayError( frame, MsgLine );
}
if( i == 12 ) /* Special Symbole defined */
for( jj = strlen(Buffer); jj > 0 ; )
for( jj = strlen( Buffer ); jj > 0; )
{
switch(Buffer[--jj])
switch( Buffer[--jj] )
{
case '~': break;
case 'N': Pin->m_Attributs |= PINNOTDRAW; break;
case 'I': Pin->m_PinShape |= INVERT; break;
case 'C': Pin->m_PinShape |= CLOCK; break;
case 'L': Pin->m_PinShape |= LOWLEVEL_IN; break;
case 'V': Pin->m_PinShape |= LOWLEVEL_OUT; break;
case '~':
break;
case 'N':
Pin->m_Attributs |= PINNOTDRAW; break;
case 'I':
Pin->m_PinShape |= INVERT; break;
case 'C':
Pin->m_PinShape |= CLOCK; break;
case 'L':
Pin->m_PinShape |= LOWLEVEL_IN; break;
case 'V':
Pin->m_PinShape |= LOWLEVEL_OUT; break;
default:
MsgLine.Printf( wxT("Unknown Pin Shape [%c] line %d"),
Buffer[jj], *LineNum);
DisplayError(frame, MsgLine); break;
MsgLine.Printf( wxT( "Unknown Pin Shape [%c] line %d" ),
Buffer[jj], *LineNum );
DisplayError( frame, MsgLine ); break;
}
}
}
break;
case 'P': /* Polyline */
{
LibDrawPolyline * Polyl = new LibDrawPolyline();
LibDrawPolyline* Polyl = new LibDrawPolyline();
New = Polyl;
if (sscanf(&Line[2], "%d %d %d %d",
if( sscanf( &Line[2], "%d %d %d %d",
&Polyl->n, &Unit, &Convert,
&Polyl->m_Width) == 4 &&
Polyl->n > 0)
&Polyl->m_Width ) == 4
&& Polyl->n > 0 )
{
Polyl->m_Unit = Unit; Polyl->m_Convert = Convert;
Polyl->PolyList = (int *)
MyZMalloc(sizeof(int) * Polyl->n * 2);
Polyl->PolyList = (int*)
MyZMalloc( sizeof(int) * Polyl->n * 2 );
p = strtok(&Line[2], " \t\n");
p = strtok(NULL, " \t\n");
p = strtok(NULL, " \t\n");
p = strtok(NULL, " \t\n");
p = strtok( &Line[2], " \t\n" );
p = strtok( NULL, " \t\n" );
p = strtok( NULL, " \t\n" );
p = strtok( NULL, " \t\n" );
for (i = 0; i < Polyl->n * 2 && !Error; i++)
for( i = 0; i < Polyl->n * 2 && !Error; i++ )
{
p = strtok(NULL, " \t\n");
Error = sscanf(p, "%d", &Polyl->PolyList[i]) != 1;
p = strtok( NULL, " \t\n" );
Error = sscanf( p, "%d", &Polyl->PolyList[i] ) != 1;
}
Polyl->m_Fill = NO_FILL;
if ( (p = strtok(NULL, " \t\n")) != NULL )
if( ( p = strtok( NULL, " \t\n" ) ) != NULL )
{
if ( p[0] == 'F') Polyl->m_Fill = FILLED_SHAPE;
if ( p[0] == 'f')
if( p[0] == 'F' )
Polyl->m_Fill = FILLED_SHAPE;
if( p[0] == 'f' )
Polyl->m_Fill = FILLED_WITH_BG_BODYCOLOR;
}
}
else Error = TRUE;
else
Error = TRUE;
}
break;
default:
MsgLine.Printf( wxT("Undefined DRAW command in line %d, aborted."),
*LineNum);
DisplayError(frame, MsgLine);
MsgLine.Printf( wxT( "Undefined DRAW command in line %d, aborted." ),
*LineNum );
DisplayError( frame, MsgLine );
return Head;
}
if (Error)
if( Error )
{
MsgLine.Printf( wxT("Error in %c DRAW command in line %d, aborted."),
Line[0], *LineNum);
DisplayError(frame, MsgLine);
MsgLine.Printf( wxT( "Error in %c DRAW command in line %d, aborted." ),
Line[0], *LineNum );
DisplayError( frame, MsgLine );
delete New;
/* FLush till end of draw: */
do {
if (GetLine(f, Line, LineNum, 1024 ) == NULL)
if( GetLine( f, Line, LineNum, 1024 ) == NULL )
{
DisplayError(frame, wxT("File ended prematurely") );
DisplayError( frame, wxT( "File ended prematurely" ) );
return Head;
}
} while (strncmp(Line, "ENDDRAW", 7) != 0);
return (Head);
}
} while( strncmp( Line, "ENDDRAW", 7 ) != 0 );
return Head;
}
else
{
if (Head == NULL) Head = Tail = New;
if( Head == NULL )
Head = Tail = New;
else
{
Tail->Pnext = New; Tail = New;
......@@ -719,79 +788,102 @@ LibEDA_BaseStruct *Tail = NULL,
/*****************************************************************************
* Routine to find the library given its name. *
*****************************************************************************/
LibraryStruct *FindLibrary(const wxString & Name)
LibraryStruct* FindLibrary( const wxString& Name )
{
LibraryStruct *Lib = g_LibraryList;
LibraryStruct* Lib = g_LibraryList;
while (Lib)
while( Lib )
{
if (Lib->m_Name == Name ) return Lib;
if( Lib->m_Name == Name )
return Lib;
Lib = Lib->m_Pnext;
}
return NULL;
}
/*****************************************************************************
* Routine to find the number of libraries currently loaded. *
*****************************************************************************/
int NumOfLibraries(void)
int NumOfLibraries( void )
{
int ii;
LibraryStruct *Lib = g_LibraryList;
int ii;
LibraryStruct* Lib = g_LibraryList;
for( ii = 0; Lib != NULL; Lib = Lib->m_Pnext )
ii++;
for (ii = 0; Lib != NULL; Lib = Lib->m_Pnext) ii++;
return ii;
}
/*****************************************************************************/
static bool GetLibEntryField(EDA_LibComponentStruct *LibEntry, char * line)
static bool GetLibEntryField( EDA_LibComponentStruct* LibEntry, char* line )
/*****************************************************************************/
/* Analyse la ligne de description du champ de la forme:
Fn "CA3130" 150 -200 50 H V
ou n = 0 (REFERENCE), 1 (VALUE) , 2 .. 11 = autres champs, facultatifs
*/
* Fn "CA3130" 150 -200 50 H V
* ou n = 0 (REFERENCE), 1 (VALUE) , 2 .. 11 = autres champs, facultatifs
*/
{
int posx, posy, size, orient, hjustify, vjustify;
bool draw;
char *Text,
int posx, posy, size, orient, hjustify, vjustify;
bool draw;
char* Text,
Char1[256], Char2[256],
Char3[256], Char4[256],
FieldUserName[1024];
int NumOfField, nbparam;
LibDrawField * Field = NULL;
int NumOfField, nbparam;
LibDrawField* Field = NULL;
if( sscanf(line+1, "%d", &NumOfField) != 1) return(0);
if( sscanf( line + 1, "%d", &NumOfField ) != 1 )
return 0;
/* Recherche du debut des donnees (debut du texte suivant) */
while(*line != 0) line++;
while(*line == 0) line++;
while( *line != 0 )
line++;
while( *line == 0 )
line++;
/* recherche du texte */
while ( *line && (*line != '"') ) line++;
if ( *line == 0 ) return(0);
line ++; Text = line;
while( *line && (*line != '"') )
line++;
if( *line == 0 )
return 0;
line++; Text = line;
/* recherche fin de texte */
while ( *line && (*line != '"') ) line++;
if ( *line == 0 ) return(0);
while( *line && (*line != '"') )
line++;
if( *line == 0 )
return 0;
*line = 0; line++;
FieldUserName[0] = 0;
nbparam = sscanf(line, " %d %d %d %c %c %c %c",
&posx, &posy, &size, Char1, Char2, Char3, Char4);
orient = TEXT_ORIENT_HORIZ; if(Char1[0] == 'V') orient = TEXT_ORIENT_VERT;
draw = TRUE; if(Char2[0] == 'I') draw = FALSE;
nbparam = sscanf( line, " %d %d %d %c %c %c %c",
&posx, &posy, &size, Char1, Char2, Char3, Char4 );
orient = TEXT_ORIENT_HORIZ; if( Char1[0] == 'V' )
orient = TEXT_ORIENT_VERT;
draw = TRUE; if( Char2[0] == 'I' )
draw = FALSE;
hjustify = GR_TEXT_HJUSTIFY_CENTER;
vjustify = GR_TEXT_VJUSTIFY_CENTER;
if ( nbparam >= 6 )
if( nbparam >= 6 )
{
if ( *Char3 == 'L' ) hjustify = GR_TEXT_HJUSTIFY_LEFT;
else if ( *Char3 == 'R' ) hjustify = GR_TEXT_HJUSTIFY_RIGHT;
if ( *Char4 == 'B' ) vjustify = GR_TEXT_VJUSTIFY_BOTTOM;
else if ( *Char4 == 'T' ) vjustify = GR_TEXT_VJUSTIFY_TOP;
if( *Char3 == 'L' )
hjustify = GR_TEXT_HJUSTIFY_LEFT;
else if( *Char3 == 'R' )
hjustify = GR_TEXT_HJUSTIFY_RIGHT;
if( *Char4 == 'B' )
vjustify = GR_TEXT_VJUSTIFY_BOTTOM;
else if( *Char4 == 'T' )
vjustify = GR_TEXT_VJUSTIFY_TOP;
}
switch(NumOfField)
switch( NumOfField )
{
case REFERENCE:
Field = &LibEntry->m_Prefix;
......@@ -804,302 +896,335 @@ LibDrawField * Field = NULL;
break;
default:
if(NumOfField >= NUMBER_OF_FIELDS ) break;
Field = new LibDrawField(NumOfField);
if( NumOfField >= NUMBER_OF_FIELDS )
break;
Field = new LibDrawField( NumOfField );
Field->Pnext = LibEntry->Fields;
LibEntry->Fields = Field;
break;
}
if ( Field == NULL ) return FALSE;
if( Field == NULL )
return FALSE;
Field->m_Pos.x = posx; Field->m_Pos.y = posy;
Field->m_Orient = orient;
if( draw == FALSE ) Field->m_Attributs |= TEXT_NO_VISIBLE;
if( draw == FALSE )
Field->m_Attributs |= TEXT_NO_VISIBLE;
Field->m_Size.x = Field->m_Size.y = size;
Field->m_Text = CONV_FROM_UTF8(Text);
if ( NumOfField >= FIELD1 )
Field->m_Text = CONV_FROM_UTF8( Text );
if( NumOfField >= FIELD1 )
{
ReadDelimitedText(FieldUserName,line, sizeof(FieldUserName) );
Field->m_Name = CONV_FROM_UTF8(FieldUserName);
ReadDelimitedText( FieldUserName, line, sizeof(FieldUserName) );
Field->m_Name = CONV_FROM_UTF8( FieldUserName );
}
Field->m_HJustify = hjustify;
Field->m_VJustify = vjustify;
return(TRUE);
return TRUE;
}
/********************************************************************/
static bool AddAliasNames(EDA_LibComponentStruct *LibEntry, char * line)
static bool AddAliasNames( EDA_LibComponentStruct* LibEntry, char* line )
/********************************************************************/
/* Read the alias names (in buffer line) and add them in alias list
names are separated by spaces
*/
* names are separated by spaces
*/
{
char * text;
wxString name;
text = strtok(line, " \t\r\n");
char* text;
wxString name;
text = strtok( line, " \t\r\n" );
while ( text )
while( text )
{
name = CONV_FROM_UTF8(text);
LibEntry->m_AliasList.Add(name);
text = strtok(NULL, " \t\r\n");
name = CONV_FROM_UTF8( text );
LibEntry->m_AliasList.Add( name );
text = strtok( NULL, " \t\r\n" );
}
return( TRUE );
return TRUE;
}
/********************************************************************/
static void InsertAlias(PriorQue ** PQ, EDA_LibComponentStruct *LibEntry,
int *NumOfParts)
static void InsertAlias( PriorQue** PQ, EDA_LibComponentStruct* LibEntry,
int* NumOfParts )
/********************************************************************/
/* create in library (in list PQ) aliases of the "root" component LibEntry*/
{
EDA_LibCmpAliasStruct *AliasEntry;
unsigned ii;
EDA_LibCmpAliasStruct* AliasEntry;
unsigned ii;
if(LibEntry->m_AliasList.GetCount() == 0)
return; /* No alias for this component */
if( LibEntry->m_AliasList.GetCount() == 0 )
return;/* No alias for this component */
for( ii = 0; ii < LibEntry->m_AliasList.GetCount(); ii++ )
{
AliasEntry = new EDA_LibCmpAliasStruct(LibEntry->m_AliasList[ii],
LibEntry->m_Name.m_Text.GetData());
++*NumOfParts;
PQInsert(PQ, AliasEntry);
AliasEntry = new EDA_LibCmpAliasStruct( LibEntry->m_AliasList[ii],
LibEntry->m_Name.m_Text.GetData() );
++ * NumOfParts;
PQInsert( PQ, AliasEntry );
}
}
/*******************************************************/
/* Routines de lecture des Documentation de composants */
/*******************************************************/
/*******************************************************/
/* Routines de lecture des Documentation de composants */
/*******************************************************/
/**********************************************************************************************/
int LoadDocLib(WinEDA_DrawFrame * frame, const wxString & FullDocLibName, const wxString & Libname)
int LoadDocLib( WinEDA_DrawFrame* frame, const wxString& FullDocLibName, const wxString& Libname )
/**********************************************************************************************/
/* Routine to load a library from given open file.*/
{
int LineNum = 0;
char Line[1024], *Name, *Text;
EDA_LibComponentStruct * Entry;
FILE * f;
wxString msg;
int LineNum = 0;
char Line[1024], * Name, * Text;
EDA_LibComponentStruct* Entry;
FILE* f;
wxString msg;
f = wxFopen(FullDocLibName, wxT("rt") );
if (f == NULL) return(0);
f = wxFopen( FullDocLibName, wxT( "rt" ) );
if( f == NULL )
return 0;
if ( GetLine(f, Line, &LineNum, sizeof(Line) ) == NULL)
if( GetLine( f, Line, &LineNum, sizeof(Line) ) == NULL )
{ /* pas de lignes utiles */
fclose(f);
fclose( f );
return 0;
}
if( strnicmp(Line, DOCFILE_IDENT, 10) != 0)
if( strnicmp( Line, DOCFILE_IDENT, 10 ) != 0 )
{
DisplayError(frame, wxT("File is NOT EESCHEMA doclib!") );
fclose(f);
DisplayError( frame, wxT( "File is NOT EESCHEMA doclib!" ) );
fclose( f );
return 0;
}
while (GetLine(f, Line, &LineNum, sizeof(Line)) )
while( GetLine( f, Line, &LineNum, sizeof(Line) ) )
{
if (strncmp(Line, "$CMP",4) != 0)
if( strncmp( Line, "$CMP", 4 ) != 0 )
{
msg.Printf( wxT("$CMP command expected in line %d, aborted."), LineNum);
DisplayError(frame, msg);
fclose(f);
msg.Printf( wxT( "$CMP command expected in line %d, aborted." ), LineNum );
DisplayError( frame, msg );
fclose( f );
return 0;
}
/* Read one $CMP/$ENDCMP part entry from library: */
Name = strtok(Line + 5,"\n\r");
wxString cmpname; cmpname = CONV_FROM_UTF8(Name);
Entry = FindLibPart(cmpname.GetData(),Libname,FIND_ALIAS);
while( GetLine(f, Line, &LineNum, sizeof(Line)) )
Name = strtok( Line + 5, "\n\r" );
wxString cmpname; cmpname = CONV_FROM_UTF8( Name );
Entry = FindLibPart( cmpname.GetData(), Libname, FIND_ALIAS );
while( GetLine( f, Line, &LineNum, sizeof(Line) ) )
{
if( strncmp(Line, "$ENDCMP",7) == 0) break;
Text = strtok(Line + 2,"\n\r");
switch ( Line[0] )
if( strncmp( Line, "$ENDCMP", 7 ) == 0 )
break;
Text = strtok( Line + 2, "\n\r" );
switch( Line[0] )
{
case 'D':
if(Entry) Entry->m_Doc = CONV_FROM_UTF8(Text);
if( Entry )
Entry->m_Doc = CONV_FROM_UTF8( Text );
break;
case 'K':
if(Entry) Entry->m_KeyWord = CONV_FROM_UTF8(Text);
if( Entry )
Entry->m_KeyWord = CONV_FROM_UTF8( Text );
break;
case 'F':
if(Entry) Entry->m_DocFile = CONV_FROM_UTF8(Text);
if( Entry )
Entry->m_DocFile = CONV_FROM_UTF8( Text );
break;
}
}
}
fclose(f);
fclose( f );
return 1;
}
/*********************************************************************************/
static bool ReadLibEntryDateAndTime(EDA_LibComponentStruct * LibEntry, char * Line)
static bool ReadLibEntryDateAndTime( EDA_LibComponentStruct* LibEntry, char* Line )
/*********************************************************************************/
/* lit date et time de modif composant sous le format:
"Ti yy/mm/jj hh:mm:ss"
*/
* "Ti yy/mm/jj hh:mm:ss"
*/
{
int year,mon,day,hour,min,sec;
char * text;
int year, mon, day, hour, min, sec;
char* text;
year = mon = day = hour = min = sec = 0;
text = strtok(Line," \r\t\n");
text = strtok(NULL," \r\t\n"); // text pointe donnees utiles
text = strtok( Line, " \r\t\n" );
text = strtok( NULL, " \r\t\n" ); // text pointe donnees utiles
sscanf(Line,"%d/%d/%d %d:%d:%d",&year,&mon,&day,&hour,&min,&sec);
sscanf( Line, "%d/%d/%d %d:%d:%d", &year, &mon, &day, &hour, &min, &sec );
LibEntry->m_LastDate = (sec & 63)
+ ((min & 63) << 6)
+ ((hour & 31) << 12)
+ ((day & 31) << 17)
+ ((mon & 15) << 22)
+ ((year-1990) << 26);
+ ( (min & 63) << 6 )
+ ( (hour & 31) << 12 )
+ ( (day & 31) << 17 )
+ ( (mon & 15) << 22 )
+ ( (year - 1990) << 26 );
return TRUE;
}
/*******************************************/
static int SortItemsFct(const void * ref, const void * item);
void EDA_LibComponentStruct::SortDrawItems(void)
static int SortItemsFct( const void* ref, const void* item );
void EDA_LibComponentStruct::SortDrawItems( void )
/*******************************************/
/* Trie les lments graphiques d'un composant lib pour amliorer
le trac:
items remplis en premier, pins en dernier
En cas de superposition d'items, c'est plus lisible
*/
* le trac:
* items remplis en premier, pins en dernier
* En cas de superposition d'items, c'est plus lisible
*/
{
LibEDA_BaseStruct ** Bufentry, ** BufentryBase, *Entry = m_Drawings;
int ii, nbitems;
LibEDA_BaseStruct** Bufentry, ** BufentryBase, * Entry = m_Drawings;
int ii, nbitems;
if(Entry == NULL ) return; /* Pas d'alias pour ce composant */
if( Entry == NULL )
return; /* Pas d'alias pour ce composant */
/* calcul du nombre d'items */
for( nbitems = 0; Entry != NULL; Entry = Entry->Next()) nbitems++;
for( nbitems = 0; Entry != NULL; Entry = Entry->Next() )
nbitems++;
BufentryBase =
(LibEDA_BaseStruct **) MyZMalloc( (nbitems+1) * sizeof(LibEDA_BaseStruct *));
(LibEDA_BaseStruct**) MyZMalloc( (nbitems + 1) * sizeof(LibEDA_BaseStruct *) );
/* memorisation du chainage : */
for( Entry = m_Drawings, ii = 0; Entry != NULL; Entry = Entry->Next())
for( Entry = m_Drawings, ii = 0; Entry != NULL; Entry = Entry->Next() )
BufentryBase[ii++] = Entry;
/* Tri du chainage */
qsort(BufentryBase, nbitems, sizeof(LibEDA_BaseStruct *), SortItemsFct);
qsort( BufentryBase, nbitems, sizeof(LibEDA_BaseStruct *), SortItemsFct );
/* Mise a jour du chainage. Remarque:
le dernier element de BufEntryBase (BufEntryBase[nbitems]) est NULL*/
m_Drawings = * BufentryBase;
* le dernier element de BufEntryBase (BufEntryBase[nbitems]) est NULL*/
m_Drawings = *BufentryBase;
Bufentry = BufentryBase;
for (ii = 0 ; ii < nbitems; ii++)
for( ii = 0; ii < nbitems; ii++ )
{
(* Bufentry)->Pnext = * (Bufentry+1);
(*Bufentry)->Pnext = *(Bufentry + 1);
Bufentry++;
}
MyFree(BufentryBase);
MyFree( BufentryBase );
}
int SortItemsFct(const void * ref, const void * item)
int SortItemsFct( const void* ref, const void* item )
{
#define Ref (*(LibEDA_BaseStruct **)(ref))
#define Item (*(LibEDA_BaseStruct **)(item))
#define Ref ( *(LibEDA_BaseStruct**) (ref) )
#define Item ( *(LibEDA_BaseStruct**) (item) )
#define BEFORE -1
#define AFTER 1
int fill_ref = 0, fill_item = 0;
int fill_ref = 0, fill_item = 0;
switch (Ref->m_StructType)
switch( Ref->m_StructType )
{
case COMPONENT_ARC_DRAW_TYPE:
{
const LibDrawArc * draw = (const LibDrawArc *) Ref;
const LibDrawArc* draw = (const LibDrawArc*) Ref;
fill_ref = draw->m_Fill;
break;
}
case COMPONENT_CIRCLE_DRAW_TYPE:
{
const LibDrawCircle * draw = (const LibDrawCircle *) Ref;
const LibDrawCircle* draw = (const LibDrawCircle*) Ref;
fill_ref = draw->m_Fill;
break;
}
case COMPONENT_RECT_DRAW_TYPE:
{
const LibDrawSquare * draw = (const LibDrawSquare *) Ref;
const LibDrawSquare* draw = (const LibDrawSquare*) Ref;
fill_ref = draw->m_Fill;
break;
}
case COMPONENT_POLYLINE_DRAW_TYPE:
{
const LibDrawPolyline * draw = (const LibDrawPolyline *) Ref;
const LibDrawPolyline* draw = (const LibDrawPolyline*) Ref;
fill_ref = draw->m_Fill;
break;
}
case COMPONENT_GRAPHIC_TEXT_DRAW_TYPE:
if ( Item->m_StructType == COMPONENT_PIN_DRAW_TYPE ) return BEFORE;
if ( Item->m_StructType == COMPONENT_GRAPHIC_TEXT_DRAW_TYPE ) return 0;
if( Item->m_StructType == COMPONENT_PIN_DRAW_TYPE )
return BEFORE;
if( Item->m_StructType == COMPONENT_GRAPHIC_TEXT_DRAW_TYPE )
return 0;
return 1;
break;
case COMPONENT_PIN_DRAW_TYPE:
if ( Item->m_StructType == COMPONENT_PIN_DRAW_TYPE )
if( Item->m_StructType == COMPONENT_PIN_DRAW_TYPE )
{
int ii;
// We sort the pins by orientation
ii = ((LibDrawPin *) Ref)->m_Orient - ((LibDrawPin *) Item)->m_Orient;
if ( ii ) return ii;
ii = ( (LibDrawPin*) Ref )->m_Orient - ( (LibDrawPin*) Item )->m_Orient;
if( ii )
return ii;
/* We sort the pins by position (x or y).
note: at this point, most of pins have same x pos or y pos,
because they are sorted by orientation and generally are vertically or
horizontally aligned */
* note: at this point, most of pins have same x pos or y pos,
* because they are sorted by orientation and generally are vertically or
* horizontally aligned */
wxPoint pos_ref, pos_tst;
pos_ref = ((LibDrawPin *) Ref)->m_Pos;
pos_tst = ((LibDrawPin *) Item)->m_Pos;
if ( (ii = pos_ref.x - pos_tst.x) ) return ii;
pos_ref = ( (LibDrawPin*) Ref )->m_Pos;
pos_tst = ( (LibDrawPin*) Item )->m_Pos;
if( (ii = pos_ref.x - pos_tst.x) )
return ii;
ii = pos_ref.y - pos_tst.y;
return ii;
}
else return AFTER;
else
return AFTER;
break;
default:
;
}
/* Test de l'item */
switch (Item->m_StructType)
switch( Item->m_StructType )
{
case COMPONENT_ARC_DRAW_TYPE:
{
const LibDrawArc * draw = (const LibDrawArc *) Item;
const LibDrawArc* draw = (const LibDrawArc*) Item;
fill_item = draw->m_Fill;
break;
}
case COMPONENT_CIRCLE_DRAW_TYPE:
{
const LibDrawCircle * draw = (const LibDrawCircle *) Item;
const LibDrawCircle* draw = (const LibDrawCircle*) Item;
fill_item = draw->m_Fill;
break;
}
case COMPONENT_RECT_DRAW_TYPE:
{
const LibDrawSquare * draw = (const LibDrawSquare *) Item;
const LibDrawSquare* draw = (const LibDrawSquare*) Item;
fill_item = draw->m_Fill;
break;
}
case COMPONENT_POLYLINE_DRAW_TYPE:
{
const LibDrawPolyline * draw = (const LibDrawPolyline *) Item;
const LibDrawPolyline* draw = (const LibDrawPolyline*) Item;
fill_item = draw->m_Fill;
break;
}
......@@ -1111,38 +1236,44 @@ int fill_ref = 0, fill_item = 0;
case COMPONENT_PIN_DRAW_TYPE:
return BEFORE;
break;
default:
;
}
if ( fill_ref & fill_item ) return 0;
if ( fill_ref ) return BEFORE;
if( fill_ref & fill_item )
return 0;
if( fill_ref )
return BEFORE;
return AFTER;
}
/*****************************************************************************/
int AddFootprintFilterList(EDA_LibComponentStruct *LibEntryLibEntry, FILE * f,
char * Line, int *LineNum)
int AddFootprintFilterList( EDA_LibComponentStruct* LibEntryLibEntry, FILE* f,
char* Line, int* LineNum )
/******************************************************************************/
/* read the FootprintFilter List stating with:
FPLIST
and ending with:
ENDFPLIST
*/
* FPLIST
* and ending with:
* ENDFPLIST
*/
{
for ( ; ; )
for( ; ; )
{
if (GetLine(f, Line, LineNum, 1024 ) == NULL)
if( GetLine( f, Line, LineNum, 1024 ) == NULL )
{
DisplayError(NULL, wxT("File ended prematurely"));
DisplayError( NULL, wxT( "File ended prematurely" ) );
return 0;
}
if ( stricmp(Line, "$ENDFPLIST") == 0 )
if( stricmp( Line, "$ENDFPLIST" ) == 0 )
{
break; /*normal exit on end of list */
}
LibEntryLibEntry->m_FootprintList.Add(CONV_FROM_UTF8(Line+1));
LibEntryLibEntry->m_FootprintList.Add( CONV_FROM_UTF8( Line + 1 ) );
}
return 1;
......
eeschema/hotkeys.cpp
View file @ f3c324d5
......@@ -212,6 +212,8 @@ wxPoint MousePos = m_CurrentScreen->m_MousePosition;
}
ChangeTextOrient( (DrawTextStruct*)DrawStruct, DC);
break;
default:;
}
break;
......
eeschema/libclass.cpp
View file @ f3c324d5
......@@ -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;
char BufLine[1024];
bool succes = TRUE;
DateAndTime(BufLine);
if ( fprintf(file,"%s %d.%d Date: %s\n", LIBFILE_IDENT,
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)
bool LibraryStruct::ReadHeader( FILE* libfile, int* LineNum )
/***********************************************************/
/* Ecrit l'entete du fichier librairie
*/
*/
{
char Line[1024], * text, * data;
char Line[1024], * text, * data;
while (GetLine(libfile, Line, LineNum, sizeof(Line)) )
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 )
*/
EDA_LibCmpAliasStruct:: EDA_LibCmpAliasStruct( const wxChar * CmpName,
const wxChar * CmpRootName):
LibCmpEntry(ALIAS, CmpName)
{
if ( CmpRootName == NULL) m_RootName.Empty();
else m_RootName = CmpRootName;
* An alias uses the component defintion (graphic, pins...)
* but has its own name and documentation.
* Therefore, when the component is modified, alias of this component are modified.
* This is a simple method to create components with differs very few
* (like 74LS00, 74HC00 ... and many op amps )
*/
EDA_LibCmpAliasStruct:: EDA_LibCmpAliasStruct( const wxChar* CmpName,
const wxChar* CmpRootName ) :
LibCmpEntry( ALIAS, CmpName )
{
if( CmpRootName == NULL )
m_RootName.Empty();
else
m_RootName = CmpRootName;
}
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])
int LibDrawPin::ReturnPinDrawOrient( int TransMat[2][2] )
/********************************************************/
/* Return the pin real orientation (PIN_UP, PIN_DOWN, PIN_RIGHT, PIN_LEFT),
according to its orientation,
AND the matrix transform (rot, mirror) TransMat
*/
* according to its orientation,
* AND the matrix transform (rot, mirror) TransMat
*/
{
int orient;
int x1 = 0, y1 = 0;
int t1, t2;
int orient;
int x1 = 0, y1 = 0;
int t1, t2;
switch ( m_Orient )
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;
}
eeschema/libcmp.h
View file @ f3c324d5
......@@ -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);
void DrawPinTexts(WinEDA_DrawPanel * panel, wxDC * DC,
wxPoint & pin_pos, int orient,
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,
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'lment que l'on
peut rpter (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'lment que l'on
* peut rpter (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
eeschema/libframe.cpp
View file @ f3c324d5
......@@ -543,6 +543,7 @@ wxClientDC dc(DrawPanel);
case COMPONENT_GRAPHIC_TEXT_DRAW_TYPE:
EditSymbolText(&dc, CurrentDrawItem);
break;
default:;
}
DrawPanel->CursorOn(&dc);
}
......
eeschema/locate.cpp
View file @ f3c324d5
......@@ -839,6 +839,9 @@ int seuil;
return(DrawItem); /* Texte trouve */
}
break;
default:
;
}
}
return(NULL);
......
eeschema/plot.cpp
View file @ f3c324d5
......@@ -290,6 +290,9 @@ wxPoint pos;
MyFree(Poly);
}
break;
default:;
} /* Fin Switch */
Plume('U');
} /* Fin Boucle de dessin */
......
eeschema/program.h
View file @ f3c324d5
/********************************************/
/* 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 */
eeschema/symbdraw.cpp
View file @ f3c324d5
/*********************************************************************/
/* EESchema - symbdraw.cpp */
/* Create, move .. graphic shapes used to build and draw a component */
/* (lines, arcs .. */
/*********************************************************************/
/*********************************************************************/
/* EESchema - symbdraw.cpp */
/* Create, move .. graphic shapes used to build and draw a component */
/* (lines, arcs .. */
/*********************************************************************/
#include "fctsys.h"
......@@ -19,10 +19,10 @@
#include "id.h"
/* Routines locales */
static void SymbolDisplayDraw(WinEDA_DrawPanel * panel, wxDC * DC, bool erase);
static void ComputeArc(LibDrawArc * DrawItem, wxPoint ArcCentre);
static void RedrawWhileMovingCursor(WinEDA_DrawPanel * panel, wxDC * DC, bool erase);
static void MoveLibDrawItemAt(LibEDA_BaseStruct * DrawItem, wxPoint newpos);
static void SymbolDisplayDraw( WinEDA_DrawPanel* panel, wxDC* DC, bool erase );
static void ComputeArc( LibDrawArc* DrawItem, wxPoint ArcCentre );
static void RedrawWhileMovingCursor( WinEDA_DrawPanel* panel, wxDC* DC, bool erase );
static void MoveLibDrawItemAt( LibEDA_BaseStruct* DrawItem, wxPoint newpos );
/* Variables locales */
static int StateDrawArc, ArcStartX, ArcStartY, ArcEndX, ArcEndY;
......@@ -30,126 +30,137 @@ static wxPoint InitPosition, StartCursor, ItemPreviousPos;
static int FlSymbol_Fill = NO_FILL;
/************************************/
/* class WinEDA_PartPropertiesFrame */
/************************************/
/************************************/
/* class WinEDA_PartPropertiesFrame */
/************************************/
#include "dialog_cmp_graphic_properties.cpp"
/************************************************************/
void WinEDA_bodygraphics_PropertiesFrame::
bodygraphics_PropertiesAccept(wxCommandEvent& event)
bodygraphics_PropertiesAccept( wxCommandEvent& event )
/************************************************************/
/* Update the current draw item
*/
*/
{
g_FlDrawSpecificConvert = m_CommonConvert->GetValue() ? FALSE : TRUE;
g_FlDrawSpecificUnit = m_CommonUnit->GetValue() ? FALSE : TRUE;
if ( m_Filled )
if( m_Filled )
FlSymbol_Fill = m_Filled->GetSelection();
g_LibSymbolDefaultLineWidth = m_GraphicShapeWidthCtrl->GetValue();
if ( CurrentDrawItem )
if( CurrentDrawItem )
{
if ( ! (CurrentDrawItem->m_Flags & IS_NEW) ) // if IS_NEW, copy for undo is done before place
m_Parent->SaveCopyInUndoList(CurrentLibEntry);
wxClientDC dc(m_Parent->DrawPanel);
m_Parent->DrawPanel->PrepareGraphicContext(&dc);
if( !(CurrentDrawItem->m_Flags & IS_NEW) ) // if IS_NEW, copy for undo is done before place
m_Parent->SaveCopyInUndoList( CurrentLibEntry );
wxClientDC dc( m_Parent->DrawPanel );
DrawLibraryDrawStruct(m_Parent->DrawPanel, &dc, CurrentLibEntry, 0 , 0,
CurrentDrawItem, CurrentUnit, g_XorMode);
m_Parent->DrawPanel->PrepareGraphicContext( &dc );
if( g_FlDrawSpecificUnit ) CurrentDrawItem->m_Unit = CurrentUnit;
else CurrentDrawItem->m_Unit = 0;
if( g_FlDrawSpecificConvert ) CurrentDrawItem->m_Convert = CurrentConvert;
else CurrentDrawItem->m_Convert = 0;
if ( m_Filled )
DrawLibraryDrawStruct( m_Parent->DrawPanel, &dc, CurrentLibEntry, 0, 0,
CurrentDrawItem, CurrentUnit, g_XorMode );
if( g_FlDrawSpecificUnit )
CurrentDrawItem->m_Unit = CurrentUnit;
else
CurrentDrawItem->m_Unit = 0;
if( g_FlDrawSpecificConvert )
CurrentDrawItem->m_Convert = CurrentConvert;
else
CurrentDrawItem->m_Convert = 0;
if( m_Filled )
{
switch(CurrentDrawItem->m_StructType)
switch( CurrentDrawItem->m_StructType )
{
case COMPONENT_ARC_DRAW_TYPE:
((LibDrawArc*)CurrentDrawItem)->m_Fill = FlSymbol_Fill;
((LibDrawArc*)CurrentDrawItem)->m_Width = m_GraphicShapeWidthCtrl->GetValue();
( (LibDrawArc*) CurrentDrawItem )->m_Fill = FlSymbol_Fill;
( (LibDrawArc*) CurrentDrawItem )->m_Width = m_GraphicShapeWidthCtrl->GetValue();
break;
case COMPONENT_CIRCLE_DRAW_TYPE:
((LibDrawCircle*)CurrentDrawItem)->m_Fill = FlSymbol_Fill;
((LibDrawCircle*)CurrentDrawItem)->m_Width = m_GraphicShapeWidthCtrl->GetValue();
( (LibDrawCircle*) CurrentDrawItem )->m_Fill = FlSymbol_Fill;
( (LibDrawCircle*) CurrentDrawItem )->m_Width = m_GraphicShapeWidthCtrl->GetValue();
break;
case COMPONENT_RECT_DRAW_TYPE:
((LibDrawSquare*)CurrentDrawItem)->m_Fill = FlSymbol_Fill;
((LibDrawSquare*)CurrentDrawItem)->m_Width = m_GraphicShapeWidthCtrl->GetValue();
( (LibDrawSquare*) CurrentDrawItem )->m_Fill = FlSymbol_Fill;
( (LibDrawSquare*) CurrentDrawItem )->m_Width = m_GraphicShapeWidthCtrl->GetValue();
break;
case COMPONENT_POLYLINE_DRAW_TYPE:
((LibDrawPolyline*)CurrentDrawItem)->m_Fill = FlSymbol_Fill;
((LibDrawPolyline*)CurrentDrawItem)->m_Width = m_GraphicShapeWidthCtrl->GetValue();
( (LibDrawPolyline*) CurrentDrawItem )->m_Fill = FlSymbol_Fill;
( (LibDrawPolyline*) CurrentDrawItem )->m_Width = m_GraphicShapeWidthCtrl->
GetValue();
break;
default: break;
default:
break;
}
}
CurrentLibEntry->SortDrawItems();
m_Parent->m_CurrentScreen->SetModify();
DrawLibraryDrawStruct(m_Parent->DrawPanel, &dc, CurrentLibEntry, 0 , 0,
CurrentDrawItem, CurrentUnit, g_XorMode);
DrawLibraryDrawStruct( m_Parent->DrawPanel, &dc, CurrentLibEntry, 0, 0,
CurrentDrawItem, CurrentUnit, g_XorMode );
}
Close();
if ( CurrentDrawItem )
CurrentDrawItem->Display_Infos_DrawEntry(m_Parent);
if( CurrentDrawItem )
CurrentDrawItem->Display_Infos_DrawEntry( m_Parent );
m_Parent->ReDrawPanel();
}
/**********************************************************/
void WinEDA_LibeditFrame::EditGraphicSymbol(wxDC * DC,
LibEDA_BaseStruct * DrawItem)
void WinEDA_LibeditFrame::EditGraphicSymbol( wxDC* DC,
LibEDA_BaseStruct* DrawItem )
/**********************************************************/
/* Install the dialog box for editing a graphical item properties
*/
*/
{
if ( DrawItem == NULL ) return;
if( DrawItem == NULL )
return;
WinEDA_bodygraphics_PropertiesFrame* frame = new WinEDA_bodygraphics_PropertiesFrame( this );
WinEDA_bodygraphics_PropertiesFrame * frame = new
WinEDA_bodygraphics_PropertiesFrame(this);
frame->ShowModal(); frame->Destroy();
}
/****************************************************************/
static void AbortSymbolTraceOn(WinEDA_DrawPanel * Panel, wxDC * DC)
static void AbortSymbolTraceOn( WinEDA_DrawPanel* Panel, wxDC* DC )
/****************************************************************/
{
StateDrawArc = 0;
Panel->ManageCurseur = NULL;
Panel->ForceCloseManageCurseur = NULL;
if(CurrentDrawItem == NULL) return;
if( CurrentDrawItem == NULL )
return;
if(CurrentDrawItem->m_Flags & IS_NEW)
if( CurrentDrawItem->m_Flags & IS_NEW )
{
if ( CurrentDrawItem->m_StructType == COMPONENT_ARC_DRAW_TYPE )
if( CurrentDrawItem->m_StructType == COMPONENT_ARC_DRAW_TYPE )
{
Panel->m_Parent->RedrawActiveWindow( DC,TRUE);
Panel->m_Parent->RedrawActiveWindow( DC, TRUE );
}
else DrawLibraryDrawStruct(Panel, DC, CurrentLibEntry, 0 , 0,
CurrentDrawItem, CurrentUnit, g_XorMode);
else
DrawLibraryDrawStruct( Panel, DC, CurrentLibEntry, 0, 0,
CurrentDrawItem, CurrentUnit, g_XorMode );
delete CurrentDrawItem;
}
else
{
wxPoint curpos;
curpos = Panel->GetScreen()->m_Curseur;
Panel->GetScreen()->m_Curseur = StartCursor;
RedrawWhileMovingCursor(Panel, DC, TRUE);
RedrawWhileMovingCursor( Panel, DC, TRUE );
Panel->GetScreen()->m_Curseur = curpos;
DrawLibraryDrawStruct(Panel, DC, CurrentLibEntry, 0 , 0,
CurrentDrawItem, CurrentUnit, GR_DEFAULT_DRAWMODE);
DrawLibraryDrawStruct( Panel, DC, CurrentLibEntry, 0, 0,
CurrentDrawItem, CurrentUnit, GR_DEFAULT_DRAWMODE );
CurrentDrawItem->m_Flags = 0;
}
......@@ -158,25 +169,27 @@ static void AbortSymbolTraceOn(WinEDA_DrawPanel * Panel, wxDC * DC)
}
/*********************************************************************/
LibEDA_BaseStruct * WinEDA_LibeditFrame::CreateGraphicItem(wxDC * DC)
LibEDA_BaseStruct* WinEDA_LibeditFrame::CreateGraphicItem( wxDC* DC )
/*********************************************************************/
/* Routine de creation d'un nouvel element type LibraryDrawStruct
POLYLINE
ARC
CIRCLE
RECTANGLE
*/
* POLYLINE
* ARC
* CIRCLE
* RECTANGLE
*/
{
int DrawType;
int * ptpoly;
int DrawType;
int* ptpoly;
if(CurrentDrawItem) return NULL;
if( CurrentDrawItem )
return NULL;
DrawPanel->m_IgnoreMouseEvents = TRUE;
// Creation du nouvel element
switch ( m_ID_current_state )
switch( m_ID_current_state )
{
case ID_LIBEDIT_BODY_LINE_BUTT:
DrawType = COMPONENT_POLYLINE_DRAW_TYPE;
......@@ -199,21 +212,22 @@ int * ptpoly;
break;
default:
DisplayError(this, wxT("SymbolBeginDrawItem Internal err: Id error"));
DisplayError( this, wxT( "SymbolBeginDrawItem Internal err: Id error" ) );
return NULL;
}
DrawPanel->ManageCurseur = SymbolDisplayDraw;
DrawPanel->ForceCloseManageCurseur = AbortSymbolTraceOn;
switch ( DrawType )
switch( DrawType )
{
case COMPONENT_ARC_DRAW_TYPE:
{
LibDrawArc * Arc = new LibDrawArc();
LibDrawArc* Arc = new LibDrawArc();
CurrentDrawItem = Arc;
ArcStartX = ArcEndX = m_CurrentScreen->m_Curseur.x;
ArcStartY = ArcEndY = - m_CurrentScreen->m_Curseur.y;
ArcStartY = ArcEndY = -m_CurrentScreen->m_Curseur.y;
StateDrawArc = 1;
Arc->m_Fill = FlSymbol_Fill;
Arc->m_Width = g_LibSymbolDefaultLineWidth;
......@@ -222,10 +236,11 @@ int * ptpoly;
case COMPONENT_CIRCLE_DRAW_TYPE:
{
LibDrawCircle * Circle = new LibDrawCircle();
LibDrawCircle* Circle = new LibDrawCircle();
CurrentDrawItem = Circle;
Circle->m_Pos.x = m_CurrentScreen->m_Curseur.x;
Circle->m_Pos.y = - m_CurrentScreen->m_Curseur.y;
Circle->m_Pos.y = -m_CurrentScreen->m_Curseur.y;
Circle->m_Fill = FlSymbol_Fill;
Circle->m_Width = g_LibSymbolDefaultLineWidth;
}
......@@ -233,10 +248,11 @@ int * ptpoly;
case COMPONENT_RECT_DRAW_TYPE:
{
LibDrawSquare * Square = new LibDrawSquare();
LibDrawSquare* Square = new LibDrawSquare();
CurrentDrawItem = Square;
Square->m_Pos.x = m_CurrentScreen->m_Curseur.x;
Square->m_Pos.y = - m_CurrentScreen->m_Curseur.y;
Square->m_Pos.y = -m_CurrentScreen->m_Curseur.y;
Square->m_End = Square->m_Pos;
Square->m_Fill = FlSymbol_Fill;
Square->m_Width = g_LibSymbolDefaultLineWidth;
......@@ -246,12 +262,13 @@ int * ptpoly;
case COMPONENT_POLYLINE_DRAW_TYPE:
{
LibDrawPolyline* polyline = new LibDrawPolyline();
CurrentDrawItem = polyline;
polyline->n = 2;
ptpoly = (int*)MyZMalloc( 4 * sizeof(int));
ptpoly = (int*) MyZMalloc( 4 * sizeof(int) );
polyline->PolyList = ptpoly;
ptpoly[0] = ptpoly[2] = m_CurrentScreen->m_Curseur.x;
ptpoly[1] = ptpoly[3] = - m_CurrentScreen->m_Curseur.y;
ptpoly[1] = ptpoly[3] = -m_CurrentScreen->m_Curseur.y;
polyline->m_Fill = FlSymbol_Fill;
polyline->m_Width = g_LibSymbolDefaultLineWidth;
}
......@@ -260,6 +277,7 @@ int * ptpoly;
case COMPONENT_LINE_DRAW_TYPE:
{
LibDrawSegment* Segment = new LibDrawSegment();
CurrentDrawItem = Segment;
Segment->m_Pos.x = m_CurrentScreen->m_Curseur.x;
Segment->m_Pos.y = -m_CurrentScreen->m_Curseur.y;
......@@ -271,13 +289,14 @@ int * ptpoly;
case COMPONENT_GRAPHIC_TEXT_DRAW_TYPE:
{
LibDrawText* Text = new LibDrawText();
CurrentDrawItem = Text;
Text->m_Size.x = Text->m_Size.y = g_LastTextSize;
Text->m_Horiz = g_LastTextOrient;
Text->m_Pos.x = m_CurrentScreen->m_Curseur.x;
Text->m_Pos.y = - m_CurrentScreen->m_Curseur.y;
EditSymbolText(NULL, Text);
if ( Text->m_Text.IsEmpty() )
Text->m_Pos.y = -m_CurrentScreen->m_Curseur.y;
EditSymbolText( NULL, Text );
if( Text->m_Text.IsEmpty() )
{
delete Text;
CurrentDrawItem = NULL;
......@@ -286,19 +305,21 @@ int * ptpoly;
}
else
{
StartMoveDrawSymbol(DC);
DrawLibraryDrawStruct(DrawPanel, DC, CurrentLibEntry, 0 , 0,
Text, CurrentUnit, g_XorMode);
StartMoveDrawSymbol( DC );
DrawLibraryDrawStruct( DrawPanel, DC, CurrentLibEntry, 0, 0,
Text, CurrentUnit, g_XorMode );
}
}
break;
}
if ( CurrentDrawItem )
if( CurrentDrawItem )
{
CurrentDrawItem->m_Flags |= IS_NEW;
if(g_FlDrawSpecificUnit) CurrentDrawItem->m_Unit = CurrentUnit;
if(g_FlDrawSpecificConvert) CurrentDrawItem->m_Convert = CurrentConvert;
if( g_FlDrawSpecificUnit )
CurrentDrawItem->m_Unit = CurrentUnit;
if( g_FlDrawSpecificConvert )
CurrentDrawItem->m_Convert = CurrentConvert;
}
DrawPanel->MouseToCursorSchema();
......@@ -309,26 +330,28 @@ int * ptpoly;
/********************************************************/
void WinEDA_LibeditFrame::GraphicItemBeginDraw(wxDC * DC)
void WinEDA_LibeditFrame::GraphicItemBeginDraw( wxDC* DC )
/********************************************************/
/* Routine de creation d'un nouvel element type LibraryDrawStruct
*/
*/
{
if(CurrentDrawItem == NULL) return;
if( CurrentDrawItem == NULL )
return;
switch ( CurrentDrawItem->m_StructType )
switch( CurrentDrawItem->m_StructType )
{
case COMPONENT_ARC_DRAW_TYPE:
if(StateDrawArc == 1)
if( StateDrawArc == 1 )
{
SymbolDisplayDraw(DrawPanel,DC, FALSE);
SymbolDisplayDraw( DrawPanel, DC, FALSE );
StateDrawArc = 2;
SymbolDisplayDraw(DrawPanel,DC, FALSE);
SymbolDisplayDraw( DrawPanel, DC, FALSE );
break;
}
if(StateDrawArc > 1)
if( StateDrawArc > 1 )
{
EndDrawGraphicItem(DC);
EndDrawGraphicItem( DC );
return;
}
break;
......@@ -336,96 +359,99 @@ void WinEDA_LibeditFrame::GraphicItemBeginDraw(wxDC * DC)
case COMPONENT_CIRCLE_DRAW_TYPE:
case COMPONENT_RECT_DRAW_TYPE:
case COMPONENT_GRAPHIC_TEXT_DRAW_TYPE:
EndDrawGraphicItem(DC);
EndDrawGraphicItem( DC );
return;
case COMPONENT_POLYLINE_DRAW_TYPE:
{
wxPoint pos = m_CurrentScreen->m_Curseur;
((LibDrawPolyline*)CurrentDrawItem)->AddPoint(pos);
( (LibDrawPolyline*) CurrentDrawItem )->AddPoint( pos );
}
break;
case COMPONENT_LINE_DRAW_TYPE:
break;
}
default:
;
}
}
/**************************************************************************/
static void RedrawWhileMovingCursor(WinEDA_DrawPanel * panel, wxDC * DC, bool erase)
static void RedrawWhileMovingCursor( WinEDA_DrawPanel* panel, wxDC* DC, bool erase )
/**************************************************************************/
/* Redraw the graphoc shape while moving
*/
*/
{
BASE_SCREEN * Screen = panel->m_Parent->m_CurrentScreen;
int mx, my;
BASE_SCREEN* Screen = panel->m_Parent->m_CurrentScreen;
int mx, my;
/* Erase shape in the old positon*/
if( erase )
{
mx = ItemPreviousPos.x - StartCursor.x ,
my = ItemPreviousPos.y - StartCursor.y ;
mx = ItemPreviousPos.x - StartCursor.x,
my = ItemPreviousPos.y - StartCursor.y;
DrawLibraryDrawStruct(panel, DC, CurrentLibEntry, mx, my,
CurrentDrawItem, CurrentUnit, g_XorMode);
DrawLibraryDrawStruct( panel, DC, CurrentLibEntry, mx, my,
CurrentDrawItem, CurrentUnit, g_XorMode );
}
/* Redraw moved shape */
mx = Screen->m_Curseur.x - StartCursor.x ,
my = Screen->m_Curseur.y - StartCursor.y ;
DrawLibraryDrawStruct(panel, DC, CurrentLibEntry, mx , my,
CurrentDrawItem, CurrentUnit, g_XorMode);
mx = Screen->m_Curseur.x - StartCursor.x,
my = Screen->m_Curseur.y - StartCursor.y;
DrawLibraryDrawStruct( panel, DC, CurrentLibEntry, mx, my,
CurrentDrawItem, CurrentUnit, g_XorMode );
ItemPreviousPos = Screen->m_Curseur;
}
/*****************************************************************/
void MoveLibDrawItemAt(LibEDA_BaseStruct * DrawItem, wxPoint newpos)
void MoveLibDrawItemAt( LibEDA_BaseStruct* DrawItem, wxPoint newpos )
/*****************************************************************/
{
int mx = newpos.x, my = newpos.y;
wxSize size;
int mx = newpos.x, my = newpos.y;
wxSize size;
switch ( DrawItem->m_StructType )
switch( DrawItem->m_StructType )
{
case COMPONENT_ARC_DRAW_TYPE:
{
int dx = mx - ((LibDrawArc*)CurrentDrawItem)->m_Pos.x;
int dy = - my - ((LibDrawArc*)CurrentDrawItem)->m_Pos.y;
((LibDrawArc*)CurrentDrawItem)->m_Pos.x = mx;
((LibDrawArc*)CurrentDrawItem)->m_Pos.y = - my;
((LibDrawArc*)CurrentDrawItem)->m_ArcStart.x += dx;
((LibDrawArc*)CurrentDrawItem)->m_ArcStart.y += dy;
((LibDrawArc*)CurrentDrawItem)->m_ArcEnd.x += dx;
((LibDrawArc*)CurrentDrawItem)->m_ArcEnd.y += dy;
int dx = mx - ( (LibDrawArc*) CurrentDrawItem )->m_Pos.x;
int dy = -my - ( (LibDrawArc*) CurrentDrawItem )->m_Pos.y;
( (LibDrawArc*) CurrentDrawItem )->m_Pos.x = mx;
( (LibDrawArc*) CurrentDrawItem )->m_Pos.y = -my;
( (LibDrawArc*) CurrentDrawItem )->m_ArcStart.x += dx;
( (LibDrawArc*) CurrentDrawItem )->m_ArcStart.y += dy;
( (LibDrawArc*) CurrentDrawItem )->m_ArcEnd.x += dx;
( (LibDrawArc*) CurrentDrawItem )->m_ArcEnd.y += dy;
break;
}
case COMPONENT_CIRCLE_DRAW_TYPE:
((LibDrawCircle*)CurrentDrawItem)->m_Pos.x = mx;
((LibDrawCircle*)CurrentDrawItem)->m_Pos.y = - my;
( (LibDrawCircle*) CurrentDrawItem )->m_Pos.x = mx;
( (LibDrawCircle*) CurrentDrawItem )->m_Pos.y = -my;
break;
case COMPONENT_RECT_DRAW_TYPE:
size.x = ((LibDrawSquare*)CurrentDrawItem)->m_End.x -
((LibDrawSquare*)CurrentDrawItem)->m_Pos.x;
size.y = ((LibDrawSquare*)CurrentDrawItem)->m_End.y -
((LibDrawSquare*)CurrentDrawItem)->m_Pos.y;
((LibDrawSquare*)CurrentDrawItem)->m_Pos.x = mx;
((LibDrawSquare*)CurrentDrawItem)->m_Pos.y = - my;
((LibDrawSquare*)CurrentDrawItem)->m_End.x = mx + size.x;
((LibDrawSquare*)CurrentDrawItem)->m_End.y = - my + size.y;
size.x = ( (LibDrawSquare*) CurrentDrawItem )->m_End.x -
( (LibDrawSquare*) CurrentDrawItem )->m_Pos.x;
size.y = ( (LibDrawSquare*) CurrentDrawItem )->m_End.y -
( (LibDrawSquare*) CurrentDrawItem )->m_Pos.y;
( (LibDrawSquare*) CurrentDrawItem )->m_Pos.x = mx;
( (LibDrawSquare*) CurrentDrawItem )->m_Pos.y = -my;
( (LibDrawSquare*) CurrentDrawItem )->m_End.x = mx + size.x;
( (LibDrawSquare*) CurrentDrawItem )->m_End.y = -my + size.y;
break;
case COMPONENT_POLYLINE_DRAW_TYPE:
{
int ii , imax = ((LibDrawPolyline*)CurrentDrawItem)->n * 2;
int * ptpoly = ((LibDrawPolyline*)CurrentDrawItem)->PolyList;
int ii, imax = ( (LibDrawPolyline*) CurrentDrawItem )->n * 2;
int* ptpoly = ( (LibDrawPolyline*) CurrentDrawItem )->PolyList;
int dx = mx - ptpoly[0];
int dy = - my - ptpoly[1];
for ( ii = 0; ii < imax; ii += 2)
int dy = -my - ptpoly[1];
for( ii = 0; ii < imax; ii += 2 )
{
ptpoly[ii] += dx;
ptpoly[ii + 1] += dy;
......@@ -437,240 +463,260 @@ wxSize size;
break;
case COMPONENT_GRAPHIC_TEXT_DRAW_TYPE:
((LibDrawText*)CurrentDrawItem)->m_Pos.x = mx;
((LibDrawText*)CurrentDrawItem)->m_Pos.y = - my;
( (LibDrawText*) CurrentDrawItem )->m_Pos.x = mx;
( (LibDrawText*) CurrentDrawItem )->m_Pos.y = -my;
break;
default:
;
}
}
/************************************************************/
void WinEDA_LibeditFrame::StartMoveDrawSymbol(wxDC * DC)
void WinEDA_LibeditFrame::StartMoveDrawSymbol( wxDC* DC )
/************************************************************/
{
if(CurrentDrawItem == NULL) return;
if( CurrentDrawItem == NULL )
return;
SetCursor(wxCURSOR_HAND);
SetCursor( wxCURSOR_HAND );
CurrentDrawItem->m_Flags |= IS_MOVED;
StartCursor = m_CurrentScreen->m_Curseur;
switch ( CurrentDrawItem->m_StructType )
switch( CurrentDrawItem->m_StructType )
{
case COMPONENT_ARC_DRAW_TYPE:
InitPosition = ((LibDrawArc*)CurrentDrawItem)->m_Pos;
InitPosition = ( (LibDrawArc*) CurrentDrawItem )->m_Pos;
break;
case COMPONENT_CIRCLE_DRAW_TYPE:
InitPosition = ((LibDrawCircle*)CurrentDrawItem)->m_Pos;
InitPosition = ( (LibDrawCircle*) CurrentDrawItem )->m_Pos;
break;
case COMPONENT_RECT_DRAW_TYPE:
InitPosition = ((LibDrawSquare*)CurrentDrawItem)->m_Pos;
InitPosition = ( (LibDrawSquare*) CurrentDrawItem )->m_Pos;
break;
case COMPONENT_POLYLINE_DRAW_TYPE:
InitPosition.x = * ((LibDrawPolyline*)CurrentDrawItem)->PolyList;
InitPosition.y = * (((LibDrawPolyline*)CurrentDrawItem)->PolyList + 1);
InitPosition.x = *( (LibDrawPolyline*) CurrentDrawItem )->PolyList;
InitPosition.y = *( ( (LibDrawPolyline*) CurrentDrawItem )->PolyList + 1 );
break;
case COMPONENT_LINE_DRAW_TYPE:
break;
case COMPONENT_GRAPHIC_TEXT_DRAW_TYPE:
InitPosition = ((LibDrawText*)CurrentDrawItem)->m_Pos;
InitPosition = ( (LibDrawText*) CurrentDrawItem )->m_Pos;
break;
default:
;
}
ItemPreviousPos = m_CurrentScreen->m_Curseur;
DrawPanel->ManageCurseur = RedrawWhileMovingCursor;
DrawPanel->ForceCloseManageCurseur = AbortSymbolTraceOn;
DrawPanel->ManageCurseur(DrawPanel, DC, TRUE);
DrawPanel->ManageCurseur( DrawPanel, DC, TRUE );
}
/****************************************************************/
/* Routine de Gestion des evenements souris lors de la creation */
/* d'un nouvel element type LibraryDrawStruct */
/****************************************************************/
static void SymbolDisplayDraw(WinEDA_DrawPanel * panel, wxDC * DC, bool erase)
static void SymbolDisplayDraw( WinEDA_DrawPanel* panel, wxDC* DC, bool erase )
{
int DrawMode = g_XorMode;
int * ptpoly;
int dx, dy;
BASE_SCREEN * Screen = panel->m_Parent->m_CurrentScreen;
int mx = Screen->m_Curseur.x,
int DrawMode = g_XorMode;
int* ptpoly;
int dx, dy;
BASE_SCREEN* Screen = panel->m_Parent->m_CurrentScreen;
int mx = Screen->m_Curseur.x,
my = Screen->m_Curseur.y;
GRSetDrawMode(DC, DrawMode);
GRSetDrawMode( DC, DrawMode );
if( erase )
{
if( StateDrawArc == 1 )
{
int Color = ReturnLayerColor(LAYER_DEVICE);
GRLine(&panel->m_ClipBox, DC, ArcStartX, - ArcStartY, ArcEndX, - ArcEndY, 0, Color);
int Color = ReturnLayerColor( LAYER_DEVICE );
GRLine( &panel->m_ClipBox, DC, ArcStartX, -ArcStartY, ArcEndX, -ArcEndY, 0, Color );
}
else
{
DrawLibraryDrawStruct(panel, DC, CurrentLibEntry, 0 , 0,
CurrentDrawItem, CurrentUnit, DrawMode);
if(CurrentDrawItem->m_StructType == COMPONENT_ARC_DRAW_TYPE)
DrawLibraryDrawStruct( panel, DC, CurrentLibEntry, 0, 0,
CurrentDrawItem, CurrentUnit, DrawMode );
if( CurrentDrawItem->m_StructType == COMPONENT_ARC_DRAW_TYPE )
{
int Color = ReturnLayerColor(LAYER_DEVICE);
GRDashedLine(&panel->m_ClipBox, DC, ArcStartX, - ArcStartY,
((LibDrawArc*)CurrentDrawItem)->m_Pos.x,
- ((LibDrawArc*)CurrentDrawItem)->m_Pos.y,
0, Color);
GRDashedLine(&panel->m_ClipBox, DC, ArcEndX, - ArcEndY,
((LibDrawArc*)CurrentDrawItem)->m_Pos.x,
- ((LibDrawArc*)CurrentDrawItem)->m_Pos.y,
0, Color);
int Color = ReturnLayerColor( LAYER_DEVICE );
GRDashedLine( &panel->m_ClipBox, DC, ArcStartX, -ArcStartY,
( (LibDrawArc*) CurrentDrawItem )->m_Pos.x,
-( (LibDrawArc*) CurrentDrawItem )->m_Pos.y,
0, Color );
GRDashedLine( &panel->m_ClipBox, DC, ArcEndX, -ArcEndY,
( (LibDrawArc*) CurrentDrawItem )->m_Pos.x,
-( (LibDrawArc*) CurrentDrawItem )->m_Pos.y,
0, Color );
}
}
}
switch ( CurrentDrawItem->m_StructType )
switch( CurrentDrawItem->m_StructType )
{
case COMPONENT_ARC_DRAW_TYPE:
if( StateDrawArc == 1)
if( StateDrawArc == 1 )
{
ArcEndX = mx; ArcEndY = - my;
ArcEndX = mx; ArcEndY = -my;
}
if( StateDrawArc == 2)
if( StateDrawArc == 2 )
{
ComputeArc((LibDrawArc*)CurrentDrawItem, Screen->m_Curseur);
ComputeArc( (LibDrawArc*) CurrentDrawItem, Screen->m_Curseur );
}
((LibDrawArc*)CurrentDrawItem)->m_Fill = FlSymbol_Fill;
( (LibDrawArc*) CurrentDrawItem )->m_Fill = FlSymbol_Fill;
break;
case COMPONENT_CIRCLE_DRAW_TYPE:
dx = ((LibDrawCircle*)CurrentDrawItem)->m_Pos.x - mx;
dy = ((LibDrawCircle*)CurrentDrawItem)->m_Pos.y + my;
((LibDrawCircle*)CurrentDrawItem)->m_Rayon = (int)sqrt( (dx*dx) + (dy*dy) );
((LibDrawCircle*)CurrentDrawItem)->m_Fill = FlSymbol_Fill;
dx = ( (LibDrawCircle*) CurrentDrawItem )->m_Pos.x - mx;
dy = ( (LibDrawCircle*) CurrentDrawItem )->m_Pos.y + my;
( (LibDrawCircle*) CurrentDrawItem )->m_Rayon = (int) sqrt( (dx * dx) + (dy * dy) );
( (LibDrawCircle*) CurrentDrawItem )->m_Fill = FlSymbol_Fill;
break;
case COMPONENT_RECT_DRAW_TYPE:
((LibDrawSquare*)CurrentDrawItem)->m_End.x = mx;
((LibDrawSquare*)CurrentDrawItem)->m_End.y = - my;
((LibDrawSquare*)CurrentDrawItem)->m_Fill = FlSymbol_Fill;
( (LibDrawSquare*) CurrentDrawItem )->m_End.x = mx;
( (LibDrawSquare*) CurrentDrawItem )->m_End.y = -my;
( (LibDrawSquare*) CurrentDrawItem )->m_Fill = FlSymbol_Fill;
break;
case COMPONENT_POLYLINE_DRAW_TYPE:
ptpoly = ((LibDrawPolyline*)CurrentDrawItem)->PolyList;
ptpoly += 2 * (((LibDrawPolyline*)CurrentDrawItem)->n - 1);
ptpoly = ( (LibDrawPolyline*) CurrentDrawItem )->PolyList;
ptpoly += 2 * ( ( (LibDrawPolyline*) CurrentDrawItem )->n - 1 );
ptpoly[0] = mx;
ptpoly[1] = - my;
((LibDrawPolyline*)CurrentDrawItem)->m_Fill = FlSymbol_Fill;
ptpoly[1] = -my;
( (LibDrawPolyline*) CurrentDrawItem )->m_Fill = FlSymbol_Fill;
break;
case COMPONENT_LINE_DRAW_TYPE:
((LibDrawSegment*)CurrentDrawItem)->m_End.x = mx;
((LibDrawSegment*)CurrentDrawItem)->m_End.y = - my;
( (LibDrawSegment*) CurrentDrawItem )->m_End.x = mx;
( (LibDrawSegment*) CurrentDrawItem )->m_End.y = -my;
break;
case COMPONENT_GRAPHIC_TEXT_DRAW_TYPE: /* Traite par des routines specifiques */
break;
default:
;
}
if( StateDrawArc == 1 )
{
int Color = ReturnLayerColor(LAYER_DEVICE);
GRLine(&panel->m_ClipBox, DC, ArcStartX, - ArcStartY, ArcEndX, - ArcEndY, 0, Color);
int Color = ReturnLayerColor( LAYER_DEVICE );
GRLine( &panel->m_ClipBox, DC, ArcStartX, -ArcStartY, ArcEndX, -ArcEndY, 0, Color );
}
else
{
DrawLibraryDrawStruct(panel, DC, CurrentLibEntry, 0 , 0,
CurrentDrawItem, CurrentUnit, DrawMode);
if(CurrentDrawItem->m_StructType == COMPONENT_ARC_DRAW_TYPE)
DrawLibraryDrawStruct( panel, DC, CurrentLibEntry, 0, 0,
CurrentDrawItem, CurrentUnit, DrawMode );
if( CurrentDrawItem->m_StructType == COMPONENT_ARC_DRAW_TYPE )
{
int Color = ReturnLayerColor(LAYER_DEVICE);
GRDashedLine(&panel->m_ClipBox, DC, ArcStartX, - ArcStartY,
((LibDrawArc*)CurrentDrawItem)->m_Pos.x,
- ((LibDrawArc*)CurrentDrawItem)->m_Pos.y,
0, Color);
GRDashedLine(&panel->m_ClipBox, DC, ArcEndX, - ArcEndY,
((LibDrawArc*)CurrentDrawItem)->m_Pos.x,
- ((LibDrawArc*)CurrentDrawItem)->m_Pos.y,
0, Color);
int Color = ReturnLayerColor( LAYER_DEVICE );
GRDashedLine( &panel->m_ClipBox, DC, ArcStartX, -ArcStartY,
( (LibDrawArc*) CurrentDrawItem )->m_Pos.x,
-( (LibDrawArc*) CurrentDrawItem )->m_Pos.y,
0, Color );
GRDashedLine( &panel->m_ClipBox, DC, ArcEndX, -ArcEndY,
( (LibDrawArc*) CurrentDrawItem )->m_Pos.x,
-( (LibDrawArc*) CurrentDrawItem )->m_Pos.y,
0, Color );
}
}
}
/******************************************************/
void WinEDA_LibeditFrame::EndDrawGraphicItem(wxDC * DC)
void WinEDA_LibeditFrame::EndDrawGraphicItem( wxDC* DC )
/******************************************************/
/* Place la structure courante en liste des structures du composant
courant, si elle existe et redessine toujours celle ci
Parametres: (tous globaux)
CurrentDrawItem
CurrentLibEntry
*/
* courant, si elle existe et redessine toujours celle ci
* Parametres: (tous globaux)
* CurrentDrawItem
* CurrentLibEntry
*/
{
if(CurrentLibEntry == NULL) return;
if(CurrentDrawItem == NULL) return;
if( CurrentLibEntry == NULL )
return;
if( CurrentDrawItem == NULL )
return;
if( CurrentDrawItem->m_StructType == COMPONENT_ARC_DRAW_TYPE )
{
if (StateDrawArc == 1 ) /* Trace d'arc en cours: doit etre termine */
if( StateDrawArc == 1 ) /* Trace d'arc en cours: doit etre termine */
{
DisplayError(this, wxT("Arc in progress.."), 10 ); return;
DisplayError( this, wxT( "Arc in progress.." ), 10 ); return;
}
else
{
if ( (CurrentDrawItem->m_Flags & IS_MOVED) == 0 )
SymbolDisplayDraw(DrawPanel, DC, FALSE);
if( (CurrentDrawItem->m_Flags & IS_MOVED) == 0 )
SymbolDisplayDraw( DrawPanel, DC, FALSE );
}
}
StateDrawArc = 0;
if ( CurrentDrawItem->m_Flags & IS_NEW )
if( CurrentDrawItem->m_Flags & IS_NEW )
{
SaveCopyInUndoList(CurrentLibEntry);
SaveCopyInUndoList( CurrentLibEntry );
CurrentDrawItem->Pnext = CurrentLibEntry->m_Drawings;
CurrentLibEntry->m_Drawings = CurrentDrawItem;
switch ( CurrentDrawItem->m_StructType )
switch( CurrentDrawItem->m_StructType )
{
case COMPONENT_ARC_DRAW_TYPE:
((LibDrawArc*)CurrentDrawItem)->m_Fill = FlSymbol_Fill;
( (LibDrawArc*) CurrentDrawItem )->m_Fill = FlSymbol_Fill;
break;
case COMPONENT_CIRCLE_DRAW_TYPE:
((LibDrawCircle*)CurrentDrawItem)->m_Fill = FlSymbol_Fill;
( (LibDrawCircle*) CurrentDrawItem )->m_Fill = FlSymbol_Fill;
break;
case COMPONENT_RECT_DRAW_TYPE:
((LibDrawSquare*)CurrentDrawItem)->m_Fill = FlSymbol_Fill;
( (LibDrawSquare*) CurrentDrawItem )->m_Fill = FlSymbol_Fill;
break;
case COMPONENT_POLYLINE_DRAW_TYPE:
((LibDrawPolyline*)CurrentDrawItem)->m_Fill = FlSymbol_Fill;
( (LibDrawPolyline*) CurrentDrawItem )->m_Fill = FlSymbol_Fill;
break;
case COMPONENT_PIN_DRAW_TYPE:
case COMPONENT_LINE_DRAW_TYPE:
case COMPONENT_GRAPHIC_TEXT_DRAW_TYPE:
break;
default:
;
}
CurrentLibEntry->SortDrawItems();
}
if ( m_ID_current_state ) SetCursor(wxCURSOR_PENCIL);
else SetCursor(wxCURSOR_ARROW);
if( m_ID_current_state )
SetCursor( wxCURSOR_PENCIL );
else
SetCursor( wxCURSOR_ARROW );
if ( (CurrentDrawItem->m_Flags & IS_MOVED) )
if( (CurrentDrawItem->m_Flags & IS_MOVED) )
{
wxPoint pos;
pos.x = GetScreen()->m_Curseur.x + InitPosition.x - StartCursor.x ,
pos.y = GetScreen()->m_Curseur.y - InitPosition.y - StartCursor.y ;
MoveLibDrawItemAt(CurrentDrawItem, pos );
pos.x = GetScreen()->m_Curseur.x + InitPosition.x - StartCursor.x,
pos.y = GetScreen()->m_Curseur.y - InitPosition.y - StartCursor.y;
MoveLibDrawItemAt( CurrentDrawItem, pos );
}
DrawLibEntry(DrawPanel, DC, CurrentLibEntry, 0, 0, CurrentUnit,
DrawLibEntry( DrawPanel, DC, CurrentLibEntry, 0, 0, CurrentUnit,
CurrentConvert, GR_DEFAULT_DRAWMODE );
CurrentDrawItem->m_Flags = 0;
......@@ -683,20 +729,20 @@ void WinEDA_LibeditFrame::EndDrawGraphicItem(wxDC * DC)
}
/***************************************************************/
static void ComputeArc(LibDrawArc * DrawItem, wxPoint ArcCentre)
static void ComputeArc( LibDrawArc* DrawItem, wxPoint ArcCentre )
/***************************************************************/
/* routine d'ajustage des parametres de l'arc en cours de trace
calcule le centre, rayon, angles pour que l'arc en cours
passe par les points ArcStartX,Y et ArcEndX,Y avec le centre le plus proche
de la pos souris
Remarque: le centre n'est evidemment pas sur la grille
*/
* calcule le centre, rayon, angles pour que l'arc en cours
* passe par les points ArcStartX,Y et ArcEndX,Y avec le centre le plus proche
* de la pos souris
* Remarque: le centre n'est evidemment pas sur la grille
*/
{
int dx, dy;
int cX, cY; /* Coord centre de l'arc */
int angle;
int dx, dy;
int cX, cY; /* Coord centre de l'arc */
int angle;
cX = ArcCentre.x; cY = ArcCentre.y;
......@@ -705,13 +751,13 @@ int angle;
/* calcul de cX et cY pour que l'arc passe par ArcStartX,Y et ArcEndX,Y */
dx = ArcEndX - ArcStartX; dy = ArcEndY - ArcStartY;
cX -= ArcStartX; cY -= ArcStartY;
angle = (int)(atan2(dy, dx) *1800 /M_PI);
RotatePoint( &dx, &dy, angle); /* Le segment dx, dy est horizontal */
angle = (int) (atan2( dy, dx ) * 1800 / M_PI);
RotatePoint( &dx, &dy, angle ); /* Le segment dx, dy est horizontal */
/* -> dx = longueur, dy = 0 */
RotatePoint( &cX, &cY, angle);
RotatePoint( &cX, &cY, angle );
cX = dx / 2; /* cX, cY est sur la mediane du segment 0,0 a dx,0 */
RotatePoint( &cX, &cY, -angle);
RotatePoint( &cX, &cY, -angle );
cX += ArcStartX; cY += ArcStartY;
DrawItem->m_Pos.x = cX; DrawItem->m_Pos.y = cY;
......@@ -719,84 +765,87 @@ int angle;
dx = ArcStartX - DrawItem->m_Pos.x;
dy = ArcStartY - DrawItem->m_Pos.y;
DrawItem->m_Rayon = (int)sqrt( (dx*dx) + (dy*dy) );
DrawItem->m_Rayon = (int) sqrt( (dx * dx) + (dy * dy) );
DrawItem->t1 = (int)(atan2(dy, dx) *1800 /M_PI);
DrawItem->t1 = (int) (atan2( dy, dx ) * 1800 / M_PI);
dx = ArcEndX - DrawItem->m_Pos.x;
dy = ArcEndY - DrawItem->m_Pos.y;
DrawItem->t2 = (int)(atan2(dy, dx) *1800 /M_PI);
DrawItem->t2 = (int) (atan2( dy, dx ) * 1800 / M_PI);
DrawItem->m_ArcStart.x = ArcStartX;
DrawItem->m_ArcStart.y = ArcStartY;
DrawItem->m_ArcEnd.x = ArcEndX;
DrawItem->m_ArcEnd.y = ArcEndY;
NORMALIZE_ANGLE(DrawItem->t1);
NORMALIZE_ANGLE(DrawItem->t2); // angles = 0 .. 3600
NORMALIZE_ANGLE( DrawItem->t1 );
NORMALIZE_ANGLE( DrawItem->t2 ); // angles = 0 .. 3600
// limitation val abs a < 1800 (1/2 cercle) pour eviter Pbs d'affichage en miroir
// car en trace on suppose que l'arc fait moins de 180 deg pour trouver
// son orientation apres rot, miroir...
if ( (DrawItem->t2 - DrawItem->t1) > 1800 ) DrawItem->t2 -= 3600;
else if ( (DrawItem->t2 - DrawItem->t1) <= -1800 ) DrawItem->t2 += 3600;
if( (DrawItem->t2 - DrawItem->t1) > 1800 )
DrawItem->t2 -= 3600;
else if( (DrawItem->t2 - DrawItem->t1) <= -1800 )
DrawItem->t2 += 3600;
wxString msg;
wxString msg;
angle = DrawItem->t2 - DrawItem->t1;
msg.Printf(_("Arc %.1f deg"), (float)angle/10 );
EDA_Appl->LibeditFrame->PrintMsg(msg);
msg.Printf( _( "Arc %.1f deg" ), (float) angle / 10 );
EDA_Appl->LibeditFrame->PrintMsg( msg );
while ( (DrawItem->t2 - DrawItem->t1) >= 1800 )
while( (DrawItem->t2 - DrawItem->t1) >= 1800 )
{
DrawItem->t2--;
DrawItem->t1++;
}
while ( (DrawItem->t1 - DrawItem->t2) >= 1800 )
while( (DrawItem->t1 - DrawItem->t2) >= 1800 )
{
DrawItem->t2++;
DrawItem->t1--;
}
NORMALIZE_ANGLE(DrawItem->t1);
NORMALIZE_ANGLE(DrawItem->t2);
NORMALIZE_ANGLE( DrawItem->t1 );
NORMALIZE_ANGLE( DrawItem->t2 );
}
/***************************************************/
void WinEDA_LibeditFrame::DeleteDrawPoly(wxDC * DC)
void WinEDA_LibeditFrame::DeleteDrawPoly( wxDC* DC )
/**************************************************/
/* Used for deleting last entered segment while creating a Polyline
*/
*/
{
if ( CurrentDrawItem == NULL ) return;
if( CurrentDrawItem == NULL )
return;
if( CurrentDrawItem->m_StructType != COMPONENT_POLYLINE_DRAW_TYPE )
return;
int * ptpoly;
LibDrawPolyline * Poly = (LibDrawPolyline*)CurrentDrawItem;
int* ptpoly;
LibDrawPolyline* Poly = (LibDrawPolyline*) CurrentDrawItem;
DrawLibraryDrawStruct(DrawPanel, DC, CurrentLibEntry, 0 , 0,
CurrentDrawItem, CurrentUnit, g_XorMode);
DrawLibraryDrawStruct( DrawPanel, DC, CurrentLibEntry, 0, 0,
CurrentDrawItem, CurrentUnit, g_XorMode );
while( Poly->n > 2 ) // First segment is kept, only its end point is changed
{
Poly->n --;
ptpoly = Poly->PolyList + (2 * (Poly->n - 1));
if ( (ptpoly[0] != m_CurrentScreen->m_Curseur.x) ||
(ptpoly[1] != - m_CurrentScreen->m_Curseur.y) )
Poly->n--;
ptpoly = Poly->PolyList + ( 2 * (Poly->n - 1) );
if( (ptpoly[0] != m_CurrentScreen->m_Curseur.x)
|| (ptpoly[1] != -m_CurrentScreen->m_Curseur.y) )
{
ptpoly[0] = m_CurrentScreen->m_Curseur.x;
ptpoly[1] = - m_CurrentScreen->m_Curseur.y;
ptpoly[1] = -m_CurrentScreen->m_Curseur.y;
break;
}
}
int allocsize = 2 * sizeof(int) * Poly->n;
Poly->PolyList = (int*)realloc(Poly->PolyList, allocsize );
Poly->PolyList = (int*) realloc( Poly->PolyList, allocsize );
DrawLibraryDrawStruct(DrawPanel, DC, CurrentLibEntry, 0 , 0,
CurrentDrawItem, CurrentUnit, g_XorMode);
DrawLibraryDrawStruct( DrawPanel, DC, CurrentLibEntry, 0, 0,
CurrentDrawItem, CurrentUnit, g_XorMode );
}
eeschema/symbedit.cpp
View file @ f3c324d5
/*************************************************/
/* 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;
if(CurrentDrawItem) return;
if( CurrentLibEntry == NULL) return;
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;
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
*/
* 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;
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);
switch( DEntryRef->m_StructType)
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 )
{
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;
default:
;
}
return(TRUE);
}
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();
}
include/base_struct.h
View file @ f3c324d5
......@@ -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 */
/**************************/
......
include/pcbstruct.h
View file @ f3c324d5
......@@ -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
......
include/wxstruct.h
View file @ f3c324d5
......@@ -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 );
};
......
pcbnew/block_module_editor.cpp
View file @ f3c324d5
......@@ -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;
......
pcbnew/class_edge_mod.cpp
View file @ f3c324d5
......@@ -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;
......
pcbnew/class_track.cpp
View file @ f3c324d5
......@@ -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;
......
pcbnew/class_track.h
View file @ f3c324d5
......@@ -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; }
......
pcbnew/classpcb.cpp
View file @ f3c324d5
......@@ -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;
}
......
pcbnew/classtrc.cpp
View file @ f3c324d5
......@@ -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;
......
pcbnew/dialog_track_options.cpp
View file @ f3c324d5
......@@ -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
{
......
pcbnew/ratsnest.cpp
View file @ f3c324d5
......@@ -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 )
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment