Skip to content

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

see my 2007-Sep-20 change_log.txt

parent 33939aeb
Show whitespace changes
Inline Side-by-side
Showing with 5692 additions and 4976 deletions
change_log.txt
View file @ 664a1f72
...@@ -4,6 +4,14 @@ Started 2007-June-11 ...@@ -4,6 +4,14 @@ Started 2007-June-11
Please add newer entries at the top, list the date and your name with Please add newer entries at the top, list the date and your name with
email address. email address.
2007-Sep-20 UPDATE Dick Hollenbeck <dick@softplc.com>
================================================================================
+ eeschema
* beautify, add debug Show() functions, changed ReturnFieldName()
to return "const wxString&" for speed, added GetFieldValue().
* tracking down questionable behavior (a bug?) in erc regarding pwr_flag, still looking
2007-sept-20 UPDATE Jean-Pierre Charras <jean-pierre.charras@inpg.fr> 2007-sept-20 UPDATE Jean-Pierre Charras <jean-pierre.charras@inpg.fr>
================================================================================ ================================================================================
+ all + all
......
common/base_screen.cpp
View file @ 664a1f72
...@@ -555,3 +555,29 @@ EDA_BaseStruct* BASE_SCREEN::GetItemFromRedoList() ...@@ -555,3 +555,29 @@ EDA_BaseStruct* BASE_SCREEN::GetItemFromRedoList()
return item; return item;
} }
#if defined(DEBUG)
/**
* Function Show
* is used to output the object tree, currently for debugging only.
* @param nestLevel An aid to prettier tree indenting, and is the level
* of nesting of this object within the overall tree.
* @param os The ostream& to output to.
*/
void BASE_SCREEN::Show( int nestLevel, std::ostream& os )
{
EDA_BaseStruct* item = EEDrawList;
// for now, make it look like XML, expand on this later.
NestedSpace( nestLevel, os ) << '<' << GetClass().Lower().mb_str() <<
">\n";
for( ; item; item = item->Next() )
{
item->Show( nestLevel+1, os );
}
NestedSpace( nestLevel, os ) << "</" << GetClass().Lower().mb_str() << ">\n";
}
#endif
\ No newline at end of file
common/base_struct.cpp
View file @ 664a1f72
...@@ -188,11 +188,14 @@ void EDA_BaseStruct::Show( int nestLevel, std::ostream& os ) ...@@ -188,11 +188,14 @@ void EDA_BaseStruct::Show( int nestLevel, std::ostream& os )
// for now, make it look like XML: // for now, make it look like XML:
NestedSpace( nestLevel, os ) << '<' << GetClass().Lower().mb_str() << ">\n"; NestedSpace( nestLevel, os ) << '<' << GetClass().Lower().mb_str() << ">\n";
/*
EDA_BaseStruct* kid = m_Son; EDA_BaseStruct* kid = m_Son;
for( ; kid; kid = kid->Pnext ) for( ; kid; kid = kid->Pnext )
{ {
kid->Show( nestLevel+1, os ); kid->Show( nestLevel+1, os );
} }
*/
NestedSpace( nestLevel+1, os ) << "Need ::Show() override, shown class is using EDA_BaseStruct::Show()\n";
NestedSpace( nestLevel, os ) << "</" << GetClass().Lower().mb_str() << ">\n"; NestedSpace( nestLevel, os ) << "</" << GetClass().Lower().mb_str() << ">\n";
} }
......
eeschema/annotate.cpp
View file @ 664a1f72
/**************************************/ /**************************************/
/* annotate.cpp: component annotation */ /* annotate.cpp: component annotation */
/**************************************/ /**************************************/
#include "annotate_dialog.cpp" #include "annotate_dialog.cpp"
...@@ -8,17 +8,17 @@ ...@@ -8,17 +8,17 @@
#include "protos.h" #include "protos.h"
/* fonctions exportees */ /* fonctions exportees */
int ListeComposants( CmpListStruct * BaseListeCmp, SCH_SCREEN *screen, int NumSheet); int ListeComposants( CmpListStruct* BaseListeCmp, SCH_SCREEN* screen, int NumSheet );
int AnnotTriComposant(CmpListStruct *Objet1, CmpListStruct *Objet2); int AnnotTriComposant( CmpListStruct* Objet1, CmpListStruct* Objet2 );
void BreakReference( CmpListStruct * BaseListeCmp,int NbOfCmp ); void BreakReference( CmpListStruct* BaseListeCmp, int NbOfCmp );
/* fonctions locales */ /* fonctions locales */
static void ReAnnotateComponents( CmpListStruct * BaseListeCmp,int NbOfCmp ); static void ReAnnotateComponents( CmpListStruct* BaseListeCmp, int NbOfCmp );
static void ComputeReferenceNumber( CmpListStruct * BaseListeCmp,int NbOfCmp); static void ComputeReferenceNumber( CmpListStruct* BaseListeCmp, int NbOfCmp );
static int GetLastReferenceNumber(CmpListStruct *Objet, CmpListStruct * BaseListeCmp, static int GetLastReferenceNumber( CmpListStruct* Objet, CmpListStruct* BaseListeCmp,
int NbOfCmp); int NbOfCmp );
static int ExistUnit(CmpListStruct *Objet, int Unit, static int ExistUnit( CmpListStruct* Objet, int Unit,
CmpListStruct * BaseListeCmp,int NbOfCmp); CmpListStruct* BaseListeCmp, int NbOfCmp );
/* Variable locales */ /* Variable locales */
static bool AnnotProject = TRUE; static bool AnnotProject = TRUE;
...@@ -28,37 +28,38 @@ static bool SortByPosition = TRUE; ...@@ -28,37 +28,38 @@ static bool SortByPosition = TRUE;
/**************************************/ /**************************************/
void ReAnnotatePowerSymbolsOnly() void ReAnnotatePowerSymbolsOnly()
/**************************************/ /**************************************/
/* Used to reannotate the power symbols, before testing erc or computing netlist
when a true component reannotation is not necessary
In order to avoid conflicts the ref number start with a 0: /* Used to reannotate the power symbols, before testing erc or computing netlist
PWR with id 12 is named PWR12 in global annotation and PWR012 by the Power annotation * when a true component reannotation is not necessary
*/ *
* In order to avoid conflicts the ref number start with a 0:
* PWR with id 12 is named PWR12 in global annotation and PWR012 by the Power annotation
*/
{ {
/* Build the screen list */ /* Build the screen list */
EDA_ScreenList ScreenList(NULL); EDA_ScreenList ScreenList( NULL );
/* Update the sheet number, sheet count and date */ /* Update the sheet number, sheet count and date */
ScreenList.UpdateSheetNumberAndDate(); ScreenList.UpdateSheetNumberAndDate();
SCH_SCREEN* screen; SCH_SCREEN* screen;
int CmpNumber = 1; int CmpNumber = 1;
for ( screen = ScreenList.GetFirst(); screen != NULL; screen = ScreenList.GetNext() ) for( screen = ScreenList.GetFirst(); screen != NULL; screen = ScreenList.GetNext() )
{ {
EDA_BaseStruct *DrawList = screen->EEDrawList; EDA_BaseStruct* DrawList = screen->EEDrawList;
for ( ; DrawList != NULL ; DrawList = DrawList->Pnext ) for( ; DrawList != NULL; DrawList = DrawList->Pnext )
{ {
if ( DrawList->Type() != DRAW_LIB_ITEM_STRUCT_TYPE ) if( DrawList->Type() != DRAW_LIB_ITEM_STRUCT_TYPE )
continue; continue;
EDA_SchComponentStruct * DrawLibItem = (EDA_SchComponentStruct *) DrawList; EDA_SchComponentStruct* DrawLibItem = (EDA_SchComponentStruct*) DrawList;
EDA_LibComponentStruct * Entry = EDA_LibComponentStruct* Entry =
FindLibPart(DrawLibItem->m_ChipName.GetData(), wxEmptyString, FIND_ROOT); FindLibPart( DrawLibItem->m_ChipName.GetData(), wxEmptyString, FIND_ROOT );
if ( (Entry == NULL) || (Entry->m_Options != ENTRY_POWER) ) if( (Entry == NULL) || (Entry->m_Options != ENTRY_POWER) )
continue; continue;
DrawLibItem->ClearAnnotation(); DrawLibItem->ClearAnnotation();
DrawLibItem->m_RefIdNumber = CmpNumber; DrawLibItem->m_RefIdNumber = CmpNumber;
DrawLibItem->m_Field[REFERENCE].m_Text.RemoveLast(); // Remove the '?' DrawLibItem->m_Field[REFERENCE].m_Text.RemoveLast(); // Remove the '?'
DrawLibItem->m_Field[REFERENCE].m_Text << wxT("0") << CmpNumber; DrawLibItem->m_Field[REFERENCE].m_Text << wxT( "0" ) << CmpNumber;
CmpNumber++; CmpNumber++;
} }
} }
...@@ -66,25 +67,27 @@ In order to avoid conflicts the ref number start with a 0: ...@@ -66,25 +67,27 @@ In order to avoid conflicts the ref number start with a 0:
/******************************************************************/ /******************************************************************/
void InstallAnnotateFrame(WinEDA_SchematicFrame *parent, wxPoint & pos) void InstallAnnotateFrame( WinEDA_SchematicFrame* parent, wxPoint& pos )
/******************************************************************/ /******************************************************************/
{ {
WinEDA_AnnotateFrame * frame = new WinEDA_AnnotateFrame(parent); WinEDA_AnnotateFrame* frame = new WinEDA_AnnotateFrame( parent );
frame->ShowModal(); frame->Destroy(); frame->ShowModal(); frame->Destroy();
} }
/******************************************************************/ /******************************************************************/
void WinEDA_AnnotateFrame::AnnotateComponents(wxCommandEvent& event) void WinEDA_AnnotateFrame::AnnotateComponents( wxCommandEvent& event )
/******************************************************************/ /******************************************************************/
/* /*
Compute the annotation of the components for the whole projeect, or the current sheet only. * Compute the annotation of the components for the whole projeect, or the current sheet only.
All the components or the new ones only will be annotated. * All the components or the new ones only will be annotated.
*/ */
{ {
int NbSheet, ii , NbOfCmp; int NbSheet, ii, NbOfCmp;
SCH_SCREEN *screen; SCH_SCREEN* screen;
CmpListStruct * BaseListeCmp; CmpListStruct* BaseListeCmp;
wxBusyCursor dummy; wxBusyCursor dummy;
...@@ -92,12 +95,15 @@ CmpListStruct * BaseListeCmp; ...@@ -92,12 +95,15 @@ CmpListStruct * BaseListeCmp;
SortByPosition = (m_AnnotSortCmpCtrl->GetSelection() == 0) ? TRUE : FALSE; SortByPosition = (m_AnnotSortCmpCtrl->GetSelection() == 0) ? TRUE : FALSE;
/* If it is an annotation for all the components, reset previous annotation: */ /* If it is an annotation for all the components, reset previous annotation: */
if( m_AnnotNewCmpCtrl->GetSelection() == 0 ) DeleteAnnotation(event); if( m_AnnotNewCmpCtrl->GetSelection() == 0 )
if (m_Abort ) return; DeleteAnnotation( event );
if( m_Abort )
return;
/* Build the screen list */ /* Build the screen list */
EDA_ScreenList ScreenList(NULL); EDA_ScreenList ScreenList( NULL );
NbSheet = ScreenList.GetCount(); NbSheet = ScreenList.GetCount();
/* Update the sheet number, sheet count and date */ /* Update the sheet number, sheet count and date */
...@@ -109,67 +115,70 @@ CmpListStruct * BaseListeCmp; ...@@ -109,67 +115,70 @@ CmpListStruct * BaseListeCmp;
if( AnnotProject == TRUE ) if( AnnotProject == TRUE )
{ {
NbOfCmp = 0; NbOfCmp = 0;
for ( screen = ScreenList.GetFirst(); screen != NULL; screen = ScreenList.GetNext() ) for( screen = ScreenList.GetFirst(); screen != NULL; screen = ScreenList.GetNext() )
{ {
NbOfCmp += ListeComposants(NULL, screen, screen->m_SheetNumber); NbOfCmp += ListeComposants( NULL, screen, screen->m_SheetNumber );
} }
} }
else NbOfCmp = ListeComposants(NULL, screen, screen->m_SheetNumber); else
NbOfCmp = ListeComposants( NULL, screen, screen->m_SheetNumber );
if( NbOfCmp == 0 ) if( NbOfCmp == 0 )
return; return;
ii = sizeof(CmpListStruct) * NbOfCmp; ii = sizeof(CmpListStruct) * NbOfCmp;
BaseListeCmp = (CmpListStruct *) MyZMalloc(ii); BaseListeCmp = (CmpListStruct*) MyZMalloc( ii );
/* Second pass : Int data tables */ /* Second pass : Int data tables */
screen = (SCH_SCREEN*) m_Parent->m_CurrentScreen; screen = (SCH_SCREEN*) m_Parent->m_CurrentScreen;
if( AnnotProject == TRUE ) if( AnnotProject == TRUE )
{ {
ii = 0; ii = 0;
for ( screen = ScreenList.GetFirst(); screen != NULL; screen = ScreenList.GetNext() ) for( screen = ScreenList.GetFirst(); screen != NULL; screen = ScreenList.GetNext() )
{ {
ii += ListeComposants(BaseListeCmp + ii, ii += ListeComposants( BaseListeCmp + ii,
screen, screen->m_SheetNumber); screen, screen->m_SheetNumber );
} }
} }
else ii = ListeComposants(BaseListeCmp, screen, screen->m_SheetNumber); else
ii = ListeComposants( BaseListeCmp, screen, screen->m_SheetNumber );
if( ii != NbOfCmp ) if( ii != NbOfCmp )
DisplayError(this, wxT("Internal error in AnnotateComponents()")); DisplayError( this, wxT( "Internal error in AnnotateComponents()" ) );
/* Separation des Numeros de la reference: IC1 -> IC, et 1 dans .m_NumRef */ /* Separation des Numeros de la reference: IC1 -> IC, et 1 dans .m_NumRef */
BreakReference(BaseListeCmp, NbOfCmp); BreakReference( BaseListeCmp, NbOfCmp );
qsort( BaseListeCmp, NbOfCmp, sizeof(CmpListStruct), qsort( BaseListeCmp, NbOfCmp, sizeof(CmpListStruct),
(int(*)(const void*, const void*))AnnotTriComposant); ( int( * ) ( const void*, const void* ) )AnnotTriComposant );
/* Recalcul des numeros de reference */ /* Recalcul des numeros de reference */
ComputeReferenceNumber(BaseListeCmp, NbOfCmp); ComputeReferenceNumber( BaseListeCmp, NbOfCmp );
ReAnnotateComponents(BaseListeCmp, NbOfCmp); ReAnnotateComponents( BaseListeCmp, NbOfCmp );
MyFree(BaseListeCmp); BaseListeCmp = NULL; MyFree( BaseListeCmp ); BaseListeCmp = NULL;
/* Final control */ /* Final control */
CheckAnnotate(m_Parent, AnnotProject ? FALSE : TRUE); CheckAnnotate( m_Parent, AnnotProject ? FALSE : TRUE );
m_Parent->DrawPanel->Refresh(TRUE); /* Refresh screen */ m_Parent->DrawPanel->Refresh( TRUE ); /* Refresh screen */
Close(); Close();
} }
/********************************************************************/ /********************************************************************/
void WinEDA_AnnotateFrame::DeleteAnnotation(wxCommandEvent& event) void WinEDA_AnnotateFrame::DeleteAnnotation( wxCommandEvent& event )
/********************************************************************/ /********************************************************************/
/* Clear the current annotation for the whole project or only for the current sheet /* Clear the current annotation for the whole project or only for the current sheet
Update sheet number and number of sheets * Update sheet number and number of sheets
*/ */
{ {
int NbSheet; int NbSheet;
SCH_SCREEN * screen; SCH_SCREEN* screen;
EDA_SchComponentStruct *DrawLibItem; EDA_SchComponentStruct* DrawLibItem;
if( !IsOK(this, _("Previous Annotation will be deleted. Continue ?") ) ) if( !IsOK( this, _( "Previous Annotation will be deleted. Continue ?" ) ) )
{ {
m_Abort = TRUE; return; m_Abort = TRUE; return;
} }
...@@ -178,7 +187,8 @@ EDA_SchComponentStruct *DrawLibItem; ...@@ -178,7 +187,8 @@ EDA_SchComponentStruct *DrawLibItem;
m_Abort = FALSE; m_Abort = FALSE;
/* Build the screen list */ /* Build the screen list */
EDA_ScreenList ScreenList(NULL); EDA_ScreenList ScreenList( NULL );
NbSheet = ScreenList.GetCount(); NbSheet = ScreenList.GetCount();
/* Update the sheet number, sheet count and date */ /* Update the sheet number, sheet count and date */
...@@ -186,58 +196,64 @@ EDA_SchComponentStruct *DrawLibItem; ...@@ -186,58 +196,64 @@ EDA_SchComponentStruct *DrawLibItem;
ScreenSch->SetModify(); ScreenSch->SetModify();
if( AnnotProject == TRUE ) screen = ScreenList.GetFirst(); if( AnnotProject == TRUE )
else screen = (SCH_SCREEN*) m_Parent->m_CurrentScreen; screen = ScreenList.GetFirst();
else
screen = (SCH_SCREEN*) m_Parent->m_CurrentScreen;
for ( ; screen != NULL; screen = ScreenList.GetNext() ) for( ; screen != NULL; screen = ScreenList.GetNext() )
{ {
EDA_BaseStruct *DrawList = screen->EEDrawList; EDA_BaseStruct* DrawList = screen->EEDrawList;
for ( ; DrawList != NULL ; DrawList = DrawList->Pnext ) for( ; DrawList != NULL; DrawList = DrawList->Pnext )
{ {
if ( DrawList->Type() == DRAW_LIB_ITEM_STRUCT_TYPE ) if( DrawList->Type() == DRAW_LIB_ITEM_STRUCT_TYPE )
{ {
DrawLibItem = (EDA_SchComponentStruct *) DrawList; DrawLibItem = (EDA_SchComponentStruct*) DrawList;
DrawLibItem->ClearAnnotation(); DrawLibItem->ClearAnnotation();
} }
} }
if( ! AnnotProject ) break;
if( !AnnotProject )
break;
} }
m_Parent->DrawPanel->Refresh(TRUE); m_Parent->DrawPanel->Refresh( TRUE );
Close(); Close();
} }
/************************************************************************************/ /************************************************************************************/
int ListeComposants(CmpListStruct * BaseListeCmp, SCH_SCREEN *screen, int NumSheet) int ListeComposants( CmpListStruct* BaseListeCmp, SCH_SCREEN* screen, int NumSheet )
/***********************************************************************************/ /***********************************************************************************/
/* if BaseListeCmp == NULL : Components counting /* if BaseListeCmp == NULL : Components counting
else update data table BaseListeCmp * else update data table BaseListeCmp
*/ */
{ {
int NbrCmp = 0; int NbrCmp = 0;
EDA_BaseStruct *DrawList = screen->EEDrawList; EDA_BaseStruct* DrawList = screen->EEDrawList;
EDA_SchComponentStruct *DrawLibItem; EDA_SchComponentStruct* DrawLibItem;
EDA_LibComponentStruct *Entry; EDA_LibComponentStruct* Entry;
DrawList = screen->EEDrawList; DrawList = screen->EEDrawList;
while ( DrawList ) while( DrawList )
{ {
switch( DrawList->Type() ) switch( DrawList->Type() )
{ {
case DRAW_SEGMENT_STRUCT_TYPE : case DRAW_SEGMENT_STRUCT_TYPE:
case DRAW_JUNCTION_STRUCT_TYPE : case DRAW_JUNCTION_STRUCT_TYPE:
case DRAW_TEXT_STRUCT_TYPE : case DRAW_TEXT_STRUCT_TYPE:
case DRAW_LABEL_STRUCT_TYPE : case DRAW_LABEL_STRUCT_TYPE:
case DRAW_GLOBAL_LABEL_STRUCT_TYPE : case DRAW_GLOBAL_LABEL_STRUCT_TYPE:
break; break;
case DRAW_LIB_ITEM_STRUCT_TYPE : case DRAW_LIB_ITEM_STRUCT_TYPE:
DrawLibItem = (EDA_SchComponentStruct *) DrawList; DrawLibItem = (EDA_SchComponentStruct*) DrawList;
Entry = FindLibPart(DrawLibItem->m_ChipName.GetData(), wxEmptyString, FIND_ROOT); Entry = FindLibPart( DrawLibItem->m_ChipName.GetData(), wxEmptyString, FIND_ROOT );
if( Entry == NULL) break; if( Entry == NULL )
if ( BaseListeCmp == NULL ) /* Items counting only */ break;
if( BaseListeCmp == NULL ) /* Items counting only */
{ {
NbrCmp++; break; NbrCmp++; break;
} }
...@@ -250,145 +266,161 @@ EDA_LibComponentStruct *Entry; ...@@ -250,145 +266,161 @@ EDA_LibComponentStruct *Entry;
BaseListeCmp[NbrCmp].m_Pos = DrawLibItem->m_Pos; BaseListeCmp[NbrCmp].m_Pos = DrawLibItem->m_Pos;
BaseListeCmp[NbrCmp].m_TimeStamp = DrawLibItem->m_TimeStamp; BaseListeCmp[NbrCmp].m_TimeStamp = DrawLibItem->m_TimeStamp;
if( DrawLibItem->m_Field[REFERENCE].m_Text.IsEmpty() ) if( DrawLibItem->m_Field[REFERENCE].m_Text.IsEmpty() )
DrawLibItem->m_Field[REFERENCE].m_Text = wxT("DefRef?"); DrawLibItem->m_Field[REFERENCE].m_Text = wxT( "DefRef?" );
strncpy( BaseListeCmp[NbrCmp].m_TextRef, strncpy( BaseListeCmp[NbrCmp].m_TextRef,
CONV_TO_UTF8(DrawLibItem->m_Field[REFERENCE].m_Text), 32); CONV_TO_UTF8( DrawLibItem->m_Field[REFERENCE].m_Text ), 32 );
BaseListeCmp[NbrCmp].m_NumRef = -1; BaseListeCmp[NbrCmp].m_NumRef = -1;
if( DrawLibItem->m_Field[VALUE].m_Text.IsEmpty() ) if( DrawLibItem->m_Field[VALUE].m_Text.IsEmpty() )
DrawLibItem->m_Field[VALUE].m_Text = wxT("~"); DrawLibItem->m_Field[VALUE].m_Text = wxT( "~" );
strncpy( BaseListeCmp[NbrCmp].m_TextValue, strncpy( BaseListeCmp[NbrCmp].m_TextValue,
CONV_TO_UTF8(DrawLibItem->m_Field[VALUE].m_Text), 32); CONV_TO_UTF8( DrawLibItem->m_Field[VALUE].m_Text ), 32 );
NbrCmp++; NbrCmp++;
break; break;
case DRAW_PICK_ITEM_STRUCT_TYPE : case DRAW_PICK_ITEM_STRUCT_TYPE:
case DRAW_POLYLINE_STRUCT_TYPE : case DRAW_POLYLINE_STRUCT_TYPE:
case DRAW_BUSENTRY_STRUCT_TYPE : case DRAW_BUSENTRY_STRUCT_TYPE:
case DRAW_SHEET_STRUCT_TYPE : case DRAW_SHEET_STRUCT_TYPE:
case DRAW_SHEETLABEL_STRUCT_TYPE : case DRAW_SHEETLABEL_STRUCT_TYPE:
case DRAW_MARKER_STRUCT_TYPE : case DRAW_MARKER_STRUCT_TYPE:
case DRAW_NOCONNECT_STRUCT_TYPE : case DRAW_NOCONNECT_STRUCT_TYPE:
break; break;
default : default:
break; break;
} }
DrawList = DrawList->Pnext; DrawList = DrawList->Pnext;
} }
return(NbrCmp); return NbrCmp;
} }
/*****************************************************************/ /*****************************************************************/
int AnnotTriComposant(CmpListStruct *Objet1, CmpListStruct *Objet2) int AnnotTriComposant( CmpListStruct* Objet1, CmpListStruct* Objet2 )
/****************************************************************/ /****************************************************************/
/* function used par qsort() for sorting the list /* function used par qsort() for sorting the list
Composants are sorted * Composants are sorted
by reference * by reference
if same reference: by value * if same reference: by value
if same value: by unit number * if same value: by unit number
if same unit number, by sheet * if same unit number, by sheet
if same sheet, by time stamp * if same sheet, by time stamp
**/ **/
{ {
int ii; int ii;
ii = strnicmp( Objet1->m_TextRef, Objet2->m_TextRef, 32 ); ii = strnicmp( Objet1->m_TextRef, Objet2->m_TextRef, 32 );
if ( SortByPosition == TRUE ) { if( SortByPosition == TRUE )
if ( ii == 0 ) ii = Objet1->m_Sheet - Objet2->m_Sheet; {
if ( ii == 0 ) ii = Objet1->m_Unit - Objet2->m_Unit; if( ii == 0 )
if ( ii == 0 ) ii = Objet1->m_Pos.x - Objet2->m_Pos.x; ii = Objet1->m_Sheet - Objet2->m_Sheet;
if ( ii == 0 ) ii = Objet1->m_Pos.y - Objet2->m_Pos.y; if( ii == 0 )
} else { ii = Objet1->m_Unit - Objet2->m_Unit;
if ( ii == 0 ) ii = strnicmp( Objet1->m_TextValue, Objet2->m_TextValue, 32 ); if( ii == 0 )
if ( ii == 0 ) ii = Objet1->m_Unit - Objet2->m_Unit; ii = Objet1->m_Pos.x - Objet2->m_Pos.x;
if ( ii == 0 ) ii = Objet1->m_Sheet - Objet2->m_Sheet; if( ii == 0 )
ii = Objet1->m_Pos.y - Objet2->m_Pos.y;
}
else
{
if( ii == 0 )
ii = strnicmp( Objet1->m_TextValue, Objet2->m_TextValue, 32 );
if( ii == 0 )
ii = Objet1->m_Unit - Objet2->m_Unit;
if( ii == 0 )
ii = Objet1->m_Sheet - Objet2->m_Sheet;
} }
if ( ii == 0 ) ii = Objet1->m_TimeStamp - Objet2->m_TimeStamp; if( ii == 0 )
ii = Objet1->m_TimeStamp - Objet2->m_TimeStamp;
return(ii); return ii;
} }
/********************************************************************/ /********************************************************************/
static void ReAnnotateComponents( CmpListStruct * BaseListeCmp, int NbOfCmp) static void ReAnnotateComponents( CmpListStruct* BaseListeCmp, int NbOfCmp )
/********************************************************************/ /********************************************************************/
/* Update the reference component for the schematic project (or the current sheet) /* Update the reference component for the schematic project (or the current sheet)
*/ */
{ {
int ii; int ii;
char *Text; char* Text;
EDA_SchComponentStruct *DrawLibItem; EDA_SchComponentStruct* DrawLibItem;
/* Reattribution des numeros */ /* Reattribution des numeros */
for ( ii = 0; ii < NbOfCmp ; ii++ ) for( ii = 0; ii < NbOfCmp; ii++ )
{ {
Text = BaseListeCmp[ii].m_TextRef; Text = BaseListeCmp[ii].m_TextRef;
DrawLibItem = BaseListeCmp[ii].m_Cmp; DrawLibItem = BaseListeCmp[ii].m_Cmp;
if ( BaseListeCmp[ii].m_NumRef < 0 ) strcat( Text, "?" ); if( BaseListeCmp[ii].m_NumRef < 0 )
else sprintf( Text + strlen(Text),"%d",BaseListeCmp[ii].m_NumRef ); strcat( Text, "?" );
else
sprintf( Text + strlen( Text ), "%d", BaseListeCmp[ii].m_NumRef );
DrawLibItem->m_Field[REFERENCE].m_Text = CONV_FROM_UTF8(Text); DrawLibItem->m_Field[REFERENCE].m_Text = CONV_FROM_UTF8( Text );
DrawLibItem->m_Multi = BaseListeCmp[ii].m_Unit; DrawLibItem->m_Multi = BaseListeCmp[ii].m_Unit;
DrawLibItem->m_RefIdNumber = BaseListeCmp[ii].m_NumRef; DrawLibItem->m_RefIdNumber = BaseListeCmp[ii].m_NumRef;
if ( DrawLibItem->m_RefIdNumber < 0 ) DrawLibItem->m_RefIdNumber = 0; if( DrawLibItem->m_RefIdNumber < 0 )
DrawLibItem->m_RefIdNumber = 0;
} }
} }
/**************************************************************/ /**************************************************************/
void BreakReference( CmpListStruct * BaseListeCmp, int NbOfCmp) void BreakReference( CmpListStruct* BaseListeCmp, int NbOfCmp )
/**************************************************************/ /**************************************************************/
/* Modifie dans BaseListeCmp la reference des composants en supprimant la /* Modifie dans BaseListeCmp la reference des composants en supprimant la
partie nombre de la partie texte. * partie nombre de la partie texte.
Place le nombre dans .m_NumRef * Place le nombre dans .m_NumRef
Pour les composants multiples non encore annotes, met .m_Unit a sa valeur max * Pour les composants multiples non encore annotes, met .m_Unit a sa valeur max
Utilise: * Utilise:
BaseListeCmp * BaseListeCmp
NbOfCmp * NbOfCmp
*/ */
{ {
int ii, ll; int ii, ll;
char * Text; char* Text;
/* Separation des Numeros de la reference: IC1 -> IC, et 1 dans .m_NumRef */ /* Separation des Numeros de la reference: IC1 -> IC, et 1 dans .m_NumRef */
for ( ii = 0; ii < NbOfCmp ; ii++ ) for( ii = 0; ii < NbOfCmp; ii++ )
{ {
BaseListeCmp[ii].m_NumRef = - 1; BaseListeCmp[ii].m_NumRef = -1;
Text = BaseListeCmp[ii].m_TextRef; Text = BaseListeCmp[ii].m_TextRef;
ll = strlen( Text ) - 1; ll = strlen( Text ) - 1;
if( Text[ll] == '?' ) if( Text[ll] == '?' )
{ {
BaseListeCmp[ii].m_IsNew = TRUE; BaseListeCmp[ii].m_IsNew = TRUE;
if ( ! BaseListeCmp[ii].m_PartsLocked ) if( !BaseListeCmp[ii].m_PartsLocked )
BaseListeCmp[ii].m_Unit = 0x7FFFFFFF; BaseListeCmp[ii].m_Unit = 0x7FFFFFFF;
Text[ll] = 0; continue; Text[ll] = 0; continue;
} }
if( isdigit(Text[ll]) == 0 ) if( isdigit( Text[ll] ) == 0 )
{ {
BaseListeCmp[ii].m_IsNew = TRUE; BaseListeCmp[ii].m_IsNew = TRUE;
if ( ! BaseListeCmp[ii].m_PartsLocked ) if( !BaseListeCmp[ii].m_PartsLocked )
BaseListeCmp[ii].m_Unit = 0x7FFFFFFF; BaseListeCmp[ii].m_Unit = 0x7FFFFFFF;
continue; continue;
} }
while( ll >= 0 ) while( ll >= 0 )
{ {
if( (Text[ll] <= ' ' ) || isdigit(Text[ll]) ) if( (Text[ll] <= ' ' ) || isdigit( Text[ll] ) )
ll--; ll--;
else else
{ {
if( isdigit(Text[ll+1]) ) if( isdigit( Text[ll + 1] ) )
BaseListeCmp[ii].m_NumRef = atoi(& Text[ll+1]); BaseListeCmp[ii].m_NumRef = atoi( &Text[ll + 1] );
Text[ll+1] = 0; Text[ll + 1] = 0;
break; break;
} }
} }
...@@ -397,21 +429,22 @@ char * Text; ...@@ -397,21 +429,22 @@ char * Text;
/*****************************************************************************/ /*****************************************************************************/
static void ComputeReferenceNumber( CmpListStruct * BaseListeCmp, int NbOfCmp) static void ComputeReferenceNumber( CmpListStruct* BaseListeCmp, int NbOfCmp )
/*****************************************************************************/ /*****************************************************************************/
/* Compute the reference number for components without reference number /* Compute the reference number for components without reference number
Compute .m_NumRef member * Compute .m_NumRef member
*/ */
{ {
int ii, jj, LastReferenceNumber, NumberOfUnits, Unit; int ii, jj, LastReferenceNumber, NumberOfUnits, Unit;
char * Text, * RefText, *ValText; char* Text, * RefText, * ValText;
CmpListStruct * ObjRef, * ObjToTest; CmpListStruct* ObjRef, * ObjToTest;
/* Components with an invisible reference (power...) always are re-annotated*/ /* Components with an invisible reference (power...) always are re-annotated*/
for ( ii = 0; ii < NbOfCmp ; ii++ ) for( ii = 0; ii < NbOfCmp; ii++ )
{ {
Text = BaseListeCmp[ii].m_TextRef; Text = BaseListeCmp[ii].m_TextRef;
if (*Text == '#') if( *Text == '#' )
{ {
BaseListeCmp[ii].m_IsNew = TRUE; BaseListeCmp[ii].m_IsNew = TRUE;
BaseListeCmp[ii].m_NumRef = 0; BaseListeCmp[ii].m_NumRef = 0;
...@@ -419,22 +452,23 @@ CmpListStruct * ObjRef, * ObjToTest; ...@@ -419,22 +452,23 @@ CmpListStruct * ObjRef, * ObjToTest;
} }
ValText = RefText = ""; LastReferenceNumber = 1; ValText = RefText = ""; LastReferenceNumber = 1;
for ( ii = 0; ii < NbOfCmp ; ii++ ) for( ii = 0; ii < NbOfCmp; ii++ )
{ {
ObjRef = & BaseListeCmp[ii]; ObjRef = &BaseListeCmp[ii];
if( BaseListeCmp[ii].m_Flag ) continue; if( BaseListeCmp[ii].m_Flag )
continue;
Text = BaseListeCmp[ii].m_TextRef; Text = BaseListeCmp[ii].m_TextRef;
if( strnicmp(RefText, Text, 32) != 0 ) /* Nouveau Identificateur */ if( strnicmp( RefText, Text, 32 ) != 0 ) /* Nouveau Identificateur */
{ {
RefText = BaseListeCmp[ii].m_TextRef; RefText = BaseListeCmp[ii].m_TextRef;
LastReferenceNumber = GetLastReferenceNumber(BaseListeCmp + ii, BaseListeCmp, NbOfCmp); LastReferenceNumber = GetLastReferenceNumber( BaseListeCmp + ii, BaseListeCmp, NbOfCmp );
} }
/* Annotation of mono-part components ( 1 part per package ) (trivial case)*/ /* Annotation of mono-part components ( 1 part per package ) (trivial case)*/
if( BaseListeCmp[ii].m_NbParts <= 1 ) if( BaseListeCmp[ii].m_NbParts <= 1 )
{ {
if ( BaseListeCmp[ii].m_IsNew ) if( BaseListeCmp[ii].m_IsNew )
{ {
LastReferenceNumber++; LastReferenceNumber++;
BaseListeCmp[ii].m_NumRef = LastReferenceNumber; BaseListeCmp[ii].m_NumRef = LastReferenceNumber;
...@@ -449,36 +483,41 @@ CmpListStruct * ObjRef, * ObjToTest; ...@@ -449,36 +483,41 @@ CmpListStruct * ObjRef, * ObjToTest;
ValText = BaseListeCmp[ii].m_TextValue; ValText = BaseListeCmp[ii].m_TextValue;
NumberOfUnits = BaseListeCmp[ii].m_NbParts; NumberOfUnits = BaseListeCmp[ii].m_NbParts;
if ( BaseListeCmp[ii].m_IsNew ) if( BaseListeCmp[ii].m_IsNew )
{ {
LastReferenceNumber++; BaseListeCmp[ii].m_NumRef = LastReferenceNumber; LastReferenceNumber++; BaseListeCmp[ii].m_NumRef = LastReferenceNumber;
if ( ! BaseListeCmp[ii].m_PartsLocked ) if( !BaseListeCmp[ii].m_PartsLocked )
BaseListeCmp[ii].m_Unit = 1; BaseListeCmp[ii].m_Unit = 1;
BaseListeCmp[ii].m_Flag = 1; BaseListeCmp[ii].m_Flag = 1;
} }
for( Unit = 1; Unit <= NumberOfUnits; Unit++ ) for( Unit = 1; Unit <= NumberOfUnits; Unit++ )
{ {
if( BaseListeCmp[ii].m_Unit == Unit ) continue; if( BaseListeCmp[ii].m_Unit == Unit )
jj = ExistUnit( BaseListeCmp + ii , Unit, BaseListeCmp, NbOfCmp ); continue;
if ( jj >= 0 ) continue; /* Unit exists for this reference */ jj = ExistUnit( BaseListeCmp + ii, Unit, BaseListeCmp, NbOfCmp );
if( jj >= 0 )
continue; /* Unit exists for this reference */
/* Search a component to annotate ( same prefix, same value) */ /* Search a component to annotate ( same prefix, same value) */
for ( jj = ii+1; jj < NbOfCmp ; jj++ ) for( jj = ii + 1; jj < NbOfCmp; jj++ )
{ {
ObjToTest = &BaseListeCmp[jj]; ObjToTest = &BaseListeCmp[jj];
if( BaseListeCmp[jj].m_Flag ) continue; if( BaseListeCmp[jj].m_Flag )
continue;
Text = BaseListeCmp[jj].m_TextRef; Text = BaseListeCmp[jj].m_TextRef;
if( strnicmp(RefText, Text, 32) != 0 ) break; // references are different if( strnicmp( RefText, Text, 32 ) != 0 )
break; // references are different
Text = BaseListeCmp[jj].m_TextValue; Text = BaseListeCmp[jj].m_TextValue;
if( strnicmp(ValText, Text, 32) != 0 ) break; // values are different if( strnicmp( ValText, Text, 32 ) != 0 )
if ( ! BaseListeCmp[jj].m_IsNew ) break; // values are different
if( !BaseListeCmp[jj].m_IsNew )
{ {
//BaseListeCmp[jj].m_Flag = 1; //BaseListeCmp[jj].m_Flag = 1;
continue; continue;
} }
/* Component without reference number found, annotate it if possible */ /* Component without reference number found, annotate it if possible */
if ( ! BaseListeCmp[jj].m_PartsLocked || (BaseListeCmp[jj].m_Unit == Unit) ) if( !BaseListeCmp[jj].m_PartsLocked || (BaseListeCmp[jj].m_Unit == Unit) )
{ {
BaseListeCmp[jj].m_NumRef = BaseListeCmp[ii].m_NumRef; BaseListeCmp[jj].m_NumRef = BaseListeCmp[ii].m_NumRef;
BaseListeCmp[jj].m_Unit = Unit; BaseListeCmp[jj].m_Unit = Unit;
...@@ -493,79 +532,89 @@ CmpListStruct * ObjRef, * ObjToTest; ...@@ -493,79 +532,89 @@ CmpListStruct * ObjRef, * ObjToTest;
/*************************************************************************************************/ /*************************************************************************************************/
static int GetLastReferenceNumber(CmpListStruct *Objet, CmpListStruct * BaseListeCmp, int NbOfCmp) static int GetLastReferenceNumber( CmpListStruct* Objet, CmpListStruct* BaseListeCmp, int NbOfCmp )
/*************************************************************************************************/ /*************************************************************************************************/
/* Recherche le plus grand numero de reference dans les composants /* Recherche le plus grand numero de reference dans les composants
de meme prefixe de reference que celui pointe par Objet * de meme prefixe de reference que celui pointe par Objet
la liste des composants est supposee triee * la liste des composants est supposee triee
*/ */
{ {
CmpListStruct * LastObjet = BaseListeCmp + NbOfCmp; CmpListStruct* LastObjet = BaseListeCmp + NbOfCmp;
int LastNumber = 0; int LastNumber = 0;
const char * RefText; const char* RefText;
RefText = Objet->m_TextRef; RefText = Objet->m_TextRef;
for ( ; Objet < LastObjet; Objet++ ) for( ; Objet < LastObjet; Objet++ )
{ {
if( strnicmp(RefText, Objet->m_TextRef, 32) != 0 ) /* Nouveau Identificateur */ if( strnicmp( RefText, Objet->m_TextRef, 32 ) != 0 ) /* Nouveau Identificateur */
break; break;
if( LastNumber < Objet->m_NumRef ) LastNumber = Objet->m_NumRef; if( LastNumber < Objet->m_NumRef )
LastNumber = Objet->m_NumRef;
} }
return(LastNumber);
return LastNumber;
} }
/*****************************************************************/ /*****************************************************************/
static int ExistUnit(CmpListStruct *Objet, int Unit, static int ExistUnit( CmpListStruct* Objet, int Unit,
CmpListStruct * BaseListeCmp, int NbOfCmp) CmpListStruct* BaseListeCmp, int NbOfCmp )
/****************************************************************/ /****************************************************************/
/* Recherche dans la liste triee des composants, pour les composants /* Recherche dans la liste triee des composants, pour les composants
multiples s'il existe pour le composant de reference Objet, * multiples s'il existe pour le composant de reference Objet,
une unite de numero Unit * une unite de numero Unit
Retourne index dans BaseListeCmp si oui * Retourne index dans BaseListeCmp si oui
retourne -1 si non * retourne -1 si non
*/ */
{ {
CmpListStruct * EndList = BaseListeCmp + NbOfCmp; CmpListStruct* EndList = BaseListeCmp + NbOfCmp;
char * RefText, * ValText; char* RefText, * ValText;
int NumRef, ii; int NumRef, ii;
CmpListStruct *ItemToTest; CmpListStruct* ItemToTest;
RefText = Objet->m_TextRef; RefText = Objet->m_TextRef;
ValText = Objet->m_TextValue; ValText = Objet->m_TextValue;
NumRef = Objet->m_NumRef; NumRef = Objet->m_NumRef;
for ( ItemToTest = BaseListeCmp, ii = 0; ItemToTest < EndList; ItemToTest++, ii++ ) for( ItemToTest = BaseListeCmp, ii = 0; ItemToTest < EndList; ItemToTest++, ii++ )
{ {
if ( Objet == ItemToTest ) continue; if( Objet == ItemToTest )
if ( ItemToTest->m_IsNew ) continue; /* non affecte */ continue;
if ( ItemToTest->m_NumRef != NumRef ) continue; if( ItemToTest->m_IsNew )
if( strnicmp(RefText, ItemToTest->m_TextRef, 32) != 0 ) /* Nouveau Identificateur */ continue; /* non affecte */
if( ItemToTest->m_NumRef != NumRef )
continue;
if( strnicmp( RefText, ItemToTest->m_TextRef, 32 ) != 0 ) /* Nouveau Identificateur */
continue; continue;
if( ItemToTest->m_Unit == Unit) if( ItemToTest->m_Unit == Unit )
{ {
return(ii); return ii;
} }
} }
return(-1);
return -1;
} }
/******************************************************************/ /******************************************************************/
int CheckAnnotate(WinEDA_SchematicFrame * frame, bool OneSheetOnly) int CheckAnnotate( WinEDA_SchematicFrame* frame, bool OneSheetOnly )
/******************************************************************/ /******************************************************************/
/* Retourne le nombre de composants non annots ou de meme rfrence (doubls) /* Retourne le nombre de composants non annots ou de meme rfrence (doubls)
Si OneSheetOnly : recherche sur le schema courant * Si OneSheetOnly : recherche sur le schema courant
sinon: recherche sur toute la hierarchie * sinon: recherche sur toute la hierarchie
*/ */
{ {
int NbSheet, ii, NumSheet = 1, error, NbOfCmp; int NbSheet, ii, NumSheet = 1, error, NbOfCmp;
SCH_SCREEN *screen; SCH_SCREEN* screen;
CmpListStruct * ListeCmp = NULL; CmpListStruct* ListeCmp = NULL;
wxString Buff; wxString Buff;
wxString msg, cmpref; wxString msg, cmpref;
/* build tje screen list */ /* build tje screen list */
EDA_ScreenList ScreenList(NULL); EDA_ScreenList ScreenList( NULL );
NbSheet = ScreenList.GetCount(); NbSheet = ScreenList.GetCount();
/* Update the sheet number, sheet count and date */ /* Update the sheet number, sheet count and date */
...@@ -574,157 +623,164 @@ wxString msg, cmpref; ...@@ -574,157 +623,164 @@ wxString msg, cmpref;
/* 1ere passe : Comptage du nombre de composants */ /* 1ere passe : Comptage du nombre de composants */
screen = (SCH_SCREEN*) frame->m_CurrentScreen; screen = (SCH_SCREEN*) frame->m_CurrentScreen;
if( ! OneSheetOnly ) if( !OneSheetOnly )
{ {
NbOfCmp = 0; NbOfCmp = 0;
for ( screen = ScreenList.GetFirst(); screen != NULL; screen = ScreenList.GetNext() ) for( screen = ScreenList.GetFirst(); screen != NULL; screen = ScreenList.GetNext() )
{ {
NbOfCmp += ListeComposants(NULL, screen, NumSheet); NbOfCmp += ListeComposants( NULL, screen, NumSheet );
} }
} }
else NbOfCmp = ListeComposants(NULL, screen, NumSheet); else
NbOfCmp = ListeComposants( NULL, screen, NumSheet );
if( NbOfCmp == 0 ) if( NbOfCmp == 0 )
{ {
wxBell(); wxBell();
return(0); return 0;
} }
ii = sizeof(CmpListStruct) * NbOfCmp; ii = sizeof(CmpListStruct) * NbOfCmp;
ListeCmp = (CmpListStruct *) MyZMalloc(ii); ListeCmp = (CmpListStruct*) MyZMalloc( ii );
/* 2eme passe : Remplissage du tableau des caracteristiques */ /* 2eme passe : Remplissage du tableau des caracteristiques */
if( OneSheetOnly == 0 ) if( OneSheetOnly == 0 )
{ {
ii = 0; screen = ScreenSch; ii = 0; screen = ScreenSch;
for ( screen = ScreenList.GetFirst(); screen != NULL; screen = ScreenList.GetNext() ) for( screen = ScreenList.GetFirst(); screen != NULL; screen = ScreenList.GetNext() )
{ {
ii += ListeComposants(ListeCmp + ii, screen, NumSheet); ii += ListeComposants( ListeCmp + ii, screen, NumSheet );
} }
} }
else else
{ {
screen = (SCH_SCREEN*) frame->m_CurrentScreen; screen = (SCH_SCREEN*) frame->m_CurrentScreen;
ListeComposants(ListeCmp, screen, NumSheet); ListeComposants( ListeCmp, screen, NumSheet );
} }
qsort( ListeCmp, NbOfCmp, sizeof(CmpListStruct), qsort( ListeCmp, NbOfCmp, sizeof(CmpListStruct),
(int(*)(const void*, const void*))AnnotTriComposant); ( int( * ) ( const void*, const void* ) )AnnotTriComposant );
/* Separation des Numeros de la reference: IC1 -> IC, et 1 dans .m_NumRef */ /* Separation des Numeros de la reference: IC1 -> IC, et 1 dans .m_NumRef */
BreakReference(ListeCmp, NbOfCmp); BreakReference( ListeCmp, NbOfCmp );
/* comptage des elements non annotes */ /* comptage des elements non annotes */
error = 0; error = 0;
for( ii = 0; ii < NbOfCmp-1 ; ii++ ) for( ii = 0; ii < NbOfCmp - 1; ii++ )
{ {
msg.Empty(); Buff.Empty(); msg.Empty(); Buff.Empty();
if ( ListeCmp[ii].m_IsNew ) if( ListeCmp[ii].m_IsNew )
{ {
if( ListeCmp[ii].m_NumRef >= 0 ) Buff << ListeCmp[ii].m_NumRef; if( ListeCmp[ii].m_NumRef >= 0 )
else Buff = wxT("?"); Buff << ListeCmp[ii].m_NumRef;
cmpref = CONV_FROM_UTF8(ListeCmp[ii].m_TextRef); else
msg.Printf( _("item not annotated: %s%s"), cmpref.GetData(), Buff.GetData()); Buff = wxT( "?" );
cmpref = CONV_FROM_UTF8( ListeCmp[ii].m_TextRef );
msg.Printf( _( "item not annotated: %s%s" ), cmpref.GetData(), Buff.GetData() );
if( (ListeCmp[ii].m_Unit > 0) && (ListeCmp[ii].m_Unit < 0x7FFFFFFF) ) if( (ListeCmp[ii].m_Unit > 0) && (ListeCmp[ii].m_Unit < 0x7FFFFFFF) )
{ {
Buff.Printf( _("( unit %d)"), ListeCmp[ii].m_Unit); Buff.Printf( _( "( unit %d)" ), ListeCmp[ii].m_Unit );
msg << Buff; msg << Buff;
} }
DisplayError(NULL, msg); DisplayError( NULL, msg );
error++; break; error++; break;
} }
if( MAX(ListeCmp[ii].m_NbParts, 1) < ListeCmp[ii].m_Unit ) // Annotate error if( MAX( ListeCmp[ii].m_NbParts, 1 ) < ListeCmp[ii].m_Unit ) // Annotate error
{ {
if( ListeCmp[ii].m_NumRef >= 0 ) Buff << ListeCmp[ii].m_NumRef; if( ListeCmp[ii].m_NumRef >= 0 )
else Buff = wxT("?"); Buff << ListeCmp[ii].m_NumRef;
else
Buff = wxT( "?" );
cmpref = CONV_FROM_UTF8(ListeCmp[ii].m_TextRef); cmpref = CONV_FROM_UTF8( ListeCmp[ii].m_TextRef );
msg.Printf( _("Error item %s%s"), cmpref.GetData(), Buff.GetData()); msg.Printf( _( "Error item %s%s" ), cmpref.GetData(), Buff.GetData() );
Buff.Printf( _(" unit %d and no more than %d parts"), Buff.Printf( _( " unit %d and no more than %d parts" ),
ListeCmp[ii].m_Unit, ListeCmp[ii].m_NbParts); ListeCmp[ii].m_Unit, ListeCmp[ii].m_NbParts );
msg << Buff; msg << Buff;
DisplayError(frame, msg); DisplayError( frame, msg );
error++; break; error++; break;
} }
} }
if ( error ) return error; if( error )
return error;
/* comptage des elements doubls (si tous sont annots) */ /* comptage des elements doubls (si tous sont annots) */
for( ii = 0; (ii < NbOfCmp-1) && (error < 4); ii++ ) for( ii = 0; (ii < NbOfCmp - 1) && (error < 4); ii++ )
{ {
msg.Empty(); Buff.Empty(); msg.Empty(); Buff.Empty();
if( (stricmp(ListeCmp[ii].m_TextRef,ListeCmp[ii+1].m_TextRef) != 0) || if( (stricmp( ListeCmp[ii].m_TextRef, ListeCmp[ii + 1].m_TextRef ) != 0)
( ListeCmp[ii].m_NumRef != ListeCmp[ii+1].m_NumRef ) ) || ( ListeCmp[ii].m_NumRef != ListeCmp[ii + 1].m_NumRef ) )
continue; continue;
/* Meme reference trouve */ /* Meme reference trouve */
/* Il y a erreur si meme unite */ /* Il y a erreur si meme unite */
if( ListeCmp[ii].m_Unit == ListeCmp[ii+1].m_Unit ) if( ListeCmp[ii].m_Unit == ListeCmp[ii + 1].m_Unit )
{ {
if( ListeCmp[ii].m_NumRef >= 0 )
Buff << ListeCmp[ii].m_NumRef;
else
Buff = wxT( "?" );
if( ListeCmp[ii].m_NumRef >= 0 ) Buff << ListeCmp[ii].m_NumRef; cmpref = CONV_FROM_UTF8( ListeCmp[ii].m_TextRef );
else Buff = wxT("?"); msg.Printf( _( "Multiple item %s%s" ),
cmpref.GetData(), Buff.GetData() );
cmpref = CONV_FROM_UTF8(ListeCmp[ii].m_TextRef);
msg.Printf( _("Multiple item %s%s"),
cmpref.GetData(),Buff.GetData());
if( (ListeCmp[ii].m_Unit > 0) && (ListeCmp[ii].m_Unit < 0x7FFFFFFF) ) if( (ListeCmp[ii].m_Unit > 0) && (ListeCmp[ii].m_Unit < 0x7FFFFFFF) )
{ {
Buff.Printf( _(" (unit %d)"), ListeCmp[ii].m_Unit); Buff.Printf( _( " (unit %d)" ), ListeCmp[ii].m_Unit );
msg << Buff; msg << Buff;
} }
DisplayError(frame, msg); DisplayError( frame, msg );
error++; continue; error++; continue;
} }
/* Il y a erreur si unites differentes mais nombre de parts differentes /* Il y a erreur si unites differentes mais nombre de parts differentes
par boitier (ex U3 ( 1 part) et U3B sont incompatibles) */ * par boitier (ex U3 ( 1 part) et U3B sont incompatibles) */
if( ListeCmp[ii].m_NbParts != ListeCmp[ii+1].m_NbParts ) if( ListeCmp[ii].m_NbParts != ListeCmp[ii + 1].m_NbParts )
{ {
if( ListeCmp[ii].m_NumRef >= 0 )
Buff << ListeCmp[ii].m_NumRef;
else
Buff = wxT( "?" );
if( ListeCmp[ii].m_NumRef >= 0 ) Buff << ListeCmp[ii].m_NumRef; cmpref = CONV_FROM_UTF8( ListeCmp[ii].m_TextRef );
else Buff = wxT("?"); msg.Printf( _( "Multiple item %s%s" ), cmpref.GetData(), Buff.GetData() );
cmpref = CONV_FROM_UTF8(ListeCmp[ii].m_TextRef);
msg.Printf( _("Multiple item %s%s"), cmpref.GetData(), Buff.GetData());
if( (ListeCmp[ii].m_Unit > 0) && (ListeCmp[ii].m_Unit < 0x7FFFFFFF) ) if( (ListeCmp[ii].m_Unit > 0) && (ListeCmp[ii].m_Unit < 0x7FFFFFFF) )
{ {
Buff.Printf( _(" (unit %d)"), ListeCmp[ii].m_Unit); Buff.Printf( _( " (unit %d)" ), ListeCmp[ii].m_Unit );
msg << Buff; msg << Buff;
} }
DisplayError(frame, msg); DisplayError( frame, msg );
error++; error++;
} }
/* Il y a erreur si unites differentes ET valeurs diffrentes */ /* Il y a erreur si unites differentes ET valeurs diffrentes */
if( stricmp(ListeCmp[ii].m_TextValue,ListeCmp[ii+1].m_TextValue) != 0) if( stricmp( ListeCmp[ii].m_TextValue, ListeCmp[ii + 1].m_TextValue ) != 0 )
{ {
wxString nextcmpref, cmpvalue, nextcmpvalue; wxString nextcmpref, cmpvalue, nextcmpvalue;
cmpref = CONV_FROM_UTF8(ListeCmp[ii].m_TextRef); cmpref = CONV_FROM_UTF8( ListeCmp[ii].m_TextRef );
nextcmpref = CONV_FROM_UTF8(ListeCmp[ii+1].m_TextRef); nextcmpref = CONV_FROM_UTF8( ListeCmp[ii + 1].m_TextRef );
cmpvalue = CONV_FROM_UTF8(ListeCmp[ii].m_TextValue); cmpvalue = CONV_FROM_UTF8( ListeCmp[ii].m_TextValue );
nextcmpvalue = CONV_FROM_UTF8(ListeCmp[ii+1].m_TextValue); nextcmpvalue = CONV_FROM_UTF8( ListeCmp[ii + 1].m_TextValue );
msg.Printf( _("Diff values for %s%d%c (%s) and %s%d%c (%s)"), msg.Printf( _( "Diff values for %s%d%c (%s) and %s%d%c (%s)" ),
cmpref.GetData(), ListeCmp[ii].m_NumRef, ListeCmp[ii].m_Unit+'A'-1, cmpref.GetData(), ListeCmp[ii].m_NumRef, ListeCmp[ii].m_Unit + 'A' - 1,
cmpvalue.GetData(), cmpvalue.GetData(),
nextcmpref.GetData(), ListeCmp[ii+1].m_NumRef, ListeCmp[ii+1].m_Unit+'A'-1, nextcmpref.GetData(
nextcmpvalue.GetData()); ), ListeCmp[ii + 1].m_NumRef, ListeCmp[ii + 1].m_Unit + 'A' - 1,
nextcmpvalue.GetData() );
DisplayError(frame, msg); DisplayError( frame, msg );
error++; error++;
} }
} }
MyFree(ListeCmp); MyFree( ListeCmp );
return(error); return error;
} }
eeschema/class_screen.h
View file @ 664a1f72
...@@ -90,12 +90,12 @@ class SCH_SCREEN : public BASE_SCREEN ...@@ -90,12 +90,12 @@ class SCH_SCREEN : public BASE_SCREEN
public: public:
SCH_SCREEN( int idtype, KICAD_T aType = SCREEN_STRUCT_TYPE ); SCH_SCREEN( int idtype, KICAD_T aType = SCREEN_STRUCT_TYPE );
~SCH_SCREEN(); ~SCH_SCREEN();
virtual wxString GetClass() const virtual wxString GetClass() const
{ {
return wxT("SCH_SCREEN"); return wxT("SCH_SCREEN");
} }
void FreeDrawList(); // Free EESchema drawing list (does not delete the sub hierarchies) void FreeDrawList(); // Free EESchema drawing list (does not delete the sub hierarchies)
void Place( WinEDA_DrawFrame* frame, wxDC* DC ) { }; void Place( WinEDA_DrawFrame* frame, wxDC* DC ) { };
......
eeschema/cleanup.cpp
View file @ 664a1f72
/*********************************/ /*********************************/
/* Module de nettoyage du schema */ /* Module de nettoyage du schema */
/*********************************/ /*********************************/
#include "fctsys.h" #include "fctsys.h"
#include "gr_basic.h" #include "gr_basic.h"
...@@ -15,102 +15,107 @@ ...@@ -15,102 +15,107 @@
/* Routines locales */ /* Routines locales */
static int TstAlignSegment(EDA_DrawLineStruct* RefSegm, EDA_DrawLineStruct* TstSegm); static int TstAlignSegment( EDA_DrawLineStruct* RefSegm, EDA_DrawLineStruct* TstSegm );
/* Variable locales */ /* Variable locales */
/*******************************************/ /*******************************************/
bool SCH_SCREEN::SchematicCleanUp(wxDC * DC) bool SCH_SCREEN::SchematicCleanUp( wxDC* DC )
/*******************************************/ /*******************************************/
/* Routine de nettoyage: /* Routine de nettoyage:
- regroupe les segments de fils (ou de bus) alignes en 1 seul segment * - regroupe les segments de fils (ou de bus) alignes en 1 seul segment
- Detecte les objets identiques superposes * - Detecte les objets identiques superposes
*/ */
{ {
EDA_BaseStruct *DrawList, * TstDrawList; EDA_BaseStruct* DrawList, * TstDrawList;
int flag; int flag;
bool Modify = FALSE; bool Modify = FALSE;
DrawList = EEDrawList; DrawList = EEDrawList;
for ( ;DrawList != NULL; DrawList = DrawList->Pnext ) for( ; DrawList != NULL; DrawList = DrawList->Pnext )
{ {
if( DrawList->Type() == DRAW_SEGMENT_STRUCT_TYPE ) if( DrawList->Type() == DRAW_SEGMENT_STRUCT_TYPE )
{ {
TstDrawList = DrawList->Pnext; TstDrawList = DrawList->Pnext;
while ( TstDrawList ) while( TstDrawList )
{ {
if( TstDrawList->Type() == DRAW_SEGMENT_STRUCT_TYPE ) if( TstDrawList->Type() == DRAW_SEGMENT_STRUCT_TYPE )
{ {
flag = TstAlignSegment( (EDA_DrawLineStruct*)DrawList, flag = TstAlignSegment( (EDA_DrawLineStruct*) DrawList,
(EDA_DrawLineStruct*)TstDrawList); (EDA_DrawLineStruct*) TstDrawList );
if (flag ) /* Suppression de TstSegm */ if( flag ) /* Suppression de TstSegm */
{ {
/* keep the bits set in .m_Flags, because the deleted segment can be flagged */ /* keep the bits set in .m_Flags, because the deleted segment can be flagged */
DrawList->m_Flags |= TstDrawList->m_Flags; DrawList->m_Flags |= TstDrawList->m_Flags;
EraseStruct(TstDrawList, this); EraseStruct( TstDrawList, this );
SetRefreshReq(); SetRefreshReq();
TstDrawList = EEDrawList; TstDrawList = EEDrawList;
Modify = TRUE; Modify = TRUE;
} }
else TstDrawList = TstDrawList->Pnext; else
TstDrawList = TstDrawList->Pnext;
} }
else TstDrawList = TstDrawList->Pnext; else
TstDrawList = TstDrawList->Pnext;
} }
} }
} }
EDA_Appl->SchematicFrame->TestDanglingEnds(EEDrawList, DC);
EDA_Appl->SchematicFrame->TestDanglingEnds( EEDrawList, DC );
return Modify; return Modify;
} }
/***********************************************/ /***********************************************/
void BreakSegmentOnJunction( SCH_SCREEN * Screen ) void BreakSegmentOnJunction( SCH_SCREEN* Screen )
/************************************************/ /************************************************/
/* Routine creant des debuts / fin de segment (BUS ou WIRES) sur les jonctions /* Routine creant des debuts / fin de segment (BUS ou WIRES) sur les jonctions
et les raccords * et les raccords
*/ */
{ {
EDA_BaseStruct *DrawList; EDA_BaseStruct* DrawList;
if( Screen == NULL ) if( Screen == NULL )
{ {
DisplayError(NULL, wxT("BreakSegmentOnJunction() error: NULL screen")); DisplayError( NULL, wxT( "BreakSegmentOnJunction() error: NULL screen" ) );
return; return;
} }
DrawList = Screen->EEDrawList; DrawList = Screen->EEDrawList;
while ( DrawList ) while( DrawList )
{ {
switch( DrawList->Type() ) switch( DrawList->Type() )
{ {
case DRAW_JUNCTION_STRUCT_TYPE : case DRAW_JUNCTION_STRUCT_TYPE:
#undef STRUCT #undef STRUCT
#define STRUCT ((DrawJunctionStruct*)DrawList) #define STRUCT ( (DrawJunctionStruct*) DrawList )
BreakSegment(Screen, STRUCT->m_Pos); BreakSegment( Screen, STRUCT->m_Pos );
break; break;
case DRAW_BUSENTRY_STRUCT_TYPE : case DRAW_BUSENTRY_STRUCT_TYPE:
#undef STRUCT #undef STRUCT
#define STRUCT ((DrawBusEntryStruct*)DrawList) #define STRUCT ( (DrawBusEntryStruct*) DrawList )
BreakSegment(Screen, STRUCT->m_Pos); BreakSegment( Screen, STRUCT->m_Pos );
BreakSegment(Screen, STRUCT->m_End()); BreakSegment( Screen, STRUCT->m_End() );
break; break;
case DRAW_SEGMENT_STRUCT_TYPE : case DRAW_SEGMENT_STRUCT_TYPE:
case DRAW_NOCONNECT_STRUCT_TYPE : case DRAW_NOCONNECT_STRUCT_TYPE:
case DRAW_LABEL_STRUCT_TYPE : case DRAW_LABEL_STRUCT_TYPE:
case DRAW_GLOBAL_LABEL_STRUCT_TYPE : case DRAW_GLOBAL_LABEL_STRUCT_TYPE:
case DRAW_LIB_ITEM_STRUCT_TYPE : case DRAW_LIB_ITEM_STRUCT_TYPE:
case DRAW_PICK_ITEM_STRUCT_TYPE : case DRAW_PICK_ITEM_STRUCT_TYPE:
case DRAW_POLYLINE_STRUCT_TYPE : case DRAW_POLYLINE_STRUCT_TYPE:
case DRAW_MARKER_STRUCT_TYPE : case DRAW_MARKER_STRUCT_TYPE:
case DRAW_TEXT_STRUCT_TYPE : case DRAW_TEXT_STRUCT_TYPE:
case DRAW_SHEET_STRUCT_TYPE : case DRAW_SHEET_STRUCT_TYPE:
case DRAW_SHEETLABEL_STRUCT_TYPE : case DRAW_SHEETLABEL_STRUCT_TYPE:
break; break;
default : default:
break; break;
} }
DrawList = DrawList->Pnext; DrawList = DrawList->Pnext;
...@@ -119,39 +124,44 @@ EDA_BaseStruct *DrawList; ...@@ -119,39 +124,44 @@ EDA_BaseStruct *DrawList;
/*********************************************************/ /*********************************************************/
DrawPickedStruct * BreakSegment(SCH_SCREEN * screen, DrawPickedStruct* BreakSegment( SCH_SCREEN* screen,
wxPoint breakpoint, bool PutInUndoList) wxPoint breakpoint, bool PutInUndoList )
/*********************************************************/ /*********************************************************/
/* Coupe un segment ( BUS, WIRE ) en 2 au point breakpoint, /* Coupe un segment ( BUS, WIRE ) en 2 au point breakpoint,
- si ce point est sur le segment * - si ce point est sur le segment
- extremites non comprises * - extremites non comprises
If PutInUndoList == TRUE, create a list of modifictions, for undo command * If PutInUndoList == TRUE, create a list of modifictions, for undo command
*/ */
{ {
EDA_BaseStruct *DrawList; EDA_BaseStruct* DrawList;
EDA_DrawLineStruct * segment, * NewSegment; EDA_DrawLineStruct* segment, * NewSegment;
int ox, oy, fx, fy; int ox, oy, fx, fy;
DrawPickedStruct * List = NULL; DrawPickedStruct* List = NULL;
DrawList = screen->EEDrawList; DrawList = screen->EEDrawList;
while ( DrawList ) while( DrawList )
{ {
switch( DrawList->Type() ) switch( DrawList->Type() )
{ {
case DRAW_SEGMENT_STRUCT_TYPE : case DRAW_SEGMENT_STRUCT_TYPE:
segment = (EDA_DrawLineStruct*)DrawList; segment = (EDA_DrawLineStruct*) DrawList;
ox = segment->m_Start.x; oy = segment->m_Start.y; ox = segment->m_Start.x; oy = segment->m_Start.y;
fx = segment->m_End.x; fy = segment->m_End.y; fx = segment->m_End.x; fy = segment->m_End.y;
if( distance( fx - ox, fy - oy, breakpoint.x - ox, breakpoint.y - oy, 0 ) == 0 ) if( distance( fx - ox, fy - oy, breakpoint.x - ox, breakpoint.y - oy, 0 ) == 0 )
break; break;
/* Segment connecte: doit etre coupe en 2 si px,py n'est /* Segment connecte: doit etre coupe en 2 si px,py n'est
pas une extremite */ * pas une extremite */
if( (ox == breakpoint.x) && (oy == breakpoint.y ) ) break; if( (ox == breakpoint.x) && (oy == breakpoint.y ) )
if( (fx == breakpoint.x) && (fy == breakpoint.y ) ) break; break;
if( (fx == breakpoint.x) && (fy == breakpoint.y ) )
break;
/* Ici il faut couper le segment en 2 */ /* Ici il faut couper le segment en 2 */
if ( PutInUndoList ) // First: put copy of the old segment in undo list if( PutInUndoList ) // First: put copy of the old segment in undo list
{ {
DrawPickedStruct * wrapper = new DrawPickedStruct(); DrawPickedStruct* wrapper = new DrawPickedStruct();
wrapper->m_Flags = IS_CHANGED; wrapper->m_Flags = IS_CHANGED;
wrapper->m_PickedStruct = segment->GenCopy(); wrapper->m_PickedStruct = segment->GenCopy();
wrapper->m_Image = segment; wrapper->m_Image = segment;
...@@ -165,9 +175,10 @@ DrawPickedStruct * List = NULL; ...@@ -165,9 +175,10 @@ DrawPickedStruct * List = NULL;
NewSegment->Pnext = segment->Pnext; NewSegment->Pnext = segment->Pnext;
segment->Pnext = NewSegment; segment->Pnext = NewSegment;
DrawList = NewSegment; DrawList = NewSegment;
if ( PutInUndoList ) if( PutInUndoList )
{ {
DrawPickedStruct * wrapper = new DrawPickedStruct(); DrawPickedStruct* wrapper = new DrawPickedStruct();
wrapper->m_Flags = IS_NEW; wrapper->m_Flags = IS_NEW;
wrapper->m_Image = NewSegment; wrapper->m_Image = NewSegment;
wrapper->Pnext = List; wrapper->Pnext = List;
...@@ -175,14 +186,15 @@ DrawPickedStruct * List = NULL; ...@@ -175,14 +186,15 @@ DrawPickedStruct * List = NULL;
} }
break; break;
case DRAW_JUNCTION_STRUCT_TYPE : case DRAW_JUNCTION_STRUCT_TYPE:
case DRAW_BUSENTRY_STRUCT_TYPE : case DRAW_BUSENTRY_STRUCT_TYPE:
case DRAW_POLYLINE_STRUCT_TYPE : case DRAW_POLYLINE_STRUCT_TYPE:
break; break;
default : default:
break; break;
} }
DrawList = DrawList->Pnext; DrawList = DrawList->Pnext;
} }
...@@ -190,68 +202,67 @@ DrawPickedStruct * List = NULL; ...@@ -190,68 +202,67 @@ DrawPickedStruct * List = NULL;
} }
/***********************************************************/ /***********************************************************/
static int TstAlignSegment( EDA_DrawLineStruct* RefSegm, static int TstAlignSegment( EDA_DrawLineStruct* RefSegm,
EDA_DrawLineStruct* TstSegm) EDA_DrawLineStruct* TstSegm )
/***********************************************************/ /***********************************************************/
/* Search if the 2 segments RefSegm and TstSegm are on a line. /* Search if the 2 segments RefSegm and TstSegm are on a line.
Retourn 0 if no * Retourn 0 if no
1 if yes, and RefSegm is modified to be the equivalent segment * 1 if yes, and RefSegm is modified to be the equivalent segment
*/ */
{ {
if( RefSegm == TstSegm ) return(0); if( RefSegm == TstSegm )
if( RefSegm->m_Layer != TstSegm->m_Layer ) return(0); return 0;
if( RefSegm->m_Layer != TstSegm->m_Layer )
return 0;
// search for a common end, and modify coordinates to ensure RefSegm->m_End == TstSegm->m_Start // search for a common end, and modify coordinates to ensure RefSegm->m_End == TstSegm->m_Start
if ( RefSegm->m_Start == TstSegm->m_Start ) if( RefSegm->m_Start == TstSegm->m_Start )
{ {
if ( RefSegm->m_End == TstSegm->m_End ) // trivial case: RefSegm and TstSegm are identical if( RefSegm->m_End == TstSegm->m_End ) // trivial case: RefSegm and TstSegm are identical
return 1; return 1;
EXCHG(RefSegm->m_Start, RefSegm->m_End); // at this point, RefSegm->m_End == TstSegm->m_Start EXCHG( RefSegm->m_Start, RefSegm->m_End ); // at this point, RefSegm->m_End == TstSegm->m_Start
} }
else if ( RefSegm->m_Start == TstSegm->m_End ) else if( RefSegm->m_Start == TstSegm->m_End )
{ {
EXCHG(RefSegm->m_Start, RefSegm->m_End); EXCHG( RefSegm->m_Start, RefSegm->m_End );
EXCHG(TstSegm->m_Start, TstSegm->m_End); // at this point, RefSegm->m_End == TstSegm->m_Start EXCHG( TstSegm->m_Start, TstSegm->m_End ); // at this point, RefSegm->m_End == TstSegm->m_Start
} }
else if ( RefSegm->m_End == TstSegm->m_End ) else if( RefSegm->m_End == TstSegm->m_End )
{ {
EXCHG(TstSegm->m_Start, TstSegm->m_End); // at this point, RefSegm->m_End == TstSegm->m_Start EXCHG( TstSegm->m_Start, TstSegm->m_End ); // at this point, RefSegm->m_End == TstSegm->m_Start
} }
else if ( RefSegm->m_End != TstSegm->m_Start ) // No common end point, segments cannot be merged else if( RefSegm->m_End != TstSegm->m_Start ) // No common end point, segments cannot be merged
return 0; return 0;
/* Test alignment: */ /* Test alignment: */
if ( RefSegm->m_Start.y == RefSegm->m_End.y ) // Horizontal segment if( RefSegm->m_Start.y == RefSegm->m_End.y ) // Horizontal segment
{ {
if ( TstSegm->m_Start.y == TstSegm->m_End.y ) if( TstSegm->m_Start.y == TstSegm->m_End.y )
{ {
RefSegm->m_End = TstSegm->m_End; RefSegm->m_End = TstSegm->m_End;
return 1; return 1;
} }
} }
else if( RefSegm->m_Start.x == RefSegm->m_End.x ) // Vertical segment
else if ( RefSegm->m_Start.x == RefSegm->m_End.x ) // Vertical segment
{ {
if ( TstSegm->m_Start.x == TstSegm->m_End.x ) if( TstSegm->m_Start.x == TstSegm->m_End.x )
{ {
RefSegm->m_End = TstSegm->m_End; RefSegm->m_End = TstSegm->m_End;
return 1; return 1;
} }
} }
else else
{ {
if (atan2(RefSegm->m_Start.x - RefSegm->m_End.x, RefSegm->m_Start.y - RefSegm->m_End.y) == if( atan2( RefSegm->m_Start.x - RefSegm->m_End.x, RefSegm->m_Start.y -
atan2(TstSegm->m_Start.x - TstSegm->m_End.x, TstSegm->m_Start.y - TstSegm->m_End.y) ) RefSegm->m_End.y ) ==
atan2( TstSegm->m_Start.x - TstSegm->m_End.x, TstSegm->m_Start.y - TstSegm->m_End.y ) )
{ {
RefSegm->m_End = TstSegm->m_End; RefSegm->m_End = TstSegm->m_End;
return 1; return 1;
} }
} }
return(0); return 0;
} }
eeschema/cmpclass.cpp
View file @ 664a1f72
...@@ -143,6 +143,23 @@ wxString DrawMarkerStruct::GetComment() ...@@ -143,6 +143,23 @@ wxString DrawMarkerStruct::GetComment()
} }
#if defined(DEBUG)
/**
* Function Show
* is used to output the object tree, currently for debugging only.
* @param nestLevel An aid to prettier tree indenting, and is the level
* of nesting of this object within the overall tree.
* @param os The ostream& to output to.
*/
void DrawMarkerStruct::Show( int nestLevel, std::ostream& os )
{
// for now, make it look like XML:
NestedSpace( nestLevel, os ) << '<' << GetClass().Lower().mb_str() << m_Pos
<< "/>\n";
}
#endif
/***************************/ /***************************/
/* Class EDA_DrawLineStruct */ /* Class EDA_DrawLineStruct */
/***************************/ /***************************/
...@@ -201,6 +218,28 @@ bool EDA_DrawLineStruct::IsOneEndPointAt( const wxPoint& pos ) ...@@ -201,6 +218,28 @@ bool EDA_DrawLineStruct::IsOneEndPointAt( const wxPoint& pos )
} }
#if defined(DEBUG)
/**
* Function Show
* is used to output the object tree, currently for debugging only.
* @param nestLevel An aid to prettier tree indenting, and is the level
* of nesting of this object within the overall tree.
* @param os The ostream& to output to.
*/
void EDA_DrawLineStruct::Show( int nestLevel, std::ostream& os )
{
NestedSpace( nestLevel, os ) << '<' << GetClass().Lower().mb_str() <<
" layer=\"" << m_Layer << '"' <<
" width=\"" << m_Width << '"' <<
" startIsDangling=\"" << m_StartIsDangling << '"' <<
" endIsDangling=\"" << m_EndIsDangling << '"' << ">" <<
" <start" << m_Start << "/>" <<
" <end" << m_End << "/>" <<
"</" << GetClass().Lower().mb_str() << ">\n";
}
#endif
/****************************/ /****************************/
/* Class DrawPolylineStruct */ /* Class DrawPolylineStruct */
/****************************/ /****************************/
......
eeschema/component_class.cpp
View file @ 664a1f72
...@@ -17,74 +17,102 @@ ...@@ -17,74 +17,102 @@
#include "macros.h" #include "macros.h"
/***************************/ /***************************/
/* class DrawPartStruct */ /* class DrawPartStruct */
/* class EDA_SchComponentStruct */ /* class EDA_SchComponentStruct */
/***************************/ /***************************/
/***********************************************************************************/ /***********************************************************************************/
DrawPartStruct::DrawPartStruct( KICAD_T struct_type, const wxPoint & pos): DrawPartStruct::DrawPartStruct( KICAD_T struct_type, const wxPoint& pos ) :
EDA_BaseStruct(struct_type) EDA_BaseStruct( struct_type )
/***********************************************************************************/ /***********************************************************************************/
{ {
m_Layer = 0;
m_Pos = pos; m_Pos = pos;
m_TimeStamp = 0; m_TimeStamp = 0;
} }
/************************************/ /************************************/
DrawPartStruct::~DrawPartStruct() DrawPartStruct::~DrawPartStruct()
/************************************/ /************************************/
{ {
} }
/****************************************************************/ /****************************************************************/
wxString ReturnDefaultFieldName(int FieldNumber) const wxString& ReturnDefaultFieldName( int aFieldNdx )
/****************************************************************/ /****************************************************************/
/* Return the defult ield name from its number (REFERENCE, VALUE ..)
FieldDefaultNameList is not static, because we want the text translation /* Return the default field name from its index (REFERENCE, VALUE ..)
for I18n * FieldDefaultNameList is not static, because we want the text translation
*/ * for I18n
*/
{ {
wxString FieldDefaultNameList[] = { // avoid unnecessarily copying wxStrings.
_("Ref"), /* Reference of part, i.e. "IC21" */ static const wxString FieldDefaultNameList[] = {
_("Value"), /* Value of part, i.e. "3.3K" */ _( "Ref" ), /* Reference of part, i.e. "IC21" */
_("Footprint"), /* Footprint, used by cvpcb or pcbnew, i.e. "16DIP300" */ _( "Value" ), /* Value of part, i.e. "3.3K" */
_("Sheet"), /* for components which are a schematic file, schematic file name, i.e. "cnt16.sch" */ _( "Footprint" ), /* Footprint, used by cvpcb or pcbnew, i.e. "16DIP300" */
_("Field") /* User fields (1 to n) have an editable name*/ _( "Sheet" ), /* for components which are a schematic file, schematic file name, i.e. "cnt16.sch" */
_( "Field1" ), /* User fields (1 to n) have an editable name*/
_( "Field2" ),
_( "Field3" ),
_( "Field4" ),
_( "Field5" ),
_( "Field6" ),
_( "Field7" ),
_( "Field8" ),
wxT( "badFieldNdx!" ) // error, and "sentinel" value
}; };
int ii = FieldNumber;
if ( ii > FIELD1 ) ii = FIELD1;
wxString FieldName = FieldDefaultNameList[ii];
if (FieldNumber >= FIELD1 ) FieldName << (FieldNumber - FIELD1 + 1); if( (unsigned) aFieldNdx > FIELD8 ) // catches < 0 also
return FieldName; aFieldNdx = FIELD8+1; // return the sentinel text
return FieldDefaultNameList[aFieldNdx];
} }
/****************************************************************/ /****************************************************************/
wxString EDA_SchComponentStruct::ReturnFieldName(int FieldNumber) const wxString& EDA_SchComponentStruct::ReturnFieldName( int aFieldNdx ) const
/****************************************************************/ /****************************************************************/
/* Return the Field name from its number (REFERENCE, VALUE ..)
*/ /* Return the Field name from its index (REFERENCE, VALUE ..)
*/
{
// avoid unnecessarily copying wxStrings.
if( aFieldNdx < FIELD1 || m_Field[aFieldNdx].m_Name.IsEmpty() )
return ReturnDefaultFieldName( aFieldNdx );
return m_Field[aFieldNdx].m_Name;
}
const wxString& EDA_SchComponentStruct::GetFieldValue( int aFieldNdx ) const
{ {
wxString FieldName = m_Field[FieldNumber].m_Name; // avoid unnecessarily copying wxStrings.
static const wxString myEmpty = wxEmptyString;
if( (unsigned) aFieldNdx > FIELD8 || m_Field[aFieldNdx].m_Text.IsEmpty() )
return myEmpty;
if ( (FieldNumber < FIELD1) || FieldName.IsEmpty() ) return m_Field[aFieldNdx].m_Text;
FieldName = ReturnDefaultFieldName(FieldNumber);
return FieldName;
} }
/*******************************************************************/ /*******************************************************************/
EDA_SchComponentStruct::EDA_SchComponentStruct(const wxPoint & pos): EDA_SchComponentStruct::EDA_SchComponentStruct( const wxPoint& pos ) :
DrawPartStruct(DRAW_LIB_ITEM_STRUCT_TYPE, pos) DrawPartStruct( DRAW_LIB_ITEM_STRUCT_TYPE, pos )
/*******************************************************************/ /*******************************************************************/
{ {
int ii; int ii;
m_Multi = 0; /* In multi unit chip - which unit to draw. */ m_Multi = 0; /* In multi unit chip - which unit to draw. */
m_RefIdNumber = 0; m_RefIdNumber = 0;
m_FlagControlMulti = 0; m_FlagControlMulti = 0;
m_Convert = 0; /* Gestion des mutiples representations (conversion De Morgan) */ m_Convert = 0; /* Gestion des mutiples representations (conversion De Morgan) */
/* The rotation/mirror transformation matrix. pos normal*/ /* The rotation/mirror transformation matrix. pos normal*/
m_Transform[0][0] = 1; m_Transform[0][0] = 1;
m_Transform[0][1] = 0; m_Transform[0][1] = 0;
...@@ -92,7 +120,7 @@ int ii; ...@@ -92,7 +120,7 @@ int ii;
m_Transform[1][1] = -1; m_Transform[1][1] = -1;
/* initialisation des Fields */ /* initialisation des Fields */
for(ii = 0; ii < NUMBER_OF_FIELDS; ii++) for( ii = 0; ii < NUMBER_OF_FIELDS; ii++ )
{ {
m_Field[ii].m_Pos = m_Pos; m_Field[ii].m_Pos = m_Pos;
m_Field[ii].m_Layer = LAYER_FIELDS; m_Field[ii].m_Layer = LAYER_FIELDS;
...@@ -104,7 +132,6 @@ int ii; ...@@ -104,7 +132,6 @@ int ii;
m_Field[REFERENCE].m_Layer = LAYER_REFERENCEPART; m_Field[REFERENCE].m_Layer = LAYER_REFERENCEPART;
m_PinIsDangling = NULL; m_PinIsDangling = NULL;
} }
...@@ -112,19 +139,21 @@ int ii; ...@@ -112,19 +139,21 @@ int ii;
EDA_Rect EDA_SchComponentStruct::GetBoundaryBox() EDA_Rect EDA_SchComponentStruct::GetBoundaryBox()
/**********************************************************************/ /**********************************************************************/
{ {
EDA_LibComponentStruct * Entry = FindLibPart(m_ChipName.GetData(), wxEmptyString, FIND_ROOT); EDA_LibComponentStruct* Entry = FindLibPart( m_ChipName.GetData(), wxEmptyString, FIND_ROOT );
EDA_Rect BoundaryBox; EDA_Rect BoundaryBox;
int x0, xm, y0, ym; int x0, xm, y0, ym;
/* Get the basic Boundary box */ /* Get the basic Boundary box */
if ( Entry ) if( Entry )
{ {
BoundaryBox = Entry->GetBoundaryBox( m_Multi, m_Convert); BoundaryBox = Entry->GetBoundaryBox( m_Multi, m_Convert );
x0 = BoundaryBox.GetX(); xm = BoundaryBox.GetRight(); x0 = BoundaryBox.GetX(); xm = BoundaryBox.GetRight();
// We must reverse Y values, because matrix orientation // We must reverse Y values, because matrix orientation
// suppose Y axis normal for the library items coordinates, // suppose Y axis normal for the library items coordinates,
// m_Transform reverse Y values, but BoundaryBox ais already reversed! // m_Transform reverse Y values, but BoundaryBox ais already reversed!
y0 = - BoundaryBox.GetY(); y0 = -BoundaryBox.GetY();
ym = - BoundaryBox.GetBottom(); ym = -BoundaryBox.GetBottom();
} }
else /* if lib Entry not found, give a reasonable size */ else /* if lib Entry not found, give a reasonable size */
{ {
...@@ -142,110 +171,123 @@ int x0, xm, y0, ym; ...@@ -142,110 +171,123 @@ int x0, xm, y0, ym;
int y2 = m_Transform[1][0] * xm + m_Transform[1][1] * ym; int y2 = m_Transform[1][0] * xm + m_Transform[1][1] * ym;
// H and W must be > 0 for wxRect: // H and W must be > 0 for wxRect:
if ( x2 < x1 ) EXCHG( x2, x1 ); if( x2 < x1 )
if ( y2 < y1 ) EXCHG( y2, y1 ); EXCHG( x2, x1 );
BoundaryBox.SetX(x1); BoundaryBox.SetY(y1); if( y2 < y1 )
BoundaryBox.SetWidth(x2-x1); EXCHG( y2, y1 );
BoundaryBox.SetHeight(y2-y1);
BoundaryBox.SetX( x1 ); BoundaryBox.SetY( y1 );
BoundaryBox.SetWidth( x2 - x1 );
BoundaryBox.SetHeight( y2 - y1 );
BoundaryBox.Offset(m_Pos); BoundaryBox.Offset( m_Pos );
return BoundaryBox; return BoundaryBox;
} }
/**************************************************************************/ /**************************************************************************/
void PartTextStruct::SwapData(PartTextStruct * copyitem) void PartTextStruct::SwapData( PartTextStruct* copyitem )
/**************************************************************************/ /**************************************************************************/
/* Used if undo / redo command: /* Used if undo / redo command:
swap data between this and copyitem * swap data between this and copyitem
*/ */
{ {
EXCHG(m_Text, copyitem->m_Text); EXCHG( m_Text, copyitem->m_Text );
EXCHG(m_Layer, copyitem->m_Layer); EXCHG( m_Layer, copyitem->m_Layer );
EXCHG(m_Pos, copyitem->m_Pos); EXCHG( m_Pos, copyitem->m_Pos );
EXCHG(m_Size, copyitem->m_Size); EXCHG( m_Size, copyitem->m_Size );
EXCHG(m_Width, copyitem->m_Width); EXCHG( m_Width, copyitem->m_Width );
EXCHG(m_Orient, copyitem->m_Orient); EXCHG( m_Orient, copyitem->m_Orient );
EXCHG(m_Miroir, copyitem->m_Miroir); EXCHG( m_Miroir, copyitem->m_Miroir );
EXCHG(m_Attributs, copyitem->m_Attributs); EXCHG( m_Attributs, copyitem->m_Attributs );
EXCHG(m_CharType, copyitem->m_CharType); EXCHG( m_CharType, copyitem->m_CharType );
EXCHG(m_HJustify, copyitem->m_HJustify); EXCHG( m_HJustify, copyitem->m_HJustify );
EXCHG(m_VJustify, copyitem->m_VJustify); EXCHG( m_VJustify, copyitem->m_VJustify );
EXCHG(m_ZoomLevelDrawable, copyitem->m_ZoomLevelDrawable); EXCHG( m_ZoomLevelDrawable, copyitem->m_ZoomLevelDrawable );
EXCHG(m_TextDrawings, copyitem->m_TextDrawings); EXCHG( m_TextDrawings, copyitem->m_TextDrawings );
EXCHG(m_TextDrawingsSize, copyitem->m_TextDrawingsSize); EXCHG( m_TextDrawingsSize, copyitem->m_TextDrawingsSize );
} }
/**************************************************************************/ /**************************************************************************/
void EDA_SchComponentStruct::SwapData(EDA_SchComponentStruct * copyitem) void EDA_SchComponentStruct::SwapData( EDA_SchComponentStruct* copyitem )
/**************************************************************************/ /**************************************************************************/
/* Used if undo / redo command: /* Used if undo / redo command:
swap data between this and copyitem * swap data between this and copyitem
*/ */
{ {
EXCHG(m_Pos, copyitem->m_Pos); EXCHG( m_Pos, copyitem->m_Pos );
EXCHG(m_Multi, copyitem->m_Multi); EXCHG( m_Multi, copyitem->m_Multi );
EXCHG(m_Convert, copyitem->m_Convert); EXCHG( m_Convert, copyitem->m_Convert );
EXCHG(m_Transform[0][0], copyitem->m_Transform[0][0]); EXCHG( m_Transform[0][0], copyitem->m_Transform[0][0] );
EXCHG(m_Transform[0][1], copyitem->m_Transform[0][1]); EXCHG( m_Transform[0][1], copyitem->m_Transform[0][1] );
EXCHG(m_Transform[1][0], copyitem->m_Transform[1][0]); EXCHG( m_Transform[1][0], copyitem->m_Transform[1][0] );
EXCHG(m_Transform[1][1], copyitem->m_Transform[1][1]); EXCHG( m_Transform[1][1], copyitem->m_Transform[1][1] );
for ( int ii = 0; ii < NUMBER_OF_FIELDS; ii++ ) for( int ii = 0; ii < NUMBER_OF_FIELDS; ii++ )
{ {
m_Field[ii].SwapData(&copyitem->m_Field[ii]); m_Field[ii].SwapData( &copyitem->m_Field[ii] );
} }
} }
/***********************************************************************/ /***********************************************************************/
void EDA_SchComponentStruct::Place(WinEDA_DrawFrame * frame, wxDC * DC) void EDA_SchComponentStruct::Place( WinEDA_DrawFrame* frame, wxDC* DC )
/***********************************************************************/ /***********************************************************************/
{ {
/* save old text in undo list */ /* save old text in undo list */
if ( g_ItemToUndoCopy && if( g_ItemToUndoCopy
(g_ItemToUndoCopy->Type() == Type()) && && ( g_ItemToUndoCopy->Type() == Type() )
((m_Flags & IS_NEW) == 0) ) && ( (m_Flags & IS_NEW) == 0 ) )
{ {
/* restore old values and save new ones */ /* restore old values and save new ones */
SwapData( (EDA_SchComponentStruct*) g_ItemToUndoCopy); SwapData( (EDA_SchComponentStruct*) g_ItemToUndoCopy );
/* save in undo list */ /* save in undo list */
((WinEDA_SchematicFrame*)frame)->SaveCopyInUndoList(this, IS_CHANGED); ( (WinEDA_SchematicFrame*) frame )->SaveCopyInUndoList( this, IS_CHANGED );
/* restore new values */ /* restore new values */
SwapData( (EDA_SchComponentStruct*) g_ItemToUndoCopy); SwapData( (EDA_SchComponentStruct*) g_ItemToUndoCopy );
delete g_ItemToUndoCopy; delete g_ItemToUndoCopy;
g_ItemToUndoCopy = NULL; g_ItemToUndoCopy = NULL;
} }
EDA_BaseStruct::Place(frame, DC); EDA_BaseStruct::Place( frame, DC );
} }
/***************************************************/ /***************************************************/
void EDA_SchComponentStruct::ClearAnnotation() void EDA_SchComponentStruct::ClearAnnotation()
/***************************************************/ /***************************************************/
/* Suppress annotation ( i.i IC23 changed to IC? and part reset to 1) /* Suppress annotation ( i.i IC23 changed to IC? and part reset to 1)
*/ */
{ {
m_RefIdNumber = 0; m_RefIdNumber = 0;
while ( isdigit(m_Field[REFERENCE].m_Text.Last() ) ) while( isdigit( m_Field[REFERENCE].m_Text.Last() ) )
m_Field[REFERENCE].m_Text.RemoveLast(); m_Field[REFERENCE].m_Text.RemoveLast();
if ( m_Field[REFERENCE].m_Text.Last() != '?' )
m_Field[REFERENCE].m_Text.Append('?');
EDA_LibComponentStruct *Entry; if( m_Field[REFERENCE].m_Text.Last() != '?' )
Entry = FindLibPart(m_ChipName.GetData(),wxEmptyString,FIND_ROOT); m_Field[REFERENCE].m_Text.Append( '?' );
if ( !Entry || ! Entry->m_UnitSelectionLocked ) EDA_LibComponentStruct* Entry;
Entry = FindLibPart( m_ChipName.GetData(), wxEmptyString, FIND_ROOT );
if( !Entry || !Entry->m_UnitSelectionLocked )
m_Multi = 1; m_Multi = 1;
} }
/**************************************************************/ /**************************************************************/
EDA_SchComponentStruct * EDA_SchComponentStruct::GenCopy() EDA_SchComponentStruct* EDA_SchComponentStruct::GenCopy()
/**************************************************************/ /**************************************************************/
{ {
EDA_SchComponentStruct * new_item = new EDA_SchComponentStruct( m_Pos ); EDA_SchComponentStruct* new_item = new EDA_SchComponentStruct( m_Pos );
int ii;
int ii;
new_item->m_Multi = m_Multi; new_item->m_Multi = m_Multi;
new_item->m_ChipName = m_ChipName; new_item->m_ChipName = m_ChipName;
...@@ -259,9 +301,9 @@ int ii; ...@@ -259,9 +301,9 @@ int ii;
/* initialisation des Fields */ /* initialisation des Fields */
for(ii = 0; ii < NUMBER_OF_FIELDS; ii++) for( ii = 0; ii < NUMBER_OF_FIELDS; ii++ )
{ {
m_Field[ii].PartTextCopy(& new_item->m_Field[ii]); m_Field[ii].PartTextCopy( &new_item->m_Field[ii] );
} }
return new_item; return new_item;
...@@ -271,15 +313,16 @@ int ii; ...@@ -271,15 +313,16 @@ int ii;
/*****************************************************************/ /*****************************************************************/
void EDA_SchComponentStruct::SetRotationMiroir( int type_rotate ) void EDA_SchComponentStruct::SetRotationMiroir( int type_rotate )
/******************************************************************/ /******************************************************************/
/* Compute the new matrix transform for a schematic component /* Compute the new matrix transform for a schematic component
in order to have the requested transform (type_rotate = rot, mirror..) * in order to have the requested transform (type_rotate = rot, mirror..)
which is applied to the initial transform. * which is applied to the initial transform.
*/ */
{ {
int TempMat[2][2]; int TempMat[2][2];
bool Transform = FALSE; bool Transform = FALSE;
switch (type_rotate) switch( type_rotate )
{ {
case CMP_ORIENT_0: case CMP_ORIENT_0:
case CMP_NORMAL: /* Position Initiale */ case CMP_NORMAL: /* Position Initiale */
...@@ -332,61 +375,61 @@ bool Transform = FALSE; ...@@ -332,61 +375,61 @@ bool Transform = FALSE;
SetRotationMiroir( CMP_ROTATE_CLOCKWISE ); SetRotationMiroir( CMP_ROTATE_CLOCKWISE );
break; break;
case (CMP_ORIENT_0+CMP_MIROIR_X): case (CMP_ORIENT_0 + CMP_MIROIR_X):
SetRotationMiroir( CMP_ORIENT_0 ); SetRotationMiroir( CMP_ORIENT_0 );
SetRotationMiroir( CMP_MIROIR_X ); SetRotationMiroir( CMP_MIROIR_X );
break; break;
case (CMP_ORIENT_0+CMP_MIROIR_Y): case (CMP_ORIENT_0 + CMP_MIROIR_Y):
SetRotationMiroir( CMP_ORIENT_0 ); SetRotationMiroir( CMP_ORIENT_0 );
SetRotationMiroir( CMP_MIROIR_Y ); SetRotationMiroir( CMP_MIROIR_Y );
break; break;
case (CMP_ORIENT_90+CMP_MIROIR_X): case (CMP_ORIENT_90 + CMP_MIROIR_X):
SetRotationMiroir( CMP_ORIENT_90 ); SetRotationMiroir( CMP_ORIENT_90 );
SetRotationMiroir( CMP_MIROIR_X ); SetRotationMiroir( CMP_MIROIR_X );
break; break;
case (CMP_ORIENT_90+CMP_MIROIR_Y): case (CMP_ORIENT_90 + CMP_MIROIR_Y):
SetRotationMiroir( CMP_ORIENT_90 ); SetRotationMiroir( CMP_ORIENT_90 );
SetRotationMiroir( CMP_MIROIR_Y ); SetRotationMiroir( CMP_MIROIR_Y );
break; break;
case (CMP_ORIENT_180+CMP_MIROIR_X): case (CMP_ORIENT_180 + CMP_MIROIR_X):
SetRotationMiroir( CMP_ORIENT_180 ); SetRotationMiroir( CMP_ORIENT_180 );
SetRotationMiroir( CMP_MIROIR_X ); SetRotationMiroir( CMP_MIROIR_X );
break; break;
case (CMP_ORIENT_180+CMP_MIROIR_Y): case (CMP_ORIENT_180 + CMP_MIROIR_Y):
SetRotationMiroir( CMP_ORIENT_180 ); SetRotationMiroir( CMP_ORIENT_180 );
SetRotationMiroir( CMP_MIROIR_Y ); SetRotationMiroir( CMP_MIROIR_Y );
break; break;
case (CMP_ORIENT_270+CMP_MIROIR_X): case (CMP_ORIENT_270 + CMP_MIROIR_X):
SetRotationMiroir( CMP_ORIENT_270 ); SetRotationMiroir( CMP_ORIENT_270 );
SetRotationMiroir( CMP_MIROIR_X ); SetRotationMiroir( CMP_MIROIR_X );
break; break;
case (CMP_ORIENT_270+CMP_MIROIR_Y): case (CMP_ORIENT_270 + CMP_MIROIR_Y):
SetRotationMiroir( CMP_ORIENT_270 ); SetRotationMiroir( CMP_ORIENT_270 );
SetRotationMiroir( CMP_MIROIR_Y ); SetRotationMiroir( CMP_MIROIR_Y );
break; break;
default: default:
Transform = FALSE; Transform = FALSE;
DisplayError(NULL, wxT("SetRotateMiroir() error: ill value") ); DisplayError( NULL, wxT( "SetRotateMiroir() error: ill value" ) );
break; break;
} }
if ( Transform ) if( Transform )
{/* The new matrix transform is the old matrix transform modified by the {/* The new matrix transform is the old matrix transform modified by the
requested transformation, which is the TempMat transform (rot, mirror ..) * requested transformation, which is the TempMat transform (rot, mirror ..)
in order to have (in term of matrix transform): * in order to have (in term of matrix transform):
transform coord = new_m_Transform * coord * transform coord = new_m_Transform * coord
where transform coord is the coord modified by new_m_Transform from the initial * where transform coord is the coord modified by new_m_Transform from the initial
value coord. * value coord.
new_m_Transform is computed (from old_m_Transform and TempMat) to have: * new_m_Transform is computed (from old_m_Transform and TempMat) to have:
transform coord = old_m_Transform * coord * TempMat * transform coord = old_m_Transform * coord * TempMat
*/ */
int NewMatrix[2][2]; int NewMatrix[2][2];
...@@ -414,59 +457,59 @@ bool Transform = FALSE; ...@@ -414,59 +457,59 @@ bool Transform = FALSE;
int EDA_SchComponentStruct::GetRotationMiroir() int EDA_SchComponentStruct::GetRotationMiroir()
/****************************************************/ /****************************************************/
{ {
int type_rotate = CMP_ORIENT_0; int type_rotate = CMP_ORIENT_0;
int TempMat[2][2], MatNormal[2][2]; int TempMat[2][2], MatNormal[2][2];
int ii; int ii;
bool found = FALSE; bool found = FALSE;
memcpy(TempMat, m_Transform, sizeof(TempMat)); memcpy( TempMat, m_Transform, sizeof(TempMat) );
SetRotationMiroir(CMP_ORIENT_0); SetRotationMiroir( CMP_ORIENT_0 );
memcpy(MatNormal, m_Transform, sizeof(MatNormal)); memcpy( MatNormal, m_Transform, sizeof(MatNormal) );
for ( ii = 0; ii < 4; ii++ ) for( ii = 0; ii < 4; ii++ )
{ {
if ( memcmp(TempMat, m_Transform, sizeof(MatNormal)) == 0) if( memcmp( TempMat, m_Transform, sizeof(MatNormal) ) == 0 )
{ {
found = TRUE; break; found = TRUE; break;
} }
SetRotationMiroir(CMP_ROTATE_COUNTERCLOCKWISE); SetRotationMiroir( CMP_ROTATE_COUNTERCLOCKWISE );
} }
if ( ! found ) if( !found )
{ {
type_rotate = CMP_MIROIR_X + CMP_ORIENT_0; type_rotate = CMP_MIROIR_X + CMP_ORIENT_0;
SetRotationMiroir(CMP_NORMAL); SetRotationMiroir( CMP_NORMAL );
SetRotationMiroir(CMP_MIROIR_X); SetRotationMiroir( CMP_MIROIR_X );
for ( ii = 0; ii < 4; ii++ ) for( ii = 0; ii < 4; ii++ )
{ {
if ( memcmp(TempMat, m_Transform, sizeof(MatNormal)) == 0) if( memcmp( TempMat, m_Transform, sizeof(MatNormal) ) == 0 )
{ {
found = TRUE; break; found = TRUE; break;
} }
SetRotationMiroir(CMP_ROTATE_COUNTERCLOCKWISE); SetRotationMiroir( CMP_ROTATE_COUNTERCLOCKWISE );
} }
} }
if ( ! found ) if( !found )
{ {
type_rotate = CMP_MIROIR_Y + CMP_ORIENT_0; type_rotate = CMP_MIROIR_Y + CMP_ORIENT_0;
SetRotationMiroir(CMP_NORMAL); SetRotationMiroir( CMP_NORMAL );
SetRotationMiroir(CMP_MIROIR_Y); SetRotationMiroir( CMP_MIROIR_Y );
for ( ii = 0; ii < 4; ii++ ) for( ii = 0; ii < 4; ii++ )
{ {
if ( memcmp(TempMat, m_Transform, sizeof(MatNormal)) == 0) if( memcmp( TempMat, m_Transform, sizeof(MatNormal) ) == 0 )
{ {
found = TRUE; break; found = TRUE; break;
} }
SetRotationMiroir(CMP_ROTATE_COUNTERCLOCKWISE); SetRotationMiroir( CMP_ROTATE_COUNTERCLOCKWISE );
} }
} }
memcpy(m_Transform, TempMat, sizeof(m_Transform)); memcpy( m_Transform, TempMat, sizeof(m_Transform) );
if ( found ) if( found )
{ {
return (type_rotate + ii); return type_rotate + ii;
} }
else else
{ {
...@@ -474,43 +517,87 @@ bool found = FALSE; ...@@ -474,43 +517,87 @@ bool found = FALSE;
} }
} }
/***********************************************************************/ /***********************************************************************/
wxPoint EDA_SchComponentStruct::GetScreenCoord(const wxPoint & coord) wxPoint EDA_SchComponentStruct::GetScreenCoord( const wxPoint& coord )
/***********************************************************************/ /***********************************************************************/
/* Renvoie la coordonne du point coord, en fonction de l'orientation /* Renvoie la coordonne du point coord, en fonction de l'orientation
du composant (rotation, miroir). * du composant (rotation, miroir).
Les coord sont toujours relatives l'ancre (coord 0,0) du composant * Les coord sont toujours relatives l'ancre (coord 0,0) du composant
*/ */
{ {
wxPoint screenpos; wxPoint screenpos;
screenpos.x = m_Transform[0][0] * coord.x + m_Transform[0][1] * coord.y; screenpos.x = m_Transform[0][0] * coord.x + m_Transform[0][1] * coord.y;
screenpos.y = m_Transform[1][0] * coord.x + m_Transform[1][1] * coord.y; screenpos.y = m_Transform[1][0] * coord.x + m_Transform[1][1] * coord.y;
return screenpos; return screenpos;
} }
#if defined(DEBUG)
/**
* Function Show
* is used to output the object tree, currently for debugging only.
* @param nestLevel An aid to prettier tree indenting, and is the level
* of nesting of this object within the overall tree.
* @param os The ostream& to output to.
*/
void EDA_SchComponentStruct::Show( int nestLevel, std::ostream& os )
{
// for now, make it look like XML:
NestedSpace( nestLevel, os ) << '<' << GetClass().Lower().mb_str() <<
" ref=\"" << GetReference().mb_str() << '"' <<
" chipName=\"" << m_ChipName.mb_str() << '"' <<
m_Pos <<
" layer=\"" << m_Layer << '"' <<
"/>\n";
// skip the reference, it's been output already.
for( int i=1; i<NUMBER_OF_FIELDS; ++i )
{
wxString value = GetFieldValue( i );
if( !value.IsEmpty() )
{
NestedSpace( nestLevel+1, os ) << "<field" <<
" name=\"" << ReturnFieldName(i).mb_str() << '"' <<
" value=\"" << value.mb_str() << "\"/>\n";
}
}
NestedSpace( nestLevel, os ) << "</" << GetClass().Lower().mb_str() << ">\n";
}
#endif
/***************************************************************************/ /***************************************************************************/
PartTextStruct::PartTextStruct(const wxPoint & pos, const wxString & text): PartTextStruct::PartTextStruct( const wxPoint& pos, const wxString& text ) :
EDA_BaseStruct(DRAW_PART_TEXT_STRUCT_TYPE), EDA_BaseStruct( DRAW_PART_TEXT_STRUCT_TYPE ), EDA_TextStruct( text )
EDA_TextStruct(text)
/***************************************************************************/ /***************************************************************************/
{ {
m_Pos = pos; m_Pos = pos;
m_FieldId = 0; m_FieldId = 0;
} }
/************************************/ /************************************/
PartTextStruct::~PartTextStruct() PartTextStruct::~PartTextStruct()
/************************************/ /************************************/
{ {
} }
/***********************************************************/ /***********************************************************/
void PartTextStruct::PartTextCopy(PartTextStruct * target) void PartTextStruct::PartTextCopy( PartTextStruct* target )
/***********************************************************/ /***********************************************************/
{ {
target->m_Text = m_Text; target->m_Text = m_Text;
if ( m_FieldId >= FIELD1 )target->m_Name = m_Name; if( m_FieldId >= FIELD1 )
target->m_Name = m_Name;
target->m_Layer = m_Layer; target->m_Layer = m_Layer;
target->m_Pos = m_Pos; target->m_Pos = m_Pos;
target->m_Size = m_Size; target->m_Size = m_Size;
...@@ -526,11 +613,13 @@ void PartTextStruct::PartTextCopy(PartTextStruct * target) ...@@ -526,11 +613,13 @@ void PartTextStruct::PartTextCopy(PartTextStruct * target)
/*********************************/ /*********************************/
bool PartTextStruct::IsVoid() bool PartTextStruct::IsVoid()
/*********************************/ /*********************************/
/* return True if The field is void, i.e.: /* return True if The field is void, i.e.:
contains wxEmptyString or "~" * contains wxEmptyString or "~"
*/ */
{ {
if ( m_Text.IsEmpty() || m_Text == wxT("~") ) return TRUE; if( m_Text.IsEmpty() || m_Text == wxT( "~" ) )
return TRUE;
return FALSE; return FALSE;
} }
...@@ -538,19 +627,20 @@ bool PartTextStruct::IsVoid() ...@@ -538,19 +627,20 @@ bool PartTextStruct::IsVoid()
/********************************************/ /********************************************/
EDA_Rect PartTextStruct::GetBoundaryBox() EDA_Rect PartTextStruct::GetBoundaryBox()
/********************************************/ /********************************************/
/* return
EDA_Rect contains the real (user coordinates) boundary box for a text field,
according to the component position, rotation, mirror ...
*/ /* return
* EDA_Rect contains the real (user coordinates) boundary box for a text field,
* according to the component position, rotation, mirror ...
*
*/
{ {
EDA_Rect BoundaryBox; EDA_Rect BoundaryBox;
int hjustify, vjustify; int hjustify, vjustify;
int textlen; int textlen;
int orient; int orient;
int dx, dy, x1, y1, x2, y2; int dx, dy, x1, y1, x2, y2;
EDA_SchComponentStruct * DrawLibItem = (EDA_SchComponentStruct *) m_Parent; EDA_SchComponentStruct* DrawLibItem = (EDA_SchComponentStruct*) m_Parent;
orient = m_Orient; orient = m_Orient;
wxPoint pos = DrawLibItem->m_Pos; wxPoint pos = DrawLibItem->m_Pos;
...@@ -558,12 +648,12 @@ EDA_SchComponentStruct * DrawLibItem = (EDA_SchComponentStruct *) m_Parent; ...@@ -558,12 +648,12 @@ EDA_SchComponentStruct * DrawLibItem = (EDA_SchComponentStruct *) m_Parent;
y1 = m_Pos.y - pos.y; y1 = m_Pos.y - pos.y;
textlen = GetLength(); textlen = GetLength();
if ( m_FieldId == REFERENCE ) // Real Text can be U1 or U1A if( m_FieldId == REFERENCE ) // Real Text can be U1 or U1A
{ {
EDA_LibComponentStruct *Entry = EDA_LibComponentStruct* Entry =
FindLibPart(DrawLibItem->m_ChipName.GetData(),wxEmptyString,FIND_ROOT); FindLibPart( DrawLibItem->m_ChipName.GetData(), wxEmptyString, FIND_ROOT );
if ( Entry && (Entry->m_UnitCount > 1) ) if( Entry && (Entry->m_UnitCount > 1) )
textlen ++; // because U1 is show as U1A or U1B ... textlen++; // because U1 is show as U1A or U1B ...
} }
dx = m_Size.x * textlen; dx = m_Size.x * textlen;
...@@ -580,54 +670,64 @@ EDA_SchComponentStruct * DrawLibItem = (EDA_SchComponentStruct *) m_Parent; ...@@ -580,54 +670,64 @@ EDA_SchComponentStruct * DrawLibItem = (EDA_SchComponentStruct *) m_Parent;
+ (DrawLibItem->m_Transform[1][1] * y1); + (DrawLibItem->m_Transform[1][1] * y1);
/* If the component orientation is +/- 90 deg, the text orienation must be changed */ /* If the component orientation is +/- 90 deg, the text orienation must be changed */
if(DrawLibItem->m_Transform[0][1]) if( DrawLibItem->m_Transform[0][1] )
{ {
if ( orient == TEXT_ORIENT_HORIZ) orient = TEXT_ORIENT_VERT; if( orient == TEXT_ORIENT_HORIZ )
else orient = TEXT_ORIENT_HORIZ; orient = TEXT_ORIENT_VERT;
else
orient = TEXT_ORIENT_HORIZ;
/* is it mirrored (for text justify)*/ /* is it mirrored (for text justify)*/
EXCHG(hjustify, vjustify); EXCHG( hjustify, vjustify );
if (DrawLibItem->m_Transform[1][0] < 0 ) vjustify = - vjustify; if( DrawLibItem->m_Transform[1][0] < 0 )
if (DrawLibItem->m_Transform[0][1] > 0 ) hjustify = - hjustify; vjustify = -vjustify;
if( DrawLibItem->m_Transform[0][1] > 0 )
hjustify = -hjustify;
} }
else /* component horizontal: is it mirrored (for text justify)*/ else /* component horizontal: is it mirrored (for text justify)*/
{ {
if (DrawLibItem->m_Transform[0][0] < 0 ) if( DrawLibItem->m_Transform[0][0] < 0 )
hjustify = - hjustify; hjustify = -hjustify;
if (DrawLibItem->m_Transform[1][1] > 0 ) if( DrawLibItem->m_Transform[1][1] > 0 )
vjustify = - vjustify; vjustify = -vjustify;
} }
if ( orient == TEXT_ORIENT_VERT ) EXCHG(dx, dy); if( orient == TEXT_ORIENT_VERT )
EXCHG( dx, dy );
switch ( hjustify ) switch( hjustify )
{ {
case GR_TEXT_HJUSTIFY_CENTER: case GR_TEXT_HJUSTIFY_CENTER:
x1 = x2 - (dx/2); x1 = x2 - (dx / 2);
break; break;
case GR_TEXT_HJUSTIFY_RIGHT: case GR_TEXT_HJUSTIFY_RIGHT:
x1 = x2 - dx; x1 = x2 - dx;
break; break;
default: default:
x1 = x2; x1 = x2;
break; break;
} }
switch ( vjustify )
switch( vjustify )
{ {
case GR_TEXT_VJUSTIFY_CENTER: case GR_TEXT_VJUSTIFY_CENTER:
y1 = y2 - (dy/2); y1 = y2 - (dy / 2);
break; break;
case GR_TEXT_VJUSTIFY_BOTTOM: case GR_TEXT_VJUSTIFY_BOTTOM:
y1 = y2 - dy; y1 = y2 - dy;
break; break;
default: default:
y1 = y2; y1 = y2;
break; break;
} }
BoundaryBox.SetX(x1); BoundaryBox.SetX( x1 );
BoundaryBox.SetY(y1); BoundaryBox.SetY( y1 );
BoundaryBox.SetWidth(dx); BoundaryBox.SetWidth( dx );
BoundaryBox.SetHeight(dy); BoundaryBox.SetHeight( dy );
return BoundaryBox; return BoundaryBox;
} }
eeschema/component_class.h
View file @ 664a1f72
...@@ -15,7 +15,7 @@ ...@@ -15,7 +15,7 @@
/* Definition de la representation du composant */ /* Definition de la representation du composant */
#define NUMBER_OF_FIELDS 12 /* Nombre de champs de texte affectes au composant */ #define NUMBER_OF_FIELDS 12 /* Nombre de champs de texte affectes au composant */
typedef enum { enum NumFieldType {
REFERENCE = 0, /* Champ Reference of part, i.e. "IC21" */ REFERENCE = 0, /* Champ Reference of part, i.e. "IC21" */
VALUE, /* Champ Value of part, i.e. "3.3K" */ VALUE, /* Champ Value of part, i.e. "3.3K" */
FOOTPRINT, /* Champ Name Module PCB, i.e. "16DIP300" */ FOOTPRINT, /* Champ Name Module PCB, i.e. "16DIP300" */
...@@ -28,7 +28,7 @@ typedef enum { ...@@ -28,7 +28,7 @@ typedef enum {
FIELD6, FIELD6,
FIELD7, FIELD7,
FIELD8 FIELD8
} NumFieldType; };
/* Class to manage component fields. /* Class to manage component fields.
...@@ -46,9 +46,10 @@ public: ...@@ -46,9 +46,10 @@ public:
public: public:
PartTextStruct( const wxPoint& pos = wxPoint( 0, 0 ), const wxString& text = wxEmptyString ); PartTextStruct( const wxPoint& pos = wxPoint( 0, 0 ), const wxString& text = wxEmptyString );
~PartTextStruct(); ~PartTextStruct();
virtual wxString GetClass() const virtual wxString GetClass() const
{ {
return wxT( "PartTextStruct" ); return wxT( "PartText" );
} }
...@@ -77,10 +78,18 @@ public: ...@@ -77,10 +78,18 @@ public:
public: public:
DrawPartStruct( KICAD_T struct_type, const wxPoint &pos ); DrawPartStruct( KICAD_T struct_type, const wxPoint &pos );
~DrawPartStruct(); ~DrawPartStruct();
virtual wxString GetClass() const virtual wxString GetClass() const
{ {
return wxT( "DrawPartStruct" ); return wxT( "DrawPart" );
} }
/**
* Function GetReference
* returns a reference to the Reference
*/
const wxString& GetReference() { return m_Field[REFERENCE].m_Text; }
}; };
...@@ -101,18 +110,29 @@ public: ...@@ -101,18 +110,29 @@ public:
virtual wxString GetClass() const virtual wxString GetClass() const
{ {
return wxT( "EDA_SchComponentStruct" ); return wxT( "EDA_SchComponent" );
} }
EDA_SchComponentStruct* GenCopy( void ); EDA_SchComponentStruct* GenCopy();
void SetRotationMiroir( int type ); void SetRotationMiroir( int type );
int GetRotationMiroir(); int GetRotationMiroir();
wxPoint GetScreenCoord( const wxPoint& coord ); wxPoint GetScreenCoord( const wxPoint& coord );
void Display_Infos( WinEDA_DrawFrame* frame ); void Display_Infos( WinEDA_DrawFrame* frame );
void ClearAnnotation(); void ClearAnnotation();
EDA_Rect GetBoundaryBox(); EDA_Rect GetBoundaryBox();
wxString ReturnFieldName( int FieldNumber );
const wxString& ReturnFieldName( int aFieldNdx ) const;
/**
* Function GetFieldValue
* returns a reference to the field value.
* @param aFieldNdx An index into the array of fields, 0 - FIELD8
* @return const wxString& - the field value or wxEmptyString
*/
const wxString& GetFieldValue( int aFieldNdx ) const;
virtual void Draw( WinEDA_DrawPanel* panel, virtual void Draw( WinEDA_DrawPanel* panel,
wxDC* DC, wxDC* DC,
...@@ -122,6 +142,17 @@ public: ...@@ -122,6 +142,17 @@ public:
void SwapData( EDA_SchComponentStruct* copyitem ); void SwapData( EDA_SchComponentStruct* copyitem );
virtual void Place( WinEDA_DrawFrame* frame, wxDC* DC ); virtual void Place( WinEDA_DrawFrame* frame, wxDC* DC );
#if defined(DEBUG)
/**
* Function Show
* is used to output the object tree, currently for debugging only.
* @param nestLevel An aid to prettier tree indenting, and is the level
* of nesting of this object within the overall tree.
* @param os The ostream& to output to.
*/
void Show( int nestLevel, std::ostream& os );
#endif
}; };
......
eeschema/edit_component_in_lib.cpp
View file @ 664a1f72
...@@ -24,7 +24,6 @@ enum id_libedit { ...@@ -24,7 +24,6 @@ enum id_libedit {
}; };
/* Routines locales */ /* Routines locales */
/* Variables locales */ /* Variables locales */
...@@ -33,113 +32,129 @@ extern int CurrentUnit; ...@@ -33,113 +32,129 @@ extern int CurrentUnit;
/* Classe de la frame des proprits d'un composant en librairie */ /* Classe de la frame des proprits d'un composant en librairie */
/* Cette classe genere une fenetre type NoteBook, pour l'edition des proprits /* Cette classe genere une fenetre type NoteBook, pour l'edition des proprits
d'un composant le librairie. * d'un composant le librairie.
On peut diter: * On peut diter:
Texte dimensions et justification de tous les champs (Ref, Val, et autres champs) * Texte dimensions et justification de tous les champs (Ref, Val, et autres champs)
Documentation et mots clefs * Documentation et mots clefs
Nombre de part par boitier * Nombre de part par boitier
et autres proprirs gnrales * et autres proprirs gnrales
*/ */
#include "dialog_edit_component_in_lib.cpp" #include "dialog_edit_component_in_lib.cpp"
/*****************************************************************/ /*****************************************************************/
void WinEDA_LibeditFrame::InstallLibeditFrame(const wxPoint & pos) void WinEDA_LibeditFrame::InstallLibeditFrame( const wxPoint& pos )
/*****************************************************************/ /*****************************************************************/
{ {
wxPoint fpos = pos; wxPoint fpos = pos;
WinEDA_PartPropertiesFrame* frame =
new WinEDA_PartPropertiesFrame( this );
WinEDA_PartPropertiesFrame * frame =
new WinEDA_PartPropertiesFrame(this);
int IsModified = frame->ShowModal(); frame->Destroy(); int IsModified = frame->ShowModal(); frame->Destroy();
if ( IsModified ) Refresh();
if( IsModified )
Refresh();
} }
/***************************************************************************/ /***************************************************************************/
void WinEDA_PartPropertiesFrame::CopyFieldDataToBuffer(LibDrawField * Field) void WinEDA_PartPropertiesFrame::CopyFieldDataToBuffer( LibDrawField* Field )
/***************************************************************************/ /***************************************************************************/
/* copy the field data (name, attributes, size, position... to corresponding buffers /* copy the field data (name, attributes, size, position... to corresponding buffers
for editing * for editing
*/ */
{ {
int id = Field->m_FieldId; int id = Field->m_FieldId;
m_FieldFlags[id] = (Field->m_Attributs & TEXT_NO_VISIBLE) ? 0 : 1; m_FieldFlags[id] = (Field->m_Attributs & TEXT_NO_VISIBLE) ? 0 : 1;
m_FieldOrient[id] = Field->m_Orient; m_FieldOrient[id] = Field->m_Orient;
if ( Field->m_HJustify == GR_TEXT_HJUSTIFY_LEFT) if( Field->m_HJustify == GR_TEXT_HJUSTIFY_LEFT )
m_FieldHJustify[id] = 0; m_FieldHJustify[id] = 0;
else if ( Field->m_HJustify == GR_TEXT_HJUSTIFY_RIGHT) else if( Field->m_HJustify == GR_TEXT_HJUSTIFY_RIGHT )
m_FieldHJustify[id] = 2; m_FieldHJustify[id] = 2;
else else
m_FieldHJustify[id] = 1; m_FieldHJustify[id] = 1;
if ( Field->m_VJustify == GR_TEXT_VJUSTIFY_BOTTOM) if( Field->m_VJustify == GR_TEXT_VJUSTIFY_BOTTOM )
m_FieldVJustify[id] = 0; m_FieldVJustify[id] = 0;
else if ( Field->m_VJustify == GR_TEXT_VJUSTIFY_TOP) else if( Field->m_VJustify == GR_TEXT_VJUSTIFY_TOP )
m_FieldVJustify[id] = 2; m_FieldVJustify[id] = 2;
else m_FieldVJustify[id] = 1; else
m_FieldVJustify[id] = 1;
m_FieldText[id] = Field->m_Text; m_FieldText[id] = Field->m_Text;
if ( id >= FIELD1 ) m_FieldName[id] = Field->m_Name; if( id >= FIELD1 )
m_FieldName[id] = Field->m_Name;
m_FieldPosition[id] = Field->m_Pos; m_FieldPosition[id] = Field->m_Pos;
// Note: the Y axis for components in lib is from bottom to top // Note: the Y axis for components in lib is from bottom to top
// and the screen axis is top to bottom: we must change the y coord sign for editing // and the screen axis is top to bottom: we must change the y coord sign for editing
m_FieldPosition[id].y = - m_FieldPosition[id].y; m_FieldPosition[id].y = -m_FieldPosition[id].y;
m_FieldSize[id] = Field->m_Size.x; m_FieldSize[id] = Field->m_Size.x;
} }
/***************************************************************************/ /***************************************************************************/
void WinEDA_PartPropertiesFrame::CopyBufferToFieldData(LibDrawField * Field) void WinEDA_PartPropertiesFrame::CopyBufferToFieldData( LibDrawField* Field )
/***************************************************************************/ /***************************************************************************/
/* Copy data from buffers(name, attributes, size, position... )to the /* Copy data from buffers(name, attributes, size, position... )to the
field "Field" * field "Field"
*/ */
{ {
int hjustify[3] = { GR_TEXT_HJUSTIFY_LEFT , GR_TEXT_HJUSTIFY_CENTER, int hjustify[3] = {
GR_TEXT_HJUSTIFY_RIGHT }; GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_HJUSTIFY_CENTER,
int vjustify[3] = { GR_TEXT_VJUSTIFY_BOTTOM , GR_TEXT_VJUSTIFY_CENTER, GR_TEXT_HJUSTIFY_RIGHT
GR_TEXT_VJUSTIFY_TOP }; };
int ii = Field->m_FieldId; int vjustify[3] = {
GR_TEXT_VJUSTIFY_BOTTOM, GR_TEXT_VJUSTIFY_CENTER,
GR_TEXT_VJUSTIFY_TOP
};
int ii = Field->m_FieldId;
Field->m_Text = m_FieldText[ii]; Field->m_Text = m_FieldText[ii];
if ( ii >= FIELD1 && m_FieldName[ii] != ReturnDefaultFieldName(ii) ) if( ii >= FIELD1 && m_FieldName[ii] != ReturnDefaultFieldName( ii ) )
Field->m_Name = m_FieldName[ii]; Field->m_Name = m_FieldName[ii];
else Field->m_Name.Empty(); else
Field->m_Name.Empty();
Field->m_Size.x = Field->m_Size.y = m_FieldSize[ii]; Field->m_Size.x = Field->m_Size.y = m_FieldSize[ii];
Field->m_HJustify = hjustify[m_FieldHJustify[ii]]; Field->m_HJustify = hjustify[m_FieldHJustify[ii]];
Field->m_VJustify = vjustify[m_FieldVJustify[ii]]; Field->m_VJustify = vjustify[m_FieldVJustify[ii]];
if ( m_FieldFlags[ii] ) if( m_FieldFlags[ii] )
Field->m_Attributs &= ~TEXT_NO_VISIBLE; Field->m_Attributs &= ~TEXT_NO_VISIBLE;
else else
Field->m_Attributs |= TEXT_NO_VISIBLE; Field->m_Attributs |= TEXT_NO_VISIBLE;
Field->m_Orient = m_FieldOrient[ii] ? 1 : 0; Field->m_Orient = m_FieldOrient[ii] ? 1 : 0;
Field->m_Pos = m_FieldPosition[ii]; Field->m_Pos = m_FieldPosition[ii];
// Note: the Y axis for components in lib is from bottom to top // Note: the Y axis for components in lib is from bottom to top
// and the screen axis is top to bottom: we must change the y coord sign after editing // and the screen axis is top to bottom: we must change the y coord sign after editing
Field->m_Pos.y = - Field->m_Pos.y; Field->m_Pos.y = -Field->m_Pos.y;
} }
/*****************************************************/ /*****************************************************/
void WinEDA_PartPropertiesFrame::InitBuffers() void WinEDA_PartPropertiesFrame::InitBuffers()
/*****************************************************/ /*****************************************************/
/* Init the buffers to a default value, /* Init the buffers to a default value,
or to values from CurrentLibEntry if CurrentLibEntry != NULL * or to values from CurrentLibEntry if CurrentLibEntry != NULL
*/ */
{ {
int ii; int ii;
m_CurrentFieldId = REFERENCE; m_CurrentFieldId = REFERENCE;
for ( ii = 0; ii < NUMBER_OF_FIELDS; ii++ ) for( ii = 0; ii < NUMBER_OF_FIELDS; ii++ )
{ {
if ( ii < FIELD1 ) if( ii < FIELD1 )
m_FieldName[ii] = ReturnDefaultFieldName(ii); m_FieldName[ii] = ReturnDefaultFieldName( ii );
m_FieldFlags[ii] = 1; m_FieldFlags[ii] = 1;
m_FieldOrient[ii] = 0; m_FieldOrient[ii] = 0;
m_FieldSize[ii] = DEFAULT_TEXT_SIZE; m_FieldSize[ii] = DEFAULT_TEXT_SIZE;
...@@ -148,20 +163,20 @@ int ii; ...@@ -148,20 +163,20 @@ int ii;
} }
m_AliasLocation = -1; m_AliasLocation = -1;
if ( CurrentLibEntry == NULL ) if( CurrentLibEntry == NULL )
{ {
m_Title = _("Lib Component Properties"); m_Title = _( "Lib Component Properties" );
return; return;
} }
wxString msg_text = _("Properties for "); wxString msg_text = _( "Properties for " );
if ( ! CurrentAliasName.IsEmpty() ) if( !CurrentAliasName.IsEmpty() )
{ {
m_AliasLocation = LocateAlias( CurrentLibEntry->m_AliasList, CurrentAliasName); m_AliasLocation = LocateAlias( CurrentLibEntry->m_AliasList, CurrentAliasName );
m_Title = msg_text + CurrentAliasName + m_Title = msg_text + CurrentAliasName +
_("(alias of ") + _( "(alias of " ) +
wxString(CurrentLibEntry->m_Name.m_Text) wxString( CurrentLibEntry->m_Name.m_Text )
+ wxT(")"); + wxT( ")" );
} }
else else
{ {
...@@ -169,14 +184,14 @@ int ii; ...@@ -169,14 +184,14 @@ int ii;
CurrentAliasName.Empty(); CurrentAliasName.Empty();
} }
CopyFieldDataToBuffer(& CurrentLibEntry->m_Prefix); CopyFieldDataToBuffer( &CurrentLibEntry->m_Prefix );
CopyFieldDataToBuffer(& CurrentLibEntry->m_Name); CopyFieldDataToBuffer( &CurrentLibEntry->m_Name );
LibDrawField * Field = CurrentLibEntry->Fields; LibDrawField* Field = CurrentLibEntry->Fields;
while ( Field ) while( Field )
{ {
CopyFieldDataToBuffer(Field); CopyFieldDataToBuffer( Field );
Field = (LibDrawField*)Field->Pnext; Field = (LibDrawField*) Field->Pnext;
} }
} }
...@@ -184,58 +199,68 @@ int ii; ...@@ -184,58 +199,68 @@ int ii;
/*****************************************************/ /*****************************************************/
void WinEDA_PartPropertiesFrame::BuildPanelAlias() void WinEDA_PartPropertiesFrame::BuildPanelAlias()
/*****************************************************/ /*****************************************************/
/* create the panel for component alias list editing /* create the panel for component alias list editing
*/ */
{ {
wxButton * Button; wxButton* Button;
m_PanelAlias->SetFont(*g_DialogFont); m_PanelAlias->SetFont( *g_DialogFont );
wxBoxSizer * PanelAliasBoxSizer = new wxBoxSizer(wxHORIZONTAL); wxBoxSizer* PanelAliasBoxSizer = new wxBoxSizer( wxHORIZONTAL );
m_PanelAlias->SetSizer(PanelAliasBoxSizer);
wxBoxSizer * LeftBoxSizer = new wxBoxSizer(wxVERTICAL);
PanelAliasBoxSizer->Add(LeftBoxSizer, 0 , wxGROW|wxALL, 5);
wxStaticText * Msg = new wxStaticText(m_PanelAlias, -1, _("Alias")); m_PanelAlias->SetSizer( PanelAliasBoxSizer );
Msg->SetForegroundColour(wxColour(200,0,0) ); wxBoxSizer* LeftBoxSizer = new wxBoxSizer( wxVERTICAL );
LeftBoxSizer->Add(Msg, 0 , wxGROW|wxLEFT|wxRIGHT|wxTOP, 5);
m_PartAliasList = new wxListBox(m_PanelAlias, PanelAliasBoxSizer->Add( LeftBoxSizer, 0, wxGROW | wxALL, 5 );
wxStaticText* Msg = new wxStaticText( m_PanelAlias, -1, _( "Alias" ) );
Msg->SetForegroundColour( wxColour( 200, 0, 0 ) );
LeftBoxSizer->Add( Msg, 0, wxGROW | wxLEFT | wxRIGHT | wxTOP, 5 );
m_PartAliasList = new wxListBox( m_PanelAlias,
-1, -1,
wxDefaultPosition, wxSize(200,250), wxDefaultPosition, wxSize( 200, 250 ),
0,NULL, 0, NULL,
wxLB_ALWAYS_SB|wxLB_SINGLE); wxLB_ALWAYS_SB | wxLB_SINGLE );
LeftBoxSizer->Add(m_PartAliasList, 0 , wxGROW|wxLEFT|wxRIGHT|wxBOTTOM, 5);
LeftBoxSizer->Add( m_PartAliasList, 0, wxGROW | wxLEFT | wxRIGHT | wxBOTTOM, 5 );
wxBoxSizer * RightBoxSizer = new wxBoxSizer(wxVERTICAL); wxBoxSizer* RightBoxSizer = new wxBoxSizer( wxVERTICAL );
PanelAliasBoxSizer->Add(RightBoxSizer, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
Button = new wxButton(m_PanelAlias, ID_ADD_ALIAS, _("Add")); PanelAliasBoxSizer->Add( RightBoxSizer, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5 );
Button->SetForegroundColour(*wxBLUE);
RightBoxSizer->Add(Button, 0 , wxGROW|wxALL, 5);
m_ButtonDeleteOneAlias = new wxButton(m_PanelAlias, ID_DELETE_ONE_ALIAS, Button = new wxButton( m_PanelAlias, ID_ADD_ALIAS, _( "Add" ) );
_("Delete"));
m_ButtonDeleteOneAlias->SetForegroundColour(*wxRED);
RightBoxSizer->Add(m_ButtonDeleteOneAlias, 0 , wxGROW|wxALL, 5);
m_ButtonDeleteAllAlias = new wxButton(m_PanelAlias, ID_DELETE_ALL_ALIAS, Button->SetForegroundColour( *wxBLUE );
_("Delete All")); RightBoxSizer->Add( Button, 0, wxGROW | wxALL, 5 );
m_ButtonDeleteAllAlias->SetForegroundColour(*wxRED);
if ( ! CurrentAliasName.IsEmpty() ) m_ButtonDeleteAllAlias->Enable(FALSE); m_ButtonDeleteOneAlias = new wxButton( m_PanelAlias, ID_DELETE_ONE_ALIAS,
RightBoxSizer->Add(m_ButtonDeleteAllAlias, 0 , wxGROW|wxALL, 5); _( "Delete" ) );
m_ButtonDeleteOneAlias->SetForegroundColour( *wxRED );
RightBoxSizer->Add( m_ButtonDeleteOneAlias, 0, wxGROW | wxALL, 5 );
m_ButtonDeleteAllAlias = new wxButton( m_PanelAlias, ID_DELETE_ALL_ALIAS,
_( "Delete All" ) );
m_ButtonDeleteAllAlias->SetForegroundColour( *wxRED );
if( !CurrentAliasName.IsEmpty() )
m_ButtonDeleteAllAlias->Enable( FALSE );
RightBoxSizer->Add( m_ButtonDeleteAllAlias, 0, wxGROW | wxALL, 5 );
/* lecture des noms des alias */ /* lecture des noms des alias */
if ( CurrentLibEntry ) if( CurrentLibEntry )
{ {
for ( unsigned ii = 0; ii < CurrentLibEntry->m_AliasList.GetCount(); ii += ALIAS_NEXT) for( unsigned ii = 0; ii < CurrentLibEntry->m_AliasList.GetCount(); ii += ALIAS_NEXT )
m_PartAliasList->Append(CurrentLibEntry->m_AliasList[ii+ALIAS_NAME]); m_PartAliasList->Append( CurrentLibEntry->m_AliasList[ii + ALIAS_NAME] );
} }
if ( (CurrentLibEntry == NULL) || (CurrentLibEntry->m_AliasList.GetCount() == 0) ) if( (CurrentLibEntry == NULL) || (CurrentLibEntry->m_AliasList.GetCount() == 0) )
{ {
m_ButtonDeleteAllAlias->Enable(FALSE); m_ButtonDeleteAllAlias->Enable( FALSE );
m_ButtonDeleteOneAlias->Enable(FALSE); m_ButtonDeleteOneAlias->Enable( FALSE );
} }
} }
...@@ -243,290 +268,350 @@ wxButton * Button; ...@@ -243,290 +268,350 @@ wxButton * Button;
/*****************************************************************/ /*****************************************************************/
void WinEDA_PartPropertiesFrame::BuildPanelFootprintFilter() void WinEDA_PartPropertiesFrame::BuildPanelFootprintFilter()
/*****************************************************************/ /*****************************************************************/
/* create the panel for footprint filtering in cvpcb list /* create the panel for footprint filtering in cvpcb list
*/ */
{ {
m_PanelFootprintFilter = new wxPanel( m_NoteBook,
-1,
wxDefaultPosition,
wxDefaultSize,
wxSUNKEN_BORDER | wxTAB_TRAVERSAL );
m_NoteBook->AddPage( m_PanelFootprintFilter, _( "Footprint Filter" ) );
m_PanelFootprintFilter->SetFont( *g_DialogFont );
m_PanelFootprintFilter = new wxPanel( m_NoteBook, -1, wxDefaultPosition, wxDefaultSize, wxSUNKEN_BORDER|wxTAB_TRAVERSAL ); wxBoxSizer* PanelFpFilterBoxSizer = new wxBoxSizer( wxHORIZONTAL );
m_NoteBook->AddPage(m_PanelFootprintFilter, _("Footprint Filter"));
m_PanelFootprintFilter->SetFont(*g_DialogFont); m_PanelFootprintFilter->SetSizer( PanelFpFilterBoxSizer );
wxBoxSizer* LeftBoxSizer = new wxBoxSizer( wxVERTICAL );
wxBoxSizer * PanelFpFilterBoxSizer = new wxBoxSizer(wxHORIZONTAL); PanelFpFilterBoxSizer->Add( LeftBoxSizer, 0, wxGROW | wxALL, 5 );
m_PanelFootprintFilter->SetSizer(PanelFpFilterBoxSizer);
wxBoxSizer * LeftBoxSizer = new wxBoxSizer(wxVERTICAL);
PanelFpFilterBoxSizer->Add(LeftBoxSizer, 0 , wxGROW|wxALL, 5);
wxStaticText * Msg = new wxStaticText(m_PanelFootprintFilter, -1, _("Footprints")); wxStaticText* Msg = new wxStaticText( m_PanelFootprintFilter, -1, _(
Msg->SetForegroundColour(wxColour(200,0,0) ); "Footprints" ) );
LeftBoxSizer->Add(Msg, 0 , wxGROW|wxLEFT|wxRIGHT|wxTOP, 5);
m_FootprintFilterListBox = new wxListBox(m_PanelFootprintFilter, Msg->SetForegroundColour( wxColour( 200, 0, 0 ) );
LeftBoxSizer->Add( Msg, 0, wxGROW | wxLEFT | wxRIGHT | wxTOP, 5 );
m_FootprintFilterListBox = new wxListBox( m_PanelFootprintFilter,
-1, -1,
wxDefaultPosition, wxSize(200,250), wxDefaultPosition, wxSize( 200, 250 ),
0,NULL, 0, NULL,
wxLB_ALWAYS_SB|wxLB_SINGLE); wxLB_ALWAYS_SB | wxLB_SINGLE );
LeftBoxSizer->Add(m_FootprintFilterListBox, 0 , wxGROW|wxLEFT|wxRIGHT|wxBOTTOM, 5);
LeftBoxSizer->Add( m_FootprintFilterListBox, 0, wxGROW | wxLEFT | wxRIGHT | wxBOTTOM, 5 );
wxBoxSizer* RightBoxSizer = new wxBoxSizer( wxVERTICAL );
PanelFpFilterBoxSizer->Add( RightBoxSizer, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5 );
wxBoxSizer * RightBoxSizer = new wxBoxSizer(wxVERTICAL); wxButton* Button = new wxButton( m_PanelFootprintFilter,
PanelFpFilterBoxSizer->Add(RightBoxSizer, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5); ID_ADD_FOOTPRINT_FILTER, _(
"Add" ) );
wxButton * Button = new wxButton(m_PanelFootprintFilter, ID_ADD_FOOTPRINT_FILTER, _("Add")); Button->SetForegroundColour( *wxBLUE );
Button->SetForegroundColour(*wxBLUE); RightBoxSizer->Add( Button, 0, wxGROW | wxALL, 5 );
RightBoxSizer->Add(Button, 0 , wxGROW|wxALL, 5);
m_ButtonDeleteOneFootprintFilter = new wxButton(m_PanelFootprintFilter, ID_DELETE_ONE_FOOTPRINT_FILTER, m_ButtonDeleteOneFootprintFilter = new wxButton( m_PanelFootprintFilter,
_("Delete")); ID_DELETE_ONE_FOOTPRINT_FILTER,
m_ButtonDeleteOneFootprintFilter->SetForegroundColour(*wxRED); _(
RightBoxSizer->Add(m_ButtonDeleteOneFootprintFilter, 0 , wxGROW|wxALL, 5); "Delete" ) );
m_ButtonDeleteAllFootprintFilter = new wxButton(m_PanelFootprintFilter, ID_DELETE_ALL_FOOTPRINT_FILTER, m_ButtonDeleteOneFootprintFilter->SetForegroundColour( *wxRED );
_("Delete All")); RightBoxSizer->Add( m_ButtonDeleteOneFootprintFilter, 0, wxGROW | wxALL, 5 );
m_ButtonDeleteAllFootprintFilter->SetForegroundColour(*wxRED);
RightBoxSizer->Add(m_ButtonDeleteAllFootprintFilter, 0 , wxGROW|wxALL, 5); m_ButtonDeleteAllFootprintFilter = new wxButton( m_PanelFootprintFilter,
ID_DELETE_ALL_FOOTPRINT_FILTER,
_(
"Delete All" ) );
m_ButtonDeleteAllFootprintFilter->SetForegroundColour( *wxRED );
RightBoxSizer->Add( m_ButtonDeleteAllFootprintFilter, 0, wxGROW | wxALL, 5 );
/* Read the Footprint Filter list */ /* Read the Footprint Filter list */
if ( CurrentLibEntry ) if( CurrentLibEntry )
{ {
for ( unsigned ii = 0; ii < CurrentLibEntry->m_FootprintList.GetCount(); ii ++) for( unsigned ii = 0; ii < CurrentLibEntry->m_FootprintList.GetCount(); ii++ )
m_FootprintFilterListBox->Append(CurrentLibEntry->m_FootprintList[ii]); m_FootprintFilterListBox->Append( CurrentLibEntry->m_FootprintList[ii] );
} }
if ( (CurrentLibEntry == NULL) || (CurrentLibEntry->m_FootprintList.GetCount() == 0) ) if( (CurrentLibEntry == NULL) || (CurrentLibEntry->m_FootprintList.GetCount() == 0) )
{ {
m_ButtonDeleteAllFootprintFilter->Enable(FALSE); m_ButtonDeleteAllFootprintFilter->Enable( FALSE );
m_ButtonDeleteOneFootprintFilter->Enable(FALSE); m_ButtonDeleteOneFootprintFilter->Enable( FALSE );
} }
} }
/*****************************************************/ /*****************************************************/
void WinEDA_PartPropertiesFrame::BuildPanelDoc() void WinEDA_PartPropertiesFrame::BuildPanelDoc()
/*****************************************************/ /*****************************************************/
/* create the panel for component doc editing /* create the panel for component doc editing
*/ */
{ {
wxString msg_text; wxString msg_text;
if ( m_AliasLocation >= 0 ) if( m_AliasLocation >= 0 )
msg_text = CurrentLibEntry->m_AliasList[m_AliasLocation+ALIAS_DOC]; msg_text = CurrentLibEntry->m_AliasList[m_AliasLocation + ALIAS_DOC];
else else
{ {
if (CurrentLibEntry && CurrentLibEntry->m_Doc) if( CurrentLibEntry && CurrentLibEntry->m_Doc )
msg_text = CurrentLibEntry->m_Doc; msg_text = CurrentLibEntry->m_Doc;
} }
m_Doc->SetValue( msg_text ); m_Doc->SetValue( msg_text );
msg_text.Empty(); msg_text.Empty();
if ( m_AliasLocation >= 0 ) if( m_AliasLocation >= 0 )
msg_text = CurrentLibEntry->m_AliasList[m_AliasLocation+ALIAS_KEYWORD]; msg_text = CurrentLibEntry->m_AliasList[m_AliasLocation + ALIAS_KEYWORD];
else else
{ {
if (CurrentLibEntry ) msg_text = CurrentLibEntry->m_KeyWord; if( CurrentLibEntry )
msg_text = CurrentLibEntry->m_KeyWord;
} }
m_Keywords->SetValue(msg_text); m_Keywords->SetValue( msg_text );
msg_text.Empty(); msg_text.Empty();
if ( m_AliasLocation >= 0 ) if( m_AliasLocation >= 0 )
msg_text = CurrentLibEntry->m_AliasList[m_AliasLocation+ALIAS_DOC_FILENAME]; msg_text = CurrentLibEntry->m_AliasList[m_AliasLocation + ALIAS_DOC_FILENAME];
else else
{ {
if (CurrentLibEntry) msg_text = CurrentLibEntry->m_DocFile; if( CurrentLibEntry )
msg_text = CurrentLibEntry->m_DocFile;
} }
m_Docfile->SetValue( msg_text ); m_Docfile->SetValue( msg_text );
if ( m_AliasLocation < 0 ) m_ButtonCopyDoc->Enable(FALSE); if( m_AliasLocation < 0 )
m_ButtonCopyDoc->Enable( FALSE );
} }
/*****************************************************/ /*****************************************************/
void WinEDA_PartPropertiesFrame::BuildPanelBasic() void WinEDA_PartPropertiesFrame::BuildPanelBasic()
/*****************************************************/ /*****************************************************/
/* create the basic panel for component properties editing /* create the basic panel for component properties editing
*/ */
{ {
m_PanelBasic->SetFont(*g_DialogFont); m_PanelBasic->SetFont( *g_DialogFont );
AsConvertButt = new wxCheckBox(m_PanelBasic,-1, _("As Convert")); AsConvertButt = new wxCheckBox( m_PanelBasic, -1, _( "As Convert" ) );
if ( g_AsDeMorgan ) AsConvertButt->SetValue(TRUE);
m_OptionsBoxSizer->Add(AsConvertButt, 0, wxGROW|wxLEFT|wxRIGHT|wxBOTTOM, 5);
ShowPinNumButt = new wxCheckBox(m_PanelBasic,-1, _("Show Pin Num")); if( g_AsDeMorgan )
if ( CurrentLibEntry ) AsConvertButt->SetValue( TRUE );
m_OptionsBoxSizer->Add( AsConvertButt, 0, wxGROW | wxLEFT | wxRIGHT | wxBOTTOM, 5 );
ShowPinNumButt = new wxCheckBox( m_PanelBasic, -1, _( "Show Pin Num" ) );
if( CurrentLibEntry )
{ {
if ( CurrentLibEntry->m_DrawPinNum ) ShowPinNumButt->SetValue(TRUE); if( CurrentLibEntry->m_DrawPinNum )
ShowPinNumButt->SetValue( TRUE );
} }
else ShowPinNumButt->SetValue(TRUE); else
m_OptionsBoxSizer->Add(ShowPinNumButt, 0, wxGROW|wxLEFT|wxRIGHT|wxBOTTOM, 5); ShowPinNumButt->SetValue( TRUE );
m_OptionsBoxSizer->Add( ShowPinNumButt, 0, wxGROW | wxLEFT | wxRIGHT | wxBOTTOM, 5 );
ShowPinNameButt = new wxCheckBox(m_PanelBasic,-1, _("Show Pin Name")); ShowPinNameButt = new wxCheckBox( m_PanelBasic, -1, _( "Show Pin Name" ) );
if ( CurrentLibEntry )
if( CurrentLibEntry )
{ {
if( CurrentLibEntry->m_DrawPinName ) ShowPinNameButt->SetValue(TRUE); if( CurrentLibEntry->m_DrawPinName )
ShowPinNameButt->SetValue( TRUE );
} }
else ShowPinNameButt->SetValue(TRUE); else
m_OptionsBoxSizer->Add(ShowPinNameButt, 0, wxGROW|wxLEFT|wxRIGHT|wxBOTTOM, 5); ShowPinNameButt->SetValue( TRUE );
m_OptionsBoxSizer->Add( ShowPinNameButt, 0, wxGROW | wxLEFT | wxRIGHT | wxBOTTOM, 5 );
m_PinsNameInsideButt = new wxCheckBox( m_PanelBasic, -1, _( "Pin Name Inside" ) );
m_PinsNameInsideButt = new wxCheckBox(m_PanelBasic,-1, _("Pin Name Inside")); if( CurrentLibEntry )
if ( CurrentLibEntry )
{ {
if ( CurrentLibEntry->m_TextInside ) m_PinsNameInsideButt->SetValue(TRUE); if( CurrentLibEntry->m_TextInside )
m_PinsNameInsideButt->SetValue( TRUE );
} }
else m_PinsNameInsideButt->SetValue(TRUE); else
m_OptionsBoxSizer->Add(m_PinsNameInsideButt, 0, wxGROW|wxLEFT|wxRIGHT|wxBOTTOM, 5); m_PinsNameInsideButt->SetValue( TRUE );
m_OptionsBoxSizer->Add( m_PinsNameInsideButt, 0, wxGROW | wxLEFT | wxRIGHT | wxBOTTOM, 5 );
int number, number_of_units; int number, number_of_units;
if ( CurrentLibEntry ) number_of_units = CurrentLibEntry->m_UnitCount; if( CurrentLibEntry )
else number_of_units = 1; number_of_units = CurrentLibEntry->m_UnitCount;
SelNumberOfUnits->SetValue(number_of_units); else
number_of_units = 1;
SelNumberOfUnits->SetValue( number_of_units );
if ( CurrentLibEntry && CurrentLibEntry->m_TextInside) if( CurrentLibEntry && CurrentLibEntry->m_TextInside )
number = CurrentLibEntry->m_TextInside; number = CurrentLibEntry->m_TextInside;
else number = 40; else
number = 40;
m_SetSkew->SetValue( number ); m_SetSkew->SetValue( number );
if ( CurrentLibEntry ) if( CurrentLibEntry )
{ {
if( CurrentLibEntry->m_Options == ENTRY_POWER ) if( CurrentLibEntry->m_Options == ENTRY_POWER )
m_OptionPower->SetValue(TRUE); m_OptionPower->SetValue( TRUE );
} }
if ( CurrentLibEntry ) if( CurrentLibEntry )
{ {
if( CurrentLibEntry->m_UnitSelectionLocked ) if( CurrentLibEntry->m_UnitSelectionLocked )
m_OptionPartsLocked->SetValue(TRUE); m_OptionPartsLocked->SetValue( TRUE );
} }
} }
/*********************************************************/ /*********************************************************/
void WinEDA_PartPropertiesFrame::BuildPanelEditField() void WinEDA_PartPropertiesFrame::BuildPanelEditField()
/**********************************************************/ /**********************************************************/
/* Create and build the panel managing the fields (REF, VALUE ...) /* Create and build the panel managing the fields (REF, VALUE ...)
of the component * of the component
*/ */
{ {
wxString Hjustify_list[] = wxString Hjustify_list[] =
{ _("Left justify"),_("Center"),_("Right justify")}; { _( "Left justify" ), _( "Center" ), _( "Right justify" ) };
wxString Vjustify_list[] = wxString Vjustify_list[] =
{ _("Bottom justify"),_("Center"),_("Top justify")}; { _( "Bottom justify" ), _( "Center" ), _( "Top justify" ) };
int FieldId = m_CurrentFieldId; int FieldId = m_CurrentFieldId;
m_PanelField = new wxPanel(m_NoteBook, ID_PANEL_FIELD); m_PanelField = new wxPanel( m_NoteBook, ID_PANEL_FIELD );
m_PanelField->SetFont(*g_DialogFont);
m_NoteBook->AddPage(m_PanelField, _("Fields"), FALSE); m_PanelField->SetFont( *g_DialogFont );
m_NoteBook->AddPage( m_PanelField, _( "Fields" ), FALSE );
wxBoxSizer * PanelFieldBoxSizer = new wxBoxSizer(wxHORIZONTAL);
m_PanelField->SetSizer(PanelFieldBoxSizer); wxBoxSizer* PanelFieldBoxSizer = new wxBoxSizer( wxHORIZONTAL );
wxBoxSizer * LeftBoxSizer = new wxBoxSizer(wxVERTICAL);
PanelFieldBoxSizer->Add(LeftBoxSizer, 0 , wxGROW|wxALL, 5); m_PanelField->SetSizer( PanelFieldBoxSizer );
wxBoxSizer * MiddleBoxSizer = new wxBoxSizer(wxVERTICAL); wxBoxSizer* LeftBoxSizer = new wxBoxSizer( wxVERTICAL );
PanelFieldBoxSizer->Add(MiddleBoxSizer, 0 , wxGROW|wxALL, 5);
PanelFieldBoxSizer->Add( LeftBoxSizer, 0, wxGROW | wxALL, 5 );
m_ShowFieldTextCtrl = new wxCheckBox(m_PanelField,-1, wxBoxSizer* MiddleBoxSizer = new wxBoxSizer( wxVERTICAL );
_("Show Text") );
LeftBoxSizer->Add(m_ShowFieldTextCtrl, 0 , wxGROW|wxALL, 5); PanelFieldBoxSizer->Add( MiddleBoxSizer, 0, wxGROW | wxALL, 5 );
m_VorientFieldTextCtrl = new wxCheckBox(m_PanelField,-1, m_ShowFieldTextCtrl = new wxCheckBox( m_PanelField, -1,
_("Vertical")); _( "Show Text" ) );
LeftBoxSizer->Add(m_VorientFieldTextCtrl, 0 , wxGROW|wxALL, 5);
LeftBoxSizer->Add( m_ShowFieldTextCtrl, 0, wxGROW | wxALL, 5 );
m_VorientFieldTextCtrl = new wxCheckBox( m_PanelField, -1,
_( "Vertical" ) );
LeftBoxSizer->Add( m_VorientFieldTextCtrl, 0, wxGROW | wxALL, 5 );
// Create the box for field name display or edition // Create the box for field name display or edition
m_FieldNameCtrl = new WinEDA_EnterText( m_PanelField, m_FieldNameCtrl = new WinEDA_EnterText( m_PanelField,
_("Field Name:"), m_FieldName[FieldId], _( "Field Name:" ), m_FieldName[FieldId],
LeftBoxSizer, wxSize( 200, -1) ); LeftBoxSizer, wxSize( 200, -1 ) );
if ( FieldId < FIELD1 ) m_FieldNameCtrl->Enable(FALSE );
else m_FieldNameCtrl->Enable( TRUE ); if( FieldId < FIELD1 )
m_FieldNameCtrl->Enable( FALSE );
else
m_FieldNameCtrl->Enable( TRUE );
// Create the box for text editing (text, size) // Create the box for text editing (text, size)
m_FieldTextCtrl = new WinEDA_GraphicTextCtrl( m_PanelField, m_FieldTextCtrl = new WinEDA_GraphicTextCtrl( m_PanelField,
_("Value:"), _( "Value:" ),
m_FieldText[FieldId], m_FieldSize[FieldId], m_FieldText[FieldId], m_FieldSize[FieldId],
g_UnitMetric, LeftBoxSizer, 200); g_UnitMetric, LeftBoxSizer, 200 );
// Create the box for text editing (position) // Create the box for text editing (position)
m_FieldPositionCtrl = new WinEDA_PositionCtrl( m_PanelField, m_FieldPositionCtrl = new WinEDA_PositionCtrl( m_PanelField,
_("Pos"), m_FieldPosition[FieldId], _( "Pos" ), m_FieldPosition[FieldId],
g_UnitMetric , LeftBoxSizer); g_UnitMetric, LeftBoxSizer );
m_FieldHJustifyCtrl = new wxRadioBox(m_PanelField,-1, m_FieldHJustifyCtrl = new wxRadioBox( m_PanelField, -1,
_("Hor Justify"), wxDefaultPosition, wxDefaultSize, _( "Hor Justify" ), wxDefaultPosition, wxDefaultSize,
3,Hjustify_list, 1 , wxRA_SPECIFY_COLS); 3, Hjustify_list, 1, wxRA_SPECIFY_COLS );
m_FieldHJustifyCtrl->SetSelection(1);
MiddleBoxSizer->Add(m_FieldHJustifyCtrl, 0 , wxGROW|wxALL, 5);
m_FieldVJustifyCtrl = new wxRadioBox(m_PanelField,-1, m_FieldHJustifyCtrl->SetSelection( 1 );
_("Vert Justify"), wxDefaultPosition, wxDefaultSize, MiddleBoxSizer->Add( m_FieldHJustifyCtrl, 0, wxGROW | wxALL, 5 );
3,Vjustify_list, 1 , wxRA_SPECIFY_COLS);
m_FieldVJustifyCtrl->SetSelection(1); m_FieldVJustifyCtrl = new wxRadioBox( m_PanelField, -1,
MiddleBoxSizer->Add(m_FieldVJustifyCtrl, 0 , wxGROW|wxALL, 5); _( "Vert Justify" ), wxDefaultPosition, wxDefaultSize,
3, Vjustify_list, 1, wxRA_SPECIFY_COLS );
m_FieldVJustifyCtrl->SetSelection( 1 );
MiddleBoxSizer->Add( m_FieldVJustifyCtrl, 0, wxGROW | wxALL, 5 );
// Create the field list // Create the field list
wxString fieldnamelist[NUMBER_OF_FIELDS]; wxString fieldnamelist[NUMBER_OF_FIELDS];
for ( int ii = 0; ii < NUMBER_OF_FIELDS; ii++ ) for( int ii = 0; ii < NUMBER_OF_FIELDS; ii++ )
{ {
if ( m_FieldName[ii].IsEmpty() ) if( m_FieldName[ii].IsEmpty() )
fieldnamelist[ii] = ReturnDefaultFieldName(ii); fieldnamelist[ii] = ReturnDefaultFieldName( ii );
else fieldnamelist[ii] = m_FieldName[ii]; else
fieldnamelist[ii] = m_FieldName[ii];
} }
m_FieldSelection = new wxRadioBox(m_PanelField, ID_ON_SELECT_FIELD, m_FieldSelection = new wxRadioBox( m_PanelField, ID_ON_SELECT_FIELD,
_("Field to edit"), wxDefaultPosition, wxDefaultSize, _( "Field to edit" ), wxDefaultPosition, wxDefaultSize,
NUMBER_OF_FIELDS, fieldnamelist, 2 , wxRA_SPECIFY_COLS); NUMBER_OF_FIELDS, fieldnamelist, 2, wxRA_SPECIFY_COLS );
PanelFieldBoxSizer->Add(m_FieldSelection, 0 , wxGROW|wxALL, 5);
CopyDataToPanelField(); PanelFieldBoxSizer->Add( m_FieldSelection, 0, wxGROW | wxALL, 5 );
CopyDataToPanelField();
} }
/****************************************************************/ /****************************************************************/
void WinEDA_PartPropertiesFrame::CopyDataToPanelField() void WinEDA_PartPropertiesFrame::CopyDataToPanelField()
/****************************************************************/ /****************************************************************/
/* Set the values displayed on the panel field according to /* Set the values displayed on the panel field according to
the current field number * the current field number
*/ */
{ {
int FieldId = m_CurrentFieldId; int FieldId = m_CurrentFieldId;
for ( int ii = FIELD1; ii < NUMBER_OF_FIELDS; ii++ ) for( int ii = FIELD1; ii < NUMBER_OF_FIELDS; ii++ )
{ {
if ( ! m_FieldName[ii].IsEmpty() ) if( !m_FieldName[ii].IsEmpty() )
m_FieldSelection->SetString(ii, m_FieldName[ii]); m_FieldSelection->SetString( ii, m_FieldName[ii] );
else m_FieldSelection->SetString(ii, ReturnDefaultFieldName(ii)); else
m_FieldSelection->SetString( ii, ReturnDefaultFieldName( ii ) );
} }
if ( m_FieldFlags[FieldId] ) if( m_FieldFlags[FieldId] )
m_ShowFieldTextCtrl->SetValue(TRUE); m_ShowFieldTextCtrl->SetValue( TRUE );
else m_ShowFieldTextCtrl->SetValue(FALSE); else
m_ShowFieldTextCtrl->SetValue( FALSE );
if ( m_FieldOrient[FieldId] ) m_VorientFieldTextCtrl->SetValue(TRUE);
else m_VorientFieldTextCtrl->SetValue(FALSE);
m_FieldHJustifyCtrl->SetSelection(m_FieldHJustify[FieldId]); if( m_FieldOrient[FieldId] )
m_VorientFieldTextCtrl->SetValue( TRUE );
else
m_VorientFieldTextCtrl->SetValue( FALSE );
m_FieldVJustifyCtrl->SetSelection(m_FieldVJustify[FieldId]); m_FieldHJustifyCtrl->SetSelection( m_FieldHJustify[FieldId] );
m_FieldPositionCtrl->SetValue(m_FieldPosition[FieldId].x, m_FieldPosition[FieldId].y ); m_FieldVJustifyCtrl->SetSelection( m_FieldVJustify[FieldId] );
m_FieldNameCtrl->SetValue(m_FieldName[FieldId]); m_FieldPositionCtrl->SetValue( m_FieldPosition[FieldId].x, m_FieldPosition[FieldId].y );
if ( FieldId < FIELD1 ) m_FieldNameCtrl->Enable(FALSE );
else m_FieldNameCtrl->Enable( TRUE );
m_FieldTextCtrl->SetValue(m_FieldText[FieldId]); // display new text field
m_FieldTextCtrl->SetValue(m_FieldSize[FieldId]); // display new size field
m_FieldNameCtrl->SetValue( m_FieldName[FieldId] );
if( FieldId < FIELD1 )
m_FieldNameCtrl->Enable( FALSE );
else
m_FieldNameCtrl->Enable( TRUE );
m_FieldTextCtrl->SetValue( m_FieldText[FieldId] ); // display new text field
m_FieldTextCtrl->SetValue( m_FieldSize[FieldId] ); // display new size field
} }
/****************************************************************/ /****************************************************************/
void WinEDA_PartPropertiesFrame::CopyPanelFieldToData() void WinEDA_PartPropertiesFrame::CopyPanelFieldToData()
/****************************************************************/ /****************************************************************/
/* Copy the values displayed on the panel field to the buffers according to /* Copy the values displayed on the panel field to the buffers according to
the current field number * the current field number
*/ */
{ {
int id = m_CurrentFieldId; int id = m_CurrentFieldId;
m_FieldFlags[id] = m_ShowFieldTextCtrl->GetValue(); m_FieldFlags[id] = m_ShowFieldTextCtrl->GetValue();
m_FieldOrient[id] = m_VorientFieldTextCtrl->GetValue(); m_FieldOrient[id] = m_VorientFieldTextCtrl->GetValue();
...@@ -540,24 +625,27 @@ int id = m_CurrentFieldId; ...@@ -540,24 +625,27 @@ int id = m_CurrentFieldId;
/********************************************************************/ /********************************************************************/
void WinEDA_PartPropertiesFrame::SelectNewField(wxCommandEvent& event) void WinEDA_PartPropertiesFrame::SelectNewField( wxCommandEvent& event )
/********************************************************************/ /********************************************************************/
/* called when changing the current field selected /* called when changing the current field selected
Save the current field settings in buffer and display the new one * Save the current field settings in buffer and display the new one
*/ */
{ {
CopyPanelFieldToData(); CopyPanelFieldToData();
m_CurrentFieldId = m_FieldSelection->GetSelection(); m_CurrentFieldId = m_FieldSelection->GetSelection();
CopyDataToPanelField(); CopyDataToPanelField();
} }
/**************************************************************************/ /**************************************************************************/
void WinEDA_PartPropertiesFrame::PartPropertiesAccept(wxCommandEvent& event) void WinEDA_PartPropertiesFrame::PartPropertiesAccept( wxCommandEvent& event )
/**************************************************************************/ /**************************************************************************/
/* Updaye the current component parameters /* Updaye the current component parameters
*/ */
{ {
int ii, jj; int ii, jj;
if( CurrentLibEntry == NULL ) if( CurrentLibEntry == NULL )
{ {
...@@ -565,116 +653,118 @@ int ii, jj; ...@@ -565,116 +653,118 @@ int ii, jj;
} }
m_Parent->m_CurrentScreen->SetModify(); m_Parent->m_CurrentScreen->SetModify();
m_Parent->SaveCopyInUndoList(CurrentLibEntry); m_Parent->SaveCopyInUndoList( CurrentLibEntry );
CopyPanelFieldToData(); CopyPanelFieldToData();
/* A new name could be entered in VALUE field. /* A new name could be entered in VALUE field.
Must not be an existing alias name in alias list box */ * Must not be an existing alias name in alias list box */
jj = m_PartAliasList->GetCount(); jj = m_PartAliasList->GetCount();
wxString newvalue = m_FieldText[VALUE]; wxString newvalue = m_FieldText[VALUE];
for ( ii = 0; ii < jj; ii++ ) for( ii = 0; ii < jj; ii++ )
{ {
if( newvalue.CmpNoCase(m_PartAliasList->GetString(ii).GetData()) == 0 ) if( newvalue.CmpNoCase( m_PartAliasList->GetString( ii ).GetData() ) == 0 )
{ {
wxString msg; wxString msg;
msg.Printf( wxT("Alias %s exists!"), newvalue.GetData()); msg.Printf( wxT( "Alias %s exists!" ), newvalue.GetData() );
DisplayError(this, msg); DisplayError( this, msg );
return; return;
} }
} }
/* Update the doc, keyword and doc filename strings */ /* Update the doc, keyword and doc filename strings */
if ( m_AliasLocation < 0 ) if( m_AliasLocation < 0 )
{ {
CurrentLibEntry->m_Doc = m_Doc->GetValue(); CurrentLibEntry->m_Doc = m_Doc->GetValue();
CurrentLibEntry->m_KeyWord = m_Keywords->GetValue(); CurrentLibEntry->m_KeyWord = m_Keywords->GetValue();
CurrentLibEntry->m_DocFile = m_Docfile->GetValue(); CurrentLibEntry->m_DocFile = m_Docfile->GetValue();
} }
else else
{ {
CurrentLibEntry->m_AliasList[m_AliasLocation+ALIAS_DOC] = m_Doc->GetValue(); CurrentLibEntry->m_AliasList[m_AliasLocation + ALIAS_DOC] = m_Doc->GetValue();
CurrentLibEntry->m_AliasList[m_AliasLocation+ALIAS_KEYWORD] = m_Keywords->GetValue(); CurrentLibEntry->m_AliasList[m_AliasLocation + ALIAS_KEYWORD] = m_Keywords->GetValue();
CurrentLibEntry->m_AliasList[m_AliasLocation+ALIAS_DOC_FILENAME] = m_Docfile->GetValue(); CurrentLibEntry->m_AliasList[m_AliasLocation + ALIAS_DOC_FILENAME] = m_Docfile->GetValue();
} }
/* Update the alias list */ /* Update the alias list */
/* 1 - Add names: test for a not existing name in old alias list: */ /* 1 - Add names: test for a not existing name in old alias list: */
jj = m_PartAliasList->GetCount(); jj = m_PartAliasList->GetCount();
for ( ii = 0; ii < jj; ii++ ) for( ii = 0; ii < jj; ii++ )
{ {
if ( LocateAlias( CurrentLibEntry->m_AliasList, m_PartAliasList->GetString(ii)) < 0 ) if( LocateAlias( CurrentLibEntry->m_AliasList, m_PartAliasList->GetString( ii ) ) < 0 )
{ // new alias must be created { // new alias must be created
CurrentLibEntry->m_AliasList.Add(m_PartAliasList->GetString(ii)); CurrentLibEntry->m_AliasList.Add( m_PartAliasList->GetString( ii ) );
CurrentLibEntry->m_AliasList.Add(wxEmptyString); // Add a void doc string CurrentLibEntry->m_AliasList.Add( wxEmptyString ); // Add a void doc string
CurrentLibEntry->m_AliasList.Add(wxEmptyString); // Add a void keyword list string CurrentLibEntry->m_AliasList.Add( wxEmptyString ); // Add a void keyword list string
CurrentLibEntry->m_AliasList.Add(wxEmptyString); // Add a void doc filename string CurrentLibEntry->m_AliasList.Add( wxEmptyString ); // Add a void doc filename string
} }
} }
/* 2 - Remove delete names: test for an non existing name in new alias list: */ /* 2 - Remove delete names: test for an non existing name in new alias list: */
int kk, kkmax = CurrentLibEntry->m_AliasList.GetCount(); int kk, kkmax = CurrentLibEntry->m_AliasList.GetCount();
for ( kk = 0; kk < kkmax; ) for( kk = 0; kk < kkmax; )
{ {
jj = m_PartAliasList->GetCount(); jj = m_PartAliasList->GetCount();
wxString aliasname = CurrentLibEntry->m_AliasList[kk]; wxString aliasname = CurrentLibEntry->m_AliasList[kk];
for ( ii = 0; ii < jj; ii++ ) for( ii = 0; ii < jj; ii++ )
{ {
if( aliasname.CmpNoCase(m_PartAliasList->GetString(ii).GetData()) == 0 ) if( aliasname.CmpNoCase( m_PartAliasList->GetString( ii ).GetData() ) == 0 )
{ {
kk += ALIAS_NEXT; // Alias exist in new list. keep it and test next old name kk += ALIAS_NEXT; // Alias exist in new list. keep it and test next old name
break; break;
} }
} }
if ( ii == jj ) // Alias not found in new list, remove it (4 strings in kk position) if( ii == jj ) // Alias not found in new list, remove it (4 strings in kk position)
{ {
for( ii = 0; ii < ALIAS_NEXT; ii++ ) CurrentLibEntry->m_AliasList.RemoveAt(kk); for( ii = 0; ii < ALIAS_NEXT; ii++ )
CurrentLibEntry->m_AliasList.RemoveAt( kk );
kkmax = CurrentLibEntry->m_AliasList.GetCount(); kkmax = CurrentLibEntry->m_AliasList.GetCount();
} }
} }
// Void fields for REFERENCE and VALUE are not allowed // Void fields for REFERENCE and VALUE are not allowed
if ( m_FieldText[REFERENCE].IsEmpty() ) if( m_FieldText[REFERENCE].IsEmpty() )
{ {
m_FieldText[REFERENCE] = CurrentLibEntry->m_Prefix.m_Text; m_FieldText[REFERENCE] = CurrentLibEntry->m_Prefix.m_Text;
} }
if ( m_FieldText[VALUE].IsEmpty() ) if( m_FieldText[VALUE].IsEmpty() )
{ {
m_FieldText[VALUE] = CurrentLibEntry->m_Name.m_Text; m_FieldText[VALUE] = CurrentLibEntry->m_Name.m_Text;
} }
else else
{ {
if ( CurrentLibEntry->m_Name.m_Text != m_FieldText[VALUE] ) if( CurrentLibEntry->m_Name.m_Text != m_FieldText[VALUE] )
m_RecreateToolbar = TRUE; m_RecreateToolbar = TRUE;
} }
CopyBufferToFieldData(& CurrentLibEntry->m_Prefix); CopyBufferToFieldData( &CurrentLibEntry->m_Prefix );
CopyBufferToFieldData(& CurrentLibEntry->m_Name); CopyBufferToFieldData( &CurrentLibEntry->m_Name );
for ( ii = FOOTPRINT; ii < NUMBER_OF_FIELDS; ii++ ) for( ii = FOOTPRINT; ii < NUMBER_OF_FIELDS; ii++ )
{ {
LibDrawField * Field = CurrentLibEntry->Fields; LibDrawField* Field = CurrentLibEntry->Fields;
LibDrawField * NextField, * previousField = NULL; LibDrawField* NextField, * previousField = NULL;
while ( Field ) while( Field )
{ {
NextField = (LibDrawField*)Field->Pnext; NextField = (LibDrawField*) Field->Pnext;
if( Field->m_FieldId == ii ) if( Field->m_FieldId == ii )
{ {
CopyBufferToFieldData(Field); CopyBufferToFieldData( Field );
// An old field exists; delete it if void // An old field exists; delete it if void
if( Field->m_Text.IsEmpty() ) if( Field->m_Text.IsEmpty() )
{ {
if ( ii < FIELD1 || Field->m_Name.IsEmpty() ) if( ii < FIELD1 || Field->m_Name.IsEmpty() )
{ {
delete Field; delete Field;
if ( previousField ) previousField->Pnext = NextField; if( previousField )
else CurrentLibEntry->Fields = NextField; previousField->Pnext = NextField;
else
CurrentLibEntry->Fields = NextField;
} }
} }
break; break;
...@@ -684,16 +774,18 @@ int ii, jj; ...@@ -684,16 +774,18 @@ int ii, jj;
Field = NextField; Field = NextField;
} }
if ( Field == NULL) // Do not exists: must be created if not void if( Field == NULL ) // Do not exists: must be created if not void
{ {
bool create = FALSE; bool create = FALSE;
if ( ! m_FieldText[ii].IsEmpty() ) create = TRUE; if( !m_FieldText[ii].IsEmpty() )
if ( ! m_FieldName[ii].IsEmpty() && (m_FieldName[ii] != ReturnDefaultFieldName(ii)) ) create = TRUE;
if( !m_FieldName[ii].IsEmpty() && ( m_FieldName[ii] != ReturnDefaultFieldName( ii ) ) )
create = TRUE; create = TRUE;
if ( create ) if( create )
{ {
Field = new LibDrawField(ii); Field = new LibDrawField( ii );
CopyBufferToFieldData(Field);
CopyBufferToFieldData( Field );
Field->Pnext = CurrentLibEntry->Fields; Field->Pnext = CurrentLibEntry->Fields;
CurrentLibEntry->Fields = Field; CurrentLibEntry->Fields = Field;
} }
...@@ -701,209 +793,224 @@ int ii, jj; ...@@ -701,209 +793,224 @@ int ii, jj;
} }
/* for a user field (FieldId >= FIELD1), if a field value is void, /* for a user field (FieldId >= FIELD1), if a field value is void,
fill it with "~" because for a library componenta void field is not a very good idea * fill it with "~" because for a library componenta void field is not a very good idea
(we do not see anything...) and in schematic this text is like a void text */ * (we do not see anything...) and in schematic this text is like a void text */
{ {
LibDrawField * Field = CurrentLibEntry->Fields; LibDrawField* Field = CurrentLibEntry->Fields;
while ( Field ) while( Field )
{ {
if( Field->m_FieldId >= FIELD1 ) if( Field->m_FieldId >= FIELD1 )
if ( Field->m_Text.IsEmpty() ) Field->m_Text = wxT("~"); if( Field->m_Text.IsEmpty() )
Field = (LibDrawField*)Field->Pnext; Field->m_Text = wxT( "~" );
Field = (LibDrawField*) Field->Pnext;
} }
} }
ii = SelNumberOfUnits->GetValue(); ii = SelNumberOfUnits->GetValue();
if ( ChangeNbUnitsPerPackage(ii) ) if( ChangeNbUnitsPerPackage( ii ) )
m_RecreateToolbar = TRUE; m_RecreateToolbar = TRUE;
if ( AsConvertButt->GetValue() ) if( AsConvertButt->GetValue() )
{ {
if ( ! g_AsDeMorgan ) if( !g_AsDeMorgan )
{ {
g_AsDeMorgan = 1; g_AsDeMorgan = 1;
if ( SetUnsetConvert() ) m_RecreateToolbar = TRUE; if( SetUnsetConvert() )
m_RecreateToolbar = TRUE;
} }
} }
else else
{ {
if ( g_AsDeMorgan ) if( g_AsDeMorgan )
{ {
g_AsDeMorgan = 0; g_AsDeMorgan = 0;
if ( SetUnsetConvert() ) m_RecreateToolbar = TRUE; if( SetUnsetConvert() )
m_RecreateToolbar = TRUE;
} }
} }
CurrentLibEntry->m_DrawPinNum = ShowPinNumButt->GetValue() ? 1 : 0; CurrentLibEntry->m_DrawPinNum = ShowPinNumButt->GetValue() ? 1 : 0;
CurrentLibEntry->m_DrawPinName = ShowPinNameButt->GetValue() ? 1 : 0; CurrentLibEntry->m_DrawPinName = ShowPinNameButt->GetValue() ? 1 : 0;
if ( m_PinsNameInsideButt->GetValue() == FALSE) if( m_PinsNameInsideButt->GetValue() == FALSE )
CurrentLibEntry->m_TextInside = 0; CurrentLibEntry->m_TextInside = 0;
else else
CurrentLibEntry->m_TextInside = m_SetSkew->GetValue(); CurrentLibEntry->m_TextInside = m_SetSkew->GetValue();
if ( m_OptionPower->GetValue() == TRUE) if( m_OptionPower->GetValue() == TRUE )
CurrentLibEntry->m_Options = ENTRY_POWER; CurrentLibEntry->m_Options = ENTRY_POWER;
else else
CurrentLibEntry->m_Options = ENTRY_NORMAL; CurrentLibEntry->m_Options = ENTRY_NORMAL;
/* Set the option "Units locked". /* Set the option "Units locked".
Obviously, cannot be TRUE if there is only one part */ * Obviously, cannot be TRUE if there is only one part */
CurrentLibEntry->m_UnitSelectionLocked = m_OptionPartsLocked->GetValue(); CurrentLibEntry->m_UnitSelectionLocked = m_OptionPartsLocked->GetValue();
if ( CurrentLibEntry->m_UnitCount <= 1 ) if( CurrentLibEntry->m_UnitCount <= 1 )
CurrentLibEntry->m_UnitSelectionLocked = FALSE; CurrentLibEntry->m_UnitSelectionLocked = FALSE;
if ( m_RecreateToolbar ) m_Parent->ReCreateHToolbar(); if( m_RecreateToolbar )
m_Parent->ReCreateHToolbar();
m_Parent->DisplayLibInfos(); m_Parent->DisplayLibInfos();
/* Update the footprint filter list */ /* Update the footprint filter list */
CurrentLibEntry->m_FootprintList.Clear(); CurrentLibEntry->m_FootprintList.Clear();
jj = m_FootprintFilterListBox->GetCount(); jj = m_FootprintFilterListBox->GetCount();
for ( ii = 0; ii < jj; ii ++) for( ii = 0; ii < jj; ii++ )
CurrentLibEntry->m_FootprintList.Add(m_FootprintFilterListBox->GetString(ii)); CurrentLibEntry->m_FootprintList.Add( m_FootprintFilterListBox->GetString( ii ) );
EndModal(1); EndModal( 1 );
} }
/*******************************************************************************/ /*******************************************************************************/
void WinEDA_PartPropertiesFrame::CopyDocToAlias(wxCommandEvent& WXUNUSED(event)) void WinEDA_PartPropertiesFrame::CopyDocToAlias( wxCommandEvent& WXUNUSED (event) )
/******************************************************************************/ /******************************************************************************/
{ {
if( CurrentLibEntry == NULL ) return; if( CurrentLibEntry == NULL )
if ( CurrentAliasName.IsEmpty() ) return; return;
if( CurrentAliasName.IsEmpty() )
return;
m_Doc->SetValue(CurrentLibEntry->m_Doc); m_Doc->SetValue( CurrentLibEntry->m_Doc );
m_Docfile->SetValue(CurrentLibEntry->m_DocFile); m_Docfile->SetValue( CurrentLibEntry->m_DocFile );
m_Keywords->SetValue(CurrentLibEntry->m_KeyWord); m_Keywords->SetValue( CurrentLibEntry->m_KeyWord );
} }
/**********************************************************/ /**********************************************************/
void WinEDA_PartPropertiesFrame::DeleteAllAliasOfPart( void WinEDA_PartPropertiesFrame::DeleteAllAliasOfPart(
wxCommandEvent& WXUNUSED(event)) wxCommandEvent& WXUNUSED (event) )
/**********************************************************/ /**********************************************************/
{ {
CurrentAliasName.Empty(); CurrentAliasName.Empty();
if( CurrentLibEntry ) if( CurrentLibEntry )
{ {
if( IsOK(this, _("Ok to Delete Alias LIST") ) ) if( IsOK( this, _( "Ok to Delete Alias LIST" ) ) )
{ {
m_PartAliasList->Clear(); m_PartAliasList->Clear();
m_RecreateToolbar = TRUE; m_RecreateToolbar = TRUE;
m_ButtonDeleteAllAlias->Enable(FALSE); m_ButtonDeleteAllAlias->Enable( FALSE );
m_ButtonDeleteOneAlias->Enable(FALSE); m_ButtonDeleteOneAlias->Enable( FALSE );
} }
} }
} }
/*******************************************************************************/ /*******************************************************************************/
void WinEDA_PartPropertiesFrame::AddAliasOfPart( wxCommandEvent& WXUNUSED(event)) void WinEDA_PartPropertiesFrame::AddAliasOfPart( wxCommandEvent& WXUNUSED (event) )
/*******************************************************************************/ /*******************************************************************************/
/* Add a new name to the alias list box /* Add a new name to the alias list box
New name cannot be the root name, and must not exists * New name cannot be the root name, and must not exists
*/ */
{ {
wxString Line; wxString Line;
wxString aliasname; wxString aliasname;
if(CurrentLibEntry == NULL) return; if( CurrentLibEntry == NULL )
return;
if( Get_Message(_("New alias:"),Line, this) != 0 ) return; if( Get_Message( _( "New alias:" ), Line, this ) != 0 )
return;
Line.Replace( wxT(" "), wxT("_") ); Line.Replace( wxT( " " ), wxT( "_" ) );
aliasname = Line; aliasname = Line;
if ( CurrentLibEntry->m_Name.m_Text.CmpNoCase(Line) == 0 ) if( CurrentLibEntry->m_Name.m_Text.CmpNoCase( Line ) == 0 )
{ {
DisplayError(this, _("This is the Root Part"), 10); return; DisplayError( this, _( "This is the Root Part" ), 10 ); return;
} }
/* test for an existing name: */ /* test for an existing name: */
int ii, jj = m_PartAliasList->GetCount(); int ii, jj = m_PartAliasList->GetCount();
for ( ii = 0; ii < jj; ii++ ) for( ii = 0; ii < jj; ii++ )
{ {
if( aliasname.CmpNoCase(m_PartAliasList->GetString(ii)) == 0 ) if( aliasname.CmpNoCase( m_PartAliasList->GetString( ii ) ) == 0 )
{ {
DisplayError(this, _("Already in use"), 10); DisplayError( this, _( "Already in use" ), 10 );
return; return;
} }
} }
m_PartAliasList->Append(aliasname); m_PartAliasList->Append( aliasname );
if ( CurrentAliasName.IsEmpty() ) m_ButtonDeleteAllAlias->Enable(TRUE); if( CurrentAliasName.IsEmpty() )
m_ButtonDeleteOneAlias->Enable(TRUE); m_ButtonDeleteAllAlias->Enable( TRUE );
m_ButtonDeleteOneAlias->Enable( TRUE );
m_RecreateToolbar = TRUE; m_RecreateToolbar = TRUE;
} }
/********************************************************/ /********************************************************/
void WinEDA_PartPropertiesFrame::DeleteAliasOfPart( void WinEDA_PartPropertiesFrame::DeleteAliasOfPart(
wxCommandEvent& WXUNUSED(event)) wxCommandEvent& WXUNUSED (event) )
/********************************************************/ /********************************************************/
{ {
wxString aliasname = m_PartAliasList->GetStringSelection(); wxString aliasname = m_PartAliasList->GetStringSelection();
if ( aliasname.IsEmpty() ) return; if( aliasname.IsEmpty() )
if ( aliasname == CurrentAliasName ) return;
if( aliasname == CurrentAliasName )
{ {
wxString msg = CurrentAliasName + _(" is Current Selected Alias!"); wxString msg = CurrentAliasName + _( " is Current Selected Alias!" );
DisplayError(this, msg ); DisplayError( this, msg );
return; return;
} }
int ii = m_PartAliasList->GetSelection(); int ii = m_PartAliasList->GetSelection();
m_PartAliasList->Delete(ii); m_PartAliasList->Delete( ii );
if ( ! CurrentLibEntry || (CurrentLibEntry->m_AliasList.GetCount() == 0) ) if( !CurrentLibEntry || (CurrentLibEntry->m_AliasList.GetCount() == 0) )
{ {
m_ButtonDeleteAllAlias->Enable(FALSE); m_ButtonDeleteAllAlias->Enable( FALSE );
m_ButtonDeleteOneAlias->Enable(FALSE); m_ButtonDeleteOneAlias->Enable( FALSE );
} }
m_RecreateToolbar = TRUE; m_RecreateToolbar = TRUE;
} }
/********************************************************************/ /********************************************************************/
bool WinEDA_PartPropertiesFrame::ChangeNbUnitsPerPackage(int MaxUnit) bool WinEDA_PartPropertiesFrame::ChangeNbUnitsPerPackage( int MaxUnit )
/********************************************************************/ /********************************************************************/
/* Routine de modification du nombre d'unites par package pour le /* Routine de modification du nombre d'unites par package pour le
composant courant; * composant courant;
*/ */
{ {
int OldNumUnits, ii, FlagDel = -1; int OldNumUnits, ii, FlagDel = -1;
LibEDA_BaseStruct* DrawItem, * NextDrawItem; LibEDA_BaseStruct* DrawItem, * NextDrawItem;
if( CurrentLibEntry == NULL ) return FALSE; if( CurrentLibEntry == NULL )
return FALSE;
/* Si pas de changement: termine */ /* Si pas de changement: termine */
if ( CurrentLibEntry->m_UnitCount == MaxUnit ) return FALSE; if( CurrentLibEntry->m_UnitCount == MaxUnit )
return FALSE;
OldNumUnits = CurrentLibEntry->m_UnitCount; OldNumUnits = CurrentLibEntry->m_UnitCount;
if ( OldNumUnits < 1 ) OldNumUnits = 1; if( OldNumUnits < 1 )
OldNumUnits = 1;
CurrentLibEntry->m_UnitCount = MaxUnit; CurrentLibEntry->m_UnitCount = MaxUnit;
/* Traitement des unites enlevees ou rajoutees */ /* Traitement des unites enlevees ou rajoutees */
if(OldNumUnits > CurrentLibEntry->m_UnitCount ) if( OldNumUnits > CurrentLibEntry->m_UnitCount )
{ {
DrawItem = CurrentLibEntry->m_Drawings; DrawItem = CurrentLibEntry->m_Drawings;
for ( ; DrawItem != NULL; DrawItem = NextDrawItem) for( ; DrawItem != NULL; DrawItem = NextDrawItem )
{ {
NextDrawItem = DrawItem->Next(); NextDrawItem = DrawItem->Next();
if( DrawItem->m_Unit > MaxUnit ) /* Item a effacer */ if( DrawItem->m_Unit > MaxUnit ) /* Item a effacer */
{ {
if( FlagDel < 0 ) if( FlagDel < 0 )
{ {
if( IsOK(this, _("Delete units") ) ) if( IsOK( this, _( "Delete units" ) ) )
{ {
/* Si part selectee n'existe plus: selection 1ere unit */ /* Si part selectee n'existe plus: selection 1ere unit */
if( CurrentUnit > MaxUnit ) CurrentUnit = 1; if( CurrentUnit > MaxUnit )
CurrentUnit = 1;
FlagDel = 1; FlagDel = 1;
} }
else else
...@@ -914,24 +1021,25 @@ LibEDA_BaseStruct* DrawItem, * NextDrawItem; ...@@ -914,24 +1021,25 @@ LibEDA_BaseStruct* DrawItem, * NextDrawItem;
return FALSE; return FALSE;
} }
} }
DeleteOneLibraryDrawStruct(m_Parent->DrawPanel, NULL, CurrentLibEntry, DeleteOneLibraryDrawStruct( m_Parent->DrawPanel, NULL, CurrentLibEntry,
DrawItem, 0); DrawItem, 0 );
} }
} }
return TRUE; return TRUE;
} }
if(OldNumUnits < CurrentLibEntry->m_UnitCount ) if( OldNumUnits < CurrentLibEntry->m_UnitCount )
{ {
DrawItem = CurrentLibEntry->m_Drawings; DrawItem = CurrentLibEntry->m_Drawings;
for ( ; DrawItem != NULL; DrawItem = DrawItem->Next() ) for( ; DrawItem != NULL; DrawItem = DrawItem->Next() )
{ {
/* Duplication des items pour autres elements */ /* Duplication des items pour autres elements */
if( DrawItem->m_Unit == 1 ) if( DrawItem->m_Unit == 1 )
{ {
for ( ii = OldNumUnits +1; ii <= MaxUnit; ii ++ ) for( ii = OldNumUnits + 1; ii <= MaxUnit; ii++ )
{ {
NextDrawItem = CopyDrawEntryStruct(this, DrawItem); NextDrawItem = CopyDrawEntryStruct( this, DrawItem );
NextDrawItem->Pnext = CurrentLibEntry->m_Drawings; NextDrawItem->Pnext = CurrentLibEntry->m_Drawings;
CurrentLibEntry->m_Drawings = NextDrawItem; CurrentLibEntry->m_Drawings = NextDrawItem;
NextDrawItem->m_Unit = ii; NextDrawItem->m_Unit = ii;
...@@ -946,55 +1054,58 @@ LibEDA_BaseStruct* DrawItem, * NextDrawItem; ...@@ -946,55 +1054,58 @@ LibEDA_BaseStruct* DrawItem, * NextDrawItem;
/*****************************************************/ /*****************************************************/
bool WinEDA_PartPropertiesFrame::SetUnsetConvert() bool WinEDA_PartPropertiesFrame::SetUnsetConvert()
/*****************************************************/ /*****************************************************/
/* cre ou efface (selon option AsConvert) les lments /* cre ou efface (selon option AsConvert) les lments
de la reprsentation convertie d'un composant * de la reprsentation convertie d'un composant
*/ */
{ {
int FlagDel = 0; int FlagDel = 0;
LibEDA_BaseStruct* DrawItem = NULL, * NextDrawItem; LibEDA_BaseStruct* DrawItem = NULL, * NextDrawItem;
if( g_AsDeMorgan ) /* Representation convertie a creer */ if( g_AsDeMorgan ) /* Representation convertie a creer */
{ {
/* Traitement des elements a ajouter ( pins seulement ) */ /* Traitement des elements a ajouter ( pins seulement ) */
if( CurrentLibEntry ) DrawItem = CurrentLibEntry->m_Drawings; if( CurrentLibEntry )
for ( ; DrawItem != NULL; DrawItem = DrawItem->Next() ) DrawItem = CurrentLibEntry->m_Drawings;
for( ; DrawItem != NULL; DrawItem = DrawItem->Next() )
{ {
/* Duplication des items pour autres elements */ /* Duplication des items pour autres elements */
if( DrawItem->Type() != COMPONENT_PIN_DRAW_TYPE ) continue; if( DrawItem->Type() != COMPONENT_PIN_DRAW_TYPE )
continue;
if( DrawItem->m_Convert == 1 ) if( DrawItem->m_Convert == 1 )
{ {
if( FlagDel == 0 ) if( FlagDel == 0 )
{ {
if( IsOK(this, _("Create pins for Convert items")) ) if( IsOK( this, _( "Create pins for Convert items" ) ) )
FlagDel = 1; FlagDel = 1;
else else
{ {
if( IsOK(this, _("Part as \"De Morgan\" anymore")) ) if( IsOK( this, _( "Part as \"De Morgan\" anymore" ) ) )
return TRUE; return TRUE;
g_AsDeMorgan = 0; return FALSE; g_AsDeMorgan = 0; return FALSE;
} }
} }
NextDrawItem = CopyDrawEntryStruct(this, DrawItem); NextDrawItem = CopyDrawEntryStruct( this, DrawItem );
NextDrawItem->Pnext = CurrentLibEntry->m_Drawings; NextDrawItem->Pnext = CurrentLibEntry->m_Drawings;
CurrentLibEntry->m_Drawings = NextDrawItem; CurrentLibEntry->m_Drawings = NextDrawItem;
NextDrawItem->m_Convert = 2; NextDrawItem->m_Convert = 2;
} }
} }
} }
else /* Representation convertie a supprimer */ else /* Representation convertie a supprimer */
{ {
/* Traitement des elements supprimer */ /* Traitement des elements supprimer */
if( CurrentLibEntry ) DrawItem = CurrentLibEntry->m_Drawings; if( CurrentLibEntry )
for ( ; DrawItem != NULL; DrawItem = NextDrawItem) DrawItem = CurrentLibEntry->m_Drawings;
for( ; DrawItem != NULL; DrawItem = NextDrawItem )
{ {
NextDrawItem = DrawItem->Next(); NextDrawItem = DrawItem->Next();
if( DrawItem->m_Convert > 1 ) /* Item a effacer */ if( DrawItem->m_Convert > 1 ) /* Item a effacer */
{ {
if( FlagDel == 0 ) if( FlagDel == 0 )
{ {
if( IsOK(this, _("Delete Convert items") ) ) if( IsOK( this, _( "Delete Convert items" ) ) )
{ {
CurrentConvert = 1; CurrentConvert = 1;
FlagDel = 1; FlagDel = 1;
...@@ -1006,24 +1117,30 @@ LibEDA_BaseStruct* DrawItem = NULL, * NextDrawItem; ...@@ -1006,24 +1117,30 @@ LibEDA_BaseStruct* DrawItem = NULL, * NextDrawItem;
} }
} }
m_Parent->GetScreen()->SetModify(); m_Parent->GetScreen()->SetModify();
DeleteOneLibraryDrawStruct(m_Parent->DrawPanel, NULL, CurrentLibEntry, DrawItem, 0); DeleteOneLibraryDrawStruct( m_Parent->DrawPanel,
NULL,
CurrentLibEntry,
DrawItem,
0 );
} }
} }
} }
return TRUE; return TRUE;
} }
/****************************************************************************/ /****************************************************************************/
void WinEDA_PartPropertiesFrame::BrowseAndSelectDocFile(wxCommandEvent& event) void WinEDA_PartPropertiesFrame::BrowseAndSelectDocFile( wxCommandEvent& event )
/****************************************************************************/ /****************************************************************************/
{ {
wxString FullFileName, mask; wxString FullFileName, mask;
wxString docpath(g_RealLibDirBuffer), filename;
docpath += wxT("doc"); wxString docpath( g_RealLibDirBuffer ), filename;
docpath += wxT( "doc" );
docpath += STRING_DIR_SEP; docpath += STRING_DIR_SEP;
mask = wxT("*"); mask = wxT( "*" );
FullFileName = EDA_FileSelector(_("Doc Files"), FullFileName = EDA_FileSelector( _( "Doc Files" ),
docpath, /* Chemin par defaut */ docpath, /* Chemin par defaut */
wxEmptyString, /* nom fichier par defaut */ wxEmptyString, /* nom fichier par defaut */
wxEmptyString, /* extension par defaut */ wxEmptyString, /* extension par defaut */
...@@ -1032,72 +1149,76 @@ wxString docpath(g_RealLibDirBuffer), filename; ...@@ -1032,72 +1149,76 @@ wxString docpath(g_RealLibDirBuffer), filename;
wxFD_OPEN, wxFD_OPEN,
TRUE TRUE
); );
if ( FullFileName.IsEmpty() ) return; if( FullFileName.IsEmpty() )
return;
// Suppression du chemin par defaut pour le fichier de doc: // Suppression du chemin par defaut pour le fichier de doc:
filename = MakeReducedFileName(FullFileName,docpath, wxEmptyString); filename = MakeReducedFileName( FullFileName, docpath, wxEmptyString );
m_Docfile->SetValue(filename); m_Docfile->SetValue( filename );
} }
/**********************************************************/ /**********************************************************/
void WinEDA_PartPropertiesFrame::DeleteAllFootprintFilter( void WinEDA_PartPropertiesFrame::DeleteAllFootprintFilter(
wxCommandEvent& WXUNUSED(event)) wxCommandEvent& WXUNUSED (event) )
/**********************************************************/ /**********************************************************/
{ {
if( IsOK( this, _( "Ok to Delete FootprintFilter LIST" ) ) )
if( IsOK(this, _("Ok to Delete FootprintFilter LIST") ) )
{ {
m_FootprintFilterListBox->Clear(); m_FootprintFilterListBox->Clear();
m_ButtonDeleteAllFootprintFilter->Enable(FALSE); m_ButtonDeleteAllFootprintFilter->Enable( FALSE );
m_ButtonDeleteOneFootprintFilter->Enable(FALSE); m_ButtonDeleteOneFootprintFilter->Enable( FALSE );
} }
} }
/*******************************************************************************/ /*******************************************************************************/
void WinEDA_PartPropertiesFrame::AddFootprintFilter( wxCommandEvent& WXUNUSED(event)) void WinEDA_PartPropertiesFrame::AddFootprintFilter( wxCommandEvent& WXUNUSED (event) )
/*******************************************************************************/ /*******************************************************************************/
/* Add a new name to the alias list box /* Add a new name to the alias list box
New name cannot be the root name, and must not exists * New name cannot be the root name, and must not exists
*/ */
{ {
wxString Line; wxString Line;
if(CurrentLibEntry == NULL) return; if( CurrentLibEntry == NULL )
return;
if( Get_Message(_("New FootprintFilter:"),Line, this) != 0 ) return; if( Get_Message( _( "New FootprintFilter:" ), Line, this ) != 0 )
return;
Line.Replace( wxT(" "), wxT("_") ); Line.Replace( wxT( " " ), wxT( "_" ) );
/* test for an existing name: */ /* test for an existing name: */
int ii, jj = m_FootprintFilterListBox->GetCount(); int ii, jj = m_FootprintFilterListBox->GetCount();
for ( ii = 0; ii < jj; ii++ ) for( ii = 0; ii < jj; ii++ )
{ {
if( Line.CmpNoCase(m_FootprintFilterListBox->GetString(ii)) == 0 ) if( Line.CmpNoCase( m_FootprintFilterListBox->GetString( ii ) ) == 0 )
{ {
DisplayError(this, _("Already in use"), 10); DisplayError( this, _( "Already in use" ), 10 );
return; return;
} }
} }
m_FootprintFilterListBox->Append(Line); m_FootprintFilterListBox->Append( Line );
m_ButtonDeleteAllFootprintFilter->Enable(TRUE); m_ButtonDeleteAllFootprintFilter->Enable( TRUE );
m_ButtonDeleteOneFootprintFilter->Enable(TRUE); m_ButtonDeleteOneFootprintFilter->Enable( TRUE );
} }
/********************************************************/ /********************************************************/
void WinEDA_PartPropertiesFrame::DeleteOneFootprintFilter( void WinEDA_PartPropertiesFrame::DeleteOneFootprintFilter(
wxCommandEvent& WXUNUSED(event)) wxCommandEvent& WXUNUSED (event) )
/********************************************************/ /********************************************************/
{ {
int ii = m_FootprintFilterListBox->GetSelection(); int ii = m_FootprintFilterListBox->GetSelection();
m_FootprintFilterListBox->Delete(ii);
m_FootprintFilterListBox->Delete( ii );
if ( ! CurrentLibEntry || (m_FootprintFilterListBox->GetCount() == 0) ) if( !CurrentLibEntry || (m_FootprintFilterListBox->GetCount() == 0) )
{ {
m_ButtonDeleteAllFootprintFilter->Enable(FALSE); m_ButtonDeleteAllFootprintFilter->Enable( FALSE );
m_ButtonDeleteOneFootprintFilter->Enable(FALSE); m_ButtonDeleteOneFootprintFilter->Enable( FALSE );
} }
} }
eeschema/erc.cpp
View file @ 664a1f72
/**************************************************/ /**************************************************/
/* Module de tst "ERC" ( Electrical Rules Check ) */ /* Module de tst "ERC" ( Electrical Rules Check ) */
/**************************************************/ /**************************************************/
#include "fctsys.h" #include "fctsys.h"
...@@ -20,9 +20,9 @@ ...@@ -20,9 +20,9 @@
#include "dialog_erc.h" #include "dialog_erc.h"
/* On teste /* On teste
1 - conflits entre pins connectees ( ex: 2 sorties connectees ) * 1 - conflits entre pins connectees ( ex: 2 sorties connectees )
2 - les imperatifs minimaux ( 1 entree doit etre connectee a une sortie ) * 2 - les imperatifs minimaux ( 1 entree doit etre connectee a une sortie )
*/ */
/* fonctions exportees */ /* fonctions exportees */
...@@ -30,74 +30,74 @@ ...@@ -30,74 +30,74 @@
/* fonctions importees */ /* fonctions importees */
/* fonctions locales */ /* fonctions locales */
static bool WriteDiagnosticERC(const wxString & FullFileName); static bool WriteDiagnosticERC( const wxString& FullFileName );
static void Diagnose(WinEDA_DrawPanel * panel, wxDC * DC, static void Diagnose( WinEDA_DrawPanel* panel, wxDC* DC,
ObjetNetListStruct * NetItemRef, ObjetNetListStruct* NetItemRef,
ObjetNetListStruct * NetItemTst, int MinConnexion, int Diag); ObjetNetListStruct* NetItemTst, int MinConnexion, int Diag );
static void TestOthersItems(WinEDA_DrawPanel * panel, static void TestOthersItems( WinEDA_DrawPanel* panel,
wxDC * DC, ObjetNetListStruct * NetItemRef, wxDC* DC, ObjetNetListStruct* NetItemRef,
ObjetNetListStruct * NetStart, ObjetNetListStruct* NetStart,
int * NetNbItems, int * MinConnexion ); int* NetNbItems, int* MinConnexion );
static void TestLabel(WinEDA_DrawPanel * panel, wxDC * DC, static void TestLabel( WinEDA_DrawPanel* panel, wxDC* DC,
ObjetNetListStruct * NetItemRef, ObjetNetListStruct* NetItemRef,
ObjetNetListStruct * StartNet); ObjetNetListStruct* StartNet );
/* Variable locales */ /* Variable locales */
int WriteFichierERC = FALSE; int WriteFichierERC = FALSE;
/* Tableau des types de conflit : /* Tableau des types de conflit :
PIN_INPUT, PIN_OUTPUT, PIN_BIDI, PIN_TRISTATE, PIN_PASSIVE, * PIN_INPUT, PIN_OUTPUT, PIN_BIDI, PIN_TRISTATE, PIN_PASSIVE,
PIN_UNSPECIFIED, PIN_POWER_IN, PIN_POWER_OUT, PIN_OPENCOLLECTOR, * PIN_UNSPECIFIED, PIN_POWER_IN, PIN_POWER_OUT, PIN_OPENCOLLECTOR,
PIN_OPENEMITTER, PIN_NC * PIN_OPENEMITTER, PIN_NC
*/ */
#define OK 0 #define OK 0
#define WAR 1 // utilis aussi dans eeredraw #define WAR 1 // utilis aussi dans eeredraw
#define ERR 2 #define ERR 2
#define UNC 3 #define UNC 3
static wxChar * CommentERC_H[] = static const wxChar* CommentERC_H[] =
{ {
wxT("Input Pin...."), wxT( "Input Pin...." ),
wxT("Output Pin..."), wxT( "Output Pin..." ),
wxT("BiDi Pin....."), wxT( "BiDi Pin....." ),
wxT("3 State Pin.."), wxT( "3 State Pin.." ),
wxT("Passive Pin.."), wxT( "Passive Pin.." ),
wxT("Unspec Pin..."), wxT( "Unspec Pin..." ),
wxT("Power IN Pin."), wxT( "Power IN Pin." ),
wxT("PowerOUT Pin."), wxT( "PowerOUT Pin." ),
wxT("Open Coll...."), wxT( "Open Coll...." ),
wxT("Open Emit...."), wxT( "Open Emit...." ),
wxT("No Conn......"), wxT( "No Conn......" ),
NULL NULL
}; };
static wxChar * CommentERC_V[] = static const wxChar* CommentERC_V[] =
{ {
wxT("Input Pin"), wxT( "Input Pin" ),
wxT("Output Pin"), wxT( "Output Pin" ),
wxT("BiDi Pin"), wxT( "BiDi Pin" ),
wxT("3 State Pin"), wxT( "3 State Pin" ),
wxT("Passive Pin"), wxT( "Passive Pin" ),
wxT("Unspec Pin"), wxT( "Unspec Pin" ),
wxT("Power IN Pin"), wxT( "Power IN Pin" ),
wxT("PowerOUT Pin"), wxT( "PowerOUT Pin" ),
wxT("Open Coll"), wxT( "Open Coll" ),
wxT("Open Emit"), wxT( "Open Emit" ),
wxT("No Conn"), wxT( "No Conn" ),
NULL NULL
}; };
/* Look up table which gives the diag for a pair of connected pins /* Look up table which gives the diag for a pair of connected pins
Can be modified by ERC options. * Can be modified by ERC options.
at start up: must be loaded by DefaultDiagErc * at start up: must be loaded by DefaultDiagErc
*/ */
static int DiagErc[PIN_NMAX][PIN_NMAX]; static int DiagErc[PIN_NMAX][PIN_NMAX];
bool DiagErcTableInit; // go to TRUE after DiagErc init bool DiagErcTableInit; // go to TRUE after DiagErc init
/* Default Look up table which gives the diag for a pair of connected pins /* Default Look up table which gives the diag for a pair of connected pins
Same as DiagErc, but cannot be modified * Same as DiagErc, but cannot be modified
Used to init or reset DiagErc * Used to init or reset DiagErc
*/ */
static int DefaultDiagErc[PIN_NMAX][PIN_NMAX] = static int DefaultDiagErc[PIN_NMAX][PIN_NMAX] =
{ /* I, O, Bi, 3S, Pas, UnS,PwrI,PwrO, OC, OE, NC */ { /* I, O, Bi, 3S, Pas, UnS,PwrI,PwrO, OC, OE, NC */
/* I */ { OK, OK, OK, OK, OK, WAR, OK, OK, OK, OK, WAR }, /* I */ { OK, OK, OK, OK, OK, WAR, OK, OK, OK, OK, WAR },
...@@ -105,13 +105,13 @@ static int DefaultDiagErc[PIN_NMAX][PIN_NMAX] = ...@@ -105,13 +105,13 @@ static int DefaultDiagErc[PIN_NMAX][PIN_NMAX] =
/* Bi*/ { OK, OK, OK, OK, OK, WAR, OK, WAR, OK, WAR, WAR }, /* Bi*/ { OK, OK, OK, OK, OK, WAR, OK, WAR, OK, WAR, WAR },
/* 3S*/ { OK, WAR, OK, OK, OK, WAR, WAR, ERR, WAR, WAR, WAR }, /* 3S*/ { OK, WAR, OK, OK, OK, WAR, WAR, ERR, WAR, WAR, WAR },
/*Pas*/ { OK, OK, OK, OK, OK, WAR, OK, OK, OK, OK, WAR }, /*Pas*/ { OK, OK, OK, OK, OK, WAR, OK, OK, OK, OK, WAR },
/*UnS */{ WAR, WAR, WAR, WAR, WAR, WAR, WAR, WAR, WAR, WAR, WAR }, /*UnS */ { WAR, WAR, WAR, WAR, WAR, WAR, WAR, WAR, WAR, WAR, WAR },
/*PwrI*/{ OK, OK, OK, WAR, OK, WAR, OK, OK, OK, OK, ERR }, /*PwrI*/ { OK, OK, OK, WAR, OK, WAR, OK, OK, OK, OK, ERR },
/*PwrO*/{ OK, ERR, WAR, ERR, OK, WAR, OK, ERR, ERR, ERR, WAR }, /*PwrO*/ { OK, ERR, WAR, ERR, OK, WAR, OK, ERR, ERR, ERR, WAR },
/* OC */{ OK, ERR, OK, WAR, OK, WAR, OK, ERR, OK, OK, WAR }, /* OC */ { OK, ERR, OK, WAR, OK, WAR, OK, ERR, OK, OK, WAR },
/* OE */{ OK, ERR, WAR, WAR, OK, WAR, OK, ERR, OK, OK, WAR }, /* OE */ { OK, ERR, WAR, WAR, OK, WAR, OK, ERR, OK, OK, WAR },
/* NC */{ WAR, WAR, WAR, WAR, WAR, WAR, WAR, WAR, WAR, WAR, WAR } /* NC */ { WAR, WAR, WAR, WAR, WAR, WAR, WAR, WAR, WAR, WAR, WAR }
} ; };
/* Minimal connection table */ /* Minimal connection table */
...@@ -121,39 +121,39 @@ static int DefaultDiagErc[PIN_NMAX][PIN_NMAX] = ...@@ -121,39 +121,39 @@ static int DefaultDiagErc[PIN_NMAX][PIN_NMAX] =
#define NOC 0 /* Pin isolee, non connectee */ #define NOC 0 /* Pin isolee, non connectee */
/* Look up table which gives the minimal drive for a pair of connected pins on a net /* Look up table which gives the minimal drive for a pair of connected pins on a net
Initial state of a net is NOC (No Connection) * Initial state of a net is NOC (No Connection)
Can be updated to NET_NC, or NOD (Not Driven) or DRV (DRIven) * Can be updated to NET_NC, or NOD (Not Driven) or DRV (DRIven)
*
Can be updated to NET_NC only if the previous state is NOC * Can be updated to NET_NC only if the previous state is NOC
*
Nets are OK when their final state is NET_NC or DRV * Nets are OK when their final state is NET_NC or DRV
Nets with the state NOD have no source signal * Nets with the state NOD have no source signal
*/ */
static int MinimalReq[PIN_NMAX][PIN_NMAX] = static int MinimalReq[PIN_NMAX][PIN_NMAX] =
{ /* In, Out, Bi, 3S, Pas, UnS,PwrI,PwrO, OC, OE, NC */ { /* In, Out, Bi, 3S, Pas, UnS,PwrI,PwrO, OC, OE, NC */
/* In*/ { NOD, DRV, DRV, DRV, DRV, DRV, NOD, DRV, DRV, DRV, NOC }, /* In*/ { NOD, DRV, DRV, DRV, DRV, DRV, NOD, DRV, DRV, DRV, NOC },
/*Out*/ { DRV, DRV, DRV, DRV, DRV, DRV, DRV, DRV, DRV, DRV, NOC }, /*Out*/ { DRV, DRV, DRV, DRV, DRV, DRV, DRV, DRV, DRV, DRV, NOC },
/* Bi*/ { DRV, DRV, DRV, DRV, DRV, DRV, NOD, DRV, DRV, DRV, NOC }, /* Bi*/ { DRV, DRV, DRV, DRV, DRV, DRV, NOD, DRV, DRV, DRV, NOC },
/* 3S*/ { DRV, DRV, DRV, DRV, DRV, DRV, NOD, DRV, DRV, DRV, NOC }, /* 3S*/ { DRV, DRV, DRV, DRV, DRV, DRV, NOD, DRV, DRV, DRV, NOC },
/*Pas*/ { DRV, DRV, DRV, DRV, DRV, DRV, NOD, DRV, DRV, DRV, NOC }, /*Pas*/ { DRV, DRV, DRV, DRV, DRV, DRV, NOD, DRV, DRV, DRV, NOC },
/*UnS*/ { DRV, DRV, DRV, DRV, DRV, DRV, NOD, DRV, DRV, DRV, NOC }, /*UnS*/ { DRV, DRV, DRV, DRV, DRV, DRV, NOD, DRV, DRV, DRV, NOC },
/*PwrI*/{ NOD, DRV, NOD, NOD, NOD, NOD, NOD, DRV, NOD, NOD, NOC }, /*PwrI*/ { NOD, DRV, NOD, NOD, NOD, NOD, NOD, DRV, NOD, NOD, NOC },
/*PwrO*/{ DRV, DRV, DRV, DRV, DRV, DRV, DRV, DRV, DRV, DRV, NOC }, /*PwrO*/ { DRV, DRV, DRV, DRV, DRV, DRV, DRV, DRV, DRV, DRV, NOC },
/* OC*/ { DRV, DRV, DRV, DRV, DRV, DRV, NOD, DRV, DRV, DRV, NOC }, /* OC*/ { DRV, DRV, DRV, DRV, DRV, DRV, NOD, DRV, DRV, DRV, NOC },
/* OE*/ { DRV, DRV, DRV, DRV, DRV, DRV, NOD, DRV, DRV, DRV, NOC }, /* OE*/ { DRV, DRV, DRV, DRV, DRV, DRV, NOD, DRV, DRV, DRV, NOC },
/* NC*/ { NOC, NOC, NOC, NOC, NOC, NOC, NOC, NOC, NOC, NOC, NOC } /* NC*/ { NOC, NOC, NOC, NOC, NOC, NOC, NOC, NOC, NOC, NOC, NOC }
} ; };
/*************************************************************/ /*************************************************************/
void InstallErcFrame(WinEDA_SchematicFrame *parent, wxPoint & pos) void InstallErcFrame( WinEDA_SchematicFrame* parent, wxPoint& pos )
/*************************************************************/ /*************************************************************/
/* Install function for the ERC dialog frame /* Install function for the ERC dialog frame
*/ */
{ {
WinEDA_ErcFrame * frame = new WinEDA_ErcFrame(parent); WinEDA_ErcFrame* frame = new WinEDA_ErcFrame( parent );
frame->ShowModal(); frame->Destroy(); frame->ShowModal(); frame->Destroy();
} }
...@@ -161,149 +161,168 @@ void InstallErcFrame(WinEDA_SchematicFrame *parent, wxPoint & pos) ...@@ -161,149 +161,168 @@ void InstallErcFrame(WinEDA_SchematicFrame *parent, wxPoint & pos)
/*********************************************/ /*********************************************/
void WinEDA_ErcFrame::ReBuildMatrixPanel() void WinEDA_ErcFrame::ReBuildMatrixPanel()
/*********************************************/ /*********************************************/
/* Build or rebuild the panel showing the ERC matrix /* Build or rebuild the panel showing the ERC matrix
*/ */
{ {
int ii, jj, event_id, text_height; int ii, jj, event_id, text_height;
wxPoint pos, BoxMatrixPosition; wxPoint pos, BoxMatrixPosition;
#define BITMAP_SIZE 19 #define BITMAP_SIZE 19
int bitmap_size = BITMAP_SIZE; int bitmap_size = BITMAP_SIZE;
wxStaticText * text; wxStaticText* text;
int x, y; int x, y;
wxSize BoxMatrixMinSize; wxSize BoxMatrixMinSize;
if ( ! DiagErcTableInit ) if( !DiagErcTableInit )
{ {
memcpy(DiagErc, DefaultDiagErc, sizeof (DefaultDiagErc)); memcpy( DiagErc, DefaultDiagErc, sizeof(DefaultDiagErc) );
DiagErcTableInit = TRUE; DiagErcTableInit = TRUE;
} }
// Get the current text size : // Get the current text size :
text = new wxStaticText( m_PanelERCOptions,-1,wxT("W"), pos); // this is a dummy text text = new wxStaticText( m_PanelERCOptions, -1, wxT( "W" ), pos ); // this is a dummy text
text_height = text->GetRect().GetHeight(); text_height = text->GetRect().GetHeight();
bitmap_size = MAX(bitmap_size, text_height); bitmap_size = MAX( bitmap_size, text_height );
delete text; delete text;
// compute the Y pos interval: // compute the Y pos interval:
BoxMatrixMinSize.y = (bitmap_size*(PIN_NMAX+1)) + 5; BoxMatrixMinSize.y = ( bitmap_size * (PIN_NMAX + 1) ) + 5;
GetSizer()->Fit(this); GetSizer()->Fit( this );
GetSizer()->SetSizeHints(this); GetSizer()->SetSizeHints( this );
pos = m_MatrixSizer->GetPosition(); pos = m_MatrixSizer->GetPosition();
// Size computation is not made in constructor, in some wxWidgets version, // Size computation is not made in constructor, in some wxWidgets version,
// and m_BoxSizerForERC_Opt position is always 0,0. and we can't use it // and m_BoxSizerForERC_Opt position is always 0,0. and we can't use it
pos.x = MAX( pos.x, 5); pos.x = MAX( pos.x, 5 );
pos.y = MAX( pos.y, m_ResetOptButton->GetRect().GetHeight() + 30); pos.y = MAX( pos.y, m_ResetOptButton->GetRect().GetHeight() + 30 );
BoxMatrixPosition = pos; BoxMatrixPosition = pos;
pos.y += text_height; pos.y += text_height;
if ( m_Initialized == FALSE ) if( m_Initialized == FALSE )
{ {
for ( ii = 0; ii < PIN_NMAX; ii++ ) for( ii = 0; ii < PIN_NMAX; ii++ )
{ {
y = pos.y + (ii * bitmap_size); y = pos.y + (ii * bitmap_size);
text = new wxStaticText( m_PanelERCOptions,-1,CommentERC_H[ii], wxPoint(5,y)); text = new wxStaticText( m_PanelERCOptions, -1, CommentERC_H[ii], wxPoint( 5, y ) );
x = text->GetRect().GetRight(); x = text->GetRect().GetRight();
pos.x = MAX(pos.x, x); pos.x = MAX( pos.x, x );
} }
pos.x += 5; pos.x += 5;
} }
else pos = m_ButtonList[0][0]->GetPosition(); else
pos = m_ButtonList[0][0]->GetPosition();
for ( ii = 0; ii < PIN_NMAX; ii++ ) for( ii = 0; ii < PIN_NMAX; ii++ )
{ {
y = pos.y + (ii * bitmap_size); y = pos.y + (ii * bitmap_size);
for ( jj = 0; jj <= ii; jj++ ) for( jj = 0; jj <= ii; jj++ )
{ {
int diag = DiagErc[ii][jj]; int diag = DiagErc[ii][jj];
x = pos.x + (jj * bitmap_size); x = pos.x + (jj * bitmap_size);
if( (ii == jj) && ! m_Initialized ) if( (ii == jj) && !m_Initialized )
{ {
wxPoint txtpos; wxPoint txtpos;
txtpos.x = x + 4; txtpos.y = y - bitmap_size; txtpos.x = x + 4; txtpos.y = y - bitmap_size;
text = new wxStaticText( m_PanelERCOptions,-1,CommentERC_V[ii], txtpos); text = new wxStaticText( m_PanelERCOptions, -1, CommentERC_V[ii], txtpos );
BoxMatrixMinSize.x = MAX( BoxMatrixMinSize.x, text->GetRect().GetRight());
BoxMatrixMinSize.x = MAX( BoxMatrixMinSize.x, text->GetRect().GetRight() );
} }
event_id = ID_MATRIX_0 + ii + (jj * PIN_NMAX); event_id = ID_MATRIX_0 + ii + (jj * PIN_NMAX);
delete m_ButtonList[ii][jj]; delete m_ButtonList[ii][jj];
switch ( diag )
switch( diag )
{ {
case OK: case OK:
m_ButtonList[ii][jj] = new wxBitmapButton(m_PanelERCOptions, m_ButtonList[ii][jj] = new wxBitmapButton( m_PanelERCOptions,
event_id, event_id,
wxBitmap(green_xpm), wxBitmap (green_xpm),
wxPoint(x,y) ); wxPoint (x, y) );
break; break;
case WAR: case WAR:
m_ButtonList[ii][jj] = new wxBitmapButton(m_PanelERCOptions, m_ButtonList[ii][jj] = new wxBitmapButton( m_PanelERCOptions,
event_id, event_id,
wxBitmap(warning_xpm), wxBitmap (warning_xpm),
wxPoint(x,y) ); wxPoint (x, y) );
break; break;
case ERR: case ERR:
m_ButtonList[ii][jj] = new wxBitmapButton(m_PanelERCOptions, m_ButtonList[ii][jj] = new wxBitmapButton( m_PanelERCOptions,
event_id, event_id,
wxBitmap(error_xpm), wxBitmap (error_xpm),
wxPoint(x,y) ); wxPoint (x, y) );
break; break;
} }
} }
} }
if ( !m_Initialized ) if( !m_Initialized )
{ {
BoxMatrixMinSize.x += 5; BoxMatrixMinSize.x += 5;
m_MatrixSizer->SetMinSize(BoxMatrixMinSize); m_MatrixSizer->SetMinSize( BoxMatrixMinSize );
BoxMatrixMinSize.y += BoxMatrixPosition.y; BoxMatrixMinSize.y += BoxMatrixPosition.y;
m_PanelMatrixSizer->SetMinSize(BoxMatrixMinSize); m_PanelMatrixSizer->SetMinSize( BoxMatrixMinSize );
} }
m_Initialized = TRUE; m_Initialized = TRUE;
} }
/**************************************************/ /**************************************************/
void WinEDA_ErcFrame::TestErc(wxCommandEvent& event) void WinEDA_ErcFrame::TestErc( wxCommandEvent& event )
/**************************************************/ /**************************************************/
{ {
ObjetNetListStruct * NetItemRef, * OldItem, * StartNet, * Lim; ObjetNetListStruct* NetItemRef;
int NetNbItems, MinConn; ObjetNetListStruct* OldItem;
ObjetNetListStruct* StartNet;
ObjetNetListStruct* Lim;
if ( ! DiagErcTableInit ) int NetNbItems, MinConn;
if( !DiagErcTableInit )
{ {
memcpy(DiagErc, DefaultDiagErc, sizeof (DefaultDiagErc)); memcpy( DiagErc, DefaultDiagErc, sizeof(DefaultDiagErc) );
DiagErcTableInit = TRUE; DiagErcTableInit = TRUE;
} }
WriteFichierERC = m_WriteResultOpt->GetValue(); WriteFichierERC = m_WriteResultOpt->GetValue();
ReAnnotatePowerSymbolsOnly(); ReAnnotatePowerSymbolsOnly();
if( CheckAnnotate(m_Parent, 0) ) if( CheckAnnotate( m_Parent, 0 ) )
{ {
DisplayError(this, _("Annotation Required!") ); DisplayError( this, _( "Annotation Required!" ) );
return; return;
} }
/* Effacement des anciens marqueurs DRC */ /* Effacement des anciens marqueurs DRC */
DelERCMarkers(event); DelERCMarkers( event );
wxClientDC dc(m_Parent->DrawPanel); wxClientDC dc( m_Parent->DrawPanel );
m_Parent->DrawPanel->PrepareGraphicContext(&dc); m_Parent->DrawPanel->PrepareGraphicContext( &dc );
g_EESchemaVar.NbErrorErc = 0; g_EESchemaVar.NbErrorErc = 0;
g_EESchemaVar.NbWarningErc = 0; g_EESchemaVar.NbWarningErc = 0;
/* Cleanup the entire hierarchy */ /* Cleanup the entire hierarchy */
EDA_ScreenList ScreenList(NULL); EDA_ScreenList ScreenList( NULL );
for ( SCH_SCREEN * Screen = ScreenList.GetFirst(); Screen != NULL; Screen = ScreenList.GetNext() )
for( SCH_SCREEN* Screen = ScreenList.GetFirst(); Screen != NULL; Screen = ScreenList.GetNext() )
{ {
bool ModifyWires; bool ModifyWires;
ModifyWires = Screen->SchematicCleanUp(NULL); ModifyWires = Screen->SchematicCleanUp( NULL );
/* if wire list has changed, delete Udo Redo list to avoid /* if wire list has changed, delete Udo Redo list to avoid
pointers on deleted data problems */ * pointers on deleted data problems */
if ( ModifyWires ) if( ModifyWires )
Screen->ClearUndoRedoList(); Screen->ClearUndoRedoList();
} }
...@@ -313,20 +332,25 @@ wxClientDC dc(m_Parent->DrawPanel); ...@@ -313,20 +332,25 @@ wxClientDC dc(m_Parent->DrawPanel);
Lim = g_TabObjNet + g_NbrObjNet; Lim = g_TabObjNet + g_NbrObjNet;
/* Reset du flag m_FlagOfConnection, utilise par la suite */ /* Reset du flag m_FlagOfConnection, utilise par la suite */
for (NetItemRef = g_TabObjNet; NetItemRef < Lim; NetItemRef ++ ) for( NetItemRef = g_TabObjNet; NetItemRef < Lim; NetItemRef++ )
NetItemRef->m_FlagOfConnection = (IsConnectType) 0; NetItemRef->m_FlagOfConnection = (IsConnectType) 0;
NetNbItems = 0; MinConn = NOC; NetNbItems = 0;
MinConn = NOC;
StartNet = OldItem = NetItemRef = g_TabObjNet; StartNet = OldItem = NetItemRef = g_TabObjNet;
for ( ; NetItemRef < Lim; NetItemRef ++ )
for( ; NetItemRef < Lim; NetItemRef++ )
{ {
/* Tst changement de net */ /* Tst changement de net */
if( OldItem->m_NetCode != NetItemRef->m_NetCode) if( OldItem->m_NetCode != NetItemRef->m_NetCode )
{ {
MinConn = NOC; NetNbItems = 0; StartNet = NetItemRef; MinConn = NOC;
NetNbItems = 0;
StartNet = NetItemRef;
} }
switch ( NetItemRef->m_Type ) switch( NetItemRef->m_Type )
{ {
case NET_SEGMENT: case NET_SEGMENT:
case NET_BUS: case NET_BUS:
...@@ -340,127 +364,137 @@ wxClientDC dc(m_Parent->DrawPanel); ...@@ -340,127 +364,137 @@ wxClientDC dc(m_Parent->DrawPanel);
case NET_GLOBBUSLABELMEMBER: case NET_GLOBBUSLABELMEMBER:
case NET_SHEETLABEL: case NET_SHEETLABEL:
case NET_SHEETBUSLABELMEMBER: case NET_SHEETBUSLABELMEMBER:
TestLabel(m_Parent->DrawPanel, &dc, NetItemRef, StartNet); TestLabel( m_Parent->DrawPanel, &dc, NetItemRef, StartNet );
break; break;
case NET_NOCONNECT: case NET_NOCONNECT:
MinConn = NET_NC; MinConn = NET_NC;
if( NetNbItems != 0 ) if( NetNbItems != 0 )
Diagnose(m_Parent->DrawPanel, &dc, NetItemRef, NULL, MinConn, UNC); Diagnose( m_Parent->DrawPanel, &dc, NetItemRef, NULL, MinConn, UNC );
break; break;
case NET_PIN: case NET_PIN:
TestOthersItems(m_Parent->DrawPanel, &dc, TestOthersItems( m_Parent->DrawPanel, &dc,
NetItemRef, StartNet, &NetNbItems , &MinConn); NetItemRef, StartNet, &NetNbItems, &MinConn );
break; break;
} }
OldItem = NetItemRef; OldItem = NetItemRef;
} }
FreeTabNetList(g_TabObjNet, g_NbrObjNet ); FreeTabNetList( g_TabObjNet, g_NbrObjNet );
wxString num; wxString num;
num.Printf(wxT("%d"), g_EESchemaVar.NbErrorErc); num.Printf( wxT( "%d" ), g_EESchemaVar.NbErrorErc );
m_TotalErrCount->SetLabel(num); m_TotalErrCount->SetLabel( num );
num.Printf(wxT("%d"), g_EESchemaVar.NbErrorErc-g_EESchemaVar.NbWarningErc); num.Printf( wxT( "%d" ), g_EESchemaVar.NbErrorErc - g_EESchemaVar.NbWarningErc );
m_LastErrCount->SetLabel(num); m_LastErrCount->SetLabel( num );
num.Printf(wxT("%d"), g_EESchemaVar.NbWarningErc); num.Printf( wxT( "%d" ), g_EESchemaVar.NbWarningErc );
m_LastWarningCount->SetLabel(num); m_LastWarningCount->SetLabel( num );
/* Generation ouverture fichier diag */ /* Generation ouverture fichier diag */
if( WriteFichierERC == TRUE ) if( WriteFichierERC == TRUE )
{ {
wxString ErcFullFileName; wxString ErcFullFileName;
ErcFullFileName = ScreenSch->m_FileName; ErcFullFileName = ScreenSch->m_FileName;
ChangeFileNameExt(ErcFullFileName, wxT(".erc")); ChangeFileNameExt( ErcFullFileName, wxT( ".erc" ) );
ErcFullFileName = EDA_FileSelector(_("ERC file:"), ErcFullFileName = EDA_FileSelector( _( "ERC file:" ),
wxEmptyString, /* Chemin par defaut */ wxEmptyString, /* Chemin par defaut */
ErcFullFileName, /* nom fichier par defaut */ ErcFullFileName, /* nom fichier par defaut */
wxT(".erc"), /* extension par defaut */ wxT( ".erc" ), /* extension par defaut */
wxT("*.erc"), /* Masque d'affichage */ wxT( "*.erc" ), /* Masque d'affichage */
this, this,
wxFD_SAVE, wxFD_SAVE,
TRUE TRUE
); );
if ( ErcFullFileName.IsEmpty()) return; if( ErcFullFileName.IsEmpty() )
return;
if ( WriteDiagnosticERC(ErcFullFileName) ) if( WriteDiagnosticERC( ErcFullFileName ) )
{ {
Close(TRUE); Close( TRUE );
wxString editorname = GetEditorName(); wxString editorname = GetEditorName();
AddDelimiterString(ErcFullFileName); AddDelimiterString( ErcFullFileName );
ExecuteFile(this, editorname, ErcFullFileName); ExecuteFile( this, editorname, ErcFullFileName );
} }
} }
} }
/***********************************************************/ /***********************************************************/
void WinEDA_ErcFrame::DelERCMarkers(wxCommandEvent& event) void WinEDA_ErcFrame::DelERCMarkers( wxCommandEvent& event )
/***********************************************************/ /***********************************************************/
/* Delete the old ERC markers, over the whole hierarchy /* Delete the old ERC markers, over the whole hierarchy
*/ */
{ {
EDA_BaseStruct * DrawStruct; EDA_BaseStruct* DrawStruct;
DrawMarkerStruct * Marker; DrawMarkerStruct* Marker;
wxClientDC dc(m_Parent->DrawPanel);
m_Parent->DrawPanel->PrepareGraphicContext(&dc); wxClientDC dc( m_Parent->DrawPanel );
m_Parent->DrawPanel->PrepareGraphicContext( &dc );
// Delete markers for the current screen // Delete markers for the current screen
DrawStruct = m_Parent->GetScreen()->EEDrawList; DrawStruct = m_Parent->GetScreen()->EEDrawList;
for ( ; DrawStruct != NULL; DrawStruct = DrawStruct->Pnext ) for( ; DrawStruct != NULL; DrawStruct = DrawStruct->Pnext )
{ {
if(DrawStruct->Type() != DRAW_MARKER_STRUCT_TYPE ) continue; if( DrawStruct->Type() != DRAW_MARKER_STRUCT_TYPE )
continue;
/* Marqueur trouve */ /* Marqueur trouve */
Marker = (DrawMarkerStruct * ) DrawStruct; Marker = (DrawMarkerStruct*) DrawStruct;
if( Marker->m_Type == MARQ_ERC ) if( Marker->m_Type == MARQ_ERC )
RedrawOneStruct(m_Parent->DrawPanel, &dc, Marker, g_XorMode); RedrawOneStruct( m_Parent->DrawPanel, &dc, Marker, g_XorMode );
} }
/* Suppression en memoire des marqueurs ERC */ /* Suppression en memoire des marqueurs ERC */
DeleteAllMarkers(MARQ_ERC); DeleteAllMarkers( MARQ_ERC );
} }
/**************************************************************/ /**************************************************************/
void WinEDA_ErcFrame::ResetDefaultERCDiag(wxCommandEvent& event) void WinEDA_ErcFrame::ResetDefaultERCDiag( wxCommandEvent& event )
/**************************************************************/ /**************************************************************/
/* Remet aux valeurs par defaut la matrice de diagnostic /* Remet aux valeurs par defaut la matrice de diagnostic
*/ */
{ {
memcpy(DiagErc,DefaultDiagErc, sizeof(DiagErc) ); memcpy( DiagErc, DefaultDiagErc, sizeof(DiagErc) );
ReBuildMatrixPanel(); ReBuildMatrixPanel();
} }
/************************************************************/ /************************************************************/
void WinEDA_ErcFrame::ChangeErrorLevel(wxCommandEvent& event) void WinEDA_ErcFrame::ChangeErrorLevel( wxCommandEvent& event )
/************************************************************/ /************************************************************/
/* Change the error level for the pressed button, on the matrix table /* Change the error level for the pressed button, on the matrix table
*/ */
{ {
int id, level, ii, x, y; int id, level, ii, x, y;
wxBitmapButton * Butt; wxBitmapButton* Butt;
char ** new_bitmap_xpm = NULL; char** new_bitmap_xpm = NULL;
wxPoint pos; wxPoint pos;
id = event.GetId(); id = event.GetId();
ii = id - ID_MATRIX_0; ii = id - ID_MATRIX_0;
Butt = (wxBitmapButton*) event.GetEventObject(); Butt = (wxBitmapButton*) event.GetEventObject();
pos = Butt->GetPosition(); pos = Butt->GetPosition();
x = ii /PIN_NMAX; y = ii % PIN_NMAX; x = ii / PIN_NMAX; y = ii % PIN_NMAX;
level = DiagErc[y][x]; level = DiagErc[y][x];
switch (level )
switch( level )
{ {
case OK: case OK:
level = WAR; level = WAR;
new_bitmap_xpm = warning_xpm; new_bitmap_xpm = warning_xpm;
break; break;
case WAR : case WAR:
level = ERR; level = ERR;
new_bitmap_xpm = error_xpm; new_bitmap_xpm = error_xpm;
break; break;
...@@ -469,14 +503,14 @@ wxPoint pos; ...@@ -469,14 +503,14 @@ wxPoint pos;
level = OK; level = OK;
new_bitmap_xpm = green_xpm; new_bitmap_xpm = green_xpm;
break; break;
} }
if ( new_bitmap_xpm ) if( new_bitmap_xpm )
{ {
delete Butt; delete Butt;
Butt = new wxBitmapButton(m_PanelERCOptions, id, Butt = new wxBitmapButton( m_PanelERCOptions, id,
wxBitmap(new_bitmap_xpm), pos); wxBitmap (new_bitmap_xpm), pos );
m_ButtonList[y][x] = Butt; m_ButtonList[y][x] = Butt;
DiagErc[y][x] = DiagErc[x][y] = level; DiagErc[y][x] = DiagErc[x][y] = level;
} }
...@@ -484,25 +518,28 @@ wxPoint pos; ...@@ -484,25 +518,28 @@ wxPoint pos;
/********************************************************/ /********************************************************/
static void Diagnose(WinEDA_DrawPanel * panel, wxDC * DC, static void Diagnose( WinEDA_DrawPanel* panel, wxDC* DC,
ObjetNetListStruct * NetItemRef, ObjetNetListStruct* NetItemRef,
ObjetNetListStruct * NetItemTst, ObjetNetListStruct* NetItemTst,
int MinConn, int Diag) int MinConn, int Diag )
/********************************************************/ /********************************************************/
/* Routine de creation du marqueur ERC correspondant au conflit electrique /* Routine de creation du marqueur ERC correspondant au conflit electrique
entre NetItemRef et NetItemTst * entre NetItemRef et NetItemTst
si MinConn < 0: Traitement des erreurs sur labels * si MinConn < 0: Traitement des erreurs sur labels
*/ */
{ {
DrawMarkerStruct * Marker = NULL; DrawMarkerStruct* Marker = NULL;
wxString DiagLevel; wxString DiagLevel;
SCH_SCREEN * screen; SCH_SCREEN* screen;
int ii, jj; int ii, jj;
if( Diag == OK ) return; if( Diag == OK )
return;
/* Creation du nouveau marqueur type Erreur ERC */ /* Creation du nouveau marqueur type Erreur ERC */
Marker = new DrawMarkerStruct(NetItemRef->m_Start, wxEmptyString); Marker = new DrawMarkerStruct( NetItemRef->m_Start, wxEmptyString );
Marker->m_Type = MARQ_ERC; Marker->m_Type = MARQ_ERC;
Marker->m_MarkFlags = WAR; Marker->m_MarkFlags = WAR;
screen = NetItemRef->m_Screen; screen = NetItemRef->m_Screen;
...@@ -513,16 +550,18 @@ int ii, jj; ...@@ -513,16 +550,18 @@ int ii, jj;
if( MinConn < 0 ) // Traitement des erreurs sur labels if( MinConn < 0 ) // Traitement des erreurs sur labels
{ {
if( (NetItemRef->m_Type == NET_GLOBLABEL) || if( (NetItemRef->m_Type == NET_GLOBLABEL)
(NetItemRef->m_Type == NET_GLOBBUSLABELMEMBER) ) || (NetItemRef->m_Type == NET_GLOBBUSLABELMEMBER) )
{ {
Marker->m_Comment.Printf( _("Warning GLabel %s not connected to SheetLabel"), Marker->m_Comment.Printf( _( "Warning GLabel %s not connected to SheetLabel" ),
NetItemRef->m_Label->GetData()); NetItemRef->m_Label->GetData() );
} }
else Marker->m_Comment.Printf( _("Warning SheetLabel %s not connected to GLabel"), else
NetItemRef->m_Label->GetData()); Marker->m_Comment.Printf( _( "Warning SheetLabel %s not connected to GLabel" ),
NetItemRef->m_Label->GetData() );
if( screen == panel->GetScreen() ) RedrawOneStruct(panel, DC, Marker, GR_COPY); if( screen == panel->GetScreen() )
RedrawOneStruct( panel, DC, Marker, GR_COPY );
return; return;
} }
...@@ -532,95 +571,100 @@ int ii, jj; ...@@ -532,95 +571,100 @@ int ii, jj;
{ {
if( MinConn == NOC ) /* 1 seul element dans le net */ if( MinConn == NOC ) /* 1 seul element dans le net */
{ {
Marker->m_Comment.Printf( _("Warning Pin %s Unconnected"), MsgPinElectricType[ii]); Marker->m_Comment.Printf( _( "Warning Pin %s Unconnected" ), MsgPinElectricType[ii] );
if( screen == panel->GetScreen() ) if( screen == panel->GetScreen() )
RedrawOneStruct(panel, DC, Marker, GR_COPY); RedrawOneStruct( panel, DC, Marker, GR_COPY );
return; return;
} }
if( MinConn == NOD ) /* pas de pilotage du net */ if( MinConn == NOD ) /* pas de pilotage du net */
{ {
Marker->m_Comment.Printf( Marker->m_Comment.Printf(
_("Warning Pin %s not driven (Net %d)"), _( "Warning Pin %s not driven (Net %d)" ),
MsgPinElectricType[ii], NetItemRef->m_NetCode); MsgPinElectricType[ii], NetItemRef->m_NetCode );
if( screen == panel->GetScreen() ) if( screen == panel->GetScreen() )
RedrawOneStruct(panel, DC, Marker, GR_COPY); RedrawOneStruct( panel, DC, Marker, GR_COPY );
return; return;
} }
if( Diag == UNC ) if( Diag == UNC )
{ {
Marker->m_Comment.Printf( Marker->m_Comment.Printf(
_("Warning More than 1 Pin connected to UnConnect symbol") ); _( "Warning More than 1 Pin connected to UnConnect symbol" ) );
if( screen == panel->GetScreen() ) if( screen == panel->GetScreen() )
RedrawOneStruct(panel, DC, Marker, GR_COPY); RedrawOneStruct( panel, DC, Marker, GR_COPY );
return; return;
} }
} }
if( NetItemTst ) /* Erreur entre 2 pins */ if( NetItemTst ) /* Erreur entre 2 pins */
{ {
jj = NetItemTst->m_ElectricalType; jj = NetItemTst->m_ElectricalType;
DiagLevel = _("Warning"); DiagLevel = _( "Warning" );
if(Diag == ERR) if( Diag == ERR )
{ {
DiagLevel = _("Error"); DiagLevel = _( "Error" );
Marker->m_MarkFlags = ERR; Marker->m_MarkFlags = ERR;
g_EESchemaVar.NbWarningErc--; g_EESchemaVar.NbWarningErc--;
} }
Marker->m_Comment.Printf( _(
Marker->m_Comment.Printf( _("%s: Pin %s connected to Pin %s (net %d)"), DiagLevel.GetData(), "%s: Pin %s connected to Pin %s (net %d)" ),
DiagLevel.GetData(),
MsgPinElectricType[ii], MsgPinElectricType[ii],
MsgPinElectricType[jj], NetItemRef->m_NetCode); MsgPinElectricType[jj], NetItemRef->m_NetCode );
if( screen == panel->GetScreen() ) if( screen == panel->GetScreen() )
RedrawOneStruct(panel, DC, Marker, GR_COPY); RedrawOneStruct( panel, DC, Marker, GR_COPY );
} }
} }
/********************************************************************/ /********************************************************************/
static void TestOthersItems(WinEDA_DrawPanel * panel, wxDC * DC, static void TestOthersItems( WinEDA_DrawPanel* panel, wxDC* DC,
ObjetNetListStruct * NetItemRef, ObjetNetListStruct* NetItemRef,
ObjetNetListStruct * netstart, ObjetNetListStruct* netstart,
int * NetNbItems, int * MinConnexion) int* NetNbItems, int* MinConnexion )
/********************************************************************/ /********************************************************************/
/* Routine testant les conflits electriques entre /* Routine testant les conflits electriques entre
NetItemRef * NetItemRef
et les autres items du meme net * et les autres items du meme net
*/ */
{ {
ObjetNetListStruct * NetItemTst, * Lim; ObjetNetListStruct* NetItemTst;
int ref_elect_type, jj, erc = OK, local_minconn; ObjetNetListStruct* Lim;
int ref_elect_type, jj, erc = OK, local_minconn;
/* Analyse de la table des connexions : */ /* Analyse de la table des connexions : */
Lim = g_TabObjNet + g_NbrObjNet; // pointe la fin de la liste Lim = g_TabObjNet + g_NbrObjNet; // pointe la fin de la liste
ref_elect_type = NetItemRef->m_ElectricalType; ref_elect_type = NetItemRef->m_ElectricalType;
NetItemTst = netstart; NetItemTst = netstart;
local_minconn = NOC; local_minconn = NOC;
/* Examen de la liste des Pins connectees a NetItemRef */ /* Examen de la liste des Pins connectees a NetItemRef */
for ( ; ; NetItemTst ++ ) for( ; ; NetItemTst++ )
{ {
if ( NetItemRef == NetItemTst ) continue; if( NetItemRef == NetItemTst )
continue;
/* Est - on toujours dans le meme net ? */ /* Est - on toujours dans le meme net ? */
if( (NetItemTst >= Lim) || // fin de liste (donc fin de net) if( (NetItemTst >= Lim) // fin de liste (donc fin de net)
(NetItemRef->m_NetCode != NetItemTst->m_NetCode) ) // fin de net || (NetItemRef->m_NetCode != NetItemTst->m_NetCode) ) // fin de net
{ /* Fin de netcode trouve: Tst connexion minimum */ { /* Fin de netcode trouve: Tst connexion minimum */
if( (*MinConnexion < NET_NC ) && if( (*MinConnexion < NET_NC )
(local_minconn < NET_NC ) ) /* pin non connecte ou non pilotee */ && (local_minconn < NET_NC ) ) /* pin non connecte ou non pilotee */
{ {
Diagnose(panel, DC, NetItemRef, NULL, local_minconn, WAR); Diagnose( panel, DC, NetItemRef, NULL, local_minconn, WAR );
* MinConnexion = DRV; // inhibition autres messages de ce type pour ce net *MinConnexion = DRV; // inhibition autres messages de ce type pour ce net
} }
return; return;
} }
switch ( NetItemTst->m_Type ) switch( NetItemTst->m_Type )
{ {
case NET_SEGMENT: case NET_SEGMENT:
case NET_BUS: case NET_BUS:
...@@ -635,23 +679,25 @@ int ref_elect_type, jj, erc = OK, local_minconn; ...@@ -635,23 +679,25 @@ int ref_elect_type, jj, erc = OK, local_minconn;
break; break;
case NET_NOCONNECT: case NET_NOCONNECT:
local_minconn = MAX( NET_NC, local_minconn); local_minconn = MAX( NET_NC, local_minconn );
break; break;
case NET_PIN: case NET_PIN:
jj = NetItemTst->m_ElectricalType; jj = NetItemTst->m_ElectricalType;
local_minconn = MAX( MinimalReq[ref_elect_type][jj], local_minconn ); local_minconn = MAX( MinimalReq[ref_elect_type][jj], local_minconn );
if ( NetItemTst <= NetItemRef ) break; if( NetItemTst <= NetItemRef )
break;
*NetNbItems += 1; *NetNbItems += 1;
if( erc == OK ) // 1 marqueur par pin maxi if( erc == OK ) // 1 marqueur par pin maxi
{ {
erc = DiagErc[ref_elect_type][jj]; erc = DiagErc[ref_elect_type][jj];
if (erc != OK ) if( erc != OK )
{ {
if( NetItemTst->m_FlagOfConnection == 0 ) if( NetItemTst->m_FlagOfConnection == 0 )
{ {
Diagnose(panel, DC, NetItemRef, NetItemTst, 0, erc); Diagnose( panel, DC, NetItemRef, NetItemTst, 0, erc );
NetItemTst->m_FlagOfConnection = (IsConnectType) 1; NetItemTst->m_FlagOfConnection = (IsConnectType) 1;
} }
} }
...@@ -663,68 +709,79 @@ int ref_elect_type, jj, erc = OK, local_minconn; ...@@ -663,68 +709,79 @@ int ref_elect_type, jj, erc = OK, local_minconn;
/********************************************************/ /********************************************************/
static bool WriteDiagnosticERC(const wxString & FullFileName) static bool WriteDiagnosticERC( const wxString& FullFileName )
/*********************************************************/ /*********************************************************/
/* Create the Diagnostic file (<xxx>.erc file) /* Create the Diagnostic file (<xxx>.erc file)
*/ */
{ {
EDA_BaseStruct * DrawStruct; EDA_BaseStruct* DrawStruct;
DrawMarkerStruct * Marker; DrawMarkerStruct* Marker;
char Line[256]; char Line[256];
static FILE * OutErc; static FILE* OutErc;
DrawSheetStruct * Sheet; DrawSheetStruct* Sheet;
wxString msg; wxString msg;
if( ( OutErc = wxFopen( FullFileName, wxT( "wt" ) ) ) == NULL )
return FALSE;
if( (OutErc = wxFopen( FullFileName, wxT("wt"))) == NULL ) return FALSE; DateAndTime( Line );
msg = _( "ERC control" );
DateAndTime(Line); fprintf( OutErc, "%s (%s)\n", CONV_TO_UTF8( msg ), Line );
msg = _("ERC control");
fprintf( OutErc, "%s (%s)\n", CONV_TO_UTF8(msg), Line);
EDA_ScreenList ScreenList(NULL); EDA_ScreenList ScreenList( NULL );
for ( SCH_SCREEN * Screen = ScreenList.GetFirst(); Screen != NULL; Screen = ScreenList.GetNext() )
for( SCH_SCREEN* Screen = ScreenList.GetFirst(); Screen != NULL; Screen = ScreenList.GetNext() )
{ {
Sheet = (DrawSheetStruct*) Screen; Sheet = (DrawSheetStruct*) Screen;
msg.Printf( _("\n***** Sheet %d (%s)\n"),
msg.Printf( _( "\n***** Sheet %d (%s)\n" ),
Sheet->m_SheetNumber, Sheet->m_SheetNumber,
Screen == ScreenSch ? _("Root") : Sheet->m_SheetName.GetData()); Screen == ScreenSch ? _( "Root" ) : Sheet->m_SheetName.GetData() );
fprintf( OutErc, "%s", CONV_TO_UTF8(msg));
fprintf( OutErc, "%s", CONV_TO_UTF8( msg ) );
DrawStruct = Screen->EEDrawList; DrawStruct = Screen->EEDrawList;
for ( ; DrawStruct != NULL; DrawStruct = DrawStruct->Pnext) for( ; DrawStruct != NULL; DrawStruct = DrawStruct->Pnext )
{ {
if(DrawStruct->Type() != DRAW_MARKER_STRUCT_TYPE ) if( DrawStruct->Type() != DRAW_MARKER_STRUCT_TYPE )
continue; continue;
/* Marqueur trouve */ /* Marqueur trouve */
Marker = (DrawMarkerStruct * ) DrawStruct; Marker = (DrawMarkerStruct*) DrawStruct;
if( Marker->m_Type != MARQ_ERC ) continue; if( Marker->m_Type != MARQ_ERC )
continue;
/* Write diag marqueur */ /* Write diag marqueur */
msg.Printf( _("ERC: %s (X= %2.3f inches, Y= %2.3f inches\n"), msg.Printf( _( "ERC: %s (X= %2.3f inches, Y= %2.3f inches\n" ),
Marker->GetComment().GetData(), Marker->GetComment().GetData(),
(float)Marker->m_Pos.x / 1000, (float) Marker->m_Pos.x / 1000,
(float)Marker->m_Pos.y / 1000); (float) Marker->m_Pos.y / 1000 );
fprintf( OutErc, "%s", CONV_TO_UTF8(msg));
fprintf( OutErc, "%s", CONV_TO_UTF8( msg ) );
} }
} }
msg.Printf( _("\n >> Errors ERC: %d\n"), g_EESchemaVar.NbErrorErc);
fprintf( OutErc, "%s", CONV_TO_UTF8(msg)); msg.Printf( _( "\n >> Errors ERC: %d\n" ), g_EESchemaVar.NbErrorErc );
fclose ( OutErc ); fprintf( OutErc, "%s", CONV_TO_UTF8( msg ) );
fclose( OutErc );
return TRUE; return TRUE;
} }
/***********************************************************************/ /***********************************************************************/
void TestLabel(WinEDA_DrawPanel * panel, wxDC * DC, void TestLabel( WinEDA_DrawPanel* panel, wxDC* DC,
ObjetNetListStruct * NetItemRef, ObjetNetListStruct * StartNet) ObjetNetListStruct* NetItemRef, ObjetNetListStruct* StartNet )
/***********************************************************************/ /***********************************************************************/
/* Routine controlant qu'un sheetLabel est bien connecte a un Glabel de la /* Routine controlant qu'un sheetLabel est bien connecte a un Glabel de la
sous-feuille correspondante * sous-feuille correspondante
*/ */
{ {
ObjetNetListStruct * NetItemTst, * Lim; ObjetNetListStruct* NetItemTst, * Lim;
int erc = 1; int erc = 1;
/* Analyse de la table des connexions : */ /* Analyse de la table des connexions : */
Lim = g_TabObjNet + g_NbrObjNet; Lim = g_TabObjNet + g_NbrObjNet;
...@@ -732,25 +789,28 @@ int erc = 1; ...@@ -732,25 +789,28 @@ int erc = 1;
NetItemTst = StartNet; NetItemTst = StartNet;
/* Examen de la liste des Labels connectees a NetItemRef */ /* Examen de la liste des Labels connectees a NetItemRef */
for ( ; ; NetItemTst ++ ) for( ; ; NetItemTst++ )
{ {
if( NetItemTst == NetItemRef ) continue; if( NetItemTst == NetItemRef )
continue;
/* Est - on toujours dans le meme net ? */ /* Est - on toujours dans le meme net ? */
if( ( NetItemTst == Lim ) || if( ( NetItemTst == Lim )
( NetItemRef->m_NetCode != NetItemTst->m_NetCode ) ) || ( NetItemRef->m_NetCode != NetItemTst->m_NetCode ) )
{ /* Fin de netcode trouve */ {
/* Fin de netcode trouve */
if( erc ) if( erc )
{ /* GLabel ou SheetLabel orphelin */ {
Diagnose(panel, DC, NetItemRef, NULL, -1, WAR); /* GLabel ou SheetLabel orphelin */
Diagnose( panel, DC, NetItemRef, NULL, -1, WAR );
} }
return; return;
} }
if( (NetItemRef->m_Type == NET_GLOBLABEL) || if( (NetItemRef->m_Type == NET_GLOBLABEL)
(NetItemRef->m_Type == NET_GLOBBUSLABELMEMBER) ) || (NetItemRef->m_Type == NET_GLOBBUSLABELMEMBER) )
{ {
switch ( NetItemTst->m_Type ) switch( NetItemTst->m_Type )
{ {
case NET_SEGMENT: case NET_SEGMENT:
case NET_BUS: case NET_BUS:
...@@ -774,10 +834,9 @@ int erc = 1; ...@@ -774,10 +834,9 @@ int erc = 1;
break; break;
} }
} }
else else
{ {
switch ( NetItemTst->m_Type ) switch( NetItemTst->m_Type )
{ {
case NET_SEGMENT: case NET_SEGMENT:
case NET_BUS: case NET_BUS:
...@@ -803,5 +862,3 @@ int erc = 1; ...@@ -803,5 +862,3 @@ int erc = 1;
} }
} }
} }
eeschema/libedpart.cpp
View file @ 664a1f72
...@@ -50,55 +50,57 @@ enum id_libedit { ...@@ -50,55 +50,57 @@ enum id_libedit {
/************************************************/ /************************************************/
class WinEDA_PartPropertiesFrame: public wxDialog class WinEDA_PartPropertiesFrame : public wxDialog
/************************************************/ /************************************************/
/* Cette classe genere une fenetre type NoteBook, pour l'edition des proprits /* Cette classe genere une fenetre type NoteBook, pour l'edition des proprits
d'un composant le librairie. * d'un composant le librairie.
On peut diter: * On peut diter:
Texte dimensions et justification de tous les champs (Ref, Val, et autres champs) * Texte dimensions et justification de tous les champs (Ref, Val, et autres champs)
Documentation et mots clefs * Documentation et mots clefs
Nombre de part par boitier * Nombre de part par boitier
et autres proprirs gnrales * et autres proprirs gnrales
*/ */
{ {
private: private:
WinEDA_LibeditFrame * m_Parent; WinEDA_LibeditFrame* m_Parent;
wxNotebook* m_NoteBook; wxNotebook* m_NoteBook;
wxListBox * m_PartAliasList; wxListBox* m_PartAliasList;
wxPanel * m_PanelBasic; wxPanel* m_PanelBasic;
wxPanel * m_PanelAlias; wxPanel* m_PanelAlias;
wxPanel * m_PanelDoc; wxPanel* m_PanelDoc;
wxPanel * PanelField[NUMBER_OF_FIELDS]; wxPanel* PanelField[NUMBER_OF_FIELDS];
wxCheckBox * AsConvertButt; wxCheckBox* AsConvertButt;
wxCheckBox * ShowFieldText[NUMBER_OF_FIELDS]; wxCheckBox* ShowFieldText[NUMBER_OF_FIELDS];
wxCheckBox * VorientFieldText[NUMBER_OF_FIELDS]; wxCheckBox* VorientFieldText[NUMBER_OF_FIELDS];
wxCheckBox * ShowPinNumButt; wxCheckBox* ShowPinNumButt;
wxCheckBox * ShowPinNameButt; wxCheckBox* ShowPinNameButt;
wxCheckBox * m_PinsNameInsideButt; wxCheckBox* m_PinsNameInsideButt;
wxSpinCtrl * SelNumberOfUnits; wxSpinCtrl* SelNumberOfUnits;
wxSpinCtrl * m_SetSkew; wxSpinCtrl* m_SetSkew;
wxCheckBox * m_OptionPower; wxCheckBox* m_OptionPower;
wxCheckBox * m_OptionPartsLocked; wxCheckBox* m_OptionPartsLocked;
WinEDA_GraphicTextCtrl * FieldTextCtrl[NUMBER_OF_FIELDS]; WinEDA_GraphicTextCtrl* FieldTextCtrl[NUMBER_OF_FIELDS];
WinEDA_PositionCtrl * FieldPosition[NUMBER_OF_FIELDS]; WinEDA_PositionCtrl* FieldPosition[NUMBER_OF_FIELDS];
int FieldFlags[NUMBER_OF_FIELDS]; int FieldFlags[NUMBER_OF_FIELDS];
int FieldOrient[NUMBER_OF_FIELDS]; int FieldOrient[NUMBER_OF_FIELDS];
wxRadioBox * FieldHJustify[NUMBER_OF_FIELDS]; wxRadioBox* FieldHJustify[NUMBER_OF_FIELDS];
wxRadioBox * FieldVJustify[NUMBER_OF_FIELDS]; wxRadioBox* FieldVJustify[NUMBER_OF_FIELDS];
WinEDA_EnterText * m_Doc; WinEDA_EnterText* m_Doc;
WinEDA_EnterText * m_Docfile; WinEDA_EnterText* m_Docfile;
WinEDA_EnterText * m_Keywords; WinEDA_EnterText* m_Keywords;
bool m_RecreateToolbar; bool m_RecreateToolbar;
int m_AliasLocation; int m_AliasLocation;
public: public:
// Constructor and destructor // Constructor and destructor
WinEDA_PartPropertiesFrame(WinEDA_LibeditFrame *parent, wxPoint& pos); WinEDA_PartPropertiesFrame( WinEDA_LibeditFrame * parent, wxPoint & pos );
~WinEDA_PartPropertiesFrame() ~WinEDA_PartPropertiesFrame()
{ {
}; };
...@@ -107,38 +109,39 @@ private: ...@@ -107,38 +109,39 @@ private:
void BuildPanelBasic(); void BuildPanelBasic();
void BuildPanelDoc(); void BuildPanelDoc();
void BuildPanelAlias(); void BuildPanelAlias();
void BuildPanelEditField(int fieldId); void BuildPanelEditField( int fieldId );
void PartPropertiesAccept(wxCommandEvent& event); void PartPropertiesAccept( wxCommandEvent& event );
void OnQuit(wxCommandEvent& event); void OnQuit( wxCommandEvent& event );
void DeleteAllAliasOfPart(wxCommandEvent& event); void DeleteAllAliasOfPart( wxCommandEvent& event );
void DeleteAliasOfPart(wxCommandEvent& event); void DeleteAliasOfPart( wxCommandEvent& event );
void AddAliasOfPart(wxCommandEvent& event); void AddAliasOfPart( wxCommandEvent& event );
bool ChangeNbUnitsPerPackage(int newUnit); bool ChangeNbUnitsPerPackage( int newUnit );
bool SetUnsetConvert(); bool SetUnsetConvert();
void CopyDocToAlias(wxCommandEvent& event); void CopyDocToAlias( wxCommandEvent& event );
void BrowseAndSelectDocFile(wxCommandEvent& event); void BrowseAndSelectDocFile( wxCommandEvent& event );
DECLARE_EVENT_TABLE() DECLARE_EVENT_TABLE()
}; };
BEGIN_EVENT_TABLE(WinEDA_PartPropertiesFrame, wxDialog) BEGIN_EVENT_TABLE( WinEDA_PartPropertiesFrame, wxDialog )
EVT_BUTTON(ID_ACCEPT_PART_PROPERTIES, WinEDA_PartPropertiesFrame::PartPropertiesAccept) EVT_BUTTON( ID_ACCEPT_PART_PROPERTIES, WinEDA_PartPropertiesFrame::PartPropertiesAccept )
EVT_BUTTON(ID_CLOSE_PART_PROPERTIES, WinEDA_PartPropertiesFrame::OnQuit) EVT_BUTTON( ID_CLOSE_PART_PROPERTIES, WinEDA_PartPropertiesFrame::OnQuit )
EVT_BUTTON(ID_ADD_ALIAS, WinEDA_PartPropertiesFrame::AddAliasOfPart) EVT_BUTTON( ID_ADD_ALIAS, WinEDA_PartPropertiesFrame::AddAliasOfPart )
EVT_BUTTON(ID_DELETE_ONE_ALIAS, WinEDA_PartPropertiesFrame::DeleteAliasOfPart) EVT_BUTTON( ID_DELETE_ONE_ALIAS, WinEDA_PartPropertiesFrame::DeleteAliasOfPart )
EVT_BUTTON(ID_DELETE_ALL_ALIAS, WinEDA_PartPropertiesFrame::DeleteAllAliasOfPart) EVT_BUTTON( ID_DELETE_ALL_ALIAS, WinEDA_PartPropertiesFrame::DeleteAllAliasOfPart )
EVT_BUTTON(ID_COPY_DOC_TO_ALIAS, WinEDA_PartPropertiesFrame::CopyDocToAlias) EVT_BUTTON( ID_COPY_DOC_TO_ALIAS, WinEDA_PartPropertiesFrame::CopyDocToAlias )
EVT_BUTTON(ID_BROWSE_DOC_FILES, WinEDA_PartPropertiesFrame::BrowseAndSelectDocFile) EVT_BUTTON( ID_BROWSE_DOC_FILES, WinEDA_PartPropertiesFrame::BrowseAndSelectDocFile )
END_EVENT_TABLE() END_EVENT_TABLE()
/*****************************************************************/ /*****************************************************************/
void WinEDA_LibeditFrame::InstallLibeditFrame(const wxPoint & pos) void WinEDA_LibeditFrame::InstallLibeditFrame( const wxPoint& pos )
/*****************************************************************/ /*****************************************************************/
{ {
wxPoint fpos = pos; wxPoint fpos = pos;
WinEDA_PartPropertiesFrame* frame =
new WinEDA_PartPropertiesFrame( this, fpos );
WinEDA_PartPropertiesFrame * frame =
new WinEDA_PartPropertiesFrame(this, fpos);
frame->ShowModal(); frame->Destroy(); frame->ShowModal(); frame->Destroy();
} }
...@@ -146,38 +149,38 @@ wxPoint fpos = pos; ...@@ -146,38 +149,38 @@ wxPoint fpos = pos;
#define XSIZE 370 #define XSIZE 370
#define YSIZE 385 #define YSIZE 385
/**********************************************************************************/ /**********************************************************************************/
WinEDA_PartPropertiesFrame::WinEDA_PartPropertiesFrame(WinEDA_LibeditFrame *parent, WinEDA_PartPropertiesFrame::WinEDA_PartPropertiesFrame( WinEDA_LibeditFrame* parent,
wxPoint& framepos): wxPoint& framepos ) :
wxDialog(parent, -1, wxEmptyString, framepos, wxSize(XSIZE, YSIZE), wxDialog( parent, -1, wxEmptyString, framepos, wxSize( XSIZE, YSIZE ),
DIALOG_STYLE) DIALOG_STYLE )
/**********************************************************************************/ /**********************************************************************************/
{ {
wxPoint pos; wxPoint pos;
wxLayoutConstraints* c; wxLayoutConstraints* c;
wxString msg_text; wxString msg_text;
wxButton * Button; wxButton* Button;
int ii; int ii;
m_Parent = parent; m_Parent = parent;
m_RecreateToolbar = FALSE; m_RecreateToolbar = FALSE;
SetFont(*g_DialogFont); SetFont( *g_DialogFont );
SetAutoLayout(TRUE); SetAutoLayout( TRUE );
for ( ii = 0; ii < NUMBER_OF_FIELDS; ii++ ) for( ii = 0; ii < NUMBER_OF_FIELDS; ii++ )
FieldFlags[ii] = 0; FieldFlags[ii] = 0;
m_AliasLocation = -1; m_AliasLocation = -1;
if ( CurrentLibEntry ) if( CurrentLibEntry )
{ {
msg_text = _("Properties for "); msg_text = _( "Properties for " );
if ( ! CurrentAliasName.IsEmpty() ) if( !CurrentAliasName.IsEmpty() )
{ {
m_AliasLocation = LocateAlias( CurrentLibEntry->m_AliasList, CurrentAliasName); m_AliasLocation = LocateAlias( CurrentLibEntry->m_AliasList, CurrentAliasName );
SetTitle( msg_text + CurrentAliasName + SetTitle( msg_text + CurrentAliasName +
_("(alias of ") + _( "(alias of " ) +
wxString(CurrentLibEntry->m_Name.m_Text) wxString( CurrentLibEntry->m_Name.m_Text )
+ wxT(")") ); + wxT( ")" ) );
} }
else else
{ {
...@@ -191,115 +194,128 @@ int ii; ...@@ -191,115 +194,128 @@ int ii;
FieldFlags[VALUE] = CurrentLibEntry->m_Name.m_Attributs; FieldFlags[VALUE] = CurrentLibEntry->m_Name.m_Attributs;
FieldOrient[VALUE] = CurrentLibEntry->m_Name.m_Orient; FieldOrient[VALUE] = CurrentLibEntry->m_Name.m_Orient;
LibDrawField * Field = CurrentLibEntry->Fields; LibDrawField* Field = CurrentLibEntry->Fields;
while ( Field ) while( Field )
{ {
FieldFlags[Field->m_FieldId] = Field->m_Attributs; FieldFlags[Field->m_FieldId] = Field->m_Attributs;
FieldOrient[Field->m_FieldId] = Field->m_Orient; FieldOrient[Field->m_FieldId] = Field->m_Orient;
Field = (LibDrawField*)Field->Pnext; Field = (LibDrawField*) Field->Pnext;
} }
} }
else
SetTitle( _( "Lib Component Properties" ) );
else SetTitle(_("Lib Component Properties")); m_NoteBook = new wxNotebook( this, ID_LIBEDIT_NOTEBOOK,
wxDefaultPosition, wxSize (XSIZE - 6, YSIZE - 70) );
m_NoteBook = new wxNotebook(this, ID_LIBEDIT_NOTEBOOK, SetFont( *g_DialogFont );
wxDefaultPosition,wxSize(XSIZE-6, YSIZE - 70) ); m_NoteBook->SetAutoLayout( TRUE );
SetFont(*g_DialogFont);
m_NoteBook->SetAutoLayout(TRUE);
c = new wxLayoutConstraints; c = new wxLayoutConstraints;
c->left.SameAs(this, wxLeft, 4); c->left.SameAs( this, wxLeft, 4 );
c->right.SameAs(this, wxRight, 4); c->right.SameAs( this, wxRight, 4 );
c->top.SameAs(this, wxTop, 4); c->top.SameAs( this, wxTop, 4 );
c->bottom.SameAs(this, wxBottom, 40); c->bottom.SameAs( this, wxBottom, 40 );
m_NoteBook->SetConstraints(c); m_NoteBook->SetConstraints( c );
/* Creation des boutons de commande */ /* Creation des boutons de commande */
pos.x = 50; pos.y = YSIZE - 60; pos.x = 50; pos.y = YSIZE - 60;
Button = new wxButton(this, ID_CLOSE_PART_PROPERTIES, Button = new wxButton( this, ID_CLOSE_PART_PROPERTIES,
_("Cancel"), pos); _( "Cancel" ), pos );
Button->SetForegroundColour(*wxBLUE);
Button->SetForegroundColour( *wxBLUE );
c = new wxLayoutConstraints; c = new wxLayoutConstraints;
c->left.SameAs(this, wxLeft, 20); c->left.SameAs( this, wxLeft, 20 );
c->height.AsIs(); c->height.AsIs();
c->width.AsIs(); c->width.AsIs();
c->bottom.SameAs(this, wxBottom, 5); c->bottom.SameAs( this, wxBottom, 5 );
Button->SetConstraints(c); Button->SetConstraints( c );
pos.x += Button->GetDefaultSize().x + 70; pos.x += Button->GetDefaultSize().x + 70;
Button = new wxButton(this, ID_ACCEPT_PART_PROPERTIES, Button = new wxButton( this, ID_ACCEPT_PART_PROPERTIES,
_("Ok"), pos); _( "Ok" ), pos );
Button->SetForegroundColour(*wxRED);
Button->SetForegroundColour( *wxRED );
c = new wxLayoutConstraints; c = new wxLayoutConstraints;
c->right.SameAs(this, wxRight, 20); c->right.SameAs( this, wxRight, 20 );
c->height.AsIs(); c->height.AsIs();
c->width.AsIs(); c->width.AsIs();
c->bottom.SameAs(this, wxBottom, 5); c->bottom.SameAs( this, wxBottom, 5 );
Button->SetConstraints(c); Button->SetConstraints( c );
// Add panel Basic // Add panel Basic
BuildPanelBasic(); BuildPanelBasic();
m_NoteBook->AddPage(m_PanelBasic, _("Options"), TRUE); m_NoteBook->AddPage( m_PanelBasic, _( "Options" ), TRUE );
// Add Panel Documentation // Add Panel Documentation
BuildPanelDoc(); BuildPanelDoc();
m_NoteBook->AddPage(m_PanelDoc, _("Doc"), FALSE); m_NoteBook->AddPage( m_PanelDoc, _( "Doc" ), FALSE );
// Add Panel Alias List // Add Panel Alias List
BuildPanelAlias(); BuildPanelAlias();
m_NoteBook->AddPage(m_PanelAlias, _("Alias"), FALSE); m_NoteBook->AddPage( m_PanelAlias, _( "Alias" ), FALSE );
// Add panel Fields // Add panel Fields
for ( ii = 0; ii < NUMBER_OF_FIELDS; ii++) BuildPanelEditField(ii); for( ii = 0; ii < NUMBER_OF_FIELDS; ii++ )
BuildPanelEditField( ii );
} }
/*****************************************************/ /*****************************************************/
void WinEDA_PartPropertiesFrame::BuildPanelAlias() void WinEDA_PartPropertiesFrame::BuildPanelAlias()
/*****************************************************/ /*****************************************************/
/* create the panel for component alias list editing /* create the panel for component alias list editing
*/ */
{ {
wxPoint pos; wxPoint pos;
wxButton * Button; wxButton* Button;
m_PanelAlias = new wxPanel(m_NoteBook, -1); m_PanelAlias = new wxPanel( m_NoteBook, -1 );
m_PanelAlias->SetFont(*g_DialogFont);
wxLayoutConstraints * c = new wxLayoutConstraints; m_PanelAlias->SetFont( *g_DialogFont );
c->left.SameAs(m_NoteBook, wxLeft); wxLayoutConstraints* c = new wxLayoutConstraints;
c->right.SameAs(m_NoteBook, wxRight); c->left.SameAs( m_NoteBook, wxLeft );
c->bottom.SameAs(m_NoteBook, wxBottom); c->right.SameAs( m_NoteBook, wxRight );
m_PanelAlias->SetConstraints(c); c->bottom.SameAs( m_NoteBook, wxBottom );
m_PanelAlias->SetConstraints( c );
pos.x = 200; pos.y = 70; pos.x = 200; pos.y = 70;
Button = new wxButton(m_PanelAlias, ID_ADD_ALIAS, _("Add"), pos); Button = new wxButton( m_PanelAlias, ID_ADD_ALIAS, _( "Add" ), pos );
Button->SetForegroundColour(*wxBLUE);
Button->SetForegroundColour( *wxBLUE );
pos.y += Button->GetSize().y + 10; pos.y += Button->GetSize().y + 10;
Button = new wxButton(m_PanelAlias, ID_DELETE_ONE_ALIAS, Button = new wxButton( m_PanelAlias, ID_DELETE_ONE_ALIAS,
_("Delete"), pos); _( "Delete" ), pos );
Button->SetForegroundColour(*wxRED);
Button->SetForegroundColour( *wxRED );
pos.y += Button->GetSize().y + 10; pos.y += Button->GetSize().y + 10;
Button = new wxButton(m_PanelAlias, ID_DELETE_ALL_ALIAS, Button = new wxButton( m_PanelAlias, ID_DELETE_ALL_ALIAS,
_("Delete All"), pos); _( "Delete All" ), pos );
Button->SetForegroundColour(*wxRED);
if ( ! CurrentAliasName.IsEmpty() ) Button->Enable(FALSE); Button->SetForegroundColour( *wxRED );
if( !CurrentAliasName.IsEmpty() )
Button->Enable( FALSE );
pos.x = 5; pos.y = 30; pos.x = 5; pos.y = 30;
m_PartAliasList = new wxListBox(m_PanelAlias, m_PartAliasList = new wxListBox( m_PanelAlias,
-1, -1,
pos, wxSize(160,170), pos, wxSize( 160, 170 ),
0,NULL, 0, NULL,
wxLB_ALWAYS_SB|wxLB_SINGLE); wxLB_ALWAYS_SB | wxLB_SINGLE );
wxStaticText * Msg = new wxStaticText(m_PanelAlias, -1, _("Alias"),
wxPoint(pos.x,pos.y - 20) ); wxStaticText* Msg = new wxStaticText( m_PanelAlias, -1, _( "Alias" ),
Msg->SetForegroundColour(wxColour(200,0,0) ); wxPoint (pos.x, pos.y - 20) );
Msg->SetForegroundColour( wxColour( 200, 0, 0 ) );
/* lecture des noms des alias */ /* lecture des noms des alias */
if ( CurrentLibEntry ) if( CurrentLibEntry )
{ {
for ( unsigned ii = 0; ii < CurrentLibEntry->m_AliasList.GetCount(); ii += ALIAS_NEXT) for( unsigned ii = 0; ii < CurrentLibEntry->m_AliasList.GetCount(); ii += ALIAS_NEXT )
m_PartAliasList->Append(CurrentLibEntry->m_AliasList[ii+ALIAS_NAME]); m_PartAliasList->Append( CurrentLibEntry->m_AliasList[ii + ALIAS_NAME] );
} }
} }
...@@ -307,277 +323,331 @@ wxButton * Button; ...@@ -307,277 +323,331 @@ wxButton * Button;
/*****************************************************/ /*****************************************************/
void WinEDA_PartPropertiesFrame::BuildPanelDoc() void WinEDA_PartPropertiesFrame::BuildPanelDoc()
/*****************************************************/ /*****************************************************/
/* create the panel for component doc editing /* create the panel for component doc editing
*/ */
{ {
wxPoint pos; wxPoint pos;
wxButton * Button; wxButton* Button;
wxString msg_text; wxString msg_text;
m_PanelDoc = new wxPanel(m_NoteBook, -1); m_PanelDoc = new wxPanel( m_NoteBook, -1 );
m_PanelDoc->SetFont(*g_DialogFont);
wxLayoutConstraints * c = new wxLayoutConstraints; m_PanelDoc->SetFont( *g_DialogFont );
c->left.SameAs(m_NoteBook, wxLeft); wxLayoutConstraints* c = new wxLayoutConstraints;
c->right.SameAs(m_NoteBook, wxRight); c->left.SameAs( m_NoteBook, wxLeft );
c->bottom.SameAs(m_NoteBook, wxBottom); c->right.SameAs( m_NoteBook, wxRight );
m_PanelDoc->SetConstraints(c); c->bottom.SameAs( m_NoteBook, wxBottom );
m_PanelDoc->SetConstraints( c );
pos.x = 5; pos.y = 15; pos.x = 5; pos.y = 15;
if ( CurrentLibEntry ) if( CurrentLibEntry )
{ {
msg_text = _("Properties for "); msg_text = _( "Properties for " );
if ( ! CurrentAliasName.IsEmpty() ) if( !CurrentAliasName.IsEmpty() )
{ {
msg_text += _("alias "); msg_text += _( "alias " );
msg_text += CurrentAliasName; msg_text += CurrentAliasName;
} }
else else
{ {
msg_text += CurrentLibEntry->m_Name.m_Text; msg_text += CurrentLibEntry->m_Name.m_Text;
} }
wxStaticText * text = new wxStaticText(m_PanelDoc, -1, msg_text, pos); wxStaticText* text = new wxStaticText( m_PanelDoc, -1, msg_text, pos );
text->SetForegroundColour(*wxBLUE);
text->SetForegroundColour( *wxBLUE );
} }
pos.y += 30; pos.y += 30;
if ( m_AliasLocation >= 0 ) if( m_AliasLocation >= 0 )
msg_text = CurrentLibEntry->m_AliasList[m_AliasLocation+ALIAS_DOC]; msg_text = CurrentLibEntry->m_AliasList[m_AliasLocation + ALIAS_DOC];
else else
{ {
if (CurrentLibEntry && CurrentLibEntry->m_Doc) if( CurrentLibEntry && CurrentLibEntry->m_Doc )
msg_text = CurrentLibEntry->m_Doc; msg_text = CurrentLibEntry->m_Doc;
} }
m_Doc = new WinEDA_EnterText(m_PanelDoc, m_Doc = new WinEDA_EnterText( m_PanelDoc,
_("Doc:"), msg_text, _( "Doc:" ), msg_text,
pos, wxSize(285,-1) ); pos, wxSize( 285, -1 ) );
pos.y += 40; pos.y += 40;
msg_text.Empty(); msg_text.Empty();
if ( m_AliasLocation >= 0 ) if( m_AliasLocation >= 0 )
msg_text = CurrentLibEntry->m_AliasList[m_AliasLocation+ALIAS_KEYWORD]; msg_text = CurrentLibEntry->m_AliasList[m_AliasLocation + ALIAS_KEYWORD];
else else
{ {
if (CurrentLibEntry ) msg_text = CurrentLibEntry->m_KeyWord; if( CurrentLibEntry )
msg_text = CurrentLibEntry->m_KeyWord;
} }
m_Keywords = new WinEDA_EnterText(m_PanelDoc, m_Keywords = new WinEDA_EnterText( m_PanelDoc,
_("Keywords:"), msg_text, _( "Keywords:" ), msg_text,
pos, wxSize(285,-1) ); pos, wxSize( 285, -1 ) );
pos.y += 40; pos.y += 40;
msg_text.Empty(); msg_text.Empty();
if ( m_AliasLocation >= 0 ) if( m_AliasLocation >= 0 )
msg_text = CurrentLibEntry->m_AliasList[m_AliasLocation+ALIAS_DOC_FILENAME]; msg_text = CurrentLibEntry->m_AliasList[m_AliasLocation + ALIAS_DOC_FILENAME];
else else
{ {
if (CurrentLibEntry) msg_text = CurrentLibEntry->m_DocFile; if( CurrentLibEntry )
msg_text = CurrentLibEntry->m_DocFile;
} }
m_Docfile = new WinEDA_EnterText(m_PanelDoc, m_Docfile = new WinEDA_EnterText( m_PanelDoc,
_("DocFileName:"), msg_text, _( "DocFileName:" ), msg_text,
pos, wxSize(285,-1) ); pos, wxSize( 285, -1 ) );
pos.y += 40; pos.y += 40;
Button = new wxButton(m_PanelDoc, ID_COPY_DOC_TO_ALIAS, Button = new wxButton( m_PanelDoc, ID_COPY_DOC_TO_ALIAS,
_("Copy Doc"), pos); _( "Copy Doc" ), pos );
Button->SetForegroundColour(*wxRED);
if ( m_AliasLocation < 0 ) Button->Enable(FALSE); Button->SetForegroundColour( *wxRED );
if( m_AliasLocation < 0 )
Button = new wxButton(m_PanelDoc, ID_BROWSE_DOC_FILES, Button->Enable( FALSE );
_("Browse DocFiles"), wxPoint(pos.x + 140, pos.y) );
Button->SetForegroundColour(*wxBLUE); Button = new wxButton( m_PanelDoc, ID_BROWSE_DOC_FILES,
_( "Browse DocFiles" ), wxPoint (pos.x + 140, pos.y) );
Button->SetForegroundColour( *wxBLUE );
} }
/*****************************************************/ /*****************************************************/
void WinEDA_PartPropertiesFrame::BuildPanelBasic() void WinEDA_PartPropertiesFrame::BuildPanelBasic()
/*****************************************************/ /*****************************************************/
/* create the basic panel for component properties editing /* create the basic panel for component properties editing
*/ */
{ {
wxPoint pos; wxPoint pos;
m_PanelBasic = new wxPanel( m_NoteBook, ID_PANEL_BASIC );
m_PanelBasic = new wxPanel(m_NoteBook, ID_PANEL_BASIC); m_PanelBasic->SetFont( *g_DialogFont );
m_PanelBasic->SetFont(*g_DialogFont); wxLayoutConstraints* c = new wxLayoutConstraints;
wxLayoutConstraints * c = new wxLayoutConstraints; c->left.SameAs( m_NoteBook, wxLeft );
c->left.SameAs(m_NoteBook, wxLeft); c->right.SameAs( m_NoteBook, wxRight );
c->right.SameAs(m_NoteBook, wxRight); c->bottom.SameAs( m_NoteBook, wxBottom );
c->bottom.SameAs(m_NoteBook, wxBottom); m_PanelBasic->SetConstraints( c );
m_PanelBasic->SetConstraints(c);
pos.x = 5; pos.y = 25; pos.x = 5; pos.y = 25;
new wxStaticBox(m_PanelBasic, -1,_("General :"), pos, wxSize(250, 120)); new wxStaticBox( m_PanelBasic, -1, _( "General :" ), pos, wxSize( 250, 120 ) );
pos.x = 10; pos.y += 22; pos.x = 10; pos.y += 22;
AsConvertButt = new wxCheckBox(m_PanelBasic,-1, _("As Convert"), pos); AsConvertButt = new wxCheckBox( m_PanelBasic, -1, _( "As Convert" ), pos );
if ( g_AsDeMorgan ) AsConvertButt->SetValue(TRUE);
if( g_AsDeMorgan )
AsConvertButt->SetValue( TRUE );
pos.y += 20; pos.y += 20;
ShowPinNumButt = new wxCheckBox(m_PanelBasic,-1, _("Show Pin Num"), pos); ShowPinNumButt = new wxCheckBox( m_PanelBasic, -1, _( "Show Pin Num" ), pos );
if ( CurrentLibEntry )
if( CurrentLibEntry )
{ {
if ( CurrentLibEntry->m_DrawPinNum ) ShowPinNumButt->SetValue(TRUE); if( CurrentLibEntry->m_DrawPinNum )
ShowPinNumButt->SetValue( TRUE );
} }
else ShowPinNumButt->SetValue(TRUE); else
ShowPinNumButt->SetValue( TRUE );
pos.y += 20; pos.y += 20;
ShowPinNameButt = new wxCheckBox(m_PanelBasic,-1, _("Show Pin Name"), pos); ShowPinNameButt = new wxCheckBox( m_PanelBasic, -1, _( "Show Pin Name" ), pos );
if ( CurrentLibEntry )
if( CurrentLibEntry )
{ {
if( CurrentLibEntry->m_DrawPinName ) ShowPinNameButt->SetValue(TRUE); if( CurrentLibEntry->m_DrawPinName )
ShowPinNameButt->SetValue( TRUE );
} }
else ShowPinNameButt->SetValue(TRUE); else
ShowPinNameButt->SetValue( TRUE );
pos.y += 20; pos.y += 20;
m_PinsNameInsideButt = new wxCheckBox(m_PanelBasic,-1, _("Pin Name Inside"), pos); m_PinsNameInsideButt = new wxCheckBox( m_PanelBasic, -1, _( "Pin Name Inside" ), pos );
if ( CurrentLibEntry )
if( CurrentLibEntry )
{ {
if ( CurrentLibEntry->m_TextInside ) m_PinsNameInsideButt->SetValue(TRUE); if( CurrentLibEntry->m_TextInside )
m_PinsNameInsideButt->SetValue( TRUE );
} }
else m_PinsNameInsideButt->SetValue(TRUE); else
m_PinsNameInsideButt->SetValue( TRUE );
pos.y += 40; pos.y += 40;
new wxStaticText(m_PanelBasic,-1,_("Number of Units:"), pos); new wxStaticText( m_PanelBasic, -1, _( "Number of Units:" ), pos );
pos.y += 15; pos.y += 15;
wxString number; wxString number;
if ( CurrentLibEntry ) number.Printf( wxT("%d"), CurrentLibEntry->m_UnitCount); if( CurrentLibEntry )
else number = wxT("1"); number.Printf( wxT( "%d" ), CurrentLibEntry->m_UnitCount );
SelNumberOfUnits = new wxSpinCtrl(m_PanelBasic,-1,number, pos, else
number = wxT( "1" );
SelNumberOfUnits = new wxSpinCtrl( m_PanelBasic, -1, number, pos,
wxDefaultSize, wxSP_ARROW_KEYS | wxSP_WRAP, wxDefaultSize, wxSP_ARROW_KEYS | wxSP_WRAP,
1, 16); 1, 16 );
pos.y -= 15; pos.x += 180; pos.y -= 15; pos.x += 180;
new wxStaticText(m_PanelBasic,-1,_("Skew:"), pos); new wxStaticText( m_PanelBasic, -1, _( "Skew:" ), pos );
pos.y += 15; pos.y += 15;
if ( CurrentLibEntry && CurrentLibEntry->m_TextInside) if( CurrentLibEntry && CurrentLibEntry->m_TextInside )
number.Printf( wxT("%d"), CurrentLibEntry->m_TextInside); number.Printf( wxT( "%d" ), CurrentLibEntry->m_TextInside );
else number = wxT("40"); else
m_SetSkew = new wxSpinCtrl(m_PanelBasic,-1,number, pos, number = wxT( "40" );
m_SetSkew = new wxSpinCtrl( m_PanelBasic, -1, number, pos,
wxDefaultSize, wxSP_ARROW_KEYS | wxSP_WRAP, wxDefaultSize, wxSP_ARROW_KEYS | wxSP_WRAP,
1, 100); 1, 100 );
pos.x = 5; pos.y += 40; pos.x = 5; pos.y += 40;
m_OptionPower = new wxCheckBox(m_PanelBasic,-1, _("Power Symbol"), pos); m_OptionPower = new wxCheckBox( m_PanelBasic, -1, _( "Power Symbol" ), pos );
if ( CurrentLibEntry )
if( CurrentLibEntry )
{ {
if( CurrentLibEntry->m_Options == ENTRY_POWER ) if( CurrentLibEntry->m_Options == ENTRY_POWER )
m_OptionPower->SetValue(TRUE); m_OptionPower->SetValue( TRUE );
} }
pos.y = m_OptionPower->GetRect().GetBottom() + 10; pos.y = m_OptionPower->GetRect().GetBottom() + 10;
m_OptionPartsLocked = new wxCheckBox(m_PanelBasic,-1, _("Parts are locked"), pos); m_OptionPartsLocked = new wxCheckBox( m_PanelBasic, -1, _( "Parts are locked" ), pos );
if ( CurrentLibEntry )
if( CurrentLibEntry )
{ {
if( CurrentLibEntry->m_UnitSelectionLocked ) if( CurrentLibEntry->m_UnitSelectionLocked )
m_OptionPartsLocked->SetValue(TRUE); m_OptionPartsLocked->SetValue( TRUE );
} }
if ( number == wxT("1") ) m_OptionPartsLocked->Enable(FALSE); if( number == wxT( "1" ) )
m_OptionPartsLocked->Enable( FALSE );
} }
/****************************************************************/ /****************************************************************/
void WinEDA_PartPropertiesFrame::BuildPanelEditField(int fieldId) void WinEDA_PartPropertiesFrame::BuildPanelEditField( int fieldId )
/****************************************************************/ /****************************************************************/
{ {
wxPoint pos; wxPoint pos;
int xx, yy; int xx, yy;
LibDrawField * Field; LibDrawField* Field;
wxString Hjustify_list[] = wxString Hjustify_list[] =
{ _("Left justify"),_("Center"),_("Right justify")}; { _( "Left justify" ), _( "Center" ), _( "Right justify" ) };
wxString Vjustify_list[] = wxString Vjustify_list[] =
{ _("Bottom justify"),_("Center"),_("Top justify")}; { _( "Bottom justify" ), _( "Center" ), _( "Top justify" ) };
int ii = fieldId; int ii = fieldId;
PanelField[ii] = new wxPanel(m_NoteBook, ID_PANEL_REFERENCE + ii); PanelField[ii] = new wxPanel( m_NoteBook, ID_PANEL_REFERENCE + ii );
PanelField[ii]->SetFont(*g_DialogFont);
wxLayoutConstraints * c = new wxLayoutConstraints; PanelField[ii]->SetFont( *g_DialogFont );
c->left.SameAs(m_NoteBook, wxLeft); wxLayoutConstraints* c = new wxLayoutConstraints;
c->right.SameAs(m_NoteBook, wxRight); c->left.SameAs( m_NoteBook, wxLeft );
c->bottom.SameAs(m_NoteBook, wxBottom); c->right.SameAs( m_NoteBook, wxRight );
PanelField[ii]->SetConstraints(c); c->bottom.SameAs( m_NoteBook, wxBottom );
m_NoteBook->AddPage(PanelField[ii], DrawPartStruct::ReturnFieldName(ii), FALSE); PanelField[ii]->SetConstraints( c );
m_NoteBook->AddPage( PanelField[ii], DrawPartStruct::ReturnFieldName( ii ), FALSE );
pos.x = 10; pos.y = 10; pos.x = 10; pos.y = 10;
ShowFieldText[ii] = new wxCheckBox(PanelField[ii],-1, ShowFieldText[ii] = new wxCheckBox( PanelField[ii], -1,
_("Show Text"), pos); _( "Show Text" ), pos );
if ( (FieldFlags[ii] & TEXT_NO_VISIBLE ) == 0 )
ShowFieldText[ii]->SetValue(TRUE); if( (FieldFlags[ii] & TEXT_NO_VISIBLE ) == 0 )
ShowFieldText[ii]->SetValue( TRUE );
ShowFieldText[ii]->GetSize(&xx, &yy); ShowFieldText[ii]->GetSize( &xx, &yy );
pos.y += yy + 5; pos.y += yy + 5;
VorientFieldText[ii] = new wxCheckBox(PanelField[ii],-1, VorientFieldText[ii] = new wxCheckBox( PanelField[ii], -1,
_("Vertical"), pos); _( "Vertical" ), pos );
if ( FieldOrient[ii] ) VorientFieldText[ii]->SetValue(TRUE);
if( FieldOrient[ii] )
VorientFieldText[ii]->SetValue( TRUE );
pos.x = 150; pos.y = 5; pos.x = 150; pos.y = 5;
FieldHJustify[ii] = new wxRadioBox(PanelField[ii],-1, FieldHJustify[ii] = new wxRadioBox( PanelField[ii], -1,
_("Hor Justify"), pos, wxDefaultSize, _( "Hor Justify" ), pos, wxDefaultSize,
3,Hjustify_list, 1 , wxRA_SPECIFY_COLS); 3, Hjustify_list, 1, wxRA_SPECIFY_COLS );
FieldHJustify[ii]->GetSize(&xx, &yy);
FieldHJustify[ii]->SetSelection(1); FieldHJustify[ii]->GetSize( &xx, &yy );
FieldHJustify[ii]->SetSelection( 1 );
pos.y += yy + 5; pos.y += yy + 5;
FieldVJustify[ii] = new wxRadioBox(PanelField[ii],-1, FieldVJustify[ii] = new wxRadioBox( PanelField[ii], -1,
_("Vert Justify"), pos, wxDefaultSize, _( "Vert Justify" ), pos, wxDefaultSize,
3,Vjustify_list, 1 , wxRA_SPECIFY_COLS); 3, Vjustify_list, 1, wxRA_SPECIFY_COLS );
FieldVJustify[ii]->SetSelection(1);
FieldVJustify[ii]->SetSelection( 1 );
wxPoint txtpos; wxPoint txtpos;
pos.x = 10; pos.y = 70; pos.x = 10; pos.y = 70;
#define POSY_OFFSET 70 #define POSY_OFFSET 70
switch ( ii )
switch( ii )
{ {
case REFERENCE: case REFERENCE:
if ( CurrentLibEntry ) if( CurrentLibEntry )
{ {
Field = &CurrentLibEntry->m_Prefix; Field = &CurrentLibEntry->m_Prefix;
txtpos = Field->m_Pos; txtpos = Field->m_Pos;
if ( Field->m_HJustify == GR_TEXT_HJUSTIFY_LEFT) if( Field->m_HJustify == GR_TEXT_HJUSTIFY_LEFT )
FieldHJustify[ii]->SetSelection(0); FieldHJustify[ii]->SetSelection( 0 );
else if ( Field->m_HJustify == GR_TEXT_HJUSTIFY_RIGHT) else if( Field->m_HJustify == GR_TEXT_HJUSTIFY_RIGHT )
FieldHJustify[ii]->SetSelection(2); FieldHJustify[ii]->SetSelection( 2 );
if ( Field->m_VJustify == GR_TEXT_VJUSTIFY_BOTTOM) if( Field->m_VJustify == GR_TEXT_VJUSTIFY_BOTTOM )
FieldVJustify[ii]->SetSelection(0); FieldVJustify[ii]->SetSelection( 0 );
else if ( Field->m_VJustify == GR_TEXT_VJUSTIFY_TOP) else if( Field->m_VJustify == GR_TEXT_VJUSTIFY_TOP )
FieldVJustify[ii]->SetSelection(2); FieldVJustify[ii]->SetSelection( 2 );
} }
else txtpos = wxPoint(0,0); else
txtpos = wxPoint( 0, 0 );
FieldPosition[ii] = new WinEDA_PositionCtrl( PanelField[ii], FieldPosition[ii] = new WinEDA_PositionCtrl( PanelField[ii],
_("Pos"), txtpos, _( "Pos" ), txtpos,
g_UnitMetric , pos ); g_UnitMetric, pos );
FieldTextCtrl[ii] = new WinEDA_GraphicTextCtrl( PanelField[ii],
DrawPartStruct::ReturnFieldName(ii), FieldTextCtrl[ii] = new WinEDA_GraphicTextCtrl(
PanelField[ii],
DrawPartStruct::ReturnFieldName (ii),
CurrentLibEntry ? CurrentLibEntry ?
CurrentLibEntry->m_Prefix.m_Text.GetData() : wxT("U"), CurrentLibEntry->m_Prefix.m_Text.GetData ()
CurrentLibEntry ? CurrentLibEntry->m_Prefix.m_Size.x : DEFAULT_TEXT_SIZE, : wxT(
g_UnitMetric , "U" ),
wxPoint(pos.x, pos.y +FieldPosition[ii]->GetDimension().y + POSY_OFFSET), CurrentLibEntry ? CurrentLibEntry->
200, TRUE); m_Prefix.m_Size.x : DEFAULT_TEXT_SIZE,
g_UnitMetric,
wxPoint (pos.x, pos.y +
FieldPosition[ii]->GetDimension ().y + POSY_OFFSET),
200,
TRUE );
break; break;
case VALUE: case VALUE:
if ( CurrentLibEntry ) if( CurrentLibEntry )
{ {
Field = &CurrentLibEntry->m_Name; Field = &CurrentLibEntry->m_Name;
txtpos = Field->m_Pos; txtpos = Field->m_Pos;
if ( Field->m_HJustify == GR_TEXT_HJUSTIFY_LEFT) if( Field->m_HJustify == GR_TEXT_HJUSTIFY_LEFT )
FieldHJustify[ii]->SetSelection(0); FieldHJustify[ii]->SetSelection( 0 );
else if ( Field->m_HJustify == GR_TEXT_HJUSTIFY_RIGHT) else if( Field->m_HJustify == GR_TEXT_HJUSTIFY_RIGHT )
FieldHJustify[ii]->SetSelection(2); FieldHJustify[ii]->SetSelection( 2 );
if ( Field->m_VJustify == GR_TEXT_VJUSTIFY_BOTTOM) if( Field->m_VJustify == GR_TEXT_VJUSTIFY_BOTTOM )
FieldVJustify[ii]->SetSelection(0); FieldVJustify[ii]->SetSelection( 0 );
else if ( Field->m_VJustify == GR_TEXT_VJUSTIFY_TOP) else if( Field->m_VJustify == GR_TEXT_VJUSTIFY_TOP )
FieldVJustify[ii]->SetSelection(2); FieldVJustify[ii]->SetSelection( 2 );
} }
else txtpos = wxPoint(0,0); else
txtpos = wxPoint( 0, 0 );
FieldPosition[ii] = new WinEDA_PositionCtrl( PanelField[ii], FieldPosition[ii] = new WinEDA_PositionCtrl( PanelField[ii],
_("Pos"), txtpos, _( "Pos" ), txtpos,
g_UnitMetric , pos); g_UnitMetric, pos );
FieldTextCtrl[ii] = new WinEDA_GraphicTextCtrl( PanelField[ii],
DrawPartStruct::ReturnFieldName(ii), FieldTextCtrl[ii] = new WinEDA_GraphicTextCtrl(
CurrentLibEntry ? CurrentLibEntry->m_Name.m_Text.GetData() : NULL, PanelField[ii],
CurrentLibEntry ? CurrentLibEntry->m_Name.m_Size.x : DEFAULT_TEXT_SIZE, DrawPartStruct::ReturnFieldName (ii),
g_UnitMetric , CurrentLibEntry ? CurrentLibEntry->m_Name.
wxPoint(pos.x, pos.y +FieldPosition[ii]->GetDimension().y + POSY_OFFSET), m_Text.GetData () : NULL,
200, TRUE); CurrentLibEntry ? CurrentLibEntry->m_Name.
m_Size.x : DEFAULT_TEXT_SIZE,
g_UnitMetric,
wxPoint (pos.x, pos.y +
FieldPosition[ii]->GetDimension ().y + POSY_OFFSET),
200,
TRUE );
break; break;
default: default:
...@@ -586,65 +656,78 @@ int ii = fieldId; ...@@ -586,65 +656,78 @@ int ii = fieldId;
wxPoint fpos; wxPoint fpos;
fsize = DEFAULT_TEXT_SIZE;; fsize = DEFAULT_TEXT_SIZE;;
Field = NULL; Field = NULL;
fpos = wxPoint(0,0); fpos = wxPoint( 0, 0 );
//recherche du Field de FieldId correspondant, s'il existe //recherche du Field de FieldId correspondant, s'il existe
if ( CurrentLibEntry ) if( CurrentLibEntry )
{ {
Field = CurrentLibEntry->Fields; Field = CurrentLibEntry->Fields;
while ( Field ) while( Field )
{ {
if( Field->m_FieldId == ii ) if( Field->m_FieldId == ii )
{ {
fsize = Field->m_Size.x; fsize = Field->m_Size.x;
ftext = Field->m_Text; ftext = Field->m_Text;
fpos = Field->m_Pos; fpos = Field->m_Pos;
if ( Field->m_HJustify == GR_TEXT_HJUSTIFY_LEFT) if( Field->m_HJustify == GR_TEXT_HJUSTIFY_LEFT )
FieldHJustify[ii]->SetSelection(0); FieldHJustify[ii]->SetSelection( 0 );
else if ( Field->m_HJustify == GR_TEXT_HJUSTIFY_RIGHT) else if( Field->m_HJustify == GR_TEXT_HJUSTIFY_RIGHT )
FieldHJustify[ii]->SetSelection(2); FieldHJustify[ii]->SetSelection( 2 );
if ( Field->m_VJustify == GR_TEXT_VJUSTIFY_BOTTOM) if( Field->m_VJustify == GR_TEXT_VJUSTIFY_BOTTOM )
FieldVJustify[ii]->SetSelection(0); FieldVJustify[ii]->SetSelection( 0 );
else if ( Field->m_VJustify == GR_TEXT_VJUSTIFY_TOP) else if( Field->m_VJustify == GR_TEXT_VJUSTIFY_TOP )
FieldVJustify[ii]->SetSelection(2); FieldVJustify[ii]->SetSelection( 2 );
break; break;
} }
Field = (LibDrawField*)Field->Pnext; Field = (LibDrawField*) Field->Pnext;
} }
} }
FieldPosition[ii] = new WinEDA_PositionCtrl( PanelField[ii], FieldPosition[ii] = new WinEDA_PositionCtrl( PanelField[ii],
_("Pos"), fpos, _( "Pos" ), fpos,
g_UnitMetric , pos); g_UnitMetric, pos );
FieldTextCtrl[ii] = new WinEDA_GraphicTextCtrl( PanelField[ii],
DrawPartStruct::ReturnFieldName(ii), FieldTextCtrl[ii] = new WinEDA_GraphicTextCtrl(
ftext, fsize, PanelField[ii],
g_UnitMetric , DrawPartStruct::ReturnFieldName (ii),
wxPoint(pos.x, pos.y +FieldPosition[ii]->GetDimension().y + POSY_OFFSET), ftext,
200, TRUE); fsize,
g_UnitMetric,
wxPoint (pos.x, pos.y +
FieldPosition[ii]->GetDimension ().y + POSY_OFFSET),
200,
TRUE );
break; break;
} }
} }
/************************************************************************/ /************************************************************************/
void WinEDA_PartPropertiesFrame::OnQuit(wxCommandEvent& WXUNUSED(event)) void WinEDA_PartPropertiesFrame::OnQuit( wxCommandEvent& WXUNUSED (event) )
/************************************************************************/ /************************************************************************/
{ {
// true is to force the frame to close // true is to force the frame to close
Close(true); Close( true );
} }
/**************************************************************************/ /**************************************************************************/
void WinEDA_PartPropertiesFrame::PartPropertiesAccept(wxCommandEvent& event) void WinEDA_PartPropertiesFrame::PartPropertiesAccept( wxCommandEvent& event )
/**************************************************************************/ /**************************************************************************/
/* Met a jour les differents parametres pour le composant en cours d'dition /* Met a jour les differents parametres pour le composant en cours d'dition
*/ */
{ {
int ii, jj; int ii, jj;
int hjustify[3] = { GR_TEXT_HJUSTIFY_LEFT , GR_TEXT_HJUSTIFY_CENTER, int hjustify[3] = {
GR_TEXT_HJUSTIFY_RIGHT }; GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_HJUSTIFY_CENTER,
int vjustify[3] = { GR_TEXT_VJUSTIFY_BOTTOM , GR_TEXT_VJUSTIFY_CENTER, GR_TEXT_HJUSTIFY_RIGHT
GR_TEXT_VJUSTIFY_TOP }; };
int vjustify[3] = {
GR_TEXT_VJUSTIFY_BOTTOM, GR_TEXT_VJUSTIFY_CENTER,
GR_TEXT_VJUSTIFY_TOP
};
if( CurrentLibEntry == NULL ) if( CurrentLibEntry == NULL )
{ {
...@@ -656,81 +739,80 @@ int vjustify[3] = { GR_TEXT_VJUSTIFY_BOTTOM , GR_TEXT_VJUSTIFY_CENTER, ...@@ -656,81 +739,80 @@ int vjustify[3] = { GR_TEXT_VJUSTIFY_BOTTOM , GR_TEXT_VJUSTIFY_CENTER,
m_Parent->SaveCopyInUndoList(); m_Parent->SaveCopyInUndoList();
/* A new name could be entered in VALUE field. /* A new name could be entered in VALUE field.
Must not be an existing alias name in alias list box */ * Must not be an existing alias name in alias list box */
jj = m_PartAliasList->GetCount(); jj = m_PartAliasList->GetCount();
wxString newvalue = FieldTextCtrl[VALUE]->GetText(); wxString newvalue = FieldTextCtrl[VALUE]->GetText();
for ( ii = 0; ii < jj; ii++ ) for( ii = 0; ii < jj; ii++ )
{ {
if( newvalue.CmpNoCase(m_PartAliasList->GetString(ii).GetData()) == 0 ) if( newvalue.CmpNoCase( m_PartAliasList->GetString( ii ).GetData() ) == 0 )
{ {
wxString msg; wxString msg;
msg.Printf( wxT("Alias %s exists!"), newvalue.GetData()); msg.Printf( wxT( "Alias %s exists!" ), newvalue.GetData() );
DisplayError(this, msg); DisplayError( this, msg );
return; return;
} }
} }
/* Update the doc, keyword and doc filename strings */ /* Update the doc, keyword and doc filename strings */
if ( m_AliasLocation < 0 ) if( m_AliasLocation < 0 )
{ {
CurrentLibEntry->m_Doc = m_Doc->GetValue(); CurrentLibEntry->m_Doc = m_Doc->GetValue();
CurrentLibEntry->m_KeyWord = m_Keywords->GetValue(); CurrentLibEntry->m_KeyWord = m_Keywords->GetValue();
CurrentLibEntry->m_DocFile = m_Docfile->GetValue(); CurrentLibEntry->m_DocFile = m_Docfile->GetValue();
} }
else else
{ {
CurrentLibEntry->m_AliasList[m_AliasLocation+ALIAS_DOC] = m_Doc->GetValue(); CurrentLibEntry->m_AliasList[m_AliasLocation + ALIAS_DOC] = m_Doc->GetValue();
CurrentLibEntry->m_AliasList[m_AliasLocation+ALIAS_KEYWORD] = m_Keywords->GetValue(); CurrentLibEntry->m_AliasList[m_AliasLocation + ALIAS_KEYWORD] = m_Keywords->GetValue();
CurrentLibEntry->m_AliasList[m_AliasLocation+ALIAS_DOC_FILENAME] = m_Docfile->GetValue(); CurrentLibEntry->m_AliasList[m_AliasLocation + ALIAS_DOC_FILENAME] = m_Docfile->GetValue();
} }
/* Update the alias list */ /* Update the alias list */
/* 1 - Add names: test for a not existing name in old alias list: */ /* 1 - Add names: test for a not existing name in old alias list: */
jj = m_PartAliasList->GetCount(); jj = m_PartAliasList->GetCount();
for ( ii = 0; ii < jj; ii++ ) for( ii = 0; ii < jj; ii++ )
{ {
if ( LocateAlias( CurrentLibEntry->m_AliasList, m_PartAliasList->GetString(ii)) < 0 ) if( LocateAlias( CurrentLibEntry->m_AliasList, m_PartAliasList->GetString( ii ) ) < 0 )
{ // new alias must be created { // new alias must be created
CurrentLibEntry->m_AliasList.Add(m_PartAliasList->GetString(ii)); CurrentLibEntry->m_AliasList.Add( m_PartAliasList->GetString( ii ) );
CurrentLibEntry->m_AliasList.Add(wxEmptyString); // Add a void doc string CurrentLibEntry->m_AliasList.Add( wxEmptyString ); // Add a void doc string
CurrentLibEntry->m_AliasList.Add(wxEmptyString); // Add a void keyword list string CurrentLibEntry->m_AliasList.Add( wxEmptyString ); // Add a void keyword list string
CurrentLibEntry->m_AliasList.Add(wxEmptyString); // Add a void doc filename string CurrentLibEntry->m_AliasList.Add( wxEmptyString ); // Add a void doc filename string
} }
} }
/* 2 - Remove delete names: test for an non existing name in new alias list: */ /* 2 - Remove delete names: test for an non existing name in new alias list: */
int kk, kkmax = CurrentLibEntry->m_AliasList.GetCount(); int kk, kkmax = CurrentLibEntry->m_AliasList.GetCount();
for ( kk = 0; kk < kkmax; ) for( kk = 0; kk < kkmax; )
{ {
jj = m_PartAliasList->GetCount(); jj = m_PartAliasList->GetCount();
wxString aliasname = CurrentLibEntry->m_AliasList[kk]; wxString aliasname = CurrentLibEntry->m_AliasList[kk];
for ( ii = 0; ii < jj; ii++ ) for( ii = 0; ii < jj; ii++ )
{ {
if( aliasname.CmpNoCase(m_PartAliasList->GetString(ii).GetData()) == 0 ) if( aliasname.CmpNoCase( m_PartAliasList->GetString( ii ).GetData() ) == 0 )
{ {
kk += ALIAS_NEXT; // Alias exist in new list. keep it and test next old name kk += ALIAS_NEXT; // Alias exist in new list. keep it and test next old name
break; break;
} }
} }
if ( ii == jj ) // Alias not found in new list, remove it (4 strings in kk position) if( ii == jj ) // Alias not found in new list, remove it (4 strings in kk position)
{ {
for( ii = 0; ii < ALIAS_NEXT; ii++ ) CurrentLibEntry->m_AliasList.RemoveAt(kk); for( ii = 0; ii < ALIAS_NEXT; ii++ )
CurrentLibEntry->m_AliasList.RemoveAt( kk );
kkmax = CurrentLibEntry->m_AliasList.GetCount(); kkmax = CurrentLibEntry->m_AliasList.GetCount();
} }
} }
if( !FieldTextCtrl[REFERENCE]->GetText().IsEmpty() )
if ( ! FieldTextCtrl[REFERENCE]->GetText().IsEmpty() )
{ {
CurrentLibEntry->m_Prefix.m_Text = FieldTextCtrl[REFERENCE]->GetText(); CurrentLibEntry->m_Prefix.m_Text = FieldTextCtrl[REFERENCE]->GetText();
} }
if ( ! FieldTextCtrl[VALUE]->GetText().IsEmpty() ) if( !FieldTextCtrl[VALUE]->GetText().IsEmpty() )
{ {
if ( CurrentLibEntry->m_Name.m_Text != FieldTextCtrl[VALUE]->GetText() ) if( CurrentLibEntry->m_Name.m_Text != FieldTextCtrl[VALUE]->GetText() )
{ {
m_RecreateToolbar = TRUE; m_RecreateToolbar = TRUE;
CurrentLibEntry->m_Name.m_Text = FieldTextCtrl[VALUE]->GetText(); CurrentLibEntry->m_Name.m_Text = FieldTextCtrl[VALUE]->GetText();
...@@ -757,30 +839,30 @@ int vjustify[3] = { GR_TEXT_VJUSTIFY_BOTTOM , GR_TEXT_VJUSTIFY_CENTER, ...@@ -757,30 +839,30 @@ int vjustify[3] = { GR_TEXT_VJUSTIFY_BOTTOM , GR_TEXT_VJUSTIFY_CENTER,
CurrentLibEntry->m_Name.m_VJustify = CurrentLibEntry->m_Name.m_VJustify =
vjustify[FieldVJustify[VALUE]->GetSelection()]; vjustify[FieldVJustify[VALUE]->GetSelection()];
if ( ShowFieldText[REFERENCE]->GetValue() ) if( ShowFieldText[REFERENCE]->GetValue() )
CurrentLibEntry->m_Prefix.m_Attributs &= ~TEXT_NO_VISIBLE; CurrentLibEntry->m_Prefix.m_Attributs &= ~TEXT_NO_VISIBLE;
else else
CurrentLibEntry->m_Prefix.m_Attributs |= TEXT_NO_VISIBLE; CurrentLibEntry->m_Prefix.m_Attributs |= TEXT_NO_VISIBLE;
if ( ShowFieldText[VALUE]->GetValue() ) if( ShowFieldText[VALUE]->GetValue() )
CurrentLibEntry->m_Name.m_Attributs &= ~TEXT_NO_VISIBLE; CurrentLibEntry->m_Name.m_Attributs &= ~TEXT_NO_VISIBLE;
else else
CurrentLibEntry->m_Name.m_Attributs |= TEXT_NO_VISIBLE; CurrentLibEntry->m_Name.m_Attributs |= TEXT_NO_VISIBLE;
for ( ii = FOOTPRINT; ii < NUMBER_OF_FIELDS; ii++ ) for( ii = FOOTPRINT; ii < NUMBER_OF_FIELDS; ii++ )
{ {
LibDrawField * Field = CurrentLibEntry->Fields; LibDrawField* Field = CurrentLibEntry->Fields;
LibDrawField * NextField, * previousField = NULL; LibDrawField* NextField, * previousField = NULL;
while ( Field ) while( Field )
{ {
NextField = (LibDrawField*)Field->Pnext; NextField = (LibDrawField*) Field->Pnext;
if( Field->m_FieldId == ii ) if( Field->m_FieldId == ii )
{ {
Field->m_Text = FieldTextCtrl[ii]->GetText(); Field->m_Text = FieldTextCtrl[ii]->GetText();
Field->m_Size.x = Field->m_Size.y = FieldTextCtrl[ii]->GetTextSize(); Field->m_Size.x = Field->m_Size.y = FieldTextCtrl[ii]->GetTextSize();
Field->m_HJustify = FieldHJustify[ii]->GetSelection(); Field->m_HJustify = FieldHJustify[ii]->GetSelection();
Field->m_VJustify = FieldVJustify[ii]->GetSelection(); Field->m_VJustify = FieldVJustify[ii]->GetSelection();
if ( ShowFieldText[ii]->GetValue() ) if( ShowFieldText[ii]->GetValue() )
Field->m_Attributs &= ~TEXT_NO_VISIBLE; Field->m_Attributs &= ~TEXT_NO_VISIBLE;
else else
Field->m_Attributs |= TEXT_NO_VISIBLE; Field->m_Attributs |= TEXT_NO_VISIBLE;
...@@ -789,8 +871,10 @@ int vjustify[3] = { GR_TEXT_VJUSTIFY_BOTTOM , GR_TEXT_VJUSTIFY_CENTER, ...@@ -789,8 +871,10 @@ int vjustify[3] = { GR_TEXT_VJUSTIFY_BOTTOM , GR_TEXT_VJUSTIFY_CENTER,
if( Field->m_Text.IsEmpty() ) // An old field exists; new is void, delete it if( Field->m_Text.IsEmpty() ) // An old field exists; new is void, delete it
{ {
delete Field; delete Field;
if ( previousField ) previousField->Pnext = NextField; if( previousField )
else CurrentLibEntry->Fields = NextField; previousField->Pnext = NextField;
else
CurrentLibEntry->Fields = NextField;
} }
break; break;
} }
...@@ -799,16 +883,17 @@ int vjustify[3] = { GR_TEXT_VJUSTIFY_BOTTOM , GR_TEXT_VJUSTIFY_CENTER, ...@@ -799,16 +883,17 @@ int vjustify[3] = { GR_TEXT_VJUSTIFY_BOTTOM , GR_TEXT_VJUSTIFY_CENTER,
Field = NextField; Field = NextField;
} }
if ( (Field == NULL) && ( ! FieldTextCtrl[ii]->GetText().IsEmpty() ) ) if( (Field == NULL) && ( !FieldTextCtrl[ii]->GetText().IsEmpty() ) )
{ // Do not exists: must be created { // Do not exists: must be created
Field = new LibDrawField(ii); Field = new LibDrawField( ii );
Field->m_Text = FieldTextCtrl[ii]->GetText(); Field->m_Text = FieldTextCtrl[ii]->GetText();
Field->m_Size.x = Field->m_Size.y = FieldTextCtrl[ii]->GetTextSize(); Field->m_Size.x = Field->m_Size.y = FieldTextCtrl[ii]->GetTextSize();
if ( ShowFieldText[Field->m_FieldId]->GetValue() ) if( ShowFieldText[Field->m_FieldId]->GetValue() )
Field->m_Attributs &= ~TEXT_NO_VISIBLE; Field->m_Attributs &= ~TEXT_NO_VISIBLE;
else else
Field->m_Attributs |= TEXT_NO_VISIBLE; Field->m_Attributs |= TEXT_NO_VISIBLE;
Field->m_Orient = VorientFieldText[Field->m_FieldId]->GetValue() ?1 : 0; Field->m_Orient = VorientFieldText[Field->m_FieldId]->GetValue() ? 1 : 0;
Field->m_Pos = FieldPosition[Field->m_FieldId]->GetValue(); Field->m_Pos = FieldPosition[Field->m_FieldId]->GetValue();
Field->m_HJustify = hjustify[FieldHJustify[Field->m_FieldId]->GetSelection()]; Field->m_HJustify = hjustify[FieldHJustify[Field->m_FieldId]->GetSelection()];
Field->m_VJustify = vjustify[FieldVJustify[Field->m_FieldId]->GetSelection()]; Field->m_VJustify = vjustify[FieldVJustify[Field->m_FieldId]->GetSelection()];
...@@ -818,46 +903,49 @@ int vjustify[3] = { GR_TEXT_VJUSTIFY_BOTTOM , GR_TEXT_VJUSTIFY_CENTER, ...@@ -818,46 +903,49 @@ int vjustify[3] = { GR_TEXT_VJUSTIFY_BOTTOM , GR_TEXT_VJUSTIFY_CENTER,
} }
ii = SelNumberOfUnits->GetValue(); ii = SelNumberOfUnits->GetValue();
if ( ChangeNbUnitsPerPackage(ii) ) if( ChangeNbUnitsPerPackage( ii ) )
m_RecreateToolbar = TRUE; m_RecreateToolbar = TRUE;
if ( AsConvertButt->GetValue() ) if( AsConvertButt->GetValue() )
{ {
if ( ! g_AsDeMorgan ) if( !g_AsDeMorgan )
{ {
g_AsDeMorgan = 1; g_AsDeMorgan = 1;
if ( SetUnsetConvert() ) m_RecreateToolbar = TRUE; if( SetUnsetConvert() )
m_RecreateToolbar = TRUE;
} }
} }
else else
{ {
if ( g_AsDeMorgan ) if( g_AsDeMorgan )
{ {
g_AsDeMorgan = 0; g_AsDeMorgan = 0;
if ( SetUnsetConvert() ) m_RecreateToolbar = TRUE; if( SetUnsetConvert() )
m_RecreateToolbar = TRUE;
} }
} }
CurrentLibEntry->m_DrawPinNum = ShowPinNumButt->GetValue() ? 1 : 0; CurrentLibEntry->m_DrawPinNum = ShowPinNumButt->GetValue() ? 1 : 0;
CurrentLibEntry->m_DrawPinName = ShowPinNameButt->GetValue() ? 1 : 0; CurrentLibEntry->m_DrawPinName = ShowPinNameButt->GetValue() ? 1 : 0;
if ( m_PinsNameInsideButt->GetValue() == FALSE) if( m_PinsNameInsideButt->GetValue() == FALSE )
CurrentLibEntry->m_TextInside = 0; CurrentLibEntry->m_TextInside = 0;
else else
CurrentLibEntry->m_TextInside = m_SetSkew->GetValue(); CurrentLibEntry->m_TextInside = m_SetSkew->GetValue();
if ( m_OptionPower->GetValue() == TRUE) if( m_OptionPower->GetValue() == TRUE )
CurrentLibEntry->m_Options = ENTRY_POWER; CurrentLibEntry->m_Options = ENTRY_POWER;
else else
CurrentLibEntry->m_Options = ENTRY_NORMAL; CurrentLibEntry->m_Options = ENTRY_NORMAL;
/* Set the option "Units locked". /* Set the option "Units locked".
Obviously, cannot be TRUE if there is only one part */ * Obviously, cannot be TRUE if there is only one part */
CurrentLibEntry->m_UnitSelectionLocked = m_OptionPartsLocked->GetValue(); CurrentLibEntry->m_UnitSelectionLocked = m_OptionPartsLocked->GetValue();
if ( CurrentLibEntry->m_UnitCount <= 1 ) if( CurrentLibEntry->m_UnitCount <= 1 )
CurrentLibEntry->m_UnitSelectionLocked = FALSE; CurrentLibEntry->m_UnitSelectionLocked = FALSE;
if ( m_RecreateToolbar ) m_Parent->ReCreateHToolbar(); if( m_RecreateToolbar )
m_Parent->ReCreateHToolbar();
m_Parent->DisplayLibInfos(); m_Parent->DisplayLibInfos();
...@@ -866,133 +954,143 @@ int vjustify[3] = { GR_TEXT_VJUSTIFY_BOTTOM , GR_TEXT_VJUSTIFY_CENTER, ...@@ -866,133 +954,143 @@ int vjustify[3] = { GR_TEXT_VJUSTIFY_BOTTOM , GR_TEXT_VJUSTIFY_CENTER,
/*******************************************************************************/ /*******************************************************************************/
void WinEDA_PartPropertiesFrame::CopyDocToAlias(wxCommandEvent& WXUNUSED(event)) void WinEDA_PartPropertiesFrame::CopyDocToAlias( wxCommandEvent& WXUNUSED (event) )
/******************************************************************************/ /******************************************************************************/
{ {
if( CurrentLibEntry == NULL ) return; if( CurrentLibEntry == NULL )
if ( CurrentAliasName.IsEmpty() ) return; return;
if( CurrentAliasName.IsEmpty() )
return;
m_Doc->SetValue(CurrentLibEntry->m_Doc); m_Doc->SetValue( CurrentLibEntry->m_Doc );
m_Docfile->SetValue(CurrentLibEntry->m_DocFile); m_Docfile->SetValue( CurrentLibEntry->m_DocFile );
m_Keywords->SetValue(CurrentLibEntry->m_KeyWord); m_Keywords->SetValue( CurrentLibEntry->m_KeyWord );
} }
/**********************************************************/ /**********************************************************/
void WinEDA_PartPropertiesFrame::DeleteAllAliasOfPart( void WinEDA_PartPropertiesFrame::DeleteAllAliasOfPart(
wxCommandEvent& WXUNUSED(event)) wxCommandEvent& WXUNUSED (event) )
/**********************************************************/ /**********************************************************/
{ {
CurrentAliasName.Empty(); CurrentAliasName.Empty();
if( CurrentLibEntry ) if( CurrentLibEntry )
{ {
if( IsOK(this, _("Ok to Delete Alias LIST") ) ) if( IsOK( this, _( "Ok to Delete Alias LIST" ) ) )
{ {
m_PartAliasList->Clear(); m_PartAliasList->Clear();
m_RecreateToolbar = TRUE; m_RecreateToolbar = TRUE;
} }
} }
} }
/*******************************************************************************/ /*******************************************************************************/
void WinEDA_PartPropertiesFrame::AddAliasOfPart( wxCommandEvent& WXUNUSED(event)) void WinEDA_PartPropertiesFrame::AddAliasOfPart( wxCommandEvent& WXUNUSED (event) )
/*******************************************************************************/ /*******************************************************************************/
/* Add a new name to the alias list box /* Add a new name to the alias list box
New name cannot be the root name, and must not exists * New name cannot be the root name, and must not exists
*/ */
{ {
wxString Line; wxString Line;
wxString aliasname; wxString aliasname;
if(CurrentLibEntry == NULL) return; if( CurrentLibEntry == NULL )
return;
if( Get_Message(_("New alias:"),Line, this) != 0 ) return; if( Get_Message( _( "New alias:" ), Line, this ) != 0 )
return;
Line.Replace( wxT(" "), wxT("_") ); Line.Replace( wxT( " " ), wxT( "_" ) );
aliasname = Line; aliasname = Line;
if ( CurrentLibEntry->m_Name.m_Text.CmpNoCase(Line) == 0 ) if( CurrentLibEntry->m_Name.m_Text.CmpNoCase( Line ) == 0 )
{ {
DisplayError(this, _("This is the Root Part"), 10); return; DisplayError( this, _( "This is the Root Part" ), 10 ); return;
} }
/* test for an existing name: */ /* test for an existing name: */
int ii, jj = m_PartAliasList->GetCount(); int ii, jj = m_PartAliasList->GetCount();
for ( ii = 0; ii < jj; ii++ ) for( ii = 0; ii < jj; ii++ )
{ {
if( aliasname.CmpNoCase(m_PartAliasList->GetString(ii)) == 0 ) if( aliasname.CmpNoCase( m_PartAliasList->GetString( ii ) ) == 0 )
{ {
DisplayError(this, _("Already in use"), 10); DisplayError( this, _( "Already in use" ), 10 );
return; return;
} }
} }
m_PartAliasList->Append(aliasname); m_PartAliasList->Append( aliasname );
m_RecreateToolbar = TRUE; m_RecreateToolbar = TRUE;
} }
/********************************************************/ /********************************************************/
void WinEDA_PartPropertiesFrame::DeleteAliasOfPart( void WinEDA_PartPropertiesFrame::DeleteAliasOfPart(
wxCommandEvent& WXUNUSED(event)) wxCommandEvent& WXUNUSED (event) )
/********************************************************/ /********************************************************/
{ {
wxString aliasname = m_PartAliasList->GetStringSelection(); wxString aliasname = m_PartAliasList->GetStringSelection();
if ( aliasname.IsEmpty() ) return; if( aliasname.IsEmpty() )
if ( aliasname == CurrentAliasName ) return;
if( aliasname == CurrentAliasName )
{ {
wxString msg = CurrentAliasName + _(" is Current Selected Alias!"); wxString msg = CurrentAliasName + _( " is Current Selected Alias!" );
DisplayError(this, msg ); DisplayError( this, msg );
return; return;
} }
int ii = m_PartAliasList->GetSelection(); int ii = m_PartAliasList->GetSelection();
m_PartAliasList->Delete(ii); m_PartAliasList->Delete( ii );
m_RecreateToolbar = TRUE; m_RecreateToolbar = TRUE;
} }
/********************************************************************/ /********************************************************************/
bool WinEDA_PartPropertiesFrame::ChangeNbUnitsPerPackage(int MaxUnit) bool WinEDA_PartPropertiesFrame::ChangeNbUnitsPerPackage( int MaxUnit )
/********************************************************************/ /********************************************************************/
/* Routine de modification du nombre d'unites par package pour le /* Routine de modification du nombre d'unites par package pour le
composant courant; * composant courant;
*/ */
{ {
int OldNumUnits, ii, FlagDel = -1; int OldNumUnits, ii, FlagDel = -1;
LibEDA_BaseStruct* DrawItem, * NextDrawItem; LibEDA_BaseStruct* DrawItem, * NextDrawItem;
if( CurrentLibEntry == NULL ) return FALSE; if( CurrentLibEntry == NULL )
return FALSE;
/* Si pas de changement: termine */ /* Si pas de changement: termine */
if ( CurrentLibEntry->m_UnitCount == MaxUnit ) return FALSE; if( CurrentLibEntry->m_UnitCount == MaxUnit )
return FALSE;
OldNumUnits = CurrentLibEntry->m_UnitCount; OldNumUnits = CurrentLibEntry->m_UnitCount;
if ( OldNumUnits < 1 ) OldNumUnits = 1; if( OldNumUnits < 1 )
OldNumUnits = 1;
CurrentLibEntry->m_UnitCount = MaxUnit; CurrentLibEntry->m_UnitCount = MaxUnit;
/* Traitement des unites enlevees ou rajoutees */ /* Traitement des unites enlevees ou rajoutees */
if(OldNumUnits > CurrentLibEntry->m_UnitCount ) if( OldNumUnits > CurrentLibEntry->m_UnitCount )
{ {
DrawItem = CurrentLibEntry->m_Drawings; DrawItem = CurrentLibEntry->m_Drawings;
for ( ; DrawItem != NULL; DrawItem = NextDrawItem) for( ; DrawItem != NULL; DrawItem = NextDrawItem )
{ {
NextDrawItem = DrawItem->Next(); NextDrawItem = DrawItem->Next();
if( DrawItem->m_Unit > MaxUnit ) /* Item a effacer */ if( DrawItem->m_Unit > MaxUnit ) /* Item a effacer */
{ {
if( FlagDel < 0 ) if( FlagDel < 0 )
{ {
if( IsOK(this, _("Delete units") ) ) if( IsOK( this, _( "Delete units" ) ) )
{ {
/* Si part selectee n'existe plus: selection 1ere unit */ /* Si part selectee n'existe plus: selection 1ere unit */
if( CurrentUnit > MaxUnit ) CurrentUnit = 1; if( CurrentUnit > MaxUnit )
CurrentUnit = 1;
FlagDel = 1; FlagDel = 1;
} }
else else
...@@ -1003,24 +1101,25 @@ LibEDA_BaseStruct* DrawItem, * NextDrawItem; ...@@ -1003,24 +1101,25 @@ LibEDA_BaseStruct* DrawItem, * NextDrawItem;
return FALSE; return FALSE;
} }
} }
DeleteOneLibraryDrawStruct(m_Parent->DrawPanel, NULL, CurrentLibEntry, DeleteOneLibraryDrawStruct( m_Parent->DrawPanel, NULL, CurrentLibEntry,
DrawItem, 0); DrawItem, 0 );
} }
} }
return TRUE; return TRUE;
} }
if(OldNumUnits < CurrentLibEntry->m_UnitCount ) if( OldNumUnits < CurrentLibEntry->m_UnitCount )
{ {
DrawItem = CurrentLibEntry->m_Drawings; DrawItem = CurrentLibEntry->m_Drawings;
for ( ; DrawItem != NULL; DrawItem = DrawItem->Next() ) for( ; DrawItem != NULL; DrawItem = DrawItem->Next() )
{ {
/* Duplication des items pour autres elements */ /* Duplication des items pour autres elements */
if( DrawItem->m_Unit == 1 ) if( DrawItem->m_Unit == 1 )
{ {
for ( ii = OldNumUnits +1; ii <= MaxUnit; ii ++ ) for( ii = OldNumUnits + 1; ii <= MaxUnit; ii++ )
{ {
NextDrawItem = CopyDrawEntryStruct(this, DrawItem); NextDrawItem = CopyDrawEntryStruct( this, DrawItem );
NextDrawItem->Pnext = CurrentLibEntry->m_Drawings; NextDrawItem->Pnext = CurrentLibEntry->m_Drawings;
CurrentLibEntry->m_Drawings = NextDrawItem; CurrentLibEntry->m_Drawings = NextDrawItem;
NextDrawItem->m_Unit = ii; NextDrawItem->m_Unit = ii;
...@@ -1035,55 +1134,58 @@ LibEDA_BaseStruct* DrawItem, * NextDrawItem; ...@@ -1035,55 +1134,58 @@ LibEDA_BaseStruct* DrawItem, * NextDrawItem;
/*****************************************************/ /*****************************************************/
bool WinEDA_PartPropertiesFrame::SetUnsetConvert() bool WinEDA_PartPropertiesFrame::SetUnsetConvert()
/*****************************************************/ /*****************************************************/
/* cre ou efface (selon option AsConvert) les lments /* cre ou efface (selon option AsConvert) les lments
de la reprsentation convertie d'un composant * de la reprsentation convertie d'un composant
*/ */
{ {
int FlagDel = 0; int FlagDel = 0;
LibEDA_BaseStruct* DrawItem = NULL, * NextDrawItem; LibEDA_BaseStruct* DrawItem = NULL, * NextDrawItem;
if( g_AsDeMorgan ) /* Representation convertie a creer */ if( g_AsDeMorgan ) /* Representation convertie a creer */
{ {
/* Traitement des elements a ajouter ( pins seulement ) */ /* Traitement des elements a ajouter ( pins seulement ) */
if( CurrentLibEntry ) DrawItem = CurrentLibEntry->m_Drawings; if( CurrentLibEntry )
for ( ; DrawItem != NULL; DrawItem = DrawItem->Next() ) DrawItem = CurrentLibEntry->m_Drawings;
for( ; DrawItem != NULL; DrawItem = DrawItem->Next() )
{ {
/* Duplication des items pour autres elements */ /* Duplication des items pour autres elements */
if( DrawItem->Type() != COMPONENT_PIN_DRAW_TYPE ) continue; if( DrawItem->Type() != COMPONENT_PIN_DRAW_TYPE )
continue;
if( DrawItem->m_Convert == 1 ) if( DrawItem->m_Convert == 1 )
{ {
if( FlagDel == 0 ) if( FlagDel == 0 )
{ {
if( IsOK(this, _("Create pins for Convert items")) ) if( IsOK( this, _( "Create pins for Convert items" ) ) )
FlagDel = 1; FlagDel = 1;
else else
{ {
if( IsOK(this, _("Part as \"De Morgan\" anymore")) ) if( IsOK( this, _( "Part as \"De Morgan\" anymore" ) ) )
return TRUE; return TRUE;
g_AsDeMorgan = 0; return FALSE; g_AsDeMorgan = 0; return FALSE;
} }
} }
NextDrawItem = CopyDrawEntryStruct(this, DrawItem); NextDrawItem = CopyDrawEntryStruct( this, DrawItem );
NextDrawItem->Pnext = CurrentLibEntry->m_Drawings; NextDrawItem->Pnext = CurrentLibEntry->m_Drawings;
CurrentLibEntry->m_Drawings = NextDrawItem; CurrentLibEntry->m_Drawings = NextDrawItem;
NextDrawItem->m_Convert = 2; NextDrawItem->m_Convert = 2;
} }
} }
} }
else /* Representation convertie a supprimer */ else /* Representation convertie a supprimer */
{ {
/* Traitement des elements supprimer */ /* Traitement des elements supprimer */
if( CurrentLibEntry ) DrawItem = CurrentLibEntry->m_Drawings; if( CurrentLibEntry )
for ( ; DrawItem != NULL; DrawItem = NextDrawItem) DrawItem = CurrentLibEntry->m_Drawings;
for( ; DrawItem != NULL; DrawItem = NextDrawItem )
{ {
NextDrawItem = DrawItem->Next(); NextDrawItem = DrawItem->Next();
if( DrawItem->m_Convert > 1 ) /* Item a effacer */ if( DrawItem->m_Convert > 1 ) /* Item a effacer */
{ {
if( FlagDel == 0 ) if( FlagDel == 0 )
{ {
if( IsOK(this, _("Delete Convert items") ) ) if( IsOK( this, _( "Delete Convert items" ) ) )
{ {
CurrentConvert = 1; CurrentConvert = 1;
FlagDel = 1; FlagDel = 1;
...@@ -1095,23 +1197,29 @@ LibEDA_BaseStruct* DrawItem = NULL, * NextDrawItem; ...@@ -1095,23 +1197,29 @@ LibEDA_BaseStruct* DrawItem = NULL, * NextDrawItem;
} }
} }
m_Parent->GetScreen()->SetModify(); m_Parent->GetScreen()->SetModify();
DeleteOneLibraryDrawStruct(m_Parent->DrawPanel, NULL, CurrentLibEntry, DrawItem, 0); DeleteOneLibraryDrawStruct( m_Parent->DrawPanel,
NULL,
CurrentLibEntry,
DrawItem,
0 );
} }
} }
} }
return TRUE; return TRUE;
} }
/****************************************************************************/ /****************************************************************************/
void WinEDA_PartPropertiesFrame::BrowseAndSelectDocFile(wxCommandEvent& event) void WinEDA_PartPropertiesFrame::BrowseAndSelectDocFile( wxCommandEvent& event )
/****************************************************************************/ /****************************************************************************/
{ {
wxString FullFileName; wxString FullFileName;
wxString docpath(g_RealLibDirBuffer), filename;
wxString docpath( g_RealLibDirBuffer ), filename;
docpath += wxT("doc"); docpath += wxT( "doc" );
docpath += STRING_DIR_SEP; docpath += STRING_DIR_SEP;
FullFileName = EDA_FileSelector(_("Doc Files"), FullFileName = EDA_FileSelector( _( "Doc Files" ),
docpath, /* Chemin par defaut */ docpath, /* Chemin par defaut */
wxEmptyString, /* nom fichier par defaut */ wxEmptyString, /* nom fichier par defaut */
wxEmptyString, /* extension par defaut */ wxEmptyString, /* extension par defaut */
...@@ -1120,9 +1228,10 @@ wxString docpath(g_RealLibDirBuffer), filename; ...@@ -1120,9 +1228,10 @@ wxString docpath(g_RealLibDirBuffer), filename;
wxFD_OPEN, wxFD_OPEN,
TRUE TRUE
); );
if ( FullFileName.IsEmpty() ) return; if( FullFileName.IsEmpty() )
return;
// Suppression du chemin par defaut pour le fichier de doc: // Suppression du chemin par defaut pour le fichier de doc:
filename = MakeReducedFileName(FullFileName,docpath, wxEmptyString); filename = MakeReducedFileName( FullFileName, docpath, wxEmptyString );
m_Docfile->SetValue(filename); m_Docfile->SetValue( filename );
} }
eeschema/load_one_schematic_file.cpp
View file @ 664a1f72
...@@ -272,8 +272,7 @@ bool WinEDA_SchematicFrame::LoadOneEEFile( SCH_SCREEN* screen, const wxString& F ...@@ -272,8 +272,7 @@ bool WinEDA_SchematicFrame::LoadOneEEFile( SCH_SCREEN* screen, const wxString& F
if( !Failed ) if( !Failed )
{ {
PolylineStruct->Pnext = screen->EEDrawList; PolylineStruct->Pnext = screen->EEDrawList;
screen->EEDrawList = (EDA_BaseStruct*) screen->EEDrawList = (EDA_BaseStruct*) PolylineStruct;
PolylineStruct;
} }
break; break;
...@@ -441,6 +440,10 @@ bool WinEDA_SchematicFrame::LoadOneEEFile( SCH_SCREEN* screen, const wxString& F ...@@ -441,6 +440,10 @@ bool WinEDA_SchematicFrame::LoadOneEEFile( SCH_SCREEN* screen, const wxString& F
screen->EEDrawList = Phead; screen->EEDrawList = Phead;
#if defined(DEBUG)
screen->Show( 0, std::cout );
#endif
fclose( f ); fclose( f );
TestDanglingEnds( screen->EEDrawList, NULL ); TestDanglingEnds( screen->EEDrawList, NULL );
......
eeschema/netlist.cpp
View file @ 664a1f72
/***********************************/ /***********************************/
/* Module de calcul de la Netliste */ /* Module de calcul de la Netliste */
/***********************************/ /***********************************/
#include "fctsys.h" #include "fctsys.h"
#include "gr_basic.h" #include "gr_basic.h"
...@@ -13,21 +13,22 @@ ...@@ -13,21 +13,22 @@
#include "protos.h" #include "protos.h"
/* Routines locales */ /* Routines locales */
static void PropageNetCode( int OldNetCode, int NewNetCode, int IsBus ); static void PropageNetCode( int OldNetCode, int NewNetCode, int IsBus );
static void SheetLabelConnection(ObjetNetListStruct *SheetLabel); static void SheetLabelConnection( ObjetNetListStruct* SheetLabel );
static int ListeObjetConnection(WinEDA_SchematicFrame * frame, SCH_SCREEN *screen, ObjetNetListStruct *ObjNet); static int ListeObjetConnection( WinEDA_SchematicFrame* frame,
static int ConvertBusToMembers(ObjetNetListStruct *ObjNet); SCH_SCREEN* screen,
static void PointToPointConnect(ObjetNetListStruct *RefObj, int IsBus, ObjetNetListStruct* ObjNet );
int start); static int ConvertBusToMembers( ObjetNetListStruct* ObjNet );
static void SegmentToPointConnect(ObjetNetListStruct *Jonction, int IsBus, static void PointToPointConnect( ObjetNetListStruct* RefObj, int IsBus,
int start); int start );
static void LabelConnection(ObjetNetListStruct *Label); static void SegmentToPointConnect( ObjetNetListStruct* Jonction, int IsBus,
static int TriNetCode(ObjetNetListStruct *Objet1, ObjetNetListStruct *Objet2); int start );
static void ConnectBusLabels( ObjetNetListStruct *Label, int NbItems ); static void LabelConnection( ObjetNetListStruct* Label );
static void SetUnconnectedFlag( ObjetNetListStruct *ObjNet, int NbItems ); static int TriNetCode( const void* o1, const void* o2 );
static int TriBySheet(ObjetNetListStruct *Objet1, ObjetNetListStruct *Objet2); static void ConnectBusLabels( ObjetNetListStruct* Label, int NbItems );
static void SetUnconnectedFlag( ObjetNetListStruct* ObjNet, int NbItems );
static int TriBySheet( const void* o1, const void* o2 );
/* Variable locales */ /* Variable locales */
static int FirstNumWireBus, LastNumWireBus, RootBusNameLength; static int FirstNumWireBus, LastNumWireBus, RootBusNameLength;
...@@ -35,21 +36,21 @@ static int LastNetCode, LastBusNetCode; ...@@ -35,21 +36,21 @@ static int LastNetCode, LastBusNetCode;
static int s_PassNumber; static int s_PassNumber;
/***********************************************************************/ /***********************************************************************/
void FreeTabNetList(ObjetNetListStruct * TabNetItems, int NbrNetItems) void FreeTabNetList( ObjetNetListStruct* TabNetItems, int NbrNetItems )
/***********************************************************************/ /***********************************************************************/
/* /*
Routine de liberation memoire des tableaux utilises pour le calcul * Routine de liberation memoire des tableaux utilises pour le calcul
de la netliste * de la netliste
TabNetItems = pointeur sur le tableau principal (liste des items ) * TabNetItems = pointeur sur le tableau principal (liste des items )
NbrNetItems = nombre d'elements * NbrNetItems = nombre d'elements
*/ */
{ {
int i; int i;
/* Liberation memoire des strings du champ Label reserve par ConvertBusToMembers */ /* Liberation memoire des strings du champ Label reserve par ConvertBusToMembers */
for (i = 0; i < NbrNetItems; i++) for( i = 0; i < NbrNetItems; i++ )
{ {
switch( TabNetItems[i].m_Type ) switch( TabNetItems[i].m_Type )
{ {
...@@ -63,6 +64,7 @@ int i; ...@@ -63,6 +64,7 @@ int i;
case NET_PINLABEL: case NET_PINLABEL:
case NET_NOCONNECT: case NET_NOCONNECT:
break; break;
case NET_GLOBBUSLABELMEMBER: case NET_GLOBBUSLABELMEMBER:
case NET_SHEETBUSLABELMEMBER: case NET_SHEETBUSLABELMEMBER:
case NET_BUSLABELMEMBER: case NET_BUSLABELMEMBER:
...@@ -71,32 +73,34 @@ int i; ...@@ -71,32 +73,34 @@ int i;
} }
} }
MyFree(TabNetItems); MyFree( TabNetItems );
} }
/*****************************************************/ /*****************************************************/
void * WinEDA_SchematicFrame::BuildNetListBase() void* WinEDA_SchematicFrame::BuildNetListBase()
/*****************************************************/ /*****************************************************/
/* Routine qui construit le tableau des elements connectes du projet /* Routine qui construit le tableau des elements connectes du projet
met a jour: * met a jour:
g_TabObjNet * g_TabObjNet
g_NbrObjNet * g_NbrObjNet
*/ */
{ {
int NetNumber, SheetNumber; int NetNumber, SheetNumber;
int i, istart, NetCode; int i, istart, NetCode;
SCH_SCREEN * screen; SCH_SCREEN* screen;
ObjetNetListStruct * BaseTabObjNet; wxString msg;
wxString msg; wxBusyCursor Busy;
wxBusyCursor Busy;
NetNumber = 1; NetNumber = 1;
s_PassNumber = 0; s_PassNumber = 0;
MsgPanel->EraseMsgBox(); MsgPanel->EraseMsgBox();
Affiche_1_Parametre(this, 1,_("List"), wxEmptyString, LIGHTRED); Affiche_1_Parametre( this, 1, _( "List" ), wxEmptyString, LIGHTRED );
/* Build the screen list */ /* Build the screen list */
EDA_ScreenList ScreenList(NULL); EDA_ScreenList ScreenList( NULL );
/* 1ere passe : Comptage du nombre d'objet de Net */ /* 1ere passe : Comptage du nombre d'objet de Net */
g_NbrObjNet = 0; g_NbrObjNet = 0;
...@@ -105,52 +109,55 @@ wxBusyCursor Busy; ...@@ -105,52 +109,55 @@ wxBusyCursor Busy;
/* Update the sheet number, sheet count and date and count nelist items */ /* Update the sheet number, sheet count and date and count nelist items */
ScreenSch->SetModify(); ScreenSch->SetModify();
int kk = 1; int kk = 1;
for ( screen = ScreenList.GetFirst(); screen != NULL; screen = ScreenList.GetNext() ) for( screen = ScreenList.GetFirst(); screen != NULL; screen = ScreenList.GetNext() )
{ {
screen->m_SheetNumber = kk++; screen->m_SheetNumber = kk++;
screen->m_NumberOfSheet = ScreenList.GetCount(); screen->m_NumberOfSheet = ScreenList.GetCount();
screen->m_Date = GenDate(); screen->m_Date = GenDate();
g_NbrObjNet += ListeObjetConnection(this, screen, NULL); g_NbrObjNet += ListeObjetConnection( this, screen, NULL );
} }
if( g_NbrObjNet == 0 ) if( g_NbrObjNet == 0 )
{ {
DisplayError(this, _("No component"), 20); DisplayError( this, _( "No component" ), 20 );
return(NULL); return NULL;
} }
i = sizeof(ObjetNetListStruct) * g_NbrObjNet; i = sizeof(ObjetNetListStruct) * g_NbrObjNet;
BaseTabObjNet = g_TabObjNet = (ObjetNetListStruct *) MyZMalloc(i); g_TabObjNet = (ObjetNetListStruct*) MyZMalloc( i );
if( BaseTabObjNet == NULL ) return(NULL); if( g_TabObjNet == NULL )
return NULL;
/* 2eme passe : Remplissage des champs des structures des objets de Net */ /* 2eme passe : Remplissage des champs des structures des objets de Net */
s_PassNumber ++; s_PassNumber++;
Affiche_1_Parametre(this, 1,_("List"), wxEmptyString,RED); Affiche_1_Parametre( this, 1, _( "List" ), wxEmptyString, RED );
for ( screen = ScreenList.GetFirst(); screen != NULL; screen = ScreenList.GetNext() )
screen = ScreenList.GetFirst();
for( ObjetNetListStruct* baseTabObjNet = g_TabObjNet;
screen != NULL; screen = ScreenList.GetNext() )
{ {
g_TabObjNet += ListeObjetConnection(this, screen, g_TabObjNet ); baseTabObjNet += ListeObjetConnection( this, screen, baseTabObjNet );
} }
Affiche_1_Parametre(this, -1, wxEmptyString,_("Done"),RED); Affiche_1_Parametre( this, -1, wxEmptyString, _( "Done" ), RED );
msg.Printf( wxT("%d"), g_NbrObjNet); msg.Printf( wxT( "%d" ), g_NbrObjNet );
Affiche_1_Parametre(this, 8, _("NbItems"),msg,GREEN); Affiche_1_Parametre( this, 8, _( "NbItems" ), msg, GREEN );
/* Recherche des connections pour les Segments et les Pins */ /* Recherche des connections pour les Segments et les Pins */
/* Tri du Tableau des objets de Net par Sheet */ /* Tri du Tableau des objets de Net par Sheet */
qsort(BaseTabObjNet, g_NbrObjNet, sizeof(ObjetNetListStruct), qsort( g_TabObjNet, g_NbrObjNet, sizeof(ObjetNetListStruct), TriBySheet );
(int (*)(const void *, const void *)) TriBySheet);
Affiche_1_Parametre(this, 18,_("Conn"), wxEmptyString,CYAN); Affiche_1_Parametre( this, 18, _( "Conn" ), wxEmptyString, CYAN );
g_TabObjNet = BaseTabObjNet;
SheetNumber = g_TabObjNet[0].m_SheetNumber; SheetNumber = g_TabObjNet[0].m_SheetNumber;
LastNetCode = LastBusNetCode = 1; LastNetCode = LastBusNetCode = 1;
for (i = istart = 0; i < g_NbrObjNet; i++)
for( i = istart = 0; i < g_NbrObjNet; i++ )
{ {
if(g_TabObjNet[i].m_SheetNumber != SheetNumber ) if( g_TabObjNet[i].m_SheetNumber != SheetNumber )
{ {
SheetNumber = g_TabObjNet[i].m_SheetNumber; istart = i; SheetNumber = g_TabObjNet[i].m_SheetNumber; istart = i;
} }
...@@ -161,7 +168,9 @@ wxBusyCursor Busy; ...@@ -161,7 +168,9 @@ wxBusyCursor Busy;
case NET_PINLABEL: case NET_PINLABEL:
case NET_SHEETLABEL: case NET_SHEETLABEL:
case NET_NOCONNECT: case NET_NOCONNECT:
if ( g_TabObjNet[i].m_NetCode != 0 ) break; /* Deja connecte */ if( g_TabObjNet[i].m_NetCode != 0 )
break; /* Deja connecte */
case NET_SEGMENT: case NET_SEGMENT:
/* Controle des connexions type point a point ( Sans BUS ) */ /* Controle des connexions type point a point ( Sans BUS ) */
if( g_TabObjNet[i].m_NetCode == 0 ) if( g_TabObjNet[i].m_NetCode == 0 )
...@@ -169,7 +178,7 @@ wxBusyCursor Busy; ...@@ -169,7 +178,7 @@ wxBusyCursor Busy;
g_TabObjNet[i].m_NetCode = LastNetCode; g_TabObjNet[i].m_NetCode = LastNetCode;
LastNetCode++; LastNetCode++;
} }
PointToPointConnect(g_TabObjNet+i, 0, istart); PointToPointConnect( g_TabObjNet + i, 0, istart );
break; break;
case NET_JONCTION: case NET_JONCTION:
...@@ -179,7 +188,7 @@ wxBusyCursor Busy; ...@@ -179,7 +188,7 @@ wxBusyCursor Busy;
g_TabObjNet[i].m_NetCode = LastNetCode; g_TabObjNet[i].m_NetCode = LastNetCode;
LastNetCode++; LastNetCode++;
} }
SegmentToPointConnect( g_TabObjNet+i, 0, istart); SegmentToPointConnect( g_TabObjNet + i, 0, istart );
/* Controle des jonction , sur BUS */ /* Controle des jonction , sur BUS */
if( g_TabObjNet[i].m_BusNetCode == 0 ) if( g_TabObjNet[i].m_BusNetCode == 0 )
...@@ -187,7 +196,7 @@ wxBusyCursor Busy; ...@@ -187,7 +196,7 @@ wxBusyCursor Busy;
g_TabObjNet[i].m_BusNetCode = LastBusNetCode; g_TabObjNet[i].m_BusNetCode = LastBusNetCode;
LastBusNetCode++; LastBusNetCode++;
} }
SegmentToPointConnect( g_TabObjNet+i, ISBUS, istart ); SegmentToPointConnect( g_TabObjNet + i, ISBUS, istart );
break; break;
case NET_LABEL: case NET_LABEL:
...@@ -198,11 +207,13 @@ wxBusyCursor Busy; ...@@ -198,11 +207,13 @@ wxBusyCursor Busy;
g_TabObjNet[i].m_NetCode = LastNetCode; g_TabObjNet[i].m_NetCode = LastNetCode;
LastNetCode++; LastNetCode++;
} }
SegmentToPointConnect( g_TabObjNet+i, 0, istart ); SegmentToPointConnect( g_TabObjNet + i, 0, istart );
break; break;
case NET_SHEETBUSLABELMEMBER: case NET_SHEETBUSLABELMEMBER:
if ( g_TabObjNet[i].m_BusNetCode != 0 ) break; /* Deja connecte */ if( g_TabObjNet[i].m_BusNetCode != 0 )
break; /* Deja connecte */
case NET_BUS: case NET_BUS:
/* Controle des connexions type point a point mode BUS */ /* Controle des connexions type point a point mode BUS */
if( g_TabObjNet[i].m_BusNetCode == 0 ) if( g_TabObjNet[i].m_BusNetCode == 0 )
...@@ -210,7 +221,7 @@ wxBusyCursor Busy; ...@@ -210,7 +221,7 @@ wxBusyCursor Busy;
g_TabObjNet[i].m_BusNetCode = LastBusNetCode; g_TabObjNet[i].m_BusNetCode = LastBusNetCode;
LastBusNetCode++; LastBusNetCode++;
} }
PointToPointConnect(g_TabObjNet+i, ISBUS, istart); PointToPointConnect( g_TabObjNet + i, ISBUS, istart );
break; break;
case NET_BUSLABELMEMBER: case NET_BUSLABELMEMBER:
...@@ -221,20 +232,20 @@ wxBusyCursor Busy; ...@@ -221,20 +232,20 @@ wxBusyCursor Busy;
g_TabObjNet[i].m_BusNetCode = LastBusNetCode; g_TabObjNet[i].m_BusNetCode = LastBusNetCode;
LastBusNetCode++; LastBusNetCode++;
} }
SegmentToPointConnect( g_TabObjNet+i, ISBUS, istart); SegmentToPointConnect( g_TabObjNet + i, ISBUS, istart );
break; break;
} }
} }
Affiche_1_Parametre(this, -1, wxEmptyString,_("Done"),CYAN);
Affiche_1_Parametre( this, -1, wxEmptyString, _( "Done" ), CYAN );
/* Mise a jour des NetCodes des Bus Labels connectes par les Bus */ /* Mise a jour des NetCodes des Bus Labels connectes par les Bus */
ConnectBusLabels( g_TabObjNet, g_NbrObjNet); ConnectBusLabels( g_TabObjNet, g_NbrObjNet );
Affiche_1_Parametre(this, 26,_("Labels"), wxEmptyString,CYAN); Affiche_1_Parametre( this, 26, _( "Labels" ), wxEmptyString, CYAN );
/* Connections des groupes d'objets par labels identiques */ /* Connections des groupes d'objets par labels identiques */
for (i = 0; i < g_NbrObjNet; i++) for( i = 0; i < g_NbrObjNet; i++ )
{ {
switch( g_TabObjNet[i].m_Type ) switch( g_TabObjNet[i].m_Type )
{ {
...@@ -251,117 +262,128 @@ wxBusyCursor Busy; ...@@ -251,117 +262,128 @@ wxBusyCursor Busy;
case NET_PINLABEL: case NET_PINLABEL:
case NET_BUSLABELMEMBER: case NET_BUSLABELMEMBER:
case NET_GLOBBUSLABELMEMBER: case NET_GLOBBUSLABELMEMBER:
LabelConnection( g_TabObjNet+i ); LabelConnection( g_TabObjNet + i );
break; break;
case NET_SHEETBUSLABELMEMBER: case NET_SHEETBUSLABELMEMBER:
break; break;
} }
} }
Affiche_1_Parametre(this, -1, wxEmptyString,_("Done"),CYAN); Affiche_1_Parametre( this, -1, wxEmptyString, _( "Done" ), CYAN );
/* Connexion des hierarchies */ /* Connexion des hierarchies */
Affiche_1_Parametre(this, 36,_("Hierar."), wxEmptyString,LIGHTRED); Affiche_1_Parametre( this, 36, _( "Hierar." ), wxEmptyString, LIGHTRED );
for (i = 0; i < g_NbrObjNet; i++) for( i = 0; i < g_NbrObjNet; i++ )
{ {
if( (g_TabObjNet[i].m_Type == NET_SHEETLABEL ) || if( (g_TabObjNet[i].m_Type == NET_SHEETLABEL )
( g_TabObjNet[i].m_Type == NET_SHEETBUSLABELMEMBER ) ) || ( g_TabObjNet[i].m_Type == NET_SHEETBUSLABELMEMBER ) )
SheetLabelConnection(g_TabObjNet + i); SheetLabelConnection( g_TabObjNet + i );
} }
/* Tri du Tableau des objets de Net par NetCode */ /* Tri du Tableau des objets de Net par NetCode */
qsort(g_TabObjNet, g_NbrObjNet, sizeof(ObjetNetListStruct), qsort( g_TabObjNet, g_NbrObjNet, sizeof(ObjetNetListStruct), TriNetCode );
(int (*)(const void *, const void *)) TriNetCode);
Affiche_1_Parametre(this, -1, wxEmptyString,_("Done"),RED); Affiche_1_Parametre( this, -1, wxEmptyString, _( "Done" ), RED );
/* Compression des numeros de NetCode a des valeurs consecutives */ /* Compression des numeros de NetCode a des valeurs consecutives */
Affiche_1_Parametre(this, 46,_("Sorting"), wxEmptyString,GREEN); Affiche_1_Parametre( this, 46, _( "Sorting" ), wxEmptyString, GREEN );
LastNetCode = NetCode = 0; LastNetCode = NetCode = 0;
for (i = 0; i < g_NbrObjNet; i++) for( i = 0; i < g_NbrObjNet; i++ )
{ {
if(g_TabObjNet[i].m_NetCode != LastNetCode) if( g_TabObjNet[i].m_NetCode != LastNetCode )
{ {
NetCode++; LastNetCode = g_TabObjNet[i].m_NetCode; NetCode++; LastNetCode = g_TabObjNet[i].m_NetCode;
} }
g_TabObjNet[i].m_NetCode = NetCode; g_TabObjNet[i].m_NetCode = NetCode;
} }
Affiche_1_Parametre(this, -1, wxEmptyString,_("Done"),GREEN); Affiche_1_Parametre( this, -1, wxEmptyString, _( "Done" ), GREEN );
/* Affectation du m_FlagOfConnection en fonction de connection ou non */ /* Affectation du m_FlagOfConnection en fonction de connection ou non */
SetUnconnectedFlag( BaseTabObjNet, g_NbrObjNet); SetUnconnectedFlag( g_TabObjNet, g_NbrObjNet );
return( (void*) BaseTabObjNet); return (void*) g_TabObjNet;
} }
/************************************************************* /*************************************************************
* Routine qui connecte les sous feuilles par les sheetLabels * * Routine qui connecte les sous feuilles par les sheetLabels *
**************************************************************/ **************************************************************/
static void SheetLabelConnection(ObjetNetListStruct *SheetLabel) static void SheetLabelConnection( ObjetNetListStruct* SheetLabel )
{ {
int i; int i;
ObjetNetListStruct *ObjetNet; ObjetNetListStruct* ObjetNet;
if( SheetLabel->m_NetCode == 0 ) return; if( SheetLabel->m_NetCode == 0 )
return;
/* Calcul du numero de sous feuille correspondante au sheetlabel */ /* Calcul du numero de sous feuille correspondante au sheetlabel */
/* Comparaison du SheetLabel avec les GLABELS de la sous feuille /* Comparaison du SheetLabel avec les GLABELS de la sous feuille
pour regroupement des NetCodes */ * pour regroupement des NetCodes */
for (i = 0, ObjetNet = g_TabObjNet; i < g_NbrObjNet; i++) for( i = 0, ObjetNet = g_TabObjNet; i < g_NbrObjNet; i++ )
{ {
if( ObjetNet[i].m_SheetNumber != SheetLabel->m_NumInclude ) continue; if( ObjetNet[i].m_SheetNumber != SheetLabel->m_NumInclude )
if( (ObjetNet[i].m_Type != NET_GLOBLABEL ) && continue;
(ObjetNet[i].m_Type != NET_GLOBBUSLABELMEMBER ) )
if( (ObjetNet[i].m_Type != NET_GLOBLABEL )
&& (ObjetNet[i].m_Type != NET_GLOBBUSLABELMEMBER ) )
continue;
if( ObjetNet[i].m_NetCode == SheetLabel->m_NetCode )
continue;
if( ObjetNet[i].m_Label->CmpNoCase( *SheetLabel->m_Label ) != 0 )
continue; continue;
if( ObjetNet[i].m_NetCode == SheetLabel->m_NetCode ) continue;
if( ObjetNet[i].m_Label->CmpNoCase(*SheetLabel->m_Label) != 0) continue;
/* Propagation du Netcode a tous les Objets de meme NetCode */ /* Propagation du Netcode a tous les Objets de meme NetCode */
if( ObjetNet[i].m_NetCode ) if( ObjetNet[i].m_NetCode )
PropageNetCode(ObjetNet[i].m_NetCode, SheetLabel->m_NetCode, 0); PropageNetCode( ObjetNet[i].m_NetCode, SheetLabel->m_NetCode, 0 );
else ObjetNet[i].m_NetCode = SheetLabel->m_NetCode; else
ObjetNet[i].m_NetCode = SheetLabel->m_NetCode;
} }
} }
/*****************************************************************************/ /*****************************************************************************/
static int ListeObjetConnection(WinEDA_SchematicFrame * frame, SCH_SCREEN *screen, static int ListeObjetConnection( WinEDA_SchematicFrame* frame, SCH_SCREEN* screen,
ObjetNetListStruct *ObjNet) ObjetNetListStruct* ObjNet )
/*****************************************************************************/ /*****************************************************************************/
/* Routine generant la liste des objets relatifs aux connection /* Routine generant la liste des objets relatifs aux connection
entree: * entree:
screen: pointeur sur l'ecran a traiter * screen: pointeur sur l'ecran a traiter
ObjNet: * ObjNet:
si NULL: la routine compte seulement le nombre des objets * si NULL: la routine compte seulement le nombre des objets
sinon: pointe le tableau a remplir * sinon: pointe le tableau a remplir
*/ */
{ {
int ii, NbrItem = 0, NumSheet; int ii, NbrItem = 0, NumSheet;
EDA_BaseStruct *DrawList; EDA_BaseStruct* DrawList;
EDA_SchComponentStruct *DrawLibItem; EDA_SchComponentStruct* DrawLibItem;
int TransMat[2][2], PartX, PartY, x2, y2; int TransMat[2][2], PartX, PartY, x2, y2;
EDA_LibComponentStruct *Entry; EDA_LibComponentStruct* Entry;
LibEDA_BaseStruct *DEntry; LibEDA_BaseStruct* DEntry;
DrawSheetLabelStruct *SheetLabel; DrawSheetLabelStruct* SheetLabel;
int NumInclude; int NumInclude;
NumSheet = screen->m_SheetNumber; NumSheet = screen->m_SheetNumber;
DrawList = screen->EEDrawList;
while ( DrawList ) DrawList = screen->EEDrawList;
for( ; DrawList; DrawList = DrawList->Pnext )
{ {
switch( DrawList->Type() ) switch( DrawList->Type() )
{ {
case DRAW_SEGMENT_STRUCT_TYPE : case DRAW_SEGMENT_STRUCT_TYPE:
#undef STRUCT #undef STRUCT
#define STRUCT ((EDA_DrawLineStruct *) DrawList) #define STRUCT ( (EDA_DrawLineStruct*) DrawList )
if( ObjNet) if( ObjNet )
{ {
if ( (STRUCT->m_Layer != LAYER_BUS) && if( (STRUCT->m_Layer != LAYER_BUS)
(STRUCT->m_Layer != LAYER_WIRE) ) && (STRUCT->m_Layer != LAYER_WIRE) )
break; break;
ObjNet[NbrItem].m_Comp = STRUCT; ObjNet[NbrItem].m_Comp = STRUCT;
...@@ -369,7 +391,8 @@ int NumInclude; ...@@ -369,7 +391,8 @@ int NumInclude;
ObjNet[NbrItem].m_SheetNumber = NumSheet; ObjNet[NbrItem].m_SheetNumber = NumSheet;
ObjNet[NbrItem].m_Start = STRUCT->m_Start; ObjNet[NbrItem].m_Start = STRUCT->m_Start;
ObjNet[NbrItem].m_End = STRUCT->m_End; ObjNet[NbrItem].m_End = STRUCT->m_End;
if (STRUCT->m_Layer == LAYER_BUS)
if( STRUCT->m_Layer == LAYER_BUS )
{ {
ObjNet[NbrItem].m_Type = NET_BUS; ObjNet[NbrItem].m_Type = NET_BUS;
} }
...@@ -381,10 +404,10 @@ int NumInclude; ...@@ -381,10 +404,10 @@ int NumInclude;
NbrItem++; NbrItem++;
break; break;
case DRAW_JUNCTION_STRUCT_TYPE : case DRAW_JUNCTION_STRUCT_TYPE:
#undef STRUCT #undef STRUCT
#define STRUCT ((DrawJunctionStruct *) DrawList) #define STRUCT ( (DrawJunctionStruct*) DrawList )
if( ObjNet) if( ObjNet )
{ {
ObjNet[NbrItem].m_Comp = STRUCT; ObjNet[NbrItem].m_Comp = STRUCT;
ObjNet[NbrItem].m_Screen = screen; ObjNet[NbrItem].m_Screen = screen;
...@@ -396,10 +419,10 @@ int NumInclude; ...@@ -396,10 +419,10 @@ int NumInclude;
NbrItem++; NbrItem++;
break; break;
case DRAW_NOCONNECT_STRUCT_TYPE : case DRAW_NOCONNECT_STRUCT_TYPE:
#undef STRUCT #undef STRUCT
#define STRUCT ((DrawNoConnectStruct *) DrawList) #define STRUCT ( (DrawNoConnectStruct*) DrawList )
if( ObjNet) if( ObjNet )
{ {
ObjNet[NbrItem].m_Comp = STRUCT; ObjNet[NbrItem].m_Comp = STRUCT;
ObjNet[NbrItem].m_Screen = screen; ObjNet[NbrItem].m_Screen = screen;
...@@ -411,72 +434,95 @@ int NumInclude; ...@@ -411,72 +434,95 @@ int NumInclude;
NbrItem++; NbrItem++;
break; break;
case DRAW_LABEL_STRUCT_TYPE : case DRAW_LABEL_STRUCT_TYPE:
#undef STRUCT #undef STRUCT
#define STRUCT ((DrawLabelStruct *) DrawList) #define STRUCT ( (DrawLabelStruct*) DrawList )
ii = IsBusLabel( STRUCT->m_Text); ii = IsBusLabel( STRUCT->m_Text );
if( ObjNet) if( ObjNet )
{ {
ObjNet[NbrItem].m_Comp = STRUCT; ObjNet[NbrItem].m_Comp = STRUCT;
ObjNet[NbrItem].m_Screen = screen; ObjNet[NbrItem].m_Screen = screen;
ObjNet[NbrItem].m_Type = NET_LABEL; ObjNet[NbrItem].m_Type = NET_LABEL;
if (STRUCT->m_Layer == LAYER_GLOBLABEL)
if( STRUCT->m_Layer == LAYER_GLOBLABEL )
ObjNet[NbrItem].m_Type = NET_GLOBLABEL; ObjNet[NbrItem].m_Type = NET_GLOBLABEL;
ObjNet[NbrItem].m_Label = & STRUCT->m_Text;
ObjNet[NbrItem].m_Label = &STRUCT->m_Text;
ObjNet[NbrItem].m_SheetNumber = NumSheet; ObjNet[NbrItem].m_SheetNumber = NumSheet;
ObjNet[NbrItem].m_Start = STRUCT->m_Pos; ObjNet[NbrItem].m_Start = STRUCT->m_Pos;
ObjNet[NbrItem].m_End = ObjNet[NbrItem].m_Start; ObjNet[NbrItem].m_End = ObjNet[NbrItem].m_Start;
/* Si c'est un Bus, eclatement en Label */ /* Si c'est un Bus, eclatement en Label */
if ( ii ) ConvertBusToMembers(ObjNet + NbrItem); if( ii )
ConvertBusToMembers( ObjNet + NbrItem );
} }
NbrItem += ii+1; NbrItem += ii + 1;
break; break;
case DRAW_GLOBAL_LABEL_STRUCT_TYPE : case DRAW_GLOBAL_LABEL_STRUCT_TYPE:
#undef STRUCT #undef STRUCT
#define STRUCT ((DrawGlobalLabelStruct *) DrawList) #define STRUCT ( (DrawGlobalLabelStruct*) DrawList )
ii = IsBusLabel( STRUCT->m_Text); ii = IsBusLabel( STRUCT->m_Text );
if( ObjNet) if( ObjNet )
{ {
ObjNet[NbrItem].m_Comp = STRUCT; ObjNet[NbrItem].m_Comp = STRUCT;
ObjNet[NbrItem].m_Screen = screen; ObjNet[NbrItem].m_Screen = screen;
ObjNet[NbrItem].m_Type = NET_LABEL; ObjNet[NbrItem].m_Type = NET_LABEL;
if (STRUCT->m_Layer == LAYER_GLOBLABEL)
if( STRUCT->m_Layer == LAYER_GLOBLABEL )
ObjNet[NbrItem].m_Type = NET_GLOBLABEL; ObjNet[NbrItem].m_Type = NET_GLOBLABEL;
ObjNet[NbrItem].m_Label = & STRUCT->m_Text;
ObjNet[NbrItem].m_Label = &STRUCT->m_Text;
ObjNet[NbrItem].m_SheetNumber = NumSheet; ObjNet[NbrItem].m_SheetNumber = NumSheet;
ObjNet[NbrItem].m_Start = STRUCT->m_Pos; ObjNet[NbrItem].m_Start = STRUCT->m_Pos;
ObjNet[NbrItem].m_End = ObjNet[NbrItem].m_Start; ObjNet[NbrItem].m_End = ObjNet[NbrItem].m_Start;
/* Si c'est un Bus, eclatement en Label */ /* Si c'est un Bus, eclatement en Label */
if ( ii ) ConvertBusToMembers(ObjNet + NbrItem); if( ii )
ConvertBusToMembers( ObjNet + NbrItem );
} }
NbrItem += ii+1; NbrItem += ii + 1;
break;
case DRAW_LIB_ITEM_STRUCT_TYPE:
DrawLibItem = (EDA_SchComponentStruct*) DrawList;
memcpy( TransMat, DrawLibItem->m_Transform, sizeof(TransMat) );
PartX = DrawLibItem->m_Pos.x;
PartY = DrawLibItem->m_Pos.y;
Entry = FindLibPart( DrawLibItem->m_ChipName, wxEmptyString, FIND_ROOT );
if( Entry == NULL )
break; break;
case DRAW_LIB_ITEM_STRUCT_TYPE : if( Entry->m_Drawings == NULL )
DrawLibItem = (EDA_SchComponentStruct *) DrawList; break;
memcpy(TransMat, DrawLibItem->m_Transform, sizeof(TransMat));
PartX = DrawLibItem->m_Pos.x; PartY = DrawLibItem->m_Pos.y;
Entry = FindLibPart(DrawLibItem->m_ChipName, wxEmptyString, FIND_ROOT);
if( Entry == NULL) break;
if(Entry->m_Drawings == NULL) break ;
DEntry = Entry->m_Drawings; DEntry = Entry->m_Drawings;
for ( ;DEntry != NULL; DEntry = DEntry->Next())
for( ; DEntry != NULL; DEntry = DEntry->Next() )
{ {
LibDrawPin * Pin = (LibDrawPin *) DEntry; LibDrawPin* Pin = (LibDrawPin*) DEntry;
if( DEntry->Type() != COMPONENT_PIN_DRAW_TYPE) continue; if( DEntry->Type() != COMPONENT_PIN_DRAW_TYPE )
if( DEntry->m_Unit && continue;
(DEntry->m_Unit != DrawLibItem->m_Multi) ) continue;
if( DEntry->m_Convert && if( DEntry->m_Unit
(DEntry->m_Convert != DrawLibItem->m_Convert)) continue; && (DEntry->m_Unit != DrawLibItem->m_Multi) )
continue;
if( DEntry->m_Convert
&& (DEntry->m_Convert != DrawLibItem->m_Convert) )
continue;
x2 = PartX + TransMat[0][0] * Pin->m_Pos.x x2 = PartX + TransMat[0][0] * Pin->m_Pos.x
+ TransMat[0][1] * Pin->m_Pos.y; + TransMat[0][1] * Pin->m_Pos.y;
y2 = PartY + TransMat[1][0] * Pin->m_Pos.x y2 = PartY + TransMat[1][0] * Pin->m_Pos.x
+ TransMat[1][1] * Pin->m_Pos.y; + TransMat[1][1] * Pin->m_Pos.y;
if( ObjNet) if( ObjNet )
{ {
ObjNet[NbrItem].m_Comp = DEntry; ObjNet[NbrItem].m_Comp = DEntry;
ObjNet[NbrItem].m_Type = NET_PIN; ObjNet[NbrItem].m_Type = NET_PIN;
...@@ -484,7 +530,7 @@ int NumInclude; ...@@ -484,7 +530,7 @@ int NumInclude;
ObjNet[NbrItem].m_Screen = screen; ObjNet[NbrItem].m_Screen = screen;
ObjNet[NbrItem].m_ElectricalType = Pin->m_PinType; ObjNet[NbrItem].m_ElectricalType = Pin->m_PinType;
ObjNet[NbrItem].m_PinNum = Pin->m_PinNum; ObjNet[NbrItem].m_PinNum = Pin->m_PinNum;
ObjNet[NbrItem].m_Label = & Pin->m_PinName; ObjNet[NbrItem].m_Label = &Pin->m_PinName;
ObjNet[NbrItem].m_SheetNumber = NumSheet; ObjNet[NbrItem].m_SheetNumber = NumSheet;
ObjNet[NbrItem].m_Start.x = x2; ObjNet[NbrItem].m_Start.x = x2;
ObjNet[NbrItem].m_Start.y = y2; ObjNet[NbrItem].m_Start.y = y2;
...@@ -492,16 +538,17 @@ int NumInclude; ...@@ -492,16 +538,17 @@ int NumInclude;
} }
NbrItem++; NbrItem++;
if( ( (int) Pin->m_PinType == (int) PIN_POWER_IN ) && if( ( (int) Pin->m_PinType == (int) PIN_POWER_IN )
( Pin->m_Attributs & PINNOTDRAW ) ) && ( Pin->m_Attributs & PINNOTDRAW ) )
{ /* Il y a un PIN_LABEL Associe */ {
if( ObjNet) /* Il y a un PIN_LABEL Associe */
if( ObjNet )
{ {
ObjNet[NbrItem].m_Comp = NULL; ObjNet[NbrItem].m_Comp = NULL;
ObjNet[NbrItem].m_Type = NET_PINLABEL; ObjNet[NbrItem].m_Type = NET_PINLABEL;
ObjNet[NbrItem].m_Screen = screen; ObjNet[NbrItem].m_Screen = screen;
ObjNet[NbrItem].m_SheetNumber = NumSheet; ObjNet[NbrItem].m_SheetNumber = NumSheet;
ObjNet[NbrItem].m_Label = & Pin->m_PinName; ObjNet[NbrItem].m_Label = &Pin->m_PinName;
ObjNet[NbrItem].m_Start.x = x2; ObjNet[NbrItem].m_Start.x = x2;
ObjNet[NbrItem].m_Start.y = y2; ObjNet[NbrItem].m_Start.y = y2;
ObjNet[NbrItem].m_End = ObjNet[NbrItem].m_Start; ObjNet[NbrItem].m_End = ObjNet[NbrItem].m_Start;
...@@ -509,101 +556,110 @@ int NumInclude; ...@@ -509,101 +556,110 @@ int NumInclude;
NbrItem++; NbrItem++;
} }
} }
break; break;
case DRAW_PICK_ITEM_STRUCT_TYPE : case DRAW_PICK_ITEM_STRUCT_TYPE:
case DRAW_POLYLINE_STRUCT_TYPE : case DRAW_POLYLINE_STRUCT_TYPE:
case DRAW_BUSENTRY_STRUCT_TYPE : case DRAW_BUSENTRY_STRUCT_TYPE:
case DRAW_MARKER_STRUCT_TYPE : case DRAW_MARKER_STRUCT_TYPE:
case DRAW_TEXT_STRUCT_TYPE : case DRAW_TEXT_STRUCT_TYPE:
break; break;
case DRAW_SHEET_STRUCT_TYPE : case DRAW_SHEET_STRUCT_TYPE:
#undef STRUCT #undef STRUCT
#define STRUCT ((DrawSheetStruct *) DrawList) #define STRUCT ( (DrawSheetStruct*) DrawList )
NumInclude = STRUCT->m_SheetNumber; NumInclude = STRUCT->m_SheetNumber;
SheetLabel = STRUCT->m_Label; SheetLabel = STRUCT->m_Label;
for ( ; SheetLabel != NULL; for( ; SheetLabel != NULL;
SheetLabel = (DrawSheetLabelStruct*) SheetLabel->Pnext) SheetLabel = (DrawSheetLabelStruct*) SheetLabel->Pnext )
{ {
ii = IsBusLabel(SheetLabel->m_Text); ii = IsBusLabel( SheetLabel->m_Text );
if( ObjNet) if( ObjNet )
{ {
ObjNet[NbrItem].m_Comp = SheetLabel; ObjNet[NbrItem].m_Comp = SheetLabel;
ObjNet[NbrItem].m_Link = DrawList; ObjNet[NbrItem].m_Link = DrawList;
ObjNet[NbrItem].m_Type = NET_SHEETLABEL; ObjNet[NbrItem].m_Type = NET_SHEETLABEL;
ObjNet[NbrItem].m_Screen = screen; ObjNet[NbrItem].m_Screen = screen;
ObjNet[NbrItem].m_ElectricalType = SheetLabel->m_Shape; ObjNet[NbrItem].m_ElectricalType = SheetLabel->m_Shape;
ObjNet[NbrItem].m_Label = & SheetLabel->m_Text; ObjNet[NbrItem].m_Label = &SheetLabel->m_Text;
ObjNet[NbrItem].m_SheetNumber = NumSheet; ObjNet[NbrItem].m_SheetNumber = NumSheet;
ObjNet[NbrItem].m_NumInclude = NumInclude; ObjNet[NbrItem].m_NumInclude = NumInclude;
ObjNet[NbrItem].m_Start = SheetLabel->m_Pos; ObjNet[NbrItem].m_Start = SheetLabel->m_Pos;
ObjNet[NbrItem].m_End = ObjNet[NbrItem].m_Start; ObjNet[NbrItem].m_End = ObjNet[NbrItem].m_Start;
/* Si c'est un Bus, eclatement en Label */ /* Si c'est un Bus, eclatement en Label */
if ( ii ) ConvertBusToMembers(ObjNet + NbrItem); if( ii )
ConvertBusToMembers( ObjNet + NbrItem );
} }
NbrItem += ii+1; NbrItem += ii + 1;
} }
break; break;
case DRAW_SHEETLABEL_STRUCT_TYPE : case DRAW_SHEETLABEL_STRUCT_TYPE:
DisplayError(frame, wxT("Netlist: Type DRAW_SHEETLABEL inattendu")); DisplayError( frame, wxT( "Netlist: Type DRAW_SHEETLABEL inattendu" ) );
break; break;
default: default:
{ {
wxString msg; wxString msg;
msg.Printf( wxT("Netlist: unexpected type struct %d"), msg.Printf( wxT( "Netlist: unexpected type struct %d" ),
DrawList->Type()); DrawList->Type() );
DisplayError(frame, msg); DisplayError( frame, msg );
break; break;
} }
} }
DrawList = DrawList->Pnext;
} }
return(NbrItem); return NbrItem;
} }
/************************************************************************/ /************************************************************************/
static void ConnectBusLabels( ObjetNetListStruct *Label, int NbItems ) static void ConnectBusLabels( ObjetNetListStruct* Label, int NbItems )
/************************************************************************/ /************************************************************************/
/* Routine qui analyse les labels type xxBUSLABELMEMBER /* Routine qui analyse les labels type xxBUSLABELMEMBER
Propage les Netcodes entre labels correspondants ( c'est a dire lorsque * Propage les Netcodes entre labels correspondants ( c'est a dire lorsque
leur numero de membre est identique) lorsqu'ils sont connectes * leur numero de membre est identique) lorsqu'ils sont connectes
globalement par leur BusNetCode * globalement par leur BusNetCode
Utilise et met a jour la variable LastNetCode * Utilise et met a jour la variable LastNetCode
*/ */
{ {
ObjetNetListStruct *LabelInTst, *Lim; ObjetNetListStruct* LabelInTst, * Lim;
Lim = Label + NbItems; Lim = Label + NbItems;
for ( ; Label < Lim; Label++) for( ; Label < Lim; Label++ )
{ {
if( (Label->m_Type == NET_SHEETBUSLABELMEMBER) || if( (Label->m_Type == NET_SHEETBUSLABELMEMBER)
(Label->m_Type == NET_BUSLABELMEMBER) || || (Label->m_Type == NET_BUSLABELMEMBER)
(Label->m_Type == NET_GLOBBUSLABELMEMBER) ) || (Label->m_Type == NET_GLOBBUSLABELMEMBER) )
{ {
if( Label->m_NetCode == 0 ) if( Label->m_NetCode == 0 )
{ {
Label->m_NetCode = LastNetCode; LastNetCode++; Label->m_NetCode = LastNetCode;
LastNetCode++;
} }
for ( LabelInTst = Label+1; LabelInTst < Lim; LabelInTst++)
for( LabelInTst = Label + 1; LabelInTst < Lim; LabelInTst++ )
{ {
if( (LabelInTst->m_Type == NET_SHEETBUSLABELMEMBER) || if( (LabelInTst->m_Type == NET_SHEETBUSLABELMEMBER)
(LabelInTst->m_Type == NET_BUSLABELMEMBER) || || (LabelInTst->m_Type == NET_BUSLABELMEMBER)
(LabelInTst->m_Type == NET_GLOBBUSLABELMEMBER) ) || (LabelInTst->m_Type == NET_GLOBBUSLABELMEMBER) )
{ {
if( LabelInTst->m_BusNetCode != Label->m_BusNetCode ) continue; if( LabelInTst->m_BusNetCode != Label->m_BusNetCode )
if( LabelInTst->m_Member != Label->m_Member ) continue; continue;
if( LabelInTst->m_Member != Label->m_Member )
continue;
if( LabelInTst->m_NetCode == 0 ) if( LabelInTst->m_NetCode == 0 )
LabelInTst->m_NetCode = Label->m_NetCode; LabelInTst->m_NetCode = Label->m_NetCode;
else else
PropageNetCode( LabelInTst->m_NetCode, Label->m_NetCode,0); PropageNetCode( LabelInTst->m_NetCode, Label->m_NetCode, 0 );
} }
} }
} }
...@@ -612,139 +668,156 @@ ObjetNetListStruct *LabelInTst, *Lim; ...@@ -612,139 +668,156 @@ ObjetNetListStruct *LabelInTst, *Lim;
/**************************************************/ /**************************************************/
int IsBusLabel( const wxString & LabelDrawList ) int IsBusLabel( const wxString& LabelDrawList )
/**************************************************/ /**************************************************/
/* Routine qui verifie si le Label a une notation de type Bus /* Routine qui verifie si le Label a une notation de type Bus
Retourne 0 si non * Retourne 0 si non
nombre de membres si oui * nombre de membres si oui
met a jour FirstNumWireBus, LastNumWireBus et RootBusNameLength * met a jour FirstNumWireBus, LastNumWireBus et RootBusNameLength
*/ */
{ {
unsigned Num; unsigned Num;
int ii; int ii;
wxString BufLine; wxString BufLine;
long tmp; long tmp;
bool error = FALSE; bool error = FALSE;
/* Search for '[' because a bus label is like "busname[nn..mm]" */ /* Search for '[' because a bus label is like "busname[nn..mm]" */
ii = LabelDrawList.Find('['); ii = LabelDrawList.Find( '[' );
if ( ii < 0 ) return(0); if( ii < 0 )
return 0;
Num = (unsigned) ii; Num = (unsigned) ii;
FirstNumWireBus = LastNumWireBus = 9; FirstNumWireBus = LastNumWireBus = 9;
RootBusNameLength = Num; RootBusNameLength = Num;
Num++; Num++;
while ( LabelDrawList[Num] != '.' && Num < LabelDrawList.Len()) while( LabelDrawList[Num] != '.' && Num < LabelDrawList.Len() )
{ {
BufLine.Append(LabelDrawList[Num]); BufLine.Append( LabelDrawList[Num] );
Num++; Num++;
} }
if ( ! BufLine.ToLong(&tmp) ) error = TRUE;; if( !BufLine.ToLong( &tmp ) )
error = TRUE;
FirstNumWireBus = tmp; FirstNumWireBus = tmp;
while ( LabelDrawList[Num] == '.' && Num < LabelDrawList.Len() ) while( LabelDrawList[Num] == '.' && Num < LabelDrawList.Len() )
Num++; Num++;
BufLine.Empty(); BufLine.Empty();
while ( LabelDrawList[Num] != ']' && Num < LabelDrawList.Len()) while( LabelDrawList[Num] != ']' && Num < LabelDrawList.Len() )
{ {
BufLine.Append(LabelDrawList[Num]); BufLine.Append( LabelDrawList[Num] );
Num++; Num++;
} }
if ( ! BufLine.ToLong(&tmp) ) error = TRUE;;
if( !BufLine.ToLong( &tmp ) )
error = TRUE;;
LastNumWireBus = tmp; LastNumWireBus = tmp;
if( FirstNumWireBus < 0 ) FirstNumWireBus = 0; if( FirstNumWireBus < 0 )
if( LastNumWireBus < 0 ) LastNumWireBus = 0; FirstNumWireBus = 0;
if( LastNumWireBus < 0 )
LastNumWireBus = 0;
if( FirstNumWireBus > LastNumWireBus ) if( FirstNumWireBus > LastNumWireBus )
{ {
EXCHG( FirstNumWireBus, LastNumWireBus); EXCHG( FirstNumWireBus, LastNumWireBus );
} }
if ( error && (s_PassNumber == 0) ) if( error && (s_PassNumber == 0) )
{ {
wxString msg = _("Bad Bus Label: ") + LabelDrawList; wxString msg = _( "Bad Bus Label: " ) + LabelDrawList;
DisplayError(NULL, msg); DisplayError( NULL, msg );
} }
return(LastNumWireBus - FirstNumWireBus + 1 ); return LastNumWireBus - FirstNumWireBus + 1;
} }
/***************************************************************/ /***************************************************************/
static int ConvertBusToMembers(ObjetNetListStruct * BusLabel) static int ConvertBusToMembers( ObjetNetListStruct* BusLabel )
/***************************************************************/ /***************************************************************/
/* Routine qui eclate un label type Bus en autant de Label qu'il contient de membres, /* Routine qui eclate un label type Bus en autant de Label qu'il contient de membres,
et qui cree les structures avec le type NET_GLOBBUSLABELMEMBER, NET_BUSLABELMEMBER * et qui cree les structures avec le type NET_GLOBBUSLABELMEMBER, NET_BUSLABELMEMBER
ou NET_SHEETBUSLABELMEMBER * ou NET_SHEETBUSLABELMEMBER
entree = pointeur sur l'ObjetNetListStruct initialise corresp au buslabel * entree = pointeur sur l'ObjetNetListStruct initialise corresp au buslabel
suppose que FirstNumWireBus, LastNumWireBus et RootBusNameLength sont a jour * suppose que FirstNumWireBus, LastNumWireBus et RootBusNameLength sont a jour
modifie l'ObjetNetListStruct de base et remplit les suivants * modifie l'ObjetNetListStruct de base et remplit les suivants
m_Label is a pointer to a new wxString * m_Label is a pointer to a new wxString
m_Label must be deallocated by the user (only for a NET_GLOBBUSLABELMEMBER, * m_Label must be deallocated by the user (only for a NET_GLOBBUSLABELMEMBER,
NET_BUSLABELMEMBER or a NET_SHEETBUSLABELMEMBER object type) * NET_BUSLABELMEMBER or a NET_SHEETBUSLABELMEMBER object type)
*/ */
{ {
int NumItem, BusMember; int NumItem, BusMember;
wxString BufLine; wxString BufLine;
if( BusLabel->m_Type == NET_GLOBLABEL ) if( BusLabel->m_Type == NET_GLOBLABEL )
BusLabel->m_Type = NET_GLOBBUSLABELMEMBER; BusLabel->m_Type = NET_GLOBBUSLABELMEMBER;
else if (BusLabel->m_Type == NET_SHEETLABEL) else if( BusLabel->m_Type == NET_SHEETLABEL )
BusLabel->m_Type = NET_SHEETBUSLABELMEMBER; BusLabel->m_Type = NET_SHEETBUSLABELMEMBER;
else BusLabel->m_Type = NET_BUSLABELMEMBER; else
BusLabel->m_Type = NET_BUSLABELMEMBER;
/* Convertion du BusLabel en la racine du Label + le numero du fil */ /* Convertion du BusLabel en la racine du Label + le numero du fil */
BufLine = BusLabel->m_Label->Left(RootBusNameLength); BufLine = BusLabel->m_Label->Left( RootBusNameLength );
BusMember = FirstNumWireBus; BusMember = FirstNumWireBus;
BufLine << BusMember; BufLine << BusMember;
BusLabel->m_Label = new wxString(BufLine); BusLabel->m_Label = new wxString( BufLine );
BusLabel->m_Member = BusMember; BusLabel->m_Member = BusMember;
NumItem = 1; NumItem = 1;
for ( BusMember++; BusMember <= LastNumWireBus; BusMember++) for( BusMember++; BusMember <= LastNumWireBus; BusMember++ )
{ {
*(BusLabel+1) = *BusLabel; BusLabel ++; NumItem++; *(BusLabel + 1) = *BusLabel; BusLabel++; NumItem++;
/* Convertion du BusLabel en la racine du Label + le numero du fil */ /* Convertion du BusLabel en la racine du Label + le numero du fil */
BufLine = BusLabel->m_Label->Left(RootBusNameLength); BufLine = BusLabel->m_Label->Left( RootBusNameLength );
BufLine << BusMember; BufLine << BusMember;
BusLabel->m_Label = new wxString(BufLine); BusLabel->m_Label = new wxString( BufLine );
BusLabel->m_Member = BusMember; BusLabel->m_Member = BusMember;
} }
return( NumItem);
return NumItem;
} }
/**********************************************************************/ /**********************************************************************/
static void PropageNetCode( int OldNetCode, int NewNetCode, int IsBus ) static void PropageNetCode( int OldNetCode, int NewNetCode, int IsBus )
/**********************************************************************/ /**********************************************************************/
/* PropageNetCode propage le netcode NewNetCode sur tous les elements /* PropageNetCode propage le netcode NewNetCode sur tous les elements
appartenant a l'ancien netcode OldNetCode * appartenant a l'ancien netcode OldNetCode
Si IsBus == 0; c'est le membre NetCode qui est propage * Si IsBus == 0; c'est le membre NetCode qui est propage
Si IsBus != 0; c'est le membre BusNetCode qui est propage * Si IsBus != 0; c'est le membre BusNetCode qui est propage
*/ */
{ {
int jj; int jj;
ObjetNetListStruct * Objet = g_TabObjNet; ObjetNetListStruct* Objet = g_TabObjNet;
if( OldNetCode == NewNetCode ) return; if( OldNetCode == NewNetCode )
return;
if( IsBus == 0 ) /* Propagation du NetCode */ if( IsBus == 0 ) /* Propagation du NetCode */
{ {
for (jj = 0; jj < g_NbrObjNet; jj++, Objet++) for( jj = 0; jj < g_NbrObjNet; jj++, Objet++ )
{ {
if ( Objet->m_NetCode == OldNetCode ) if( Objet->m_NetCode == OldNetCode )
{ {
Objet->m_NetCode = NewNetCode; Objet->m_NetCode = NewNetCode;
} }
} }
} }
else /* Propagation du BusNetCode */ else /* Propagation du BusNetCode */
{ {
for (jj = 0; jj < g_NbrObjNet; jj++, Objet++) for( jj = 0; jj < g_NbrObjNet; jj++, Objet++ )
{ {
if ( Objet->m_BusNetCode == OldNetCode ) if( Objet->m_BusNetCode == OldNetCode )
{ {
Objet->m_BusNetCode = NewNetCode; Objet->m_BusNetCode = NewNetCode;
} }
...@@ -752,37 +825,40 @@ ObjetNetListStruct * Objet = g_TabObjNet; ...@@ -752,37 +825,40 @@ ObjetNetListStruct * Objet = g_TabObjNet;
} }
} }
/***************************************************************************/ /***************************************************************************/
static void PointToPointConnect(ObjetNetListStruct *Ref, int IsBus, int start) static void PointToPointConnect( ObjetNetListStruct* Ref, int IsBus, int start )
/***************************************************************************/ /***************************************************************************/
/* Routine qui verifie si l'element *Ref est connecte a /* Routine qui verifie si l'element *Ref est connecte a
d'autres elements de la liste des objets du schema, selon le mode Point * d'autres elements de la liste des objets du schema, selon le mode Point
a point ( Extremites superposees ) * a point ( Extremites superposees )
*
si IsBus: * si IsBus:
la connexion ne met en jeu que des elements type bus * la connexion ne met en jeu que des elements type bus
( BUS ou BUSLABEL ou JONCTION ) * ( BUS ou BUSLABEL ou JONCTION )
sinon * sinon
la connexion ne met en jeu que des elements type non bus * la connexion ne met en jeu que des elements type non bus
( autres que BUS ou BUSLABEL ) * ( autres que BUS ou BUSLABEL )
*
L'objet Ref doit avoir un NetCode valide. * L'objet Ref doit avoir un NetCode valide.
*
La liste des objets est supposee classe par NumSheet Croissants, * La liste des objets est supposee classe par NumSheet Croissants,
et la recherche se fait a partir de l'element start, 1er element * et la recherche se fait a partir de l'element start, 1er element
de la feuille de schema * de la feuille de schema
( il ne peut y avoir connexion physique entre elements de differentes sheets) * ( il ne peut y avoir connexion physique entre elements de differentes sheets)
*/ */
{ {
int i, NetCode; int i, NetCode;
ObjetNetListStruct *Point = g_TabObjNet; ObjetNetListStruct* Point = g_TabObjNet;
if ( IsBus == 0 ) /* Objets autres que BUS et BUSLABELS */ if( IsBus == 0 ) /* Objets autres que BUS et BUSLABELS */
{ {
NetCode = Ref->m_NetCode; NetCode = Ref->m_NetCode;
for (i = start; i < g_NbrObjNet; i++) for( i = start; i < g_NbrObjNet; i++ )
{ {
if( Point[i].m_SheetNumber > Ref->m_SheetNumber ) break; if( Point[i].m_SheetNumber > Ref->m_SheetNumber )
break;
switch( Point[i].m_Type ) switch( Point[i].m_Type )
{ {
...@@ -794,15 +870,21 @@ if ( IsBus == 0 ) /* Objets autres que BUS et BUSLABELS */ ...@@ -794,15 +870,21 @@ if ( IsBus == 0 ) /* Objets autres que BUS et BUSLABELS */
case NET_PINLABEL: case NET_PINLABEL:
case NET_JONCTION: case NET_JONCTION:
case NET_NOCONNECT: case NET_NOCONNECT:
if( (((Ref->m_Start.x == Point[i].m_Start.x) && (Ref->m_Start.y == Point[i].m_Start.y))) || if( ( ( (Ref->m_Start.x == Point[i].m_Start.x) &&
(((Ref->m_Start.x == Point[i].m_End.x) && (Ref->m_Start.y == Point[i].m_End.y))) || (Ref->m_Start.y == Point[i].m_Start.y) ) )
(((Ref->m_End.x == Point[i].m_Start.x) && (Ref->m_End.y == Point[i].m_Start.y))) || || ( ( (Ref->m_Start.x == Point[i].m_End.x) &&
(((Ref->m_End.x == Point[i].m_End.x) && (Ref->m_End.y == Point[i].m_End.y))) ) (Ref->m_Start.y == Point[i].m_End.y) ) )
{ || ( ( (Ref->m_End.x == Point[i].m_Start.x) &&
if( Point[i].m_NetCode == 0 ) Point[i].m_NetCode = NetCode; (Ref->m_End.y == Point[i].m_Start.y) ) )
else PropageNetCode( Point[i].m_NetCode, NetCode , 0); || ( ( (Ref->m_End.x == Point[i].m_End.x) && (Ref->m_End.y == Point[i].m_End.y) ) ) )
{
if( Point[i].m_NetCode == 0 )
Point[i].m_NetCode = NetCode;
else
PropageNetCode( Point[i].m_NetCode, NetCode, 0 );
} }
break; break;
case NET_BUS: case NET_BUS:
case NET_BUSLABELMEMBER: case NET_BUSLABELMEMBER:
case NET_SHEETBUSLABELMEMBER: case NET_SHEETBUSLABELMEMBER:
...@@ -811,12 +893,13 @@ if ( IsBus == 0 ) /* Objets autres que BUS et BUSLABELS */ ...@@ -811,12 +893,13 @@ if ( IsBus == 0 ) /* Objets autres que BUS et BUSLABELS */
} }
} }
} }
else /* Objets type BUS et BUSLABELS ( et JONCTIONS )*/ else /* Objets type BUS et BUSLABELS ( et JONCTIONS )*/
{ {
NetCode = Ref->m_BusNetCode; NetCode = Ref->m_BusNetCode;
for (i = start; i < g_NbrObjNet; i++) for( i = start; i < g_NbrObjNet; i++ )
{ {
if( Point[i].m_SheetNumber > Ref->m_SheetNumber ) break; if( Point[i].m_SheetNumber > Ref->m_SheetNumber )
break;
switch( Point[i].m_Type ) switch( Point[i].m_Type )
{ {
...@@ -834,14 +917,18 @@ else /* Objets type BUS et BUSLABELS ( et JONCTIONS )*/ ...@@ -834,14 +917,18 @@ else /* Objets type BUS et BUSLABELS ( et JONCTIONS )*/
case NET_SHEETBUSLABELMEMBER: case NET_SHEETBUSLABELMEMBER:
case NET_GLOBBUSLABELMEMBER: case NET_GLOBBUSLABELMEMBER:
case NET_JONCTION: case NET_JONCTION:
if( (((Ref->m_Start.x == Point[i].m_Start.x) && (Ref->m_Start.y == Point[i].m_Start.y))) || if( ( ( (Ref->m_Start.x == Point[i].m_Start.x) &&
(((Ref->m_Start.x == Point[i].m_End.x) && (Ref->m_Start.y == Point[i].m_End.y))) || (Ref->m_Start.y == Point[i].m_Start.y) ) )
(((Ref->m_End.x == Point[i].m_Start.x) && (Ref->m_End.y == Point[i].m_Start.y))) || || ( ( (Ref->m_Start.x == Point[i].m_End.x) &&
(((Ref->m_End.x == Point[i].m_End.x) && (Ref->m_End.y == Point[i].m_End.y))) ) (Ref->m_Start.y == Point[i].m_End.y) ) )
|| ( ( (Ref->m_End.x == Point[i].m_Start.x) &&
(Ref->m_End.y == Point[i].m_Start.y) ) )
|| ( ( (Ref->m_End.x == Point[i].m_End.x) && (Ref->m_End.y == Point[i].m_End.y) ) ) )
{ {
if( Point[i].m_BusNetCode == 0 ) if( Point[i].m_BusNetCode == 0 )
Point[i].m_BusNetCode = NetCode; Point[i].m_BusNetCode = NetCode;
else PropageNetCode( Point[i].m_BusNetCode, NetCode,1 ); else
PropageNetCode( Point[i].m_BusNetCode, NetCode, 1 );
} }
break; break;
} }
...@@ -851,157 +938,183 @@ else /* Objets type BUS et BUSLABELS ( et JONCTIONS )*/ ...@@ -851,157 +938,183 @@ else /* Objets type BUS et BUSLABELS ( et JONCTIONS )*/
/**************************************************************/ /**************************************************************/
static void SegmentToPointConnect(ObjetNetListStruct *Jonction, static void SegmentToPointConnect( ObjetNetListStruct* Jonction,
int IsBus, int start) int IsBus, int start )
/***************************************************************/ /***************************************************************/
/* /*
Routine qui recherche si un point (jonction) est connecte a des segments, * Routine qui recherche si un point (jonction) est connecte a des segments,
et regroupe les NetCodes des objets connectes a la jonction. * et regroupe les NetCodes des objets connectes a la jonction.
Le point de jonction doit avoir un netcode valide * Le point de jonction doit avoir un netcode valide
La liste des objets est supposee classe par NumSheet Croissants, * La liste des objets est supposee classe par NumSheet Croissants,
et la recherche se fait a partir de l'element start, 1er element * et la recherche se fait a partir de l'element start, 1er element
de la feuille de schema * de la feuille de schema
( il ne peut y avoir connexion physique entre elements de differentes sheets) * ( il ne peut y avoir connexion physique entre elements de differentes sheets)
*/ */
{ {
int i; int i;
ObjetNetListStruct *Segment = g_TabObjNet; ObjetNetListStruct* Segment = g_TabObjNet;
for (i = start; i < g_NbrObjNet; i++) for( i = start; i < g_NbrObjNet; i++ )
{ {
if( Segment[i].m_SheetNumber > Jonction->m_SheetNumber ) break; if( Segment[i].m_SheetNumber > Jonction->m_SheetNumber )
break;
if( IsBus == 0) if( IsBus == 0 )
{ {
if ( Segment[i].m_Type != NET_SEGMENT ) continue; if( Segment[i].m_Type != NET_SEGMENT )
continue;
} }
else else
{ {
if ( Segment[i].m_Type != NET_BUS ) continue; if( Segment[i].m_Type != NET_BUS )
continue;
} }
if ( SegmentIntersect(Segment[i].m_Start.x, Segment[i].m_Start.y, if( SegmentIntersect( Segment[i].m_Start.x, Segment[i].m_Start.y,
Segment[i].m_End.x, Segment[i].m_End.y, Segment[i].m_End.x, Segment[i].m_End.y,
Jonction->m_Start.x, Jonction->m_Start.y) ) Jonction->m_Start.x, Jonction->m_Start.y ) )
{ {
/* Propagation du Netcode a tous les Objets de meme NetCode */ /* Propagation du Netcode a tous les Objets de meme NetCode */
if( IsBus == 0 ) if( IsBus == 0 )
{ {
if( Segment[i].m_NetCode ) if( Segment[i].m_NetCode )
PropageNetCode(Segment[i].m_NetCode, PropageNetCode( Segment[i].m_NetCode,
Jonction->m_NetCode, IsBus); Jonction->m_NetCode, IsBus );
else Segment[i].m_NetCode = Jonction->m_NetCode; else
Segment[i].m_NetCode = Jonction->m_NetCode;
} }
else else
{ {
if( Segment[i].m_BusNetCode ) if( Segment[i].m_BusNetCode )
PropageNetCode(Segment[i].m_BusNetCode, PropageNetCode( Segment[i].m_BusNetCode,
Jonction->m_BusNetCode, IsBus); Jonction->m_BusNetCode, IsBus );
else Segment[i].m_BusNetCode = Jonction->m_BusNetCode; else
Segment[i].m_BusNetCode = Jonction->m_BusNetCode;
} }
} }
} }
} }
/***************************************************************** /*****************************************************************
* Routine qui connecte les groupes d'objets si labels identiques * * Routine qui connecte les groupes d'objets si labels identiques *
*******************************************************************/ *******************************************************************/
static void LabelConnection(ObjetNetListStruct *LabelRef) static void LabelConnection( ObjetNetListStruct* LabelRef )
{ {
int i, NetCode; int i, NetCode;
ObjetNetListStruct *ObjetNet; ObjetNetListStruct* ObjetNet;
if( LabelRef->m_NetCode == 0 ) return; if( LabelRef->m_NetCode == 0 )
return;
ObjetNet = g_TabObjNet; ObjetNet = g_TabObjNet;
for (i = 0; i < g_NbrObjNet; i++) for( i = 0; i < g_NbrObjNet; i++ )
{ {
NetCode = ObjetNet[i].m_NetCode; NetCode = ObjetNet[i].m_NetCode;
if( NetCode == LabelRef->m_NetCode ) continue; if( NetCode == LabelRef->m_NetCode )
continue;
if( ObjetNet[i].m_SheetNumber != LabelRef->m_SheetNumber ) if( ObjetNet[i].m_SheetNumber != LabelRef->m_SheetNumber )
{ {
if (ObjetNet[i].m_Type != NET_PINLABEL ) continue; if( ObjetNet[i].m_Type != NET_PINLABEL )
continue;
} }
if( (ObjetNet[i].m_Type == NET_LABEL ) || if( (ObjetNet[i].m_Type == NET_LABEL )
(ObjetNet[i].m_Type == NET_GLOBLABEL ) || || (ObjetNet[i].m_Type == NET_GLOBLABEL )
(ObjetNet[i].m_Type == NET_BUSLABELMEMBER ) || || (ObjetNet[i].m_Type == NET_BUSLABELMEMBER )
(ObjetNet[i].m_Type == NET_GLOBBUSLABELMEMBER ) || || (ObjetNet[i].m_Type == NET_GLOBBUSLABELMEMBER )
(ObjetNet[i].m_Type == NET_PINLABEL ) ) || (ObjetNet[i].m_Type == NET_PINLABEL ) )
{ {
if( ObjetNet[i].m_Label->CmpNoCase(*LabelRef->m_Label) != 0) continue; if( ObjetNet[i].m_Label->CmpNoCase( *LabelRef->m_Label ) != 0 )
continue;
/* Ici 2 labels identiques */ /* Ici 2 labels identiques */
/* Propagation du Netcode a tous les Objets de meme NetCode */ /* Propagation du Netcode a tous les Objets de meme NetCode */
if( ObjetNet[i].m_NetCode ) if( ObjetNet[i].m_NetCode )
PropageNetCode(ObjetNet[i].m_NetCode, LabelRef->m_NetCode, 0); PropageNetCode( ObjetNet[i].m_NetCode, LabelRef->m_NetCode, 0 );
else ObjetNet[i].m_NetCode = LabelRef->m_NetCode; else
ObjetNet[i].m_NetCode = LabelRef->m_NetCode;
} }
} }
} }
/****************************************************************************/ /****************************************************************************/
static int TriNetCode(ObjetNetListStruct *Objet1, ObjetNetListStruct *Objet2) static int TriNetCode( const void* o1, const void* o2 )
/****************************************************************************/ /****************************************************************************/
/* Routine de comparaison pour le tri par NetCode croissant /* Routine de comparaison pour le tri par NetCode croissant
du tableau des elements connectes ( TabPinSort ) par qsort() * du tableau des elements connectes ( TabPinSort ) par qsort()
*/ */
{ {
return (Objet1->m_NetCode - Objet2->m_NetCode); ObjetNetListStruct* Objet1 = (ObjetNetListStruct*) o1;
ObjetNetListStruct* Objet2 = (ObjetNetListStruct*) o2;
return Objet1->m_NetCode - Objet2->m_NetCode;
} }
/*****************************************************************************/ /*****************************************************************************/
static int TriBySheet(ObjetNetListStruct *Objet1, ObjetNetListStruct *Objet2) static int TriBySheet( const void* o1, const void* o2 )
/*****************************************************************************/ /*****************************************************************************/
/* Routine de comparaison pour le tri par NumSheet /* Routine de comparaison pour le tri par NumSheet
du tableau des elements connectes ( TabPinSort ) par qsort() */ * du tableau des elements connectes ( TabPinSort ) par qsort() */
{ {
return (Objet1->m_SheetNumber - Objet2->m_SheetNumber); ObjetNetListStruct* Objet1 = (ObjetNetListStruct*) o1;
ObjetNetListStruct* Objet2 = (ObjetNetListStruct*) o2;
return Objet1->m_SheetNumber - Objet2->m_SheetNumber;
} }
/**********************************************************************/ /**********************************************************************/
static void SetUnconnectedFlag( ObjetNetListStruct *ListObj, int NbItems ) static void SetUnconnectedFlag( ObjetNetListStruct* ListObj, int NbItems )
/**********************************************************************/ /**********************************************************************/
/* Routine positionnant le membre .FlagNoConnect des elements de /* Routine positionnant le membre .FlagNoConnect des elements de
la liste des objets netliste, tries par ordre de NetCode * la liste des objets netliste, tries par ordre de NetCode
*/ */
{ {
ObjetNetListStruct * NetItemRef, * NetItemTst, *ItemPtr; ObjetNetListStruct* NetItemRef, * NetItemTst, * ItemPtr;
ObjetNetListStruct * NetStart, * NetEnd, * Lim; ObjetNetListStruct* NetStart, * NetEnd, * Lim;
int Nb; int Nb;
IsConnectType StateFlag; IsConnectType StateFlag;
NetStart = NetEnd = ListObj; NetStart = NetEnd = ListObj;
Lim = ListObj + NbItems;
NetItemRef = NetStart; NetItemRef = NetStart;
Nb = 0; StateFlag = UNCONNECT; Nb = 0;
StateFlag = UNCONNECT;
for ( ; NetItemRef < Lim; NetItemRef++ ) Lim = ListObj + NbItems;
for( ; NetItemRef < Lim; NetItemRef++ )
{ {
if( NetItemRef->m_Type == NET_NOCONNECT ) if( NetItemRef->m_Type == NET_NOCONNECT )
if( StateFlag != CONNECT ) StateFlag = NOCONNECT; if( StateFlag != CONNECT )
StateFlag = NOCONNECT;
/* Analyse du net en cours */ /* Analyse du net en cours */
NetItemTst = NetItemRef + 1; NetItemTst = NetItemRef + 1;
if( (NetItemTst >= Lim) || if( (NetItemTst >= Lim)
(NetItemRef->m_NetCode != NetItemTst->m_NetCode) ) || (NetItemRef->m_NetCode != NetItemTst->m_NetCode) )
{ /* Net analyse: mise a jour de m_FlagOfConnection */ {
/* Net analyse: mise a jour de m_FlagOfConnection */
NetEnd = NetItemTst; NetEnd = NetItemTst;
for( ItemPtr = NetStart; ItemPtr < NetEnd; ItemPtr++ ) for( ItemPtr = NetStart; ItemPtr < NetEnd; ItemPtr++ )
{ {
ItemPtr->m_FlagOfConnection = StateFlag; ItemPtr->m_FlagOfConnection = StateFlag;
} }
if(NetItemTst >= Lim) return;
if( NetItemTst >= Lim )
return;
/* Start Analyse Nouveau Net */ /* Start Analyse Nouveau Net */
StateFlag = UNCONNECT; StateFlag = UNCONNECT;
...@@ -1009,10 +1122,10 @@ IsConnectType StateFlag; ...@@ -1009,10 +1122,10 @@ IsConnectType StateFlag;
continue; continue;
} }
for ( ; ; NetItemTst ++) for( ; ; NetItemTst++ )
{ {
if( (NetItemTst >= Lim) || if( (NetItemTst >= Lim)
(NetItemRef->m_NetCode != NetItemTst->m_NetCode) ) || (NetItemRef->m_NetCode != NetItemTst->m_NetCode) )
break; break;
switch( NetItemTst->m_Type ) switch( NetItemTst->m_Type )
...@@ -1035,10 +1148,10 @@ IsConnectType StateFlag; ...@@ -1035,10 +1148,10 @@ IsConnectType StateFlag;
break; break;
case NET_NOCONNECT: case NET_NOCONNECT:
if( StateFlag != CONNECT ) StateFlag = NOCONNECT; if( StateFlag != CONNECT )
StateFlag = NOCONNECT;
break; break;
} }
} }
} }
} }
eeschema/netlist.h
View file @ 664a1f72
/**********************************************/ /**********************************************/
/* Module de calcul de la Netliste: netlist.h */ /* Module de calcul de la Netliste: netlist.h */
/**********************************************/ /**********************************************/
#ifndef _NETLIST_H_ #ifndef _NETLIST_H_
#define _NETLIST_H_ #define _NETLIST_H_
...@@ -15,8 +15,7 @@ ...@@ -15,8 +15,7 @@
/* Indicateurs de type de netliste generee */ /* Indicateurs de type de netliste generee */
typedef enum typedef enum {
{
NET_TYPE_NOT_INIT = 0, NET_TYPE_NOT_INIT = 0,
NET_TYPE_PCBNEW, NET_TYPE_PCBNEW,
NET_TYPE_ORCADPCB2, NET_TYPE_ORCADPCB2,
...@@ -31,7 +30,7 @@ typedef enum ...@@ -31,7 +30,7 @@ typedef enum
NET_TYPE_CUSTOM7, NET_TYPE_CUSTOM7,
NET_TYPE_CUSTOM8, NET_TYPE_CUSTOM8,
NET_TYPE_MAX NET_TYPE_MAX
} TypeNetForm ; } TypeNetForm;
/* Max pin number per component and footprint */ /* Max pin number per component and footprint */
...@@ -58,34 +57,36 @@ typedef enum { /* Valeur du Flag de connection */ ...@@ -58,34 +57,36 @@ typedef enum { /* Valeur du Flag de connection */
CONNECT /* connexion normale */ CONNECT /* connexion normale */
} IsConnectType; } IsConnectType;
/* Structure decrivant 1 element de connexion (pour netlist ) */ /* Structure decrivant 1 element de connexion (pour netlist ) */
class ObjetNetListStruct class ObjetNetListStruct
{ {
public: public:
void * m_Comp; /* Pointeur sur la definition de l'objet */ void* m_Comp; /* Pointeur sur la definition de l'objet */
void * m_Link; /* Pour SheetLabelStruct: Pointeur sur la feuille de hierarchie void* m_Link; /* Pour SheetLabelStruct: Pointeur sur la feuille de hierarchie
Pour les Pins: pointeur sur le composant */ * Pour les Pins: pointeur sur le composant */
int m_Flag; /* flag pour calculs internes */ int m_Flag; /* flag pour calculs internes */
SCH_SCREEN * m_Screen; /* Ecran d'appartenance */ SCH_SCREEN* m_Screen; /* Ecran d'appartenance */
NetObjetType m_Type; NetObjetType m_Type;
int m_ElectricalType; /* Pour Pins et sheet labels: type electrique */ int m_ElectricalType; /* Pour Pins et sheet labels: type electrique */
int m_NetCode; /* pour elements simples */ int m_NetCode; /* pour elements simples */
int m_BusNetCode; /* pour connexions type bus */ int m_BusNetCode; /* pour connexions type bus */
int m_Member; /* pour les labels type BUSWIRE ( labels de bus eclate ) int m_Member; /* pour les labels type BUSWIRE ( labels de bus eclate )
numero de membre */ * numero de membre */
IsConnectType m_FlagOfConnection; IsConnectType m_FlagOfConnection;
int m_SheetNumber; /* Sheet number for this item */ int m_SheetNumber; /* Sheet number for this item */
int m_NumInclude; /* Numero de sous schema correpondant a la sheet (Gestion des GLabels et Pin Sheet)*/ int m_NumInclude; /* Numero de sous schema correpondant a la sheet (Gestion des GLabels et Pin Sheet)*/
long m_PinNum; /* numero de pin( 4 octets -> 4 codes ascii) */ long m_PinNum; /* numero de pin( 4 octets -> 4 codes ascii) */
const wxString * m_Label; /* Tous types Labels:pointeur sur la wxString definissant le label */ const wxString* m_Label; /* Tous types Labels:pointeur sur la wxString definissant le label */
wxPoint m_Start, m_End; wxPoint m_Start, m_End;
}; };
/* Structure decrivant 1 composant de la schematique (pour annotation ) */ /* Structure decrivant 1 composant de la schematique (pour annotation ) */
struct CmpListStruct struct CmpListStruct
{ {
public: public:
EDA_SchComponentStruct * m_Cmp; /* Pointeur sur le composant */ EDA_SchComponentStruct* m_Cmp; /* Pointeur sur le composant */
int m_NbParts; /* Nombre de parts par boitier */ int m_NbParts; /* Nombre de parts par boitier */
bool m_PartsLocked; // For multi part components: True if the part cannot be changed bool m_PartsLocked; // For multi part components: True if the part cannot be changed
int m_Unit; /* Numero de part */ int m_Unit; /* Numero de part */
...@@ -102,11 +103,11 @@ public: ...@@ -102,11 +103,11 @@ public:
/* Global Variables */ /* Global Variables */
eda_global int g_NbrObjNet; eda_global int g_NbrObjNet;
eda_global ObjetNetListStruct *g_TabObjNet; eda_global ObjetNetListStruct* g_TabObjNet;
/* Prototypes: */ /* Prototypes: */
void WriteNetList(WinEDA_SchematicFrame * frame, const wxString & FileNameNL, bool use_netnames); void WriteNetList( WinEDA_SchematicFrame* frame, const wxString& FileNameNL, bool use_netnames );
void FreeTabNetList(ObjetNetListStruct * TabNetItems, int NbrNetItems); void FreeTabNetList( ObjetNetListStruct* TabNetItems, int NbrNetItems );
#endif #endif
eeschema/program.h
View file @ 664a1f72
...@@ -75,9 +75,10 @@ public: ...@@ -75,9 +75,10 @@ public:
public: public:
EDA_DrawLineStruct( const wxPoint& pos, int layer ); EDA_DrawLineStruct( const wxPoint& pos, int layer );
~EDA_DrawLineStruct() { } ~EDA_DrawLineStruct() { }
virtual wxString GetClass() const virtual wxString GetClass() const
{ {
return wxT( "EDA_DrawLineStruct" ); return wxT( "EDA_DrawLine" );
} }
...@@ -92,6 +93,17 @@ public: ...@@ -92,6 +93,17 @@ public:
virtual void Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset, int draw_mode, virtual void Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset, int draw_mode,
int Color = -1 ); int Color = -1 );
#if defined(DEBUG)
/**
* Function Show
* is used to output the object tree, currently for debugging only.
* @param nestLevel An aid to prettier tree indenting, and is the level
* of nesting of this object within the overall tree.
* @param os The ostream& to output to.
*/
void Show( int nestLevel, std::ostream& os );
#endif
}; };
...@@ -108,7 +120,7 @@ public: ...@@ -108,7 +120,7 @@ public:
~DrawMarkerStruct(); ~DrawMarkerStruct();
virtual wxString GetClass() const virtual wxString GetClass() const
{ {
return wxT( "DrawMarkerStruct" ); return wxT( "DrawMarker" );
} }
...@@ -116,6 +128,16 @@ public: ...@@ -116,6 +128,16 @@ public:
wxString GetComment(); wxString GetComment();
virtual void Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset, virtual void Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset,
int draw_mode, int Color = -1 ); int draw_mode, int Color = -1 );
#if defined(DEBUG)
/**
* Function Show
* is used to output the object tree, currently for debugging only.
* @param nestLevel An aid to prettier tree indenting, and is the level
* of nesting of this object within the overall tree.
* @param os The ostream& to output to.
*/
void Show( int nestLevel, std::ostream& os );
#endif
}; };
...@@ -129,7 +151,7 @@ public: ...@@ -129,7 +151,7 @@ public:
~DrawNoConnectStruct() { } ~DrawNoConnectStruct() { }
virtual wxString GetClass() const virtual wxString GetClass() const
{ {
return wxT( "DrawNoConnectStruct" ); return wxT( "DrawNoConnect" );
} }
...@@ -154,9 +176,10 @@ public: ...@@ -154,9 +176,10 @@ public:
public: public:
DrawBusEntryStruct( const wxPoint& pos, int shape, int id ); DrawBusEntryStruct( const wxPoint& pos, int shape, int id );
~DrawBusEntryStruct() { } ~DrawBusEntryStruct() { }
virtual wxString GetClass() const virtual wxString GetClass() const
{ {
return wxT( "DrawBusEntryStruct" ); return wxT( "DrawBusEntry" );
} }
...@@ -177,9 +200,10 @@ public: ...@@ -177,9 +200,10 @@ public:
public: public:
DrawPolylineStruct( int layer ); DrawPolylineStruct( int layer );
~DrawPolylineStruct(); ~DrawPolylineStruct();
virtual wxString GetClass() const virtual wxString GetClass() const
{ {
return wxT( "DrawPolylineStruct" ); return wxT( "DrawPolyline" );
} }
...@@ -197,9 +221,10 @@ public: ...@@ -197,9 +221,10 @@ public:
public: public:
DrawJunctionStruct( const wxPoint& pos ); DrawJunctionStruct( const wxPoint& pos );
~DrawJunctionStruct() { } ~DrawJunctionStruct() { }
virtual wxString GetClass() const virtual wxString GetClass() const
{ {
return wxT( "DrawJunctionStruct" ); return wxT( "DrawJunction" );
} }
...@@ -209,8 +234,7 @@ public: ...@@ -209,8 +234,7 @@ public:
}; };
class DrawTextStruct : public EDA_BaseStruct class DrawTextStruct : public EDA_BaseStruct, public EDA_TextStruct
, public EDA_TextStruct
{ {
public: public:
int m_Layer; int m_Layer;
...@@ -224,7 +248,7 @@ public: ...@@ -224,7 +248,7 @@ public:
virtual wxString GetClass() const virtual wxString GetClass() const
{ {
return wxT( "DrawTextStruct" ); return wxT( "DrawText" );
} }
...@@ -248,7 +272,7 @@ public: ...@@ -248,7 +272,7 @@ public:
virtual wxString GetClass() const virtual wxString GetClass() const
{ {
return wxT( "DrawLabelStruct" ); return wxT( "DrawLabel" );
} }
}; };
...@@ -264,7 +288,7 @@ public: ...@@ -264,7 +288,7 @@ public:
virtual wxString GetClass() const virtual wxString GetClass() const
{ {
return wxT( "DrawGlobalLabelStruct" ); return wxT( "DrawGlobalLabel" );
} }
}; };
......
eeschema/protos.h
View file @ 664a1f72
...@@ -8,7 +8,7 @@ LibEDA_BaseStruct * LocatePin(const wxPoint & RefPos, ...@@ -8,7 +8,7 @@ LibEDA_BaseStruct * LocatePin(const wxPoint & RefPos,
int Unit, int Convert, EDA_SchComponentStruct * DrawItem = NULL); int Unit, int Convert, EDA_SchComponentStruct * DrawItem = NULL);
/* Routine de localisation d'une PIN de la PartLib pointee par Entry */ /* Routine de localisation d'une PIN de la PartLib pointee par Entry */
wxString ReturnDefaultFieldName(int FieldNumber); const wxString& ReturnDefaultFieldName( int aFieldNdx );
/***************/ /***************/
......
include/drawpanel_wxstruct.h
View file @ 664a1f72
...@@ -215,7 +215,7 @@ private: ...@@ -215,7 +215,7 @@ private:
char m_FlagRefreshReq; /* indique que l'ecran doit redessine */ char m_FlagRefreshReq; /* indique que l'ecran doit redessine */
char m_FlagModified; // indique modif du PCB,utilise pour eviter une sortie sans sauvegarde char m_FlagModified; // indique modif du PCB,utilise pour eviter une sortie sans sauvegarde
char m_FlagSave; // indique sauvegarde auto faite char m_FlagSave; // indique sauvegarde auto faite
EDA_BaseStruct* m_CurrentItem; ///< Current selected object EDA_BaseStruct* m_CurrentItem; ///< Currently selected object
/* Valeurs du pas de grille et du zoom */ /* Valeurs du pas de grille et du zoom */
public: public:
...@@ -260,17 +260,12 @@ public: ...@@ -260,17 +260,12 @@ public:
/** /**
* Function SetCurItem * Function SetCurItem
* sets the currently selected object, m_CurrentItem. * sets the currently selected object, m_CurrentItem.
* This is intentionally not inlined so we can set breakpoints on the
* activity easier in base_screen.cpp.
* @param current Any object derived from EDA_BaseStruct * @param current Any object derived from EDA_BaseStruct
*/ */
void SetCurItem( EDA_BaseStruct* current ) void SetCurItem( EDA_BaseStruct* current ) { m_CurrentItem = current; }
{
m_CurrentItem = current;
}
EDA_BaseStruct* GetCurItem() const { return m_CurrentItem; } EDA_BaseStruct* GetCurItem() const { return m_CurrentItem; }
/* fonctions relatives au zoom */ /* fonctions relatives au zoom */
int GetZoom(); /* retourne le coeff de zoom */ int GetZoom(); /* retourne le coeff de zoom */
void SetZoom( int coeff ); /* ajuste le coeff de zoom a coeff */ void SetZoom( int coeff ); /* ajuste le coeff de zoom a coeff */
...@@ -313,6 +308,18 @@ public: ...@@ -313,6 +308,18 @@ public:
{ {
return wxT( "BASE_SCREEN" ); return wxT( "BASE_SCREEN" );
} }
#if defined(DEBUG)
/**
* Function Show
* is used to output the object tree, currently for debugging only.
* @param nestLevel An aid to prettier tree indenting, and is the level
* of nesting of this object within the overall tree.
* @param os The ostream& to output to.
*/
void Show( int nestLevel, std::ostream& os );
#endif
}; };
......
pcbnew/controle.cpp
View file @ 664a1f72
...@@ -441,10 +441,10 @@ BOARD_ITEM* WinEDA_BasePcbFrame::PcbGeneralLocateAndDisplay() ...@@ -441,10 +441,10 @@ BOARD_ITEM* WinEDA_BasePcbFrame::PcbGeneralLocateAndDisplay()
{ {
wxMenu itemMenu; wxMenu itemMenu;
int limit = MIN( MAX_ITEMS_IN_PICKER, m_Collector->GetCount() );
itemMenu.SetTitle( _("Selection Clarification") ); // does this work? not under Linux! itemMenu.SetTitle( _("Selection Clarification") ); // does this work? not under Linux!
int limit = MIN( MAX_ITEMS_IN_PICKER, m_Collector->GetCount() );
for( int i=0; i<limit; ++i ) for( int i=0; i<limit; ++i )
{ {
wxString text; wxString text;
......
pcbnew/onrightclick.cpp
View file @ 664a1f72
...@@ -124,6 +124,7 @@ void WinEDA_PcbFrame::OnRightClick( const wxPoint& aMousePos, wxMenu* aPopMenu ) ...@@ -124,6 +124,7 @@ void WinEDA_PcbFrame::OnRightClick( const wxPoint& aMousePos, wxMenu* aPopMenu )
DrawPanel->CursorOff( &dc ); DrawPanel->CursorOff( &dc );
DrawPanel->m_CanStartBlock = -1; // Avoid to start a block coomand when clicking on menu DrawPanel->m_CanStartBlock = -1; // Avoid to start a block coomand when clicking on menu
// If command in progress: Put the Cancel command (if needed) and End command // If command in progress: Put the Cancel command (if needed) and End command
if( m_ID_current_state ) if( m_ID_current_state )
{ {
...@@ -161,13 +162,11 @@ void WinEDA_PcbFrame::OnRightClick( const wxPoint& aMousePos, wxMenu* aPopMenu ) ...@@ -161,13 +162,11 @@ void WinEDA_PcbFrame::OnRightClick( const wxPoint& aMousePos, wxMenu* aPopMenu )
} }
/* Select a proper item */ /* Select a proper item */
if( (item == NULL) || (item->m_Flags == 0) ) if( !item || !item->m_Flags )
{ {
item = PcbGeneralLocateAndDisplay(); item = PcbGeneralLocateAndDisplay();
SetCurItem(item);
} }
item = GetCurItem();
if( item ) if( item )
flags = item->m_Flags; flags = item->m_Flags;
else else
...@@ -183,10 +182,18 @@ void WinEDA_PcbFrame::OnRightClick( const wxPoint& aMousePos, wxMenu* aPopMenu ) ...@@ -183,10 +182,18 @@ void WinEDA_PcbFrame::OnRightClick( const wxPoint& aMousePos, wxMenu* aPopMenu )
if( m_HTOOL_current_state == ID_TOOLBARH_PCB_AUTOPLACE ) if( m_HTOOL_current_state == ID_TOOLBARH_PCB_AUTOPLACE )
{ {
aPopMenu->AppendSeparator(); aPopMenu->AppendSeparator();
if( !((MODULE*)item)->IsLocked() )
{
ADD_MENUITEM( aPopMenu, ID_POPUP_PCB_AUTOPLACE_FIXE_MODULE, _( "Lock Module" ), ADD_MENUITEM( aPopMenu, ID_POPUP_PCB_AUTOPLACE_FIXE_MODULE, _( "Lock Module" ),
Locked_xpm ); Locked_xpm );
}
else
{
ADD_MENUITEM( aPopMenu, ID_POPUP_PCB_AUTOPLACE_FREE_MODULE, _( "Unlock Module" ), ADD_MENUITEM( aPopMenu, ID_POPUP_PCB_AUTOPLACE_FREE_MODULE, _( "Unlock Module" ),
Unlocked_xpm ); Unlocked_xpm );
}
if( !flags ) if( !flags )
aPopMenu->Append( ID_POPUP_PCB_AUTOPLACE_CURRENT_MODULE, aPopMenu->Append( ID_POPUP_PCB_AUTOPLACE_CURRENT_MODULE,
_( "Auto place Module" ) ); _( "Auto place Module" ) );
......
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