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

see changelog

This commit is contained in:
CHARRAS 2008-02-26 19:19:54 +00:00
parent df7e6f3705
commit 2a1b776be6
30 changed files with 11695 additions and 1323 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
change_log.txt
View File

@ -5,6 +5,23 @@ 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.
2008-Feb-26 UPDATE Jean-Pierre Charras <jean-pierre.charras@inpg.fr>
================================================================================
+eeschema
changed in class DrawSheetStruct m_s member name to m_AssociatedScreen
some others minor problems solved.
some files "uncrustified"
Major problem in undo/redo when a sheet is deleted not yet solved
Only for a complex hierarchy, could lost data.
When a sheet is deleted by block delete. it is put in undo list.
It is really deleted after 10 changes (when the undo list is full).
At this time, the associated data is also deleted.
If an other (not deleted) sheet shares the same data, this data is lost.
Need work to solve this problem and keep the undo/redo feature.
2008-Feb-25 UPDATE Wayne Stambaugh <stambaughw{at}verizon{dot}net> 2008-Feb-25 UPDATE Wayne Stambaugh <stambaughw{at}verizon{dot}net>
================================================================================ ================================================================================
+eeschema +eeschema

12
eeschema/annotate.cpp
View File

@ -34,9 +34,6 @@ void ReAnnotatePowerSymbolsOnly( void )
/* Build the screen list (screen, not sheet) */ /* Build the screen list (screen, not sheet) */
EDA_SheetList SheetList( NULL ); EDA_SheetList SheetList( NULL );
/* Update the screen number, sheet count and date */
//ScreenList.UpdateScreenNumberAndDate();
DrawSheetList* sheet; DrawSheetList* sheet;
int CmpNumber = 1; int CmpNumber = 1;
@ -161,7 +158,7 @@ void DeleteAnnotation( WinEDA_SchematicFrame* parent, bool annotateSchematic )
sheet->DeleteAnnotation( annotateSchematic ); sheet->DeleteAnnotation( annotateSchematic );
g_RootSheet->m_s->SetModify(); g_RootSheet->m_AssociatedScreen->SetModify();
parent->DrawPanel->Refresh( true ); parent->DrawPanel->Refresh( true );
} }
@ -192,10 +189,11 @@ void AnnotateComponents( WinEDA_SchematicFrame* parent,
/* Build the sheet list */ /* Build the sheet list */
EDA_SheetList SheetList( g_RootSheet ); EDA_SheetList SheetList( g_RootSheet );
/* Update the sheet number */ /* Update the screen number, sheet count and date */
ii = 0; SheetList.UpdateSheetNumberAndDate();
/* First pass: Component counting */ /* First pass: Component counting */
ii = 0;
sheet = parent->GetSheet(); sheet = parent->GetSheet();
if( annotateSchematic ) if( annotateSchematic )
{ {
@ -595,7 +593,7 @@ int CheckAnnotate( WinEDA_SchematicFrame* frame, bool oneSheetOnly )
/* build the screen list */ /* build the screen list */
EDA_SheetList SheetList( NULL ); EDA_SheetList SheetList( NULL );
g_RootSheet->m_s->SetModify(); g_RootSheet->m_AssociatedScreen->SetModify();
ii = 0; ii = 0;
/* first pass : count composents */ /* first pass : count composents */

4
eeschema/annotate_dialog.cpp
View File

@ -258,7 +258,7 @@ void WinEDA_AnnotateFrame::OnClear( wxCommandEvent& event )
message += _( "\n\nThis operation will clear the existing annotation " \ message += _( "\n\nThis operation will clear the existing annotation " \
"and cannot be undone." ); "and cannot be undone." );
response = wxMessageBox( message, _( "" ), response = wxMessageBox( message, wxT( "" ),
wxICON_EXCLAMATION | wxOK | wxCANCEL ); wxICON_EXCLAMATION | wxOK | wxCANCEL );
if (response == wxCANCEL) if (response == wxCANCEL)
return; return;
@ -283,7 +283,7 @@ void WinEDA_AnnotateFrame::OnApply( wxCommandEvent& event )
message += _( "\n\nThis operation will change the current annotation and " \ message += _( "\n\nThis operation will change the current annotation and " \
"cannot be undone." ); "cannot be undone." );
response = wxMessageBox( message, _( "" ), response = wxMessageBox( message, wxT( "" ),
wxICON_EXCLAMATION | wxOK | wxCANCEL ); wxICON_EXCLAMATION | wxOK | wxCANCEL );
if (response == wxCANCEL) if (response == wxCANCEL)
return; return;

8
eeschema/block.cpp
View File

@ -832,12 +832,12 @@ static EDA_BaseStruct* CopyStruct( WinEDA_DrawPanel* panel, wxDC* DC, BASE_SCREE
case DRAW_SHEET_STRUCT_TYPE: case DRAW_SHEET_STRUCT_TYPE:
{ {
//DuplicateStruct calls GenCopy, which should handle //DuplicateStruct calls GenCopy, which should handle
//m_s and m_sRefCount properly. //m_AssociatedScreen and m_sRefCount properly.
DrawSheetStruct* sheet = (DrawSheetStruct*) Struct; DrawSheetStruct* sheet = (DrawSheetStruct*) Struct;
sheet->m_TimeStamp = GetTimeStamp(); sheet->m_TimeStamp = GetTimeStamp();
//sheet->m_s->m_UndoList = NULL; //sheet->m_AssociatedScreen->m_UndoList = NULL;
//sheet->m_s->m_RedoList = NULL; //sheet->m_AssociatedScreen->m_RedoList = NULL;
//keep m_s pointer & associated. //keep m_AssociatedScreen pointer & associated.
//sheet->m_Son = NULL; m_son is involved in undo and redo. //sheet->m_Son = NULL; m_son is involved in undo and redo.
break; break;
} }

676
eeschema/class_drawsheet.cpp
View File

@ -35,7 +35,7 @@
/***********************************************************/ /***********************************************************/
DrawSheetStruct::DrawSheetStruct( const wxPoint& pos ) : DrawSheetStruct::DrawSheetStruct( const wxPoint& pos ) :
EDA_BaseStruct( DRAW_SHEET_STRUCT_TYPE ) EDA_BaseStruct( DRAW_SHEET_STRUCT_TYPE )
/***********************************************************/ /***********************************************************/
{ {
m_Label = NULL; m_Label = NULL;
@ -43,9 +43,12 @@ DrawSheetStruct::DrawSheetStruct( const wxPoint& pos ) :
m_Layer = LAYER_SHEET; m_Layer = LAYER_SHEET;
m_Pos = pos; m_Pos = pos;
m_SheetNameSize = m_FileNameSize = 60; m_SheetNameSize = m_FileNameSize = 60;
m_s = NULL; m_AssociatedScreen = NULL;
m_SheetName = wxT("Root"); m_SheetName = wxT( "Root" );
m_FileName = wxT(" "); m_FileName = wxT( " " );
m_SheetNumber = 1;
m_NumberOfSheets = 1;
} }
@ -54,21 +57,25 @@ DrawSheetStruct::~DrawSheetStruct()
/**************************************/ /**************************************/
{ {
DrawSheetLabelStruct* label = m_Label, * next_label; DrawSheetLabelStruct* label = m_Label, * next_label;
while( label ){
while( label )
{
next_label = (DrawSheetLabelStruct*) label->Pnext; next_label = (DrawSheetLabelStruct*) label->Pnext;
delete label; delete label;
label = next_label; label = next_label;
} }
//also, look at the associated sheet & its reference count //also, look at the associated sheet & its reference count
//perhaps it should be deleted also. //perhaps it should be deleted also.
if(m_s){ if( m_AssociatedScreen )
m_s->m_RefCount--; {
if(m_s->m_RefCount == 0) m_AssociatedScreen->m_RefCount--;
delete m_s; if( m_AssociatedScreen->m_RefCount == 0 )
} delete m_AssociatedScreen;
}
} }
/***********************************************/ /***********************************************/
DrawSheetStruct* DrawSheetStruct::GenCopy() DrawSheetStruct* DrawSheetStruct::GenCopy()
/***********************************************/ /***********************************************/
@ -89,9 +96,9 @@ DrawSheetStruct* DrawSheetStruct::GenCopy()
newitem->m_SheetName = m_SheetName; newitem->m_SheetName = m_SheetName;
newitem->m_SheetNameSize = m_SheetNameSize; newitem->m_SheetNameSize = m_SheetNameSize;
newitem->m_Label = NULL; newitem->m_Label = NULL;
DrawSheetLabelStruct* Slabel = NULL, *label = m_Label; DrawSheetLabelStruct* Slabel = NULL, * label = m_Label;
if( label ) if( label )
{ {
@ -108,10 +115,10 @@ DrawSheetStruct* DrawSheetStruct::GenCopy()
label = (DrawSheetLabelStruct*) label->Pnext; label = (DrawSheetLabelStruct*) label->Pnext;
} }
/* don't copy screen data - just reference it. */ /* don't copy screen data - just reference it. */
newitem->m_s = m_s; newitem->m_AssociatedScreen = m_AssociatedScreen;
if(m_s) if( m_AssociatedScreen )
m_s->m_RefCount++; m_AssociatedScreen->m_RefCount++;
return newitem; return newitem;
} }
@ -120,6 +127,7 @@ DrawSheetStruct* DrawSheetStruct::GenCopy()
/**********************************************************/ /**********************************************************/
void DrawSheetStruct::SwapData( DrawSheetStruct* copyitem ) void DrawSheetStruct::SwapData( DrawSheetStruct* copyitem )
/**********************************************************/ /**********************************************************/
/* Used if undo / redo command: /* Used if undo / redo command:
* swap data between this and copyitem * swap data between this and copyitem
*/ */
@ -132,65 +140,71 @@ void DrawSheetStruct::SwapData( DrawSheetStruct* copyitem )
EXCHG( m_Label, copyitem->m_Label ); EXCHG( m_Label, copyitem->m_Label );
EXCHG( m_NbLabel, copyitem->m_NbLabel ); EXCHG( m_NbLabel, copyitem->m_NbLabel );
} }
/****************************************************************/ /****************************************************************/
void DrawSheetStruct::Place( WinEDA_DrawFrame* frame, wxDC* DC ) void DrawSheetStruct::Place( WinEDA_DrawFrame* frame, wxDC* DC )
/****************************************************************/ /****************************************************************/
{ {
/* Placement en liste des structures si nouveau composant:*/ /* Placement en liste des structures si nouveau composant:*/
if( m_Flags & IS_NEW ) if( m_Flags & IS_NEW )
{ {
if( !( (WinEDA_SchematicFrame*) frame )->EditSheet( this, DC ) ) if( !( (WinEDA_SchematicFrame*) frame )->EditSheet( this, DC ) )
{ {
frame->GetScreen()->SetCurItem( NULL ); frame->GetScreen()->SetCurItem( NULL );
frame->DrawPanel->ManageCurseur = NULL; frame->DrawPanel->ManageCurseur = NULL;
frame->DrawPanel->ForceCloseManageCurseur = NULL; frame->DrawPanel->ForceCloseManageCurseur = NULL;
RedrawOneStruct( frame->DrawPanel, DC, this, g_XorMode ); RedrawOneStruct( frame->DrawPanel, DC, this, g_XorMode );
delete this; delete this;
return; return;
} }
} }
EDA_BaseStruct::Place( frame, DC ); //puts it on the EEDrawList. EDA_BaseStruct::Place( frame, DC ); //puts it on the EEDrawList.
} }
/********************************************************************/ /********************************************************************/
void DrawSheetStruct::CleanupSheet( WinEDA_SchematicFrame* frame, wxDC* DC ) void DrawSheetStruct::CleanupSheet( WinEDA_SchematicFrame* frame, wxDC* DC )
/********************************************************************/ /********************************************************************/
/* Delete pinsheets which are not corresponding to a hierarchal label /* Delete pinsheets which are not corresponding to a hierarchal label
* if DC != NULL, redraw Sheet * if DC != NULL, redraw Sheet
*/ */
{ {
DrawSheetLabelStruct* Pinsheet, * NextPinsheet; DrawSheetLabelStruct* Pinsheet, * NextPinsheet;
if( !IsOK( frame, _( "Ok to cleanup this sheet" ) ) ) if( !IsOK( frame, _( "Ok to cleanup this sheet" ) ) )
return; return;
Pinsheet = m_Label; Pinsheet = m_Label;
while( Pinsheet ) while( Pinsheet )
{ {
/* Search Hlabel corresponding to this Pinsheet */ /* Search Hlabel corresponding to this Pinsheet */
EDA_BaseStruct* DrawStruct = m_s->EEDrawList; EDA_BaseStruct* DrawStruct = m_AssociatedScreen->EEDrawList;
DrawHierLabelStruct* HLabel = NULL; DrawHierLabelStruct* HLabel = NULL;
for( ; DrawStruct != NULL; DrawStruct = DrawStruct->Pnext ) for( ; DrawStruct != NULL; DrawStruct = DrawStruct->Pnext )
{ {
if( DrawStruct->Type() != DRAW_HIER_LABEL_STRUCT_TYPE ) if( DrawStruct->Type() != DRAW_HIER_LABEL_STRUCT_TYPE )
continue; continue;
HLabel = (DrawHierLabelStruct*) DrawStruct; HLabel = (DrawHierLabelStruct*) DrawStruct;
if( Pinsheet->m_Text.CmpNoCase( HLabel->m_Text ) == 0 ) if( Pinsheet->m_Text.CmpNoCase( HLabel->m_Text ) == 0 )
break; // Found! break; // Found!
HLabel = NULL; HLabel = NULL;
} }
NextPinsheet = (DrawSheetLabelStruct*) Pinsheet->Pnext; NextPinsheet = (DrawSheetLabelStruct*) Pinsheet->Pnext;
if( HLabel == NULL ) // Hlabel not found: delete pinsheet if( HLabel == NULL ) // Hlabel not found: delete pinsheet
{ {
frame->GetScreen()->SetModify(); frame->GetScreen()->SetModify();
frame->DeleteSheetLabel( DC, Pinsheet ); frame->DeleteSheetLabel( DC, Pinsheet );
} }
Pinsheet = NextPinsheet; Pinsheet = NextPinsheet;
} }
} }
/**************************************************************************************/ /**************************************************************************************/
void DrawSheetStruct::Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset, void DrawSheetStruct::Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset,
int DrawMode, int Color ) int DrawMode, int Color )
@ -247,143 +261,183 @@ void DrawSheetStruct::Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& of
} }
} }
/**************************************************************************************/ /**************************************************************************************/
void DrawSheetStruct::DeleteAnnotation( bool recurse ) void DrawSheetStruct::DeleteAnnotation( bool recurse )
/**************************************************************************************/ /**************************************************************************************/
{ {
if(recurse && m_s){ if( recurse && m_AssociatedScreen )
EDA_BaseStruct* strct = m_s->EEDrawList; {
for(; strct; strct = strct->Pnext){ EDA_BaseStruct* strct = m_AssociatedScreen->EEDrawList;
if(strct->Type() == DRAW_SHEET_STRUCT_TYPE){ for( ; strct; strct = strct->Pnext )
DrawSheetStruct* sheet = (DrawSheetStruct*)strct; {
sheet->DeleteAnnotation(recurse); if( strct->Type() == DRAW_SHEET_STRUCT_TYPE )
} {
} DrawSheetStruct* sheet = (DrawSheetStruct*) strct;
} sheet->DeleteAnnotation( recurse );
EDA_BaseStruct* comp = m_s->EEDrawList; }
for( ; comp ; comp = comp->Pnext ){ }
if(comp->Type() == DRAW_LIB_ITEM_STRUCT_TYPE ){ }
((EDA_SchComponentStruct*)comp)->ClearAnnotation(); EDA_BaseStruct* comp = m_AssociatedScreen->EEDrawList;
} for( ; comp; comp = comp->Pnext )
} {
} if( comp->Type() == DRAW_LIB_ITEM_STRUCT_TYPE )
/*******************************************************************/ {
int DrawSheetStruct::ComponentCount( ) ( (EDA_SchComponentStruct*) comp )->ClearAnnotation();
/*******************************************************************/ }
{ }
//count our own components, without the power components.
/* Routine retournant le nombre de composants dans le schema,
* powers non comprises */
int n = 0;
if(m_s){
EDA_BaseStruct* bs;
for( bs = m_s->EEDrawList; bs != NULL; bs = bs->Pnext ){
if( bs->Type() == DRAW_LIB_ITEM_STRUCT_TYPE ){
DrawPartStruct* Cmp = (DrawPartStruct*) bs;
if( Cmp->m_Field[VALUE].m_Text.GetChar( 0 ) != '#' )
n++;
}
if(bs->Type() == DRAW_SHEET_STRUCT_TYPE){
DrawSheetStruct* sheet = (DrawSheetStruct*)bs;
n += sheet->ComponentCount();
}
}
}
return n;
}
/*******************************************************************************/
bool DrawSheetStruct::SearchHierarchy(wxString filename, SCH_SCREEN **screen)
/*******************************************************************************/
{
//search the existing hierarchy for an instance of screen "FileName".
if(m_s){
EDA_BaseStruct* strct = m_s->EEDrawList;
while(strct){
if(strct->Type() == DRAW_SHEET_STRUCT_TYPE){
DrawSheetStruct* ss = (DrawSheetStruct*)strct;
if(ss->m_s && ss->m_s->m_FileName.CmpNoCase(filename) == 0){
*screen = ss->m_s;
return true;
}
if(ss->SearchHierarchy(filename, screen))
return true;
}
strct = strct->Pnext;
}
}
return false;
}
/*******************************************************************************/
bool DrawSheetStruct::LocatePathOfScreen(SCH_SCREEN *screen, DrawSheetList* list)
/*******************************************************************************/
{
//search the existing hierarchy for an instance of screen "FileName".
//don't bother looking at the root sheet - it must be unique,
//no other references to its m_s otherwise there would be loops
//in the heirarchy.
//search the existing hierarchy for an instance of screen "FileName".
if(m_s){
list->Push(this);
if(m_s == screen)
return true;
EDA_BaseStruct* strct = m_s->EEDrawList;
while(strct){
if(strct->Type() == DRAW_SHEET_STRUCT_TYPE){
DrawSheetStruct* ss = (DrawSheetStruct*)strct;
if(ss->LocatePathOfScreen(screen, list))
return true;
}
strct = strct->Pnext;
}
list->Pop();
}
return false;
} }
/*******************************************************************/
int DrawSheetStruct::ComponentCount()
/*******************************************************************/
{
//count our own components, without the power components.
/* Routine retournant le nombre de composants dans le schema,
* powers non comprises */
int n = 0;
if( m_AssociatedScreen )
{
EDA_BaseStruct* bs;
for( bs = m_AssociatedScreen->EEDrawList; bs != NULL; bs = bs->Pnext )
{
if( bs->Type() == DRAW_LIB_ITEM_STRUCT_TYPE )
{
DrawPartStruct* Cmp = (DrawPartStruct*) bs;
if( Cmp->m_Field[VALUE].m_Text.GetChar( 0 ) != '#' )
n++;
}
if( bs->Type() == DRAW_SHEET_STRUCT_TYPE )
{
DrawSheetStruct* sheet = (DrawSheetStruct*) bs;
n += sheet->ComponentCount();
}
}
}
return n;
}
/*******************************************************************************/ /*******************************************************************************/
bool DrawSheetStruct::Load(WinEDA_SchematicFrame* frame) bool DrawSheetStruct::SearchHierarchy( wxString filename, SCH_SCREEN** screen )
/*******************************************************************************/ /*******************************************************************************/
{ {
if(!m_s){ //search the existing hierarchy for an instance of screen "FileName".
SCH_SCREEN* screen = NULL; if( m_AssociatedScreen )
g_RootSheet->SearchHierarchy(m_FileName, &screen); {
if(screen){ EDA_BaseStruct* strct = m_AssociatedScreen->EEDrawList;
m_s = screen; while( strct )
m_s->m_RefCount++; {
//do not need to load the sub-sheets - this has already been done. if( strct->Type() == DRAW_SHEET_STRUCT_TYPE )
}else{ {
m_s = new SCH_SCREEN(SCHEMATIC_FRAME); DrawSheetStruct* ss = (DrawSheetStruct*) strct;
m_s->m_RefCount++; if( ss->m_AssociatedScreen && ss->m_AssociatedScreen->m_FileName.CmpNoCase( filename ) == 0 )
if(!frame->LoadOneEEFile(m_s, m_FileName)) {
return false; *screen = ss->m_AssociatedScreen;
EDA_BaseStruct* bs = m_s->EEDrawList; return true;
while(bs){ }
if(bs->Type() == DRAW_SHEET_STRUCT_TYPE){ if( ss->SearchHierarchy( filename, screen ) )
DrawSheetStruct* ss = (DrawSheetStruct*)bs; return true;
if(!ss->Load(frame)) }
return false; strct = strct->Pnext;
} }
bs = bs->Pnext; }
} return false;
}
}
return true;
} }
/*******************************************************************************/
bool DrawSheetStruct::LocatePathOfScreen( SCH_SCREEN* screen, DrawSheetList* list )
/*******************************************************************************/
{
//search the existing hierarchy for an instance of screen "FileName".
//don't bother looking at the root sheet - it must be unique,
//no other references to its m_s otherwise there would be loops
//in the heirarchy.
//search the existing hierarchy for an instance of screen "FileName".
if( m_AssociatedScreen )
{
list->Push( this );
if( m_AssociatedScreen == screen )
return true;
EDA_BaseStruct* strct = m_AssociatedScreen->EEDrawList;
while( strct )
{
if( strct->Type() == DRAW_SHEET_STRUCT_TYPE )
{
DrawSheetStruct* ss = (DrawSheetStruct*) strct;
if( ss->LocatePathOfScreen( screen, list ) )
return true;
}
strct = strct->Pnext;
}
list->Pop();
}
return false;
}
/*******************************************************************************/
bool DrawSheetStruct::Load( WinEDA_SchematicFrame* frame )
/*******************************************************************************/
{
if( !m_AssociatedScreen )
{
SCH_SCREEN* screen = NULL;
g_RootSheet->SearchHierarchy( m_FileName, &screen );
if( screen )
{
m_AssociatedScreen = screen;
m_AssociatedScreen->m_RefCount++;
//do not need to load the sub-sheets - this has already been done.
}
else
{
m_AssociatedScreen = new SCH_SCREEN( SCHEMATIC_FRAME );
m_AssociatedScreen->m_RefCount++;
if( !frame->LoadOneEEFile( m_AssociatedScreen, m_FileName ) )
return false;
EDA_BaseStruct* bs = m_AssociatedScreen->EEDrawList;
while( bs )
{
if( bs->Type() == DRAW_SHEET_STRUCT_TYPE )
{
DrawSheetStruct* ss = (DrawSheetStruct*) bs;
if( !ss->Load( frame ) )
return false;
}
bs = bs->Pnext;
}
}
}
return true;
}
/*******************************************************************************/ /*******************************************************************************/
int DrawSheetStruct::CountSheets() int DrawSheetStruct::CountSheets()
/*******************************************************************************/ /*******************************************************************************/
{ {
int count = 1; //1 = this!! int count = 1; //1 = this!!
if(m_s){
EDA_BaseStruct* strct = m_s->EEDrawList; if( m_AssociatedScreen )
for(; strct; strct = strct->Pnext){ {
if(strct->Type() == DRAW_SHEET_STRUCT_TYPE){ EDA_BaseStruct* strct = m_AssociatedScreen->EEDrawList;
DrawSheetStruct* ss = (DrawSheetStruct*)strct; for( ; strct; strct = strct->Pnext )
count += ss->CountSheets(); {
} if( strct->Type() == DRAW_SHEET_STRUCT_TYPE )
} {
} DrawSheetStruct* ss = (DrawSheetStruct*) strct;
return count; count += ss->CountSheets();
}
}
}
return count;
} }
@ -394,8 +448,8 @@ int DrawSheetStruct::CountSheets()
/*******************************************************************/ /*******************************************************************/
DrawSheetLabelStruct::DrawSheetLabelStruct( DrawSheetStruct* parent, DrawSheetLabelStruct::DrawSheetLabelStruct( DrawSheetStruct* parent,
const wxPoint& pos, const wxString& text ) : const wxPoint& pos, const wxString& text ) :
EDA_BaseStruct( DRAW_SHEETLABEL_STRUCT_TYPE ), EDA_BaseStruct( DRAW_SHEETLABEL_STRUCT_TYPE )
EDA_TextStruct( text ) , EDA_TextStruct( text )
/*******************************************************************/ /*******************************************************************/
{ {
m_Layer = LAYER_SHEETLABEL; m_Layer = LAYER_SHEETLABEL;
@ -511,115 +565,179 @@ void DrawSheetLabelStruct::Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoin
GRPoly( &panel->m_ClipBox, DC, NbSegm, coord, FillShape, LineWidth, txtcolor, txtcolor ); /* Poly Non rempli */ GRPoly( &panel->m_ClipBox, DC, NbSegm, coord, FillShape, LineWidth, txtcolor, txtcolor ); /* Poly Non rempli */
} }
/**********************************************/ /**********************************************/
/* class to handle a series of sheets *********/ /* class to handle a series of sheets *********/
/* a 'path' so to speak.. *********************/ /* a 'path' so to speak.. *********************/
/**********************************************/ /**********************************************/
DrawSheetList::DrawSheetList(){ DrawSheetList::DrawSheetList()
for(int i=0; i<DSLSZ ; i++) {
m_sheets[i] = NULL; for( int i = 0; i<DSLSZ; i++ )
m_numSheets = 0; m_sheets[i] = NULL;
m_numSheets = 0;
} }
int DrawSheetList::Cmp(DrawSheetList& d){
if(m_numSheets > d.m_numSheets)
return 1; int DrawSheetList::Cmp( DrawSheetList& d )
if(m_numSheets < d.m_numSheets) {
return -1; if( m_numSheets > d.m_numSheets )
//otherwise, same number of sheets. return 1;
for(int i=0; i<m_numSheets; i++){ if( m_numSheets < d.m_numSheets )
if(m_sheets[i]->m_TimeStamp > d.m_sheets[i]->m_TimeStamp) return -1;
return 1;
if(m_sheets[i]->m_TimeStamp < d.m_sheets[i]->m_TimeStamp) //otherwise, same number of sheets.
return -1; for( int i = 0; i<m_numSheets; i++ )
} {
return 0; if( m_sheets[i]->m_TimeStamp > d.m_sheets[i]->m_TimeStamp )
return 1;
if( m_sheets[i]->m_TimeStamp < d.m_sheets[i]->m_TimeStamp )
return -1;
}
return 0;
} }
DrawSheetStruct* DrawSheetList::Last(){
if(m_numSheets)
return m_sheets[m_numSheets-1]; DrawSheetStruct* DrawSheetList::Last()
return NULL; {
if( m_numSheets )
return m_sheets[m_numSheets - 1];
return NULL;
} }
SCH_SCREEN* DrawSheetList::LastScreen(){
if(m_numSheets)
return m_sheets[m_numSheets-1]->m_s; SCH_SCREEN* DrawSheetList::LastScreen()
return NULL; {
if( m_numSheets )
return m_sheets[m_numSheets - 1]->m_AssociatedScreen;
return NULL;
} }
EDA_BaseStruct* DrawSheetList::LastDrawList(){
if(m_numSheets && m_sheets[m_numSheets-1]->m_s)
return m_sheets[m_numSheets-1]->m_s->EEDrawList; EDA_BaseStruct* DrawSheetList::LastDrawList()
return NULL; {
if( m_numSheets && m_sheets[m_numSheets - 1]->m_AssociatedScreen )
return m_sheets[m_numSheets - 1]->m_AssociatedScreen->EEDrawList;
return NULL;
} }
void DrawSheetList::Push(DrawSheetStruct* sheet){
if(m_numSheets < DSLSZ){
m_sheets[m_numSheets] = sheet; void DrawSheetList::Push( DrawSheetStruct* sheet )
m_numSheets++; {
} if( m_numSheets < DSLSZ )
{
m_sheets[m_numSheets] = sheet;
m_numSheets++;
}
} }
DrawSheetStruct* DrawSheetList::Pop(){
if(m_numSheets > 0){
m_numSheets --; DrawSheetStruct* DrawSheetList::Pop()
return m_sheets[m_numSheets]; {
} if( m_numSheets > 0 )
return NULL; {
m_numSheets--;
return m_sheets[m_numSheets];
}
return NULL;
} }
wxString DrawSheetList::Path(){
wxString s, t;
s = wxT("/"); wxString DrawSheetList::Path()
//start at 1 to avoid the root sheet, {
//which does not need to be added to the path wxString s, t;
//it's timestamp changes anyway.
for(int i=1; i< m_numSheets; i++){ s = wxT( "/" );
t.Printf(_("%8.8lX/"), m_sheets[i]->m_TimeStamp);
s = s + t; //start at 1 to avoid the root sheet,
} //which does not need to be added to the path
return s; //it's timestamp changes anyway.
for( int i = 1; i< m_numSheets; i++ )
{
t.Printf( _( "%8.8lX/" ), m_sheets[i]->m_TimeStamp );
s = s + t;
}
return s;
} }
wxString DrawSheetList::PathHumanReadable(){
wxString s, t;
s = wxT("/"); wxString DrawSheetList::PathHumanReadable()
//start at 1 to avoid the root sheet, as above. {
for(int i=1; i< m_numSheets; i++){ wxString s, t;
s = s + m_sheets[i]->m_SheetName + wxT("/");
} s = wxT( "/" );
return s;
//start at 1 to avoid the root sheet, as above.
for( int i = 1; i< m_numSheets; i++ )
{
s = s + m_sheets[i]->m_SheetName + wxT( "/" );
}
return s;
} }
void DrawSheetList::UpdateAllScreenReferences(){
EDA_BaseStruct* t = LastDrawList();
while(t){ void DrawSheetList::UpdateAllScreenReferences()
if(t->Type() == DRAW_LIB_ITEM_STRUCT_TYPE){ {
EDA_SchComponentStruct* d = (EDA_SchComponentStruct*)t; EDA_BaseStruct* t = LastDrawList();
d->m_Field[REFERENCE].m_Text = d->GetRef(this);
} while( t )
t = t->Pnext; {
} if( t->Type() == DRAW_LIB_ITEM_STRUCT_TYPE )
printf( "on sheet: %s \n", CONV_TO_UTF8(PathHumanReadable()) ); {
EDA_SchComponentStruct* d = (EDA_SchComponentStruct*) t;
d->m_Field[REFERENCE].m_Text = d->GetRef( this );
}
t = t->Pnext;
}
printf( "on sheet: %s \n", CONV_TO_UTF8( PathHumanReadable() ) );
} }
bool DrawSheetList::operator= (const DrawSheetList& d1){
m_numSheets = d1.m_numSheets;
int i; bool DrawSheetList::operator=( const DrawSheetList& d1 )
for(i=0; i<m_numSheets; i++){ {
m_sheets[i] = d1.m_sheets[i]; m_numSheets = d1.m_numSheets;
} int i;
for(; i<DSLSZ; i++){ for( i = 0; i<m_numSheets; i++ )
m_sheets[i] = 0; {
} m_sheets[i] = d1.m_sheets[i];
return true; }
for( ; i<DSLSZ; i++ )
{
m_sheets[i] = 0;
}
return true;
} }
bool DrawSheetList::operator==(const DrawSheetList &d1){
if(m_numSheets != d1.m_numSheets)
return false; bool DrawSheetList::operator==( const DrawSheetList& d1 )
for(int i=0; i<m_numSheets; i++){ {
if(m_sheets[i] != d1.m_sheets[i]) if( m_numSheets != d1.m_numSheets )
return false; return false;
} for( int i = 0; i<m_numSheets; i++ )
return true; {
if( m_sheets[i] != d1.m_sheets[i] )
return false;
}
return true;
} }
bool DrawSheetList::operator!=(const DrawSheetList &d1){
if(m_numSheets != d1.m_numSheets)
return true; bool DrawSheetList::operator!=( const DrawSheetList& d1 )
for(int i=0; i<m_numSheets; i++){ {
if(m_sheets[i] != d1.m_sheets[i]) if( m_numSheets != d1.m_numSheets )
return true; return true;
} for( int i = 0; i<m_numSheets; i++ )
return false; {
if( m_sheets[i] != d1.m_sheets[i] )
return true;
}
return false;
} }

258
eeschema/class_screen.cpp
View File

@ -20,7 +20,7 @@ void SetStructFather( EDA_BaseStruct* Struct, BASE_SCREEN* Screen )
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:
case DRAW_HIER_LABEL_STRUCT_TYPE: case DRAW_HIER_LABEL_STRUCT_TYPE:
case DRAW_LIB_ITEM_STRUCT_TYPE: case DRAW_LIB_ITEM_STRUCT_TYPE:
case DRAW_SEGMENT_STRUCT_TYPE: case DRAW_SEGMENT_STRUCT_TYPE:
case DRAW_BUSENTRY_STRUCT_TYPE: case DRAW_BUSENTRY_STRUCT_TYPE:
@ -51,9 +51,9 @@ void EDA_BaseStruct::Place( WinEDA_DrawFrame* frame, wxDC* DC )
{ {
if( m_Flags & IS_NEW ) if( m_Flags & IS_NEW )
{ {
SCH_SCREEN* screen = (SCH_SCREEN*)frame->GetScreen(); SCH_SCREEN* screen = (SCH_SCREEN*) frame->GetScreen();
if(!screen->CheckIfOnDrawList(this)) //don't want a loop! if( !screen->CheckIfOnDrawList( this ) ) //don't want a loop!
screen->AddToDrawList(this); screen->AddToDrawList( this );
g_ItemToRepeat = this; g_ItemToRepeat = this;
if( frame->m_Ident == SCHEMATIC_FRAME ) if( frame->m_Ident == SCHEMATIC_FRAME )
( (WinEDA_SchematicFrame*) frame )->SaveCopyInUndoList( this, IS_NEW ); ( (WinEDA_SchematicFrame*) frame )->SaveCopyInUndoList( this, IS_NEW );
@ -89,9 +89,9 @@ SCH_SCREEN::SCH_SCREEN( int screentype, KICAD_T aType ) :
SetZoomList( table_zoom ); SetZoomList( table_zoom );
SetGridList( g_GridList ); SetGridList( g_GridList );
m_UndoRedoCountMax = 10; m_UndoRedoCountMax = 10;
m_RefCount = 0; m_RefCount = 0;
m_ScreenNumber = 1; m_ScreenNumber = 1;
m_NumberOfScreen = 1; m_NumberOfScreen = 1;
} }
@ -117,9 +117,10 @@ void SCH_SCREEN::FreeDrawList()
{ {
DrawStruct = EEDrawList; DrawStruct = EEDrawList;
EEDrawList = EEDrawList->Pnext; EEDrawList = EEDrawList->Pnext;
SAFE_DELETE(DrawStruct); SAFE_DELETE( DrawStruct );
} }
EEDrawList = NULL;
EEDrawList = NULL;
} }
@ -147,26 +148,34 @@ void SCH_SCREEN::RemoveFromDrawList( EDA_BaseStruct* DrawStruct )
} }
} }
} }
/**************************************************************/ /**************************************************************/
bool SCH_SCREEN::CheckIfOnDrawList( EDA_BaseStruct* st ) bool SCH_SCREEN::CheckIfOnDrawList( EDA_BaseStruct* st )
/**************************************************************/ /**************************************************************/
{ {
EDA_BaseStruct* DrawList = EEDrawList; EDA_BaseStruct* DrawList = EEDrawList;
while( DrawList ){
if( DrawList == st) while( DrawList )
return true; {
DrawList = DrawList->Pnext; if( DrawList == st )
} return true;
return false; DrawList = DrawList->Pnext;
}
return false;
} }
/**************************************************************/ /**************************************************************/
void SCH_SCREEN::AddToDrawList( EDA_BaseStruct* st ) void SCH_SCREEN::AddToDrawList( EDA_BaseStruct* st )
/**************************************************************/ /**************************************************************/
{ //simple function to add to the head of the drawlist. { //simple function to add to the head of the drawlist.
st->Pnext = EEDrawList; st->Pnext = EEDrawList;
EEDrawList = st; EEDrawList = st;
} }
/*********************************************************************/ /*********************************************************************/
/* Class EDA_ScreenList to handle the list of screens in a hierarchy */ /* Class EDA_ScreenList to handle the list of screens in a hierarchy */
/*********************************************************************/ /*********************************************************************/
@ -176,18 +185,19 @@ SCH_SCREEN* EDA_ScreenList::GetFirst()
/*****************************************/ /*****************************************/
{ {
m_Index = 0; m_Index = 0;
if(m_List.GetCount() > 0) if( m_List.GetCount() > 0 )
return m_List[0]; return m_List[0];
return NULL; return NULL;
} }
/*****************************************/ /*****************************************/
SCH_SCREEN* EDA_ScreenList::GetNext() SCH_SCREEN* EDA_ScreenList::GetNext()
/*****************************************/ /*****************************************/
{ {
if( m_Index < m_List.GetCount() ) if( m_Index < m_List.GetCount() )
m_Index++; m_Index++;
return GetScreen(m_Index); return GetScreen( m_Index );
} }
@ -198,58 +208,59 @@ SCH_SCREEN* EDA_ScreenList::GetScreen( unsigned int index )
/* return the m_List[index] item /* return the m_List[index] item
*/ */
{ {
if( index < m_List.GetCount() ) if( index < m_List.GetCount() )
return m_List[index]; return m_List[index];
return NULL; return NULL;
} }
/************************************************/ /************************************************/
void EDA_ScreenList::AddScreenToList( SCH_SCREEN* testscreen ) void EDA_ScreenList::AddScreenToList( SCH_SCREEN* testscreen )
/************************************************/ /************************************************/
{ {
if(testscreen == NULL) return; if( testscreen == NULL )
for(unsigned int i=0; i< m_List.GetCount(); i++){ return;
if(m_List[i] == testscreen) for( unsigned int i = 0; i< m_List.GetCount(); i++ )
return; {
} if( m_List[i] == testscreen )
m_List.Add(testscreen); return;
}
m_List.Add( testscreen );
#ifdef DEBUG #ifdef DEBUG
printf("EDA_ScreenList::AddScreenToList adding %s\n", (const char*)testscreen->m_FileName.mb_str()); printf( "EDA_ScreenList::AddScreenToList adding %s\n",
(const char*) testscreen->m_FileName.mb_str(
) );
#endif #endif
} }
/************************************************/
void EDA_ScreenList::UpdateScreenNumberAndDate( )
/************************************************/
{
SCH_SCREEN* screen;
wxString date = GenDate();
for(int i=0; i<(int)m_List.GetCount(); i++){
screen = m_List[i];
screen->m_ScreenNumber = i;
screen->m_NumberOfScreen = m_List.GetCount();
screen->m_Date = date;
}
}
/************************************************************************/ /************************************************************************/
void EDA_ScreenList::BuildScreenList(EDA_BaseStruct* s) void EDA_ScreenList::BuildScreenList( EDA_BaseStruct* s )
/************************************************************************/ /************************************************************************/
{ {
if(s && s->Type() == DRAW_SHEET_STRUCT_TYPE){ if( s && s->Type() == DRAW_SHEET_STRUCT_TYPE )
DrawSheetStruct* ds = (DrawSheetStruct*)s; {
s = ds->m_s; DrawSheetStruct* ds = (DrawSheetStruct*) s;
} s = ds->m_AssociatedScreen;
if(s && s->Type() == SCREEN_STRUCT_TYPE){ }
SCH_SCREEN* screen = (SCH_SCREEN*)s; if( s && s->Type() == SCREEN_STRUCT_TYPE )
AddScreenToList(screen); {
EDA_BaseStruct* strct = screen->EEDrawList; SCH_SCREEN* screen = (SCH_SCREEN*) s;
while(strct){ AddScreenToList( screen );
if(strct->Type() == DRAW_SHEET_STRUCT_TYPE){ EDA_BaseStruct* strct = screen->EEDrawList;
BuildScreenList(strct); while( strct )
} {
strct = strct->Pnext; if( strct->Type() == DRAW_SHEET_STRUCT_TYPE )
} {
} BuildScreenList( strct );
}
strct = strct->Pnext;
}
}
} }
/*********************************************************************/ /*********************************************************************/
/* Class EDA_SheetList to handle the list of Sheets in a hierarchy */ /* Class EDA_SheetList to handle the list of Sheets in a hierarchy */
/*********************************************************************/ /*********************************************************************/
@ -258,58 +269,109 @@ void EDA_ScreenList::BuildScreenList(EDA_BaseStruct* s)
DrawSheetList* EDA_SheetList::GetFirst() DrawSheetList* EDA_SheetList::GetFirst()
/*****************************************/ /*****************************************/
{ {
m_index = 0; m_index = 0;
if(m_count > 0) if( m_count > 0 )
return &( m_List[0] ); return &( m_List[0] );
return NULL; return NULL;
} }
/*****************************************/ /*****************************************/
DrawSheetList* EDA_SheetList::GetNext() DrawSheetList* EDA_SheetList::GetNext()
/*****************************************/ /*****************************************/
{ {
if( m_index < m_count ) if( m_index < m_count )
m_index++; m_index++;
return GetSheet(m_index); return GetSheet( m_index );
} }
/************************************************/ /************************************************/
DrawSheetList* EDA_SheetList::GetSheet(int index ) DrawSheetList* EDA_SheetList::GetSheet( int index )
/************************************************/ /************************************************/
/* return the m_List[index] item /* return the m_List[index] item
*/ */
{ {
if( index < m_count ) if( index < m_count )
return &(m_List[index]); return &(m_List[index]);
return NULL; return NULL;
} }
/************************************************************************/ /************************************************************************/
void EDA_SheetList::BuildSheetList(DrawSheetStruct* sheet) void EDA_SheetList::BuildSheetList( DrawSheetStruct* sheet )
/************************************************************************/ /************************************************************************/
{ {
if(m_List == NULL){ if( m_List == NULL )
int count = sheet->CountSheets(); {
m_count = count; int count = sheet->CountSheets();
m_index = 0; m_count = count;
if(m_List) free(m_List); m_List = NULL; m_index = 0;
count *= sizeof(DrawSheetList); if( m_List )
m_List = (DrawSheetList*)MyZMalloc(count); free( m_List );m_List = NULL;
memset((void*)m_List, 0, count); count *= sizeof(DrawSheetList);
m_currList.Clear(); m_List = (DrawSheetList*) MyZMalloc( count );
} memset( (void*) m_List, 0, count );
m_currList.Push(sheet); m_currList.Clear();
m_List[m_index] = m_currList; }
m_index++; m_currList.Push( sheet );
if(sheet->m_s != NULL){ m_List[m_index] = m_currList;
EDA_BaseStruct* strct = m_currList.LastDrawList(); m_index++;
while(strct){ if( sheet->m_AssociatedScreen != NULL )
if(strct->Type() == DRAW_SHEET_STRUCT_TYPE){ {
DrawSheetStruct* sht = (DrawSheetStruct*)strct; EDA_BaseStruct* strct = m_currList.LastDrawList();
BuildSheetList(sht); while( strct )
} {
strct = strct->Pnext; if( strct->Type() == DRAW_SHEET_STRUCT_TYPE )
} {
} DrawSheetStruct* sht = (DrawSheetStruct*) strct;
m_currList.Pop(); BuildSheetList( sht );
}
strct = strct->Pnext;
}
}
m_currList.Pop();
}
/************************************************/
void EDA_SheetList::UpdateSheetNumberAndDate()
/************************************************/
/* Set a sheet number, the sheet count for sheets in the whoçle schematic
* and update the date in all srceens
*/
{
wxString date = GenDate();
int sheet_count = 1, sheet_number = 2; // sheet 1 is the root sheet
for( int ii = 0; ii<(int) m_count; ii++ )
{
DrawSheetList* sheetlist = GetSheet( ii );
sheet_count += sheetlist->m_numSheets;
}
for( int ii = 0; ii<(int) m_count; ii++ )
{
DrawSheetList* sheetlist = GetSheet( ii );
// Read all sheets in path, but not the root sheet (jj = 1)
for( int jj = 1; jj < sheetlist->m_numSheets; jj++ )
{
DrawSheetStruct* sheet = sheetlist->m_sheets[jj];
sheet->m_SheetNumber = sheet_number++;
sheet->m_NumberOfSheets = m_count;
SCH_SCREEN* screen = sheet->m_AssociatedScreen;
if( screen != NULL )
{
screen->m_NumberOfScreen = sheet_count;
screen->m_Date = date;
}
}
}
g_RootSheet->m_AssociatedScreen->m_Date = date;
g_RootSheet->m_AssociatedScreen->m_NumberOfScreen = sheet_count;
g_RootSheet->m_SheetNumber = 1;
g_RootSheet->m_NumberOfSheets = m_count;
} }

218
eeschema/class_screen.h
View File

@ -24,24 +24,25 @@ extern DrawSheetStruct* g_RootSheet;
class SCH_SCREEN : public BASE_SCREEN class SCH_SCREEN : public BASE_SCREEN
{ {
public: public:
int m_RefCount; //how many sheets reference this screen? int m_RefCount; //how many sheets reference this screen?
//delete when it goes to zero. //delete when it goes to zero.
int m_ScreenNumber; int m_ScreenNumber;
int m_NumberOfScreen; int m_NumberOfScreen;
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 ) { };
void RemoveFromDrawList( EDA_BaseStruct* DrawStruct );/* remove DrawStruct from EEDrawList. */ void RemoveFromDrawList( EDA_BaseStruct* DrawStruct ); /* remove DrawStruct from EEDrawList. */
bool CheckIfOnDrawList( EDA_BaseStruct* st ); bool CheckIfOnDrawList( EDA_BaseStruct* st );
void AddToDrawList( EDA_BaseStruct* DrawStruct ); void AddToDrawList( EDA_BaseStruct* DrawStruct );
void ClearUndoORRedoList( EDA_BaseStruct* List ); void ClearUndoORRedoList( EDA_BaseStruct* List );
bool SchematicCleanUp( wxDC* DC = NULL ); bool SchematicCleanUp( wxDC* DC = NULL );
@ -54,24 +55,26 @@ public:
}; };
class DrawSheetLabelStruct : public EDA_BaseStruct, public EDA_TextStruct class DrawSheetLabelStruct : public EDA_BaseStruct
, public EDA_TextStruct
{ {
public: public:
int m_Layer; int m_Layer;
int m_Edge, m_Shape; int m_Edge, m_Shape;
bool m_IsDangling; // TRUE si non connect<63> bool m_IsDangling; // TRUE non connected
public: public:
DrawSheetLabelStruct( DrawSheetStruct* parent, DrawSheetLabelStruct( DrawSheetStruct* parent,
const wxPoint& pos = wxPoint( 0, 0 ), const wxPoint& pos = wxPoint( 0, 0 ),
const wxString& text = wxEmptyString ); const wxString& text = wxEmptyString );
~DrawSheetLabelStruct() { } ~DrawSheetLabelStruct() { }
virtual wxString GetClass() const virtual wxString GetClass() const
{ {
return wxT("DrawSheetLabelStruct"); return wxT( "DrawSheetLabelStruct" );
} }
DrawSheetLabelStruct* GenCopy(); DrawSheetLabelStruct* GenCopy();
DrawSheetLabelStruct* Next() DrawSheetLabelStruct* Next()
@ -82,129 +85,170 @@ public:
int draw_mode, int Color = -1 ); int draw_mode, int Color = -1 );
}; };
WX_DEFINE_ARRAY( DrawSheetStruct*, SheetGrowArray );
/* class DrawSheetStruct
This class is the sheet symbol placed in a schematic, and is the entry point for a sub schematic
*/
WX_DEFINE_ARRAY( DrawSheetStruct *, SheetGrowArray );
class DrawSheetStruct : public EDA_BaseStruct /*public SCH_SCREEN*/ /* Gestion de la hierarchie */ class DrawSheetStruct : public EDA_BaseStruct /*public SCH_SCREEN*/ /* Gestion de la hierarchie */
{ {
public: public:
wxString m_SheetName; //this is equivalent to C101 for components: wxString m_SheetName; //this is equivalent to C101 for components:
// it is stored in F0 ... of the file. // it is stored in F0 ... of the file.
wxString m_FileName; //also in SCH_SCREEN (redundant), wxString m_FileName; //also in SCH_SCREEN (redundant),
//but need it here for loading after //but need it here for loading after
//reading the sheet description from file. //reading the sheet description from file.
int m_SheetNameSize; int m_SheetNameSize;
int m_FileNameSize; int m_FileNameSize;
wxPoint m_Pos; wxPoint m_Pos;
wxSize m_Size; /* Position and Size of sheet symbol */ wxSize m_Size; /* Position and Size of sheet symbol */
int m_Layer; int m_Layer;
DrawSheetLabelStruct* m_Label; /* Points de connection, linked list.*/ DrawSheetLabelStruct* m_Label; /* Points de connection, linked list.*/
int m_NbLabel; /* Nombre de points de connexion */ int m_NbLabel; /* Nombre de points de connexion */
SCH_SCREEN* m_s; SCH_SCREEN* m_AssociatedScreen; /* Associated Screen which handle the physical data
In complex hierarchies we can have many DrawSheetStruct using the same data
*/
int m_SheetNumber; // sheet number (used for info)
int m_NumberOfSheets; // Sheets count in the whole schematic (used for info)
public: public:
DrawSheetStruct( const wxPoint& pos = wxPoint( 0, 0 ) ); DrawSheetStruct( const wxPoint& pos = wxPoint( 0, 0 ) );
~DrawSheetStruct(); ~DrawSheetStruct();
virtual wxString GetClass() const virtual wxString GetClass() const
{ {
return wxT("DrawSheetStruct"); return wxT( "DrawSheetStruct" );
} }
void Place( WinEDA_DrawFrame* frame, wxDC* DC ); void Place( WinEDA_DrawFrame* frame, wxDC* DC );
DrawSheetStruct* GenCopy(); DrawSheetStruct* GenCopy();
void Display_Infos( WinEDA_DrawFrame* frame ); void Display_Infos( WinEDA_DrawFrame* frame );
void CleanupSheet( WinEDA_SchematicFrame* frame, wxDC* DC ); void CleanupSheet( WinEDA_SchematicFrame* frame, wxDC* DC );
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 );
void SwapData( DrawSheetStruct* copyitem ); void SwapData( DrawSheetStruct* copyitem );
void DeleteAnnotation( bool recurse ); void DeleteAnnotation( bool recurse );
int ComponentCount(); int ComponentCount();
bool Load(WinEDA_SchematicFrame* frame); bool Load( WinEDA_SchematicFrame* frame );
bool SearchHierarchy(wxString filename, SCH_SCREEN **screen); bool SearchHierarchy( wxString filename, SCH_SCREEN** screen );
bool LocatePathOfScreen(SCH_SCREEN *screen, DrawSheetList* list); bool LocatePathOfScreen( SCH_SCREEN* screen, DrawSheetList* list );
int CountSheets(); int CountSheets();
//void RemoveSheet(DrawSheetStruct* sheet);
//to remove a sheet, just delete it //void RemoveSheet(DrawSheetStruct* sheet);
//-- the destructor should take care of everything else. //to remove a sheet, just delete it
//-- the destructor should take care of everything else.
}; };
/**********************************************/
/* class to handle a series of sheets *********/
/* a 'path' so to speak.. *********************/
/**********************************************/
#define DSLSZ 32 #define DSLSZ 32
class DrawSheetList class DrawSheetList
{ {
public: public:
int m_numSheets; int m_numSheets;
DrawSheetStruct* m_sheets[DSLSZ]; DrawSheetStruct* m_sheets[DSLSZ];
DrawSheetList(); DrawSheetList();
~DrawSheetList(){}; ~DrawSheetList() { };
void Clear(){m_numSheets = 0; } void Clear() { m_numSheets = 0; }
int Cmp(DrawSheetList& d); int Cmp( DrawSheetList& d );
DrawSheetStruct* Last(); DrawSheetStruct* Last();
SCH_SCREEN* LastScreen(); SCH_SCREEN* LastScreen();
EDA_BaseStruct* LastDrawList(); EDA_BaseStruct* LastDrawList();
void Push(DrawSheetStruct* sheet); void Push( DrawSheetStruct* sheet );
DrawSheetStruct* Pop(); DrawSheetStruct* Pop();
wxString Path(); wxString Path();
wxString PathHumanReadable(); wxString PathHumanReadable();
void UpdateAllScreenReferences(); void UpdateAllScreenReferences();
bool operator= (const DrawSheetList& d1);
bool operator==(const DrawSheetList &d1); bool operator =( const DrawSheetList& d1 );
bool operator!=(const DrawSheetList &d1);
bool operator ==( const DrawSheetList& d1 );
bool operator !=( const DrawSheetList& d1 );
}; };
/*******************************************************/
/* Class to handle the list of *Sheets* in a hierarchy */ /* Class to handle the list of *Sheets* in a hierarchy */
/*******************************************************/
// sheets are not unique - can have many sheets with the same // sheets are not unique - can have many sheets with the same
// filename and the same SCH_SHEET reference. // filename and the same SCH_SHEET reference.
class EDA_SheetList class EDA_SheetList
{ {
private: private:
DrawSheetList* m_List; DrawSheetList* m_List;
int m_count; int m_count;
int m_index; int m_index;
DrawSheetList m_currList; DrawSheetList m_currList;
public: public:
EDA_SheetList( DrawSheetStruct* sheet ){ EDA_SheetList( DrawSheetStruct* sheet )
m_index = 0; {
m_count = 0; m_index = 0;
m_List = NULL; m_count = 0;
if(sheet == NULL) m_List = NULL;
sheet = g_RootSheet; if( sheet == NULL )
BuildSheetList( sheet ); sheet = g_RootSheet;
} BuildSheetList( sheet );
~EDA_SheetList() {if(m_List){free(m_List);} m_List = NULL;} }
int GetCount() { return m_count; }
DrawSheetList* GetFirst();
DrawSheetList* GetNext();
DrawSheetList* GetSheet(int index );
private:
void BuildSheetList( DrawSheetStruct* sheet ); ~EDA_SheetList()
{
if( m_List )
{
free( m_List );
}
m_List = NULL;
}
int GetCount() { return m_count; }
DrawSheetList* GetFirst();
DrawSheetList* GetNext();
DrawSheetList* GetSheet( int index );
void UpdateSheetNumberAndDate(); // Update the date displayed in the sheet count
private:
void BuildSheetList( DrawSheetStruct* sheet );
}; };
/********************************************************/
/* Class to handle the list of *screens* in a hierarchy */ /* Class to handle the list of *screens* in a hierarchy */
/********************************************************/
// screens are unique, and correspond to .sch files. // screens are unique, and correspond to .sch files.
WX_DEFINE_ARRAY( SCH_SCREEN*, ScreenGrowArray ); WX_DEFINE_ARRAY( SCH_SCREEN *, ScreenGrowArray );
class EDA_ScreenList class EDA_ScreenList
{ {
private: private:
ScreenGrowArray m_List; ScreenGrowArray m_List;
unsigned int m_Index; unsigned int m_Index;
public: public:
EDA_ScreenList(){ EDA_ScreenList()
m_Index = 0; {
BuildScreenList(g_RootSheet); m_Index = 0;
} BuildScreenList( g_RootSheet );
~EDA_ScreenList() {} }
int GetCount() { return m_List.GetCount(); }
~EDA_ScreenList() { }
int GetCount() { return m_List.GetCount(); }
SCH_SCREEN* GetFirst(); SCH_SCREEN* GetFirst();
SCH_SCREEN* GetNext(); SCH_SCREEN* GetNext();
SCH_SCREEN* GetScreen( unsigned int index ); SCH_SCREEN* GetScreen( unsigned int index );
void UpdateScreenNumberAndDate();
private: private:
void AddScreenToList( SCH_SCREEN* testscreen ); void AddScreenToList( SCH_SCREEN* testscreen );
void BuildScreenList( EDA_BaseStruct* sheet ); void BuildScreenList( EDA_BaseStruct* sheet );
}; };
#endif /* CLASS_SCREEN_H */ #endif /* CLASS_SCREEN_H */

4
eeschema/component_class.cpp
View File

@ -140,9 +140,7 @@ void EDA_SchComponentStruct::SetRef( DrawSheetList* sheet, wxString ref )
//check to see if it is already there before inserting it //check to see if it is already there before inserting it
wxString path = GetPath( sheet ); wxString path = GetPath( sheet );
printf( "SetRef path: %s ref: %s\n", // printf( "SetRef path: %s ref: %s\n", CONV_TO_UTF8( path ), CONV_TO_UTF8( ref ) ); // Debug
CONV_TO_UTF8( path ),
CONV_TO_UTF8( ref ) );
unsigned int i; unsigned int i;
bool notInArray = true; bool notInArray = true;
for( i = 0; i<m_Paths.GetCount(); i++ ) for( i = 0; i<m_Paths.GetCount(); i++ )

57
eeschema/component_class.h
View File

@ -29,7 +29,7 @@ enum NumFieldType {
FIELD6, FIELD6,
FIELD7, FIELD7,
FIELD8, FIELD8,
NUMBER_OF_FIELDS /* Nombre de champs de texte affectes au composant */ NUMBER_OF_FIELDS /* Nombre de champs de texte affectes au composant */
}; };
@ -37,7 +37,8 @@ enum NumFieldType {
* component fields are texts attached to the component (not the graphic texts) * component fields are texts attached to the component (not the graphic texts)
* There are 2 major fields : Reference and Value * There are 2 major fields : Reference and Value
*/ */
class PartTextStruct : public EDA_BaseStruct, public EDA_TextStruct class PartTextStruct : public EDA_BaseStruct
, public EDA_TextStruct
{ {
public: public:
int m_Layer; int m_Layer;
@ -78,7 +79,7 @@ public:
wxPoint m_Pos; /* Exact position of part. */ wxPoint m_Pos; /* Exact position of part. */
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
@ -87,23 +88,24 @@ public:
} }
}; };
WX_DECLARE_OBJARRAY(DrawSheetList, ArrayOfSheetLists); WX_DECLARE_OBJARRAY( DrawSheetList, ArrayOfSheetLists );
/* the class EDA_SchComponentStruct describes a real component */ /* the class EDA_SchComponentStruct describes a real component */
class EDA_SchComponentStruct : public DrawPartStruct class EDA_SchComponentStruct : public DrawPartStruct
{ {
public: public:
int m_Multi; /* In multi unit chip - which unit to draw. */ int m_Multi; /* In multi unit chip - which unit to draw. */
//int m_FlagControlMulti;
ArrayOfSheetLists m_UsedOnSheets;
int m_Convert; /* Gestion (management) des mutiples representations (ex: conversion De Morgan) */
int m_Transform[2][2]; /* The rotation/mirror transformation matrix. */
bool* m_PinIsDangling; // liste des indicateurs de pin non connectee
wxArrayString m_Paths; // /sheet1/C102, /sh2/sh1/U32 etc. //int m_FlagControlMulti;
wxArrayString m_References; // C102, U32 etc. ArrayOfSheetLists m_UsedOnSheets;
wxString m_PrefixString; //C, R, U, Q etc - the first character which typically indicates what the component is. int m_Convert; /* Gestion (management) des mutiples representations (ex: conversion De Morgan) */
//determined, upon placement, from the library component. int m_Transform[2][2]; /* The rotation/mirror transformation matrix. */
//determined, upon file load, by the first non-digits in the reference fields. bool* m_PinIsDangling; // liste des indicateurs de pin non connectee
wxArrayString m_Paths; // /sheet1/C102, /sh2/sh1/U32 etc.
wxArrayString m_References; // C102, U32 etc.
wxString m_PrefixString; /*C, R, U, Q etc - the first character which typically indicates what the component is.
* determined, upon placement, from the library component.
* determined, upon file load, by the first non-digits in the reference fields. */
public: public:
EDA_SchComponentStruct( const wxPoint& pos = wxPoint( 0, 0 ) ); EDA_SchComponentStruct( const wxPoint& pos = wxPoint( 0, 0 ) );
@ -136,21 +138,23 @@ public:
virtual void Draw( WinEDA_DrawPanel* panel, virtual void Draw( WinEDA_DrawPanel* panel,
wxDC* DC, wxDC* DC,
const wxPoint& offset, const wxPoint& offset,
int draw_mode, int draw_mode,
int Color = -1 ); int Color = -1 );
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 );
//returns a unique ID, in the form of a path. //returns a unique ID, in the form of a path.
wxString GetPath( DrawSheetList* sheet); wxString GetPath( DrawSheetList* sheet );
const wxString GetRef( DrawSheetList* sheet ); const wxString GetRef( DrawSheetList* sheet );
void SetRef( DrawSheetList* sheet, wxString ref ); void SetRef( DrawSheetList* sheet, wxString ref );
void ClearRefs(); void ClearRefs();
#if defined(DEBUG)
#if defined (DEBUG)
/** /**
* Function Show * Function Show
* is used to output the object tree, currently for debugging only. * is used to output the object tree, currently for debugging only.
@ -158,7 +162,8 @@ public:
* of nesting of this object within the overall tree. * of nesting of this object within the overall tree.
* @param os The ostream& to output to. * @param os The ostream& to output to.
*/ */
void Show( int nestLevel, std::ostream& os ); void Show( int nestLevel, std::ostream& os );
#endif #endif
}; };

10
eeschema/delsheet.cpp
View File

@ -37,20 +37,20 @@ wxString msg;
} }
/* effacement du sous schema correspondant */ /* effacement du sous schema correspondant */
if( FirstSheet->m_s->IsModify() && confirm_deletion ) if( FirstSheet->m_AssociatedScreen->IsModify() && confirm_deletion )
{ {
msg.Printf( _("Sheet %s (file %s) modified. Save it?"), msg.Printf( _("Sheet %s (file %s) modified. Save it?"),
FirstSheet->m_SheetName.GetData(), FirstSheet->m_SheetName.GetData(),
FirstSheet->m_FileName.GetData()); FirstSheet->m_FileName.GetData());
if( IsOK(NULL, msg) ) if( IsOK(NULL, msg) )
{ {
frame->SaveEEFile(FirstSheet->m_s, FILE_SAVE_AS); frame->SaveEEFile(FirstSheet->m_AssociatedScreen, FILE_SAVE_AS);
} }
} }
/* free the sub hierarchy */ /* free the sub hierarchy */
if(FirstSheet->m_s){ if(FirstSheet->m_AssociatedScreen){
EEDrawList = FirstSheet->m_s->EEDrawList; EEDrawList = FirstSheet->m_AssociatedScreen->EEDrawList;
while (EEDrawList != NULL) while (EEDrawList != NULL)
{ {
DrawStruct = EEDrawList; DrawStruct = EEDrawList;
@ -61,7 +61,7 @@ wxString msg;
} }
} }
/* Effacement des elements de la feuille courante */ /* Effacement des elements de la feuille courante */
FirstSheet->m_s->FreeDrawList(); FirstSheet->m_AssociatedScreen->FreeDrawList();
} }
} }

2
eeschema/dialog_build_BOM.cpp
View File

@ -544,7 +544,7 @@ wxString mask, filename;
else else
s_ExportSeparatorSymbol = s_ExportSeparator[0]; s_ExportSeparatorSymbol = s_ExportSeparator[0];
m_ListFileName = g_RootSheet->m_s->m_FileName; m_ListFileName = g_RootSheet->m_AssociatedScreen->m_FileName;
ChangeFileNameExt(m_ListFileName, EXT_LIST); ChangeFileNameExt(m_ListFileName, EXT_LIST);
//need to get rid of the path. //need to get rid of the path.
m_ListFileName = m_ListFileName.AfterLast('/'); m_ListFileName = m_ListFileName.AfterLast('/');

284
eeschema/eeconfig.cpp
View File

@ -1,6 +1,6 @@
/******************************************************/ /******************************************************/
/** eeconfig.cpp : routines et menus de configuration */ /** eeconfig.cpp : routines et menus de configuration */
/*******************************************************/ /*******************************************************/
#include "fctsys.h" #include "fctsys.h"
#include "common.h" #include "common.h"
@ -18,189 +18,195 @@
/* Variables locales */ /* Variables locales */
#define HOTKEY_FILENAME wxT("eeschema") #define HOTKEY_FILENAME wxT( "eeschema" )
/*********************************************************************/ /*********************************************************************/
void WinEDA_SchematicFrame::Process_Config(wxCommandEvent& event) void WinEDA_SchematicFrame::Process_Config( wxCommandEvent& event )
/*********************************************************************/ /*********************************************************************/
{ {
int id = event.GetId(); int id = event.GetId();
wxPoint pos; wxPoint pos;
wxString FullFileName; wxString FullFileName;
wxGetMousePosition(&pos.x, &pos.y); wxGetMousePosition( &pos.x, &pos.y );
pos.y += 5; pos.y += 5;
switch ( id )
{
case ID_COLORS_SETUP :
DisplayColorSetupFrame(this, pos);
break;
case ID_CONFIG_REQ : // Creation de la fenetre de configuration switch( id )
InstallConfigFrame(pos); {
break; case ID_COLORS_SETUP:
DisplayColorSetupFrame( this, pos );
break;
case ID_OPTIONS_SETUP: case ID_CONFIG_REQ: // Creation de la fenetre de configuration
DisplayOptionFrame(this, pos); InstallConfigFrame( pos );
break; break;
case ID_CONFIG_SAVE: case ID_OPTIONS_SETUP:
Save_Config(this); DisplayOptionFrame( this, pos );
break; break;
case ID_CONFIG_READ: case ID_CONFIG_SAVE:
{ Save_Config( this );
wxString mask( wxT("*") ); mask += g_Prj_Config_Filename_ext; break;
FullFileName = g_RootSheet->m_s->m_FileName;
ChangeFileNameExt( FullFileName, g_Prj_Config_Filename_ext );
FullFileName = EDA_FileSelector(_("Read config file"), case ID_CONFIG_READ:
wxGetCwd(), /* Chemin par defaut */ {
FullFileName, /* nom fichier par defaut */ wxString mask( wxT( "*" ) ); mask += g_Prj_Config_Filename_ext;
g_Prj_Config_Filename_ext, /* extension par defaut */ FullFileName = g_RootSheet->m_AssociatedScreen->m_FileName;
mask, /* Masque d'affichage */ ChangeFileNameExt( FullFileName, g_Prj_Config_Filename_ext );
this,
wxFD_OPEN,
TRUE /* ne change pas de repertoire courant */
);
if ( FullFileName.IsEmpty() ) break;
if ( ! wxFileExists(FullFileName) )
{
wxString msg = _("File ") + FullFileName +_("not found");;
DisplayError(this, msg); break;
}
Read_Config(FullFileName, TRUE );
}
break;
case ID_PREFERENCES_CREATE_CONFIG_HOTKEYS: FullFileName = EDA_FileSelector( _( "Read config file" ),
FullFileName = ReturnHotkeyConfigFilePath( g_ConfigFileLocationChoice ); wxGetCwd(), /* Chemin par defaut */
FullFileName += HOTKEY_FILENAME; FullFileName, /* nom fichier par defaut */
FullFileName += DEFAULT_HOTKEY_FILENAME_EXT; g_Prj_Config_Filename_ext, /* extension par defaut */
WriteHotkeyConfigFile(FullFileName, s_Eeschema_Hokeys_Descr, true); mask, /* Masque d'affichage */
break; this,
wxFD_OPEN,
TRUE /* ne change pas de repertoire courant */
);
if( FullFileName.IsEmpty() )
break;
if( !wxFileExists( FullFileName ) )
{
wxString msg = _( "File " ) + FullFileName + _( "not found" );;
DisplayError( this, msg ); break;
}
Read_Config( FullFileName, TRUE );
}
break;
case ID_PREFERENCES_READ_CONFIG_HOTKEYS: case ID_PREFERENCES_CREATE_CONFIG_HOTKEYS:
Read_Hotkey_Config( this, true); FullFileName = ReturnHotkeyConfigFilePath( g_ConfigFileLocationChoice );
break; FullFileName += HOTKEY_FILENAME;
FullFileName += DEFAULT_HOTKEY_FILENAME_EXT;
WriteHotkeyConfigFile( FullFileName, s_Eeschema_Hokeys_Descr, true );
break;
case ID_PREFERENCES_EDIT_CONFIG_HOTKEYS: case ID_PREFERENCES_READ_CONFIG_HOTKEYS:
{ Read_Hotkey_Config( this, true );
FullFileName = ReturnHotkeyConfigFilePath( g_ConfigFileLocationChoice ); break;
FullFileName += HOTKEY_FILENAME;
FullFileName += DEFAULT_HOTKEY_FILENAME_EXT;
wxString editorname = GetEditorName();
if ( !editorname.IsEmpty() )
ExecuteFile(this, editorname, FullFileName);
}
break;
case ID_PREFERENCES_HOTKEY_PATH_IS_HOME: case ID_PREFERENCES_EDIT_CONFIG_HOTKEYS:
case ID_PREFERENCES_HOTKEY_PATH_IS_KICAD: {
HandleHotkeyConfigMenuSelection( this, id ); FullFileName = ReturnHotkeyConfigFilePath( g_ConfigFileLocationChoice );
break; FullFileName += HOTKEY_FILENAME;
FullFileName += DEFAULT_HOTKEY_FILENAME_EXT;
wxString editorname = GetEditorName();
if( !editorname.IsEmpty() )
ExecuteFile( this, editorname, FullFileName );
}
break;
case ID_PREFERENCES_HOTKEY_SHOW_CURRENT_LIST: // Display Current hotkey list for eeschema case ID_PREFERENCES_HOTKEY_PATH_IS_HOME:
DisplayHotkeyList( this, s_Schematic_Hokeys_Descr ); case ID_PREFERENCES_HOTKEY_PATH_IS_KICAD:
break; HandleHotkeyConfigMenuSelection( this, id );
break;
default: case ID_PREFERENCES_HOTKEY_SHOW_CURRENT_LIST: // Display Current hotkey list for eeschema
DisplayError(this, wxT("WinEDA_SchematicFrame::Process_Config internal error") ); DisplayHotkeyList( this, s_Schematic_Hokeys_Descr );
} break;
default:
DisplayError( this, wxT( "WinEDA_SchematicFrame::Process_Config internal error" ) );
}
} }
/***************************************************************/ /***************************************************************/
bool Read_Hotkey_Config( WinEDA_DrawFrame * frame, bool verbose ) bool Read_Hotkey_Config( WinEDA_DrawFrame* frame, bool verbose )
/***************************************************************/ /***************************************************************/
/* /*
* Read the hotkey files config for eeschema and libedit * Read the hotkey files config for eeschema and libedit
*/ */
{ {
wxString FullFileName = ReturnHotkeyConfigFilePath( g_ConfigFileLocationChoice ); wxString FullFileName = ReturnHotkeyConfigFilePath( g_ConfigFileLocationChoice );
FullFileName += HOTKEY_FILENAME;
FullFileName += DEFAULT_HOTKEY_FILENAME_EXT;
frame->ReadHotkeyConfigFile(FullFileName, s_Eeschema_Hokeys_Descr, verbose);
return TRUE; FullFileName += HOTKEY_FILENAME;
FullFileName += DEFAULT_HOTKEY_FILENAME_EXT;
frame->ReadHotkeyConfigFile( FullFileName, s_Eeschema_Hokeys_Descr, verbose );
return TRUE;
} }
/***********************************************************************/ /***********************************************************************/
bool Read_Config( const wxString & CfgFileName, bool ForceRereadConfig ) bool Read_Config( const wxString& CfgFileName, bool ForceRereadConfig )
/***********************************************************************/ /***********************************************************************/
/* lit la configuration, si elle n'a pas deja ete lue /* lit la configuration, si elle n'a pas deja ete lue
1 - lit <nom fichier root>.pro * 1 - lit <nom fichier root>.pro
2 - si non trouve lit <chemin des binaires>../template/kicad.pro * 2 - si non trouve lit <chemin des binaires>../template/kicad.pro
3 - si non trouve: init des variables aux valeurs par defaut * 3 - si non trouve: init des variables aux valeurs par defaut
*
Retourne TRUE si lu, FALSE si config non lue * Retourne TRUE si lu, FALSE si config non lue
*/ */
{ {
wxString FullFileName; wxString FullFileName;
bool IsRead = TRUE; bool IsRead = TRUE;
wxArrayString liblist_tmp = g_LibName_List; wxArrayString liblist_tmp = g_LibName_List;
if ( CfgFileName.IsEmpty() ) FullFileName = g_RootSheet->m_s->m_FileName; if( CfgFileName.IsEmpty() )
else FullFileName = CfgFileName; FullFileName = g_RootSheet->m_AssociatedScreen->m_FileName;
g_LibName_List.Clear(); else
FullFileName = CfgFileName;
g_LibName_List.Clear();
if ( ! g_EDA_Appl->ReadProjectConfig(FullFileName, if( !g_EDA_Appl->ReadProjectConfig( FullFileName,
GROUP, ParamCfgList, ForceRereadConfig ? FALSE : TRUE) ) // Config non lue GROUP, ParamCfgList, ForceRereadConfig ? FALSE : TRUE ) ) // Config non lue
{ {
g_LibName_List = liblist_tmp; g_LibName_List = liblist_tmp;
IsRead = FALSE; IsRead = FALSE;
} }
/* Traitement des variables particulieres: */ /* Traitement des variables particulieres: */
SetRealLibraryPath( wxT("library") ); SetRealLibraryPath( wxT( "library" ) );
// If the list is void, load the libraries "power.lib" and "device.lib" // If the list is void, load the libraries "power.lib" and "device.lib"
if ( g_LibName_List.GetCount() == 0 ) if( g_LibName_List.GetCount() == 0 )
{ {
g_LibName_List.Add( wxT("power") ); g_LibName_List.Add( wxT( "power" ) );
g_LibName_List.Add( wxT("device") ); g_LibName_List.Add( wxT( "device" ) );
} }
if ( g_EDA_Appl->m_SchematicFrame ) if( g_EDA_Appl->m_SchematicFrame )
{ {
g_EDA_Appl->m_SchematicFrame->SetDrawBgColor(g_DrawBgColor); g_EDA_Appl->m_SchematicFrame->SetDrawBgColor( g_DrawBgColor );
g_EDA_Appl->m_SchematicFrame->m_Draw_Grid = g_ShowGrid; g_EDA_Appl->m_SchematicFrame->m_Draw_Grid = g_ShowGrid;
} }
LoadLibraries(g_EDA_Appl->m_SchematicFrame); LoadLibraries( g_EDA_Appl->m_SchematicFrame );
return IsRead; return IsRead;
} }
/****************************************************************/ /****************************************************************/
void WinEDA_SchematicFrame::Save_Config(wxWindow * displayframe) void WinEDA_SchematicFrame::Save_Config( wxWindow* displayframe )
/***************************************************************/ /***************************************************************/
{ {
wxString path; wxString path;
wxString FullFileName; wxString FullFileName;
wxString mask( wxT("*") ); wxString mask( wxT( "*" ) );
mask += g_Prj_Config_Filename_ext; mask += g_Prj_Config_Filename_ext;
FullFileName = g_RootSheet->m_s->m_FileName.AfterLast('/') /*ConfigFileName*/; FullFileName = g_RootSheet->m_AssociatedScreen->m_FileName.AfterLast( '/' ) /*ConfigFileName*/;
ChangeFileNameExt( FullFileName, g_Prj_Config_Filename_ext ); ChangeFileNameExt( FullFileName, g_Prj_Config_Filename_ext );
path = wxGetCwd(); path = wxGetCwd();
FullFileName = EDA_FileSelector(_("Save preferences"), FullFileName = EDA_FileSelector( _( "Save preferences" ),
path, /* Chemin par defaut */ path, /* Chemin par defaut */
FullFileName, /* nom fichier par defaut */ FullFileName, /* nom fichier par defaut */
g_Prj_Config_Filename_ext, /* extension par defaut */ g_Prj_Config_Filename_ext, /* extension par defaut */
mask, /* Masque d'affichage */ mask, /* Masque d'affichage */
displayframe, displayframe,
wxFD_SAVE, wxFD_SAVE,
TRUE TRUE
); );
if ( FullFileName.IsEmpty() ) return; if( FullFileName.IsEmpty() )
return;
/* ecriture de la configuration */ /* ecriture de la configuration */
g_EDA_Appl->WriteProjectConfig(FullFileName, GROUP, ParamCfgList); g_EDA_Appl->WriteProjectConfig( FullFileName, GROUP, ParamCfgList );
} }

3
eeschema/eeredraw.cpp
View File

@ -129,7 +129,7 @@ wxString title;
void WinEDA_DrawPanel::PrintPage(wxDC * DC, bool Print_Sheet_Ref, int PrintMask) void WinEDA_DrawPanel::PrintPage(wxDC * DC, bool Print_Sheet_Ref, int PrintMask)
/*******************************************************************************/ /*******************************************************************************/
{ {
BASE_SCREEN * screen; // * oldscreen = m_Parent->GetScreen(); BASE_SCREEN * screen;
wxBeginBusyCursor(); wxBeginBusyCursor();
@ -140,7 +140,6 @@ BASE_SCREEN * screen; // * oldscreen = m_Parent->GetScreen();
if ( Print_Sheet_Ref ) if ( Print_Sheet_Ref )
m_Parent->TraceWorkSheet(DC, screen, g_DrawMinimunLineWidth ); m_Parent->TraceWorkSheet(DC, screen, g_DrawMinimunLineWidth );
//m_Parent->m_CurrentSheet->m_s = oldscreen;
wxEndBusyCursor(); wxEndBusyCursor();
} }

2
eeschema/erc.cpp
View File

@ -400,7 +400,7 @@ void WinEDA_ErcFrame::TestErc( wxCommandEvent& event )
if( WriteFichierERC == TRUE ) if( WriteFichierERC == TRUE )
{ {
wxString ErcFullFileName; wxString ErcFullFileName;
ErcFullFileName = g_RootSheet->m_s->m_FileName; ErcFullFileName = g_RootSheet->m_AssociatedScreen->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 */

16
eeschema/files-io.cpp
View File

@ -63,7 +63,7 @@ void WinEDA_SchematicFrame::Save_File( wxCommandEvent& event )
mask = wxT( "*" ) + g_SchExtBuffer; mask = wxT( "*" ) + g_SchExtBuffer;
FullFileName = EDA_FileSelector( _( "Schematic files:" ), FullFileName = EDA_FileSelector( _( "Schematic files:" ),
wxEmptyString, //default path wxEmptyString, //default path
sheet->m_s->m_FileName,// default filename sheet->m_AssociatedScreen->m_FileName,// default filename
g_SchExtBuffer, // extension par defaut g_SchExtBuffer, // extension par defaut
mask, // Masque d'affichage mask, // Masque d'affichage
this, this,
@ -111,8 +111,8 @@ int WinEDA_SchematicFrame::LoadOneEEProject( const wxString& FileName, bool IsNe
{ {
if( !IsOK( this, _( "Clear Schematic Hierarchy (modified!)?" ) ) ) if( !IsOK( this, _( "Clear Schematic Hierarchy (modified!)?" ) ) )
return FALSE; return FALSE;
if( g_RootSheet->m_s->m_FileName != g_DefaultSchematicFileName ) if( g_RootSheet->m_AssociatedScreen->m_FileName != g_DefaultSchematicFileName )
SetLastProject( g_RootSheet->m_s->m_FileName ); SetLastProject( g_RootSheet->m_AssociatedScreen->m_FileName );
} }
FullFileName = FileName; FullFileName = FileName;
@ -146,7 +146,7 @@ int WinEDA_SchematicFrame::LoadOneEEProject( const wxString& FileName, bool IsNe
memset( &g_EESchemaVar, 0, sizeof(g_EESchemaVar) ); memset( &g_EESchemaVar, 0, sizeof(g_EESchemaVar) );
GetScreen()->ClrModify(); GetScreen()->ClrModify();
//m_CurrentSheet->m_s->Pnext = NULL; should be by default //m_CurrentSheet->m_AssociatedScreen->Pnext = NULL; should be by default
if( IsNew ) if( IsNew )
{ {
@ -190,7 +190,7 @@ int WinEDA_SchematicFrame::LoadOneEEProject( const wxString& FileName, bool IsNe
// Loading the project library cache // Loading the project library cache
wxString FullLibName; wxString FullLibName;
wxString shortfilename; wxString shortfilename;
wxSplitPath( g_RootSheet->m_s->m_FileName, NULL, &shortfilename, NULL ); wxSplitPath( g_RootSheet->m_AssociatedScreen->m_FileName, NULL, &shortfilename, NULL );
FullLibName << wxT( "." ) << STRING_DIR_SEP << shortfilename << wxT( ".cache" ) << FullLibName << wxT( "." ) << STRING_DIR_SEP << shortfilename << wxT( ".cache" ) <<
g_LibExtBuffer; g_LibExtBuffer;
if( wxFileExists( FullLibName ) ) if( wxFileExists( FullLibName ) )
@ -211,16 +211,16 @@ int WinEDA_SchematicFrame::LoadOneEEProject( const wxString& FileName, bool IsNe
LibCacheExist = TRUE; LibCacheExist = TRUE;
} }
if( !wxFileExists( g_RootSheet->m_s->m_FileName ) && !LibCacheExist ) // Nouveau projet prpbablement if( !wxFileExists( g_RootSheet->m_AssociatedScreen->m_FileName ) && !LibCacheExist ) // Nouveau projet prpbablement
{ {
msg.Printf( _( "File %s not found (new project ?)" ), msg.Printf( _( "File %s not found (new project ?)" ),
g_RootSheet->m_s->m_FileName.GetData() ); g_RootSheet->m_AssociatedScreen->m_FileName.GetData() );
DisplayInfo( this, msg, 20 ); DisplayInfo( this, msg, 20 );
return -1; return -1;
} }
//load the project. //load the project.
SAFE_DELETE(g_RootSheet->m_s); SAFE_DELETE(g_RootSheet->m_AssociatedScreen);
if(!g_RootSheet->Load(this)) if(!g_RootSheet->Load(this))
return 0; return 0;

5
eeschema/hierarch.cpp
View File

@ -273,7 +273,7 @@ void WinEDA_SchematicFrame::InstallNextScreen(DrawSheetStruct * Sheet)
/* Routine d'installation de l'ecran correspondant au symbole Sheet pointe /* Routine d'installation de l'ecran correspondant au symbole Sheet pointe
par la souris par la souris
have to be careful here because the DrawSheetStructs within the EEDrawList have to be careful here because the DrawSheetStructs within the EEDrawList
don't actually have a valid m_s (on purpose -- you need the m_SubSheet hierarchy don't actually have a valid m_AssociatedScreen (on purpose -- you need the m_SubSheet hierarchy
to maintain path info (well, this is but one way to maintain path info..) to maintain path info (well, this is but one way to maintain path info..)
*/ */
{ {
@ -297,11 +297,10 @@ static void UpdateScreenFromSheet(WinEDA_SchematicFrame * frame)
{ {
SCH_SCREEN * NewScreen; SCH_SCREEN * NewScreen;
//SCH_SCREEN * oldscreen = frame->GetScreen(); what is oldscreen used for?
NewScreen = frame->m_CurrentSheet->LastScreen(); NewScreen = frame->m_CurrentSheet->LastScreen();
if(!NewScreen) if(!NewScreen)
NewScreen = g_RootSheet->m_s; NewScreen = g_RootSheet->m_AssociatedScreen;
// Reinit des parametres d'affichage du nouvel ecran // Reinit des parametres d'affichage du nouvel ecran
// assumes m_CurrentSheet has already been updated. // assumes m_CurrentSheet has already been updated.

2
eeschema/libframe.cpp
View File

@ -656,6 +656,7 @@ void WinEDA_LibeditFrame::Process_Special_Functions( wxCommandEvent& event )
{ {
EditField( &dc, (LibDrawField*) CurrentDrawItem ); EditField( &dc, (LibDrawField*) CurrentDrawItem );
} }
DrawPanel->MouseToCursorSchema();
DrawPanel->CursorOn( &dc ); DrawPanel->CursorOn( &dc );
break; break;
@ -725,7 +726,6 @@ void WinEDA_LibeditFrame::Process_Special_Functions( wxCommandEvent& event )
break; break;
} }
DrawPanel->MouseToCursorSchema();
DrawPanel->m_IgnoreMouseEvents = FALSE; DrawPanel->m_IgnoreMouseEvents = FALSE;
if( m_ID_current_state == 0 ) if( m_ID_current_state == 0 )

8
eeschema/makefile.include
View File

@ -65,7 +65,9 @@ OBJECTS = eeschema.o\
savelib.o symbtext.o \ savelib.o symbtext.o \
symbdraw.o \ symbdraw.o \
hierarch.o files-io.o \ hierarch.o files-io.o \
annotate.o plothpgl.o \ annotate.o\
annotate_dialog.o\
plothpgl.o \
plot.o libalias.o \ plot.o libalias.o \
plotps.o netform.o \ plotps.o netform.o \
delsheet.o \ delsheet.o \
@ -110,7 +112,9 @@ find.o:find.cpp dialog_find.cpp dialog_find.h $(DEPEND)
eeconfig.o: eeconfig.cpp eeconfig.h $(DEPEND) eeconfig.o: eeconfig.cpp eeconfig.h $(DEPEND)
annotate.o: annotate.cpp annotate_dialog.cpp annotate_dialog.h $(DEPEND) netlist.h annotate.o: annotate.cpp annotate_dialog.h $(DEPEND) netlist.h
annotate_dialog.o: annotate_dialog.cpp annotate_dialog.h $(DEPEND) netlist.h
netlist.o: netlist.cpp $(DEPEND) netlist.h netlist.o: netlist.cpp $(DEPEND) netlist.h

2
eeschema/netlist.cpp
View File

@ -170,7 +170,7 @@ void* WinEDA_SchematicFrame::BuildNetListBase()
g_TabObjNet = NULL; /* Init pour le 1er passage dans ListeObjetConnection */ g_TabObjNet = NULL; /* Init pour le 1er passage dans ListeObjetConnection */
/* count nelist items */ /* count nelist items */
g_RootSheet->m_s->SetModify(); g_RootSheet->m_AssociatedScreen->SetModify();
for( sheet = SheetListList.GetFirst(); sheet != NULL; sheet = SheetListList.GetNext() ) for( sheet = SheetListList.GetFirst(); sheet != NULL; sheet = SheetListList.GetNext() )
{ {

4
eeschema/netlist_control.cpp
View File

@ -539,7 +539,7 @@ void WinEDA_NetlistFrame::GenNetlist( wxCommandEvent& event )
g_NetFormat = CurrPage->m_IdNetType; g_NetFormat = CurrPage->m_IdNetType;
/* Calculate the netlist filename */ /* Calculate the netlist filename */
FullFileName = g_RootSheet->m_s->m_FileName; FullFileName = g_RootSheet->m_AssociatedScreen->m_FileName;
switch( g_NetFormat ) switch( g_NetFormat )
{ {
@ -649,7 +649,7 @@ void WinEDA_NetlistFrame::RunSimulator( wxCommandEvent& event )
CommandLine = g_SimulatorCommandLine.AfterFirst( ' ' ); CommandLine = g_SimulatorCommandLine.AfterFirst( ' ' );
/* Calculate the netlist filename */ /* Calculate the netlist filename */
NetlistFullFileName = g_RootSheet->m_s->m_FileName; NetlistFullFileName = g_RootSheet->m_AssociatedScreen->m_FileName;
ChangeFileNameExt( NetlistFullFileName, wxT( ".cir" ) ); ChangeFileNameExt( NetlistFullFileName, wxT( ".cir" ) );
AddDelimiterString( NetlistFullFileName ); AddDelimiterString( NetlistFullFileName );
CommandLine += wxT( " " ) + NetlistFullFileName; CommandLine += wxT( " " ) + NetlistFullFileName;

6
eeschema/schedit.cpp
View File

@ -209,7 +209,7 @@ void WinEDA_SchematicFrame::Process_Special_Functions( wxCommandEvent& event )
case ID_TO_PCB: case ID_TO_PCB:
{ {
wxString Line; wxString Line;
if( g_RootSheet->m_s->m_FileName != wxEmptyString ) if( g_RootSheet->m_AssociatedScreen->m_FileName != wxEmptyString )
{ {
Line = GetScreen()->m_FileName; Line = GetScreen()->m_FileName;
AddDelimiterString( Line ); AddDelimiterString( Line );
@ -224,9 +224,9 @@ void WinEDA_SchematicFrame::Process_Special_Functions( wxCommandEvent& event )
case ID_TO_CVPCB: case ID_TO_CVPCB:
{ {
wxString Line; wxString Line;
if( g_RootSheet->m_s->m_FileName != wxEmptyString ) if( g_RootSheet->m_AssociatedScreen->m_FileName != wxEmptyString )
{ {
Line = g_RootSheet->m_s->m_FileName; Line = g_RootSheet->m_AssociatedScreen->m_FileName;
AddDelimiterString( Line ); AddDelimiterString( Line );
ChangeFileNameExt( Line, wxEmptyString ); ChangeFileNameExt( Line, wxEmptyString );
ExecuteFile( this, CVPCB_EXE, Line ); ExecuteFile( this, CVPCB_EXE, Line );

64
eeschema/schematic_undo_redo.cpp
View File

@ -90,7 +90,7 @@ void SwapData( EDA_BaseStruct* Item )
case DRAW_LABEL_STRUCT_TYPE: case DRAW_LABEL_STRUCT_TYPE:
case DRAW_GLOBAL_LABEL_STRUCT_TYPE: case DRAW_GLOBAL_LABEL_STRUCT_TYPE:
case DRAW_HIER_LABEL_STRUCT_TYPE: case DRAW_HIER_LABEL_STRUCT_TYPE:
case DRAW_TEXT_STRUCT_TYPE: case DRAW_TEXT_STRUCT_TYPE:
#undef SOURCE #undef SOURCE
#undef DEST #undef DEST
@ -286,13 +286,13 @@ void WinEDA_SchematicFrame::SaveCopyInUndoList( EDA_BaseStruct* ItemToCopy,
GetScreen()->AddItemToUndoList( NewList ); GetScreen()->AddItemToUndoList( NewList );
/* Clear redo list, because after new save there is no redo to do */ /* Clear redo list, because after new save there is no redo to do */
((SCH_SCREEN*)GetScreen())->ClearUndoORRedoList( GetScreen()->m_RedoList ); ( (SCH_SCREEN*) GetScreen() )->ClearUndoORRedoList( GetScreen()->m_RedoList );
GetScreen()->m_RedoList = NULL; GetScreen()->m_RedoList = NULL;
} }
/**********************************************************/ /**********************************************************/
bool WinEDA_SchematicFrame::GetSchematicFromRedoList() bool WinEDA_SchematicFrame::GetSchematicFromRedoList()
/**********************************************************/ /**********************************************************/
/* Redo the last edition: /* Redo the last edition:
@ -315,7 +315,7 @@ bool WinEDA_SchematicFrame::GetSchematicFromRedoList()
ReCreateHToolbar(); ReCreateHToolbar();
SetToolbars(); SetToolbars();
return TRUE; return TRUE;
} }
@ -362,7 +362,7 @@ void WinEDA_SchematicFrame::PutDataInPreviousState( DrawPickedStruct* List )
while( PickedList ) while( PickedList )
{ {
item = PickedList->m_Image; item = PickedList->m_Image;
((SCH_SCREEN*)GetScreen())->RemoveFromDrawList( item ); ( (SCH_SCREEN*) GetScreen() )->RemoveFromDrawList( item );
item->m_Flags = IS_DELETED; item->m_Flags = IS_DELETED;
PickedList->m_PickedStruct = item; PickedList->m_PickedStruct = item;
PickedList->m_Flags = IS_DELETED; PickedList->m_Flags = IS_DELETED;
@ -372,7 +372,7 @@ void WinEDA_SchematicFrame::PutDataInPreviousState( DrawPickedStruct* List )
else else
{ {
FirstItem = List->m_Image; FirstItem = List->m_Image;
((SCH_SCREEN*)GetScreen())->RemoveFromDrawList( FirstItem ); ( (SCH_SCREEN*) GetScreen() )->RemoveFromDrawList( FirstItem );
FirstItem->m_Flags = IS_DELETED; FirstItem->m_Flags = IS_DELETED;
List->m_Son = FirstItem; List->m_Son = FirstItem;
} }
@ -407,7 +407,7 @@ void WinEDA_SchematicFrame::PutDataInPreviousState( DrawPickedStruct* List )
case IS_WIRE_IMAGE: case IS_WIRE_IMAGE:
/* Exchange the current wires and the oild wires */ /* Exchange the current wires and the oild wires */
List->m_Son = ((SCH_SCREEN*)GetScreen())->ExtractWires( FALSE ); List->m_Son = ( (SCH_SCREEN*) GetScreen() )->ExtractWires( FALSE );
while( FirstItem ) while( FirstItem )
{ {
EDA_BaseStruct* nextitem = FirstItem->Pnext; EDA_BaseStruct* nextitem = FirstItem->Pnext;
@ -437,7 +437,7 @@ void WinEDA_SchematicFrame::PutDataInPreviousState( DrawPickedStruct* List )
case IS_NEW: case IS_NEW:
item = PickedList->m_Image; item = PickedList->m_Image;
((SCH_SCREEN*)GetScreen())->RemoveFromDrawList( item ); ( (SCH_SCREEN*) GetScreen() )->RemoveFromDrawList( item );
item->m_Flags = IS_DELETED; item->m_Flags = IS_DELETED;
PickedList->m_PickedStruct = item; PickedList->m_PickedStruct = item;
PickedList->m_Flags = IS_DELETED; PickedList->m_Flags = IS_DELETED;
@ -490,7 +490,7 @@ bool WinEDA_SchematicFrame::GetSchematicFromUndoList()
ReCreateHToolbar(); ReCreateHToolbar();
SetToolbars(); SetToolbars();
return TRUE; return TRUE;
} }
@ -517,7 +517,7 @@ void SCH_SCREEN::ClearUndoORRedoList( EDA_BaseStruct* List )
FirstItem = List->m_Son; FirstItem = List->m_Son;
CmdType = List->m_Flags; CmdType = List->m_Flags;
SAFE_DELETE( List ); SAFE_DELETE( List );
if( FirstItem == NULL ) if( FirstItem == NULL )
continue; continue;
@ -542,22 +542,25 @@ void SCH_SCREEN::ClearUndoORRedoList( EDA_BaseStruct* List )
{ {
if( (item->m_Flags & IS_NEW) == 0 ) if( (item->m_Flags & IS_NEW) == 0 )
{ {
printf("schematic undo_redo.cpp: undo_redo with a DRAW_SHEET_STRUCT_TYPE, checkme!!\n"); printf(
/* "schematic undo_redo.cpp: undo_redo with a DRAW_SHEET_STRUCT_TYPE, checkme!!\n" );
sheet->EEDrawList = NULL;
sheet->m_UndoList = NULL; /*
sheet->m_RedoList = NULL; * sheet->EEDrawList = NULL;
*/ * sheet->m_UndoList = NULL;
* sheet->m_RedoList = NULL;
*/
} }
} }
} }
if( (item->m_Flags & IS_NEW) == 0 ){ if( (item->m_Flags & IS_NEW) == 0 )
SAFE_DELETE( item ); {
} SAFE_DELETE( item );
}
} }
DrawPickedStruct* wrapper = PickedList; DrawPickedStruct* wrapper = PickedList;
PickedList = PickedList->Next(); PickedList = PickedList->Next();
SAFE_DELETE( wrapper ); SAFE_DELETE( wrapper );
} }
} }
else // This is a single item: deleted copy else // This is a single item: deleted copy
@ -583,18 +586,21 @@ void SCH_SCREEN::ClearUndoORRedoList( EDA_BaseStruct* List )
{ {
if( (FirstItem->m_Flags & IS_NEW) == 0 ) if( (FirstItem->m_Flags & IS_NEW) == 0 )
{ {
printf("schematic undo_redo.cpp undo_redo with a DRAW_SHEET_STRUCT_TYPE, checkme!!\n"); printf(
/* "schematic undo_redo.cpp undo_redo with a DRAW_SHEET_STRUCT_TYPE, checkme!!\n" );
sheet->EEDrawList = NULL;
sheet->m_UndoList = NULL; /*
sheet->m_RedoList = NULL; * sheet->EEDrawList = NULL;
*/ * sheet->m_UndoList = NULL;
* sheet->m_RedoList = NULL;
*/
} }
} }
} }
if( (FirstItem->m_Flags & IS_NEW) == 0 ){ if( (FirstItem->m_Flags & IS_NEW) == 0 )
SAFE_DELETE( FirstItem ); {
} SAFE_DELETE( FirstItem );
}
} }
} }
} }

21
eeschema/schframe.cpp
View File

@ -215,22 +215,22 @@ wxString WinEDA_SchematicFrame::GetScreenDesc()
} }
/******************************/ /*******************************************/
void WinEDA_SchematicFrame::CreateScreens() void WinEDA_SchematicFrame::CreateScreens()
/******************************/ /*******************************************/
{ {
/* creation des ecrans Sch , Lib */ /* creation des ecrans Sch , Lib */
if( g_RootSheet == NULL ) if( g_RootSheet == NULL )
{ {
g_RootSheet = new DrawSheetStruct(); g_RootSheet = new DrawSheetStruct();
} }
if( g_RootSheet->m_s == NULL ) if( g_RootSheet->m_AssociatedScreen == NULL )
{ {
g_RootSheet->m_s = new SCH_SCREEN( SCHEMATIC_FRAME ); g_RootSheet->m_AssociatedScreen = new SCH_SCREEN( SCHEMATIC_FRAME );
g_RootSheet->m_s->m_RefCount++; g_RootSheet->m_AssociatedScreen->m_RefCount++;
} }
g_RootSheet->m_s->m_FileName = g_DefaultSchematicFileName; g_RootSheet->m_AssociatedScreen->m_FileName = g_DefaultSchematicFileName;
g_RootSheet->m_s->m_Date = GenDate(); g_RootSheet->m_AssociatedScreen->m_Date = GenDate();
m_CurrentSheet->Clear(); m_CurrentSheet->Clear();
m_CurrentSheet->Push( g_RootSheet ); m_CurrentSheet->Push( g_RootSheet );
@ -294,10 +294,11 @@ void WinEDA_SchematicFrame::OnCloseWindow( wxCloseEvent& Event )
} }
} }
if( !GetScreen()->m_FileName.IsEmpty() && (GetScreen()->EEDrawList != NULL) ) if( !g_RootSheet->m_AssociatedScreen->m_FileName.IsEmpty() &&
SetLastProject( GetScreen()->m_FileName ); (g_RootSheet->m_AssociatedScreen->EEDrawList != NULL) )
SetLastProject( g_RootSheet->m_AssociatedScreen->m_FileName );
ClearProjectDrawList( g_RootSheet->m_s, TRUE ); ClearProjectDrawList( g_RootSheet->m_AssociatedScreen, TRUE );
/* allof sub sheets are deleted, only the main sheet is useable */ /* allof sub sheets are deleted, only the main sheet is useable */
m_CurrentSheet->Clear(); m_CurrentSheet->Clear();

141
eeschema/sheet.cpp
View File

@ -84,12 +84,12 @@ WinEDA_SheetPropertiesFrame::WinEDA_SheetPropertiesFrame()
WinEDA_SheetPropertiesFrame::WinEDA_SheetPropertiesFrame( WinEDA_SchematicFrame* parent, WinEDA_SheetPropertiesFrame::WinEDA_SheetPropertiesFrame( WinEDA_SchematicFrame* parent,
DrawSheetStruct* currentsheet, DrawSheetStruct* currentsheet,
wxWindowID id, wxWindowID id,
const wxString& caption, const wxString& caption,
const wxPoint& pos, const wxPoint& pos,
const wxSize& size, const wxSize& size,
long style ) long style )
{ {
m_Parent = parent; m_Parent = parent;
m_CurrentSheet = currentsheet; m_CurrentSheet = currentsheet;
@ -97,11 +97,11 @@ WinEDA_SheetPropertiesFrame::WinEDA_SheetPropertiesFrame( WinEDA_SchematicFrame*
AddUnitSymbol( *m_SheetNameTextSize ); AddUnitSymbol( *m_SheetNameTextSize );
PutValueInLocalUnits( *m_SheetNameSize, m_CurrentSheet->m_SheetNameSize, PutValueInLocalUnits( *m_SheetNameSize, m_CurrentSheet->m_SheetNameSize,
m_Parent->m_InternalUnits ); m_Parent->m_InternalUnits );
AddUnitSymbol( *m_FileNameTextSize ); AddUnitSymbol( *m_FileNameTextSize );
PutValueInLocalUnits( *m_FileNameSize, m_CurrentSheet->m_FileNameSize, PutValueInLocalUnits( *m_FileNameSize, m_CurrentSheet->m_FileNameSize,
m_Parent->m_InternalUnits ); m_Parent->m_InternalUnits );
} }
@ -159,52 +159,53 @@ void WinEDA_SheetPropertiesFrame::CreateControls()
itemBoxSizer3->Add( itemBoxSizer4, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5 ); itemBoxSizer3->Add( itemBoxSizer4, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5 );
wxStaticText* itemStaticText5 = new wxStaticText( itemDialog1, wxID_STATIC, _( wxStaticText* itemStaticText5 = new wxStaticText( itemDialog1, wxID_STATIC, _(
"Filename (will be created upon save if it does not already exist):" ), wxDefaultPosition, "Filename (will be created upon save if it does not already exist):" ),
wxDefaultSize, 0 ); wxDefaultPosition,
wxDefaultSize, 0 );
itemBoxSizer4->Add( itemStaticText5, itemBoxSizer4->Add( itemStaticText5,
0, 0,
wxALIGN_LEFT | wxLEFT | wxRIGHT | wxTOP | wxADJUST_MINSIZE, wxALIGN_LEFT | wxLEFT | wxRIGHT | wxTOP | wxADJUST_MINSIZE,
5 ); 5 );
m_FileNameWin = new wxTextCtrl( itemDialog1, ID_TEXTCTRL1, _T( "" ), wxDefaultPosition, m_FileNameWin = new wxTextCtrl( itemDialog1, ID_TEXTCTRL1, _T( "" ), wxDefaultPosition,
wxSize( 300, -1 ), wxTE_PROCESS_ENTER ); wxSize( 300, -1 ), wxTE_PROCESS_ENTER );
itemBoxSizer4->Add( m_FileNameWin, 0, wxALIGN_LEFT | wxLEFT | wxRIGHT | wxBOTTOM, 5 ); itemBoxSizer4->Add( m_FileNameWin, 0, wxALIGN_LEFT | wxLEFT | wxRIGHT | wxBOTTOM, 5 );
wxStaticText* itemStaticText7 = new wxStaticText( itemDialog1, wxID_STATIC, _( wxStaticText* itemStaticText7 = new wxStaticText( itemDialog1, wxID_STATIC, _(
"Sheetname:" ), wxDefaultPosition, "Sheetname:" ), wxDefaultPosition,
wxDefaultSize, 0 ); wxDefaultSize, 0 );
itemBoxSizer4->Add( itemStaticText7, itemBoxSizer4->Add( itemStaticText7,
0, 0,
wxALIGN_LEFT | wxLEFT | wxRIGHT | wxTOP | wxADJUST_MINSIZE, wxALIGN_LEFT | wxLEFT | wxRIGHT | wxTOP | wxADJUST_MINSIZE,
5 ); 5 );
m_SheetNameWin = new wxTextCtrl( itemDialog1, ID_TEXTCTRL, _T( "" ), wxDefaultPosition, m_SheetNameWin = new wxTextCtrl( itemDialog1, ID_TEXTCTRL, _T( "" ), wxDefaultPosition,
wxSize( 300, -1 ), 0 ); wxSize( 300, -1 ), 0 );
itemBoxSizer4->Add( m_SheetNameWin, 0, wxALIGN_LEFT | wxLEFT | wxRIGHT | wxBOTTOM, 5 ); itemBoxSizer4->Add( m_SheetNameWin, 0, wxALIGN_LEFT | wxLEFT | wxRIGHT | wxBOTTOM, 5 );
wxBoxSizer* itemBoxSizer9 = new wxBoxSizer( wxVERTICAL ); wxBoxSizer* itemBoxSizer9 = new wxBoxSizer( wxVERTICAL );
itemBoxSizer3->Add( itemBoxSizer9, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5 ); itemBoxSizer3->Add( itemBoxSizer9, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5 );
m_FileNameTextSize = new wxStaticText( itemDialog1, wxID_STATIC, _( m_FileNameTextSize = new wxStaticText( itemDialog1, wxID_STATIC, _(
"Size" ), wxDefaultPosition, wxDefaultSize, 0 ); "Size" ), wxDefaultPosition, wxDefaultSize, 0 );
itemBoxSizer9->Add( m_FileNameTextSize, itemBoxSizer9->Add( m_FileNameTextSize,
0, 0,
wxALIGN_LEFT | wxLEFT | wxRIGHT | wxTOP | wxADJUST_MINSIZE, wxALIGN_LEFT | wxLEFT | wxRIGHT | wxTOP | wxADJUST_MINSIZE,
5 ); 5 );
m_FileNameSize = new wxTextCtrl( itemDialog1, ID_TEXTCTRL2, _T( m_FileNameSize = new wxTextCtrl( itemDialog1, ID_TEXTCTRL2, _T(
"" ), wxDefaultPosition, wxDefaultSize, 0 ); "" ), wxDefaultPosition, wxDefaultSize, 0 );
itemBoxSizer9->Add( m_FileNameSize, 0, wxALIGN_LEFT | wxLEFT | wxRIGHT | wxBOTTOM, 5 ); itemBoxSizer9->Add( m_FileNameSize, 0, wxALIGN_LEFT | wxLEFT | wxRIGHT | wxBOTTOM, 5 );
m_SheetNameTextSize = new wxStaticText( itemDialog1, wxID_STATIC, _( m_SheetNameTextSize = new wxStaticText( itemDialog1, wxID_STATIC, _(
"Size" ), wxDefaultPosition, wxDefaultSize, 0 ); "Size" ), wxDefaultPosition, wxDefaultSize, 0 );
itemBoxSizer9->Add( m_SheetNameTextSize, itemBoxSizer9->Add( m_SheetNameTextSize,
0, 0,
wxALIGN_LEFT | wxLEFT | wxRIGHT | wxTOP | wxADJUST_MINSIZE, wxALIGN_LEFT | wxLEFT | wxRIGHT | wxTOP | wxADJUST_MINSIZE,
5 ); 5 );
m_SheetNameSize = new wxTextCtrl( itemDialog1, ID_TEXTCTRL3, _T( m_SheetNameSize = new wxTextCtrl( itemDialog1, ID_TEXTCTRL3, _T(
"" ), wxDefaultPosition, wxDefaultSize, 0 ); "" ), wxDefaultPosition, wxDefaultSize, 0 );
itemBoxSizer9->Add( m_SheetNameSize, 0, wxALIGN_LEFT | wxLEFT | wxRIGHT | wxBOTTOM, 5 ); itemBoxSizer9->Add( m_SheetNameSize, 0, wxALIGN_LEFT | wxLEFT | wxRIGHT | wxBOTTOM, 5 );
itemBoxSizer2->Add( 5, 5, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 5 ); itemBoxSizer2->Add( 5, 5, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 5 );
@ -213,12 +214,12 @@ void WinEDA_SheetPropertiesFrame::CreateControls()
itemBoxSizer2->Add( itemBoxSizer15, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 5 ); itemBoxSizer2->Add( itemBoxSizer15, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 5 );
wxButton* itemButton16 = new wxButton( itemDialog1, wxID_CANCEL, _( wxButton* itemButton16 = new wxButton( itemDialog1, wxID_CANCEL, _(
"&Cancel" ), wxDefaultPosition, wxDefaultSize, 0 ); "&Cancel" ), wxDefaultPosition, wxDefaultSize, 0 );
itemButton16->SetForegroundColour( wxColour( 0, 0, 255 ) ); itemButton16->SetForegroundColour( wxColour( 0, 0, 255 ) );
itemBoxSizer15->Add( itemButton16, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5 ); itemBoxSizer15->Add( itemButton16, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5 );
wxButton* itemButton17 = new wxButton( itemDialog1, wxID_OK, _( wxButton* itemButton17 = new wxButton( itemDialog1, wxID_OK, _(
"&OK" ), wxDefaultPosition, wxDefaultSize, 0 ); "&OK" ), wxDefaultPosition, wxDefaultSize, 0 );
itemButton17->SetForegroundColour( wxColour( 196, 0, 0 ) ); itemButton17->SetForegroundColour( wxColour( 196, 0, 0 ) );
itemBoxSizer15->Add( itemButton17, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5 ); itemBoxSizer15->Add( itemButton17, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5 );
@ -292,39 +293,45 @@ void WinEDA_SheetPropertiesFrame::SheetPropertiesAccept( wxCommandEvent& event )
{ {
m_CurrentSheet->m_FileName = FileName; m_CurrentSheet->m_FileName = FileName;
if( wxFileExists( FileName ) )//do we reload the data from the existing file if( wxFileExists( FileName ) ) //do we reload the data from the existing file
{ {
msg.Printf( _( "A file named %s exists, load it (otherwise overwrite it)?" ), FileName.GetData() ); msg.Printf( _(
"A file named %s exists, load it (otherwise overwrite it)?" ),
FileName.GetData() );
if( IsOK( this, msg ) ) if( IsOK( this, msg ) )
{ {
if( m_CurrentSheet->m_s ){ if( m_CurrentSheet->m_AssociatedScreen )
m_CurrentSheet->m_s->m_RefCount--; {
if( m_CurrentSheet->m_s->m_RefCount == 0) m_CurrentSheet->m_AssociatedScreen->m_RefCount--;
SAFE_DELETE(m_CurrentSheet->m_s); if( m_CurrentSheet->m_AssociatedScreen->m_RefCount == 0 )
} SAFE_DELETE( m_CurrentSheet->m_AssociatedScreen );
m_CurrentSheet->m_s = NULL; //so that we reload.. }
m_CurrentSheet->Load(m_Parent); m_CurrentSheet->m_AssociatedScreen = NULL; //so that we reload..
m_CurrentSheet->Load( m_Parent );
} }
}else{ }
//just make a new screen if needed. else
if( !m_CurrentSheet->m_s ){ {
m_CurrentSheet->m_s = new SCH_SCREEN(SCHEMATIC_FRAME); //just make a new screen if needed.
m_CurrentSheet->m_s->m_RefCount++; //be careful with these if( !m_CurrentSheet->m_AssociatedScreen )
m_CurrentSheet->m_s->m_FileName = FileName; {
} m_CurrentSheet->m_AssociatedScreen = new SCH_SCREEN( SCHEMATIC_FRAME );
} m_CurrentSheet->m_AssociatedScreen->m_RefCount++; //be careful with these
m_CurrentSheet->m_AssociatedScreen->m_FileName = FileName;
}
}
} }
msg = m_FileNameSize->GetValue(); msg = m_FileNameSize->GetValue();
m_CurrentSheet->m_FileNameSize = m_CurrentSheet->m_FileNameSize =
ReturnValueFromString( g_UnitMetric, ReturnValueFromString( g_UnitMetric,
msg, m_Parent->m_InternalUnits ); msg, m_Parent->m_InternalUnits );
m_CurrentSheet->m_SheetName = m_SheetNameWin->GetValue(); m_CurrentSheet->m_SheetName = m_SheetNameWin->GetValue();
msg = m_SheetNameSize->GetValue(); msg = m_SheetNameSize->GetValue();
m_CurrentSheet->m_SheetNameSize = m_CurrentSheet->m_SheetNameSize =
ReturnValueFromString( g_UnitMetric, ReturnValueFromString( g_UnitMetric,
msg, m_Parent->m_InternalUnits ); msg, m_Parent->m_InternalUnits );
if( ( m_CurrentSheet->m_SheetName.IsEmpty() ) ) if( ( m_CurrentSheet->m_SheetName.IsEmpty() ) )
m_CurrentSheet->m_SheetName = m_CurrentSheet->m_FileName; m_CurrentSheet->m_SheetName = m_CurrentSheet->m_FileName;
@ -368,19 +375,19 @@ DrawSheetStruct* WinEDA_SchematicFrame::CreateSheet( wxDC* DC )
{ {
g_ItemToRepeat = NULL; g_ItemToRepeat = NULL;
DrawSheetStruct* Sheet = new DrawSheetStruct( GetScreen()->m_Curseur ); DrawSheetStruct* Sheet = new DrawSheetStruct( GetScreen()->m_Curseur );
Sheet->m_Flags = IS_NEW | IS_RESIZED; Sheet->m_Flags = IS_NEW | IS_RESIZED;
Sheet->m_TimeStamp = GetTimeStamp(); Sheet->m_TimeStamp = GetTimeStamp();
Sheet->m_Parent = GetScreen(); Sheet->m_Parent = GetScreen();
Sheet->m_s = NULL; Sheet->m_AssociatedScreen = NULL;
s_SheetMindx = SHEET_MIN_WIDTH; s_SheetMindx = SHEET_MIN_WIDTH;
s_SheetMindy = SHEET_MIN_HEIGHT; s_SheetMindy = SHEET_MIN_HEIGHT;
//need to check if this is being added to the EEDrawList. //need to check if this is being added to the EEDrawList.
//also need to update the heirarchy, if we are adding //also need to update the heirarchy, if we are adding
// a sheet to a screen that already has multiple instances (!) // a sheet to a screen that already has multiple instances (!)
GetScreen()->SetCurItem( Sheet ); GetScreen()->SetCurItem( Sheet );
DrawPanel->ManageCurseur = DeplaceSheet; DrawPanel->ManageCurseur = DeplaceSheet;
DrawPanel->ForceCloseManageCurseur = ExitSheet; DrawPanel->ForceCloseManageCurseur = ExitSheet;
@ -422,7 +429,7 @@ void WinEDA_SchematicFrame::ReSizeSheet( DrawSheetStruct* Sheet, wxDC* DC )
while( sheetlabel ) while( sheetlabel )
{ {
s_SheetMindx = MAX( s_SheetMindx, s_SheetMindx = MAX( s_SheetMindx,
(int) ( (sheetlabel->GetLength() + 1) * sheetlabel->m_Size.x ) ); (int) ( (sheetlabel->GetLength() + 1) * sheetlabel->m_Size.x ) );
s_SheetMindy = MAX( s_SheetMindy, sheetlabel->m_Pos.y - Sheet->m_Pos.y ); s_SheetMindy = MAX( s_SheetMindy, sheetlabel->m_Pos.y - Sheet->m_Pos.y );
sheetlabel = (DrawSheetLabelStruct*) sheetlabel->Pnext; sheetlabel = (DrawSheetLabelStruct*) sheetlabel->Pnext;
} }
@ -462,7 +469,7 @@ static void DeplaceSheet( WinEDA_DrawPanel* panel, wxDC* DC, bool erase )
{ {
wxPoint move_vector; wxPoint move_vector;
DrawSheetLabelStruct* SheetLabel; DrawSheetLabelStruct* SheetLabel;
BASE_SCREEN* screen = panel->m_Parent->GetScreen(); BASE_SCREEN* screen = panel->m_Parent->GetScreen();
DrawSheetStruct* Sheet = (DrawSheetStruct*) DrawSheetStruct* Sheet = (DrawSheetStruct*)
screen->GetCurItem(); screen->GetCurItem();
@ -474,9 +481,9 @@ static void DeplaceSheet( WinEDA_DrawPanel* panel, wxDC* DC, bool erase )
if( Sheet->m_Flags & IS_RESIZED ) if( Sheet->m_Flags & IS_RESIZED )
{ {
Sheet->m_Size.x = MAX( s_SheetMindx, Sheet->m_Size.x = MAX( s_SheetMindx,
screen->m_Curseur.x - Sheet->m_Pos.x ); screen->m_Curseur.x - Sheet->m_Pos.x );
Sheet->m_Size.y = MAX( s_SheetMindy, Sheet->m_Size.y = MAX( s_SheetMindy,
screen->m_Curseur.y - Sheet->m_Pos.y ); screen->m_Curseur.y - Sheet->m_Pos.y );
SheetLabel = Sheet->m_Label; SheetLabel = Sheet->m_Label;
while( SheetLabel ) while( SheetLabel )
{ {
@ -496,7 +503,6 @@ static void DeplaceSheet( WinEDA_DrawPanel* panel, wxDC* DC, bool erase )
} }
/****************************************/ /****************************************/
/* Routine de sortie du Menu de Sheet */ /* Routine de sortie du Menu de Sheet */
/****************************************/ /****************************************/
@ -512,9 +518,9 @@ static void ExitSheet( WinEDA_DrawPanel* Panel, wxDC* DC )
if( Sheet->m_Flags & IS_NEW ) /* Nouveau Placement en cours, on l'efface */ if( Sheet->m_Flags & IS_NEW ) /* Nouveau Placement en cours, on l'efface */
{ {
RedrawOneStruct( Panel, DC, Sheet, g_XorMode ); RedrawOneStruct( Panel, DC, Sheet, g_XorMode );
SAFE_DELETE( Sheet ); SAFE_DELETE( Sheet );
} }
else if( Sheet->m_Flags & IS_RESIZED )/* resize en cours: on l'annule */ else if( Sheet->m_Flags & IS_RESIZED ) /* resize en cours: on l'annule */
{ {
RedrawOneStruct( Panel, DC, Sheet, g_XorMode ); RedrawOneStruct( Panel, DC, Sheet, g_XorMode );
Sheet->m_Size.x = s_OldPos.x; Sheet->m_Size.x = s_OldPos.x;
@ -522,10 +528,10 @@ static void ExitSheet( WinEDA_DrawPanel* Panel, wxDC* DC )
RedrawOneStruct( Panel, DC, Sheet, GR_DEFAULT_DRAWMODE ); RedrawOneStruct( Panel, DC, Sheet, GR_DEFAULT_DRAWMODE );
Sheet->m_Flags = 0; Sheet->m_Flags = 0;
} }
else if( Sheet->m_Flags & IS_MOVED )/* move en cours: on l'annule */ else if( Sheet->m_Flags & IS_MOVED ) /* move en cours: on l'annule */
{ {
wxPoint curspos = Screen->m_Curseur; wxPoint curspos = Screen->m_Curseur;
Panel->m_Parent->GetScreen()->m_Curseur = s_OldPos; Panel->m_Parent->GetScreen()->m_Curseur = s_OldPos;
DeplaceSheet( Panel, DC, TRUE ); DeplaceSheet( Panel, DC, TRUE );
RedrawOneStruct( Panel, DC, Sheet, GR_DEFAULT_DRAWMODE ); RedrawOneStruct( Panel, DC, Sheet, GR_DEFAULT_DRAWMODE );
Sheet->m_Flags = 0; Sheet->m_Flags = 0;
@ -540,7 +546,6 @@ static void ExitSheet( WinEDA_DrawPanel* Panel, wxDC* DC )
} }
/*! /*!
* wxEVT_COMMAND_BUTTON_CLICKED event handler for wxID_CANCEL * wxEVT_COMMAND_BUTTON_CLICKED event handler for wxID_CANCEL
*/ */

4
eeschema/sheetlab.cpp
View File

@ -358,8 +358,8 @@ DrawSheetLabelStruct* WinEDA_SchematicFrame::Import_PinSheet( DrawSheetStruct* S
DrawSheetLabelStruct* NewSheetLabel, * SheetLabel = NULL; DrawSheetLabelStruct* NewSheetLabel, * SheetLabel = NULL;
DrawHierLabelStruct* HLabel = NULL; DrawHierLabelStruct* HLabel = NULL;
if(!Sheet->m_s) return NULL; if(!Sheet->m_AssociatedScreen) return NULL;
DrawStruct = Sheet->m_s->EEDrawList; DrawStruct = Sheet->m_AssociatedScreen->EEDrawList;
HLabel = NULL; HLabel = NULL;
for( ; DrawStruct != NULL; DrawStruct = DrawStruct->Pnext ) for( ; DrawStruct != NULL; DrawStruct = DrawStruct->Pnext )
{ {

BIN
internat/fr/kicad.mo
View File

Binary file not shown.

999
internat/fr/kicad.po
View File

File diff suppressed because it is too large Load Diff

BIN
internat/sv/kicad.mo Normal file
View File

Binary file not shown.

10081
internat/sv/kicad.po Normal file
View File

File diff suppressed because it is too large Load Diff

10
pcbnew/gendrill.cpp
View File

@ -63,9 +63,9 @@ static std::vector<HOLE_INFO> s_HoleListBuffer;
#include "dialog_gendrill.cpp" // Dialog box for drill file generation #include "dialog_gendrill.cpp" // Dialog box for drill file generation
/**********************************************/ /************************************************/
void WinEDA_DrillFrame::InitDisplayParams( void ) void WinEDA_DrillFrame::InitDisplayParams( void )
/**********************************************/ /************************************************/
/* some param values initialisation before display dialog window /* some param values initialisation before display dialog window
*/ */
@ -121,8 +121,6 @@ void WinEDA_DrillFrame::InitDisplayParams( void )
m_MicroViasDrillSizer->Enable( m_MicroViasCount ); m_MicroViasDrillSizer->Enable( m_MicroViasCount );
m_MicroViaDrillValue->Enable( m_MicroViasCount ); m_MicroViaDrillValue->Enable( m_MicroViasCount );
/* Display statistics */
// Pads holes cound: // Pads holes cound:
m_PadsHoleCount = 0; m_PadsHoleCount = 0;
for( MODULE* module = m_Parent->m_Pcb->m_Modules; module != NULL; module = module->Next() ) for( MODULE* module = m_Parent->m_Pcb->m_Modules; module != NULL; module = module->Next() )
@ -133,10 +131,10 @@ void WinEDA_DrillFrame::InitDisplayParams( void )
{ {
if( pad->m_Drill.x != 0 ) if( pad->m_Drill.x != 0 )
m_PadsHoleCount++; m_PadsHoleCount++;
else }
else
if( MIN( pad->m_Drill.x, pad->m_Drill.y ) != 0 ) if( MIN( pad->m_Drill.x, pad->m_Drill.y ) != 0 )
m_PadsHoleCount++; m_PadsHoleCount++;
}
} }
} }