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
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>
================================================================================
+eeschema

12
eeschema/annotate.cpp
View File

@ -34,9 +34,6 @@ void ReAnnotatePowerSymbolsOnly( void )
/* Build the screen list (screen, not sheet) */
EDA_SheetList SheetList( NULL );
/* Update the screen number, sheet count and date */
//ScreenList.UpdateScreenNumberAndDate();
DrawSheetList* sheet;
int CmpNumber = 1;
@ -161,7 +158,7 @@ void DeleteAnnotation( WinEDA_SchematicFrame* parent, bool annotateSchematic )
sheet->DeleteAnnotation( annotateSchematic );
g_RootSheet->m_s->SetModify();
g_RootSheet->m_AssociatedScreen->SetModify();
parent->DrawPanel->Refresh( true );
}
@ -192,10 +189,11 @@ void AnnotateComponents( WinEDA_SchematicFrame* parent,
/* Build the sheet list */
EDA_SheetList SheetList( g_RootSheet );
/* Update the sheet number */
ii = 0;
/* Update the screen number, sheet count and date */
SheetList.UpdateSheetNumberAndDate();
/* First pass: Component counting */
ii = 0;
sheet = parent->GetSheet();
if( annotateSchematic )
{
@ -595,7 +593,7 @@ int CheckAnnotate( WinEDA_SchematicFrame* frame, bool oneSheetOnly )
/* build the screen list */
EDA_SheetList SheetList( NULL );
g_RootSheet->m_s->SetModify();
g_RootSheet->m_AssociatedScreen->SetModify();
ii = 0;
/* 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 " \
"and cannot be undone." );
response = wxMessageBox( message, _( "" ),
response = wxMessageBox( message, wxT( "" ),
wxICON_EXCLAMATION | wxOK | wxCANCEL );
if (response == wxCANCEL)
return;
@ -283,7 +283,7 @@ void WinEDA_AnnotateFrame::OnApply( wxCommandEvent& event )
message += _( "\n\nThis operation will change the current annotation and " \
"cannot be undone." );
response = wxMessageBox( message, _( "" ),
response = wxMessageBox( message, wxT( "" ),
wxICON_EXCLAMATION | wxOK | wxCANCEL );
if (response == wxCANCEL)
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:
{
//DuplicateStruct calls GenCopy, which should handle
//m_s and m_sRefCount properly.
//m_AssociatedScreen and m_sRefCount properly.
DrawSheetStruct* sheet = (DrawSheetStruct*) Struct;
sheet->m_TimeStamp = GetTimeStamp();
//sheet->m_s->m_UndoList = NULL;
//sheet->m_s->m_RedoList = NULL;
//keep m_s pointer & associated.
//sheet->m_AssociatedScreen->m_UndoList = NULL;
//sheet->m_AssociatedScreen->m_RedoList = NULL;
//keep m_AssociatedScreen pointer & associated.
//sheet->m_Son = NULL; m_son is involved in undo and redo.
break;
}

350
eeschema/class_drawsheet.cpp
View File

@ -43,9 +43,12 @@ DrawSheetStruct::DrawSheetStruct( const wxPoint& pos ) :
m_Layer = LAYER_SHEET;
m_Pos = pos;
m_SheetNameSize = m_FileNameSize = 60;
m_s = NULL;
m_SheetName = wxT("Root");
m_FileName = wxT(" ");
m_AssociatedScreen = NULL;
m_SheetName = wxT( "Root" );
m_FileName = wxT( " " );
m_SheetNumber = 1;
m_NumberOfSheets = 1;
}
@ -54,7 +57,9 @@ DrawSheetStruct::~DrawSheetStruct()
/**************************************/
{
DrawSheetLabelStruct* label = m_Label, * next_label;
while( label ){
while( label )
{
next_label = (DrawSheetLabelStruct*) label->Pnext;
delete label;
label = next_label;
@ -62,13 +67,15 @@ DrawSheetStruct::~DrawSheetStruct()
//also, look at the associated sheet & its reference count
//perhaps it should be deleted also.
if(m_s){
m_s->m_RefCount--;
if(m_s->m_RefCount == 0)
delete m_s;
if( m_AssociatedScreen )
{
m_AssociatedScreen->m_RefCount--;
if( m_AssociatedScreen->m_RefCount == 0 )
delete m_AssociatedScreen;
}
}
/***********************************************/
DrawSheetStruct* DrawSheetStruct::GenCopy()
/***********************************************/
@ -91,7 +98,7 @@ DrawSheetStruct* DrawSheetStruct::GenCopy()
newitem->m_Label = NULL;
DrawSheetLabelStruct* Slabel = NULL, *label = m_Label;
DrawSheetLabelStruct* Slabel = NULL, * label = m_Label;
if( label )
{
@ -109,9 +116,9 @@ DrawSheetStruct* DrawSheetStruct::GenCopy()
}
/* don't copy screen data - just reference it. */
newitem->m_s = m_s;
if(m_s)
m_s->m_RefCount++;
newitem->m_AssociatedScreen = m_AssociatedScreen;
if( m_AssociatedScreen )
m_AssociatedScreen->m_RefCount++;
return newitem;
}
@ -120,6 +127,7 @@ DrawSheetStruct* DrawSheetStruct::GenCopy()
/**********************************************************/
void DrawSheetStruct::SwapData( DrawSheetStruct* copyitem )
/**********************************************************/
/* Used if undo / redo command:
* swap data between this and copyitem
*/
@ -132,6 +140,8 @@ void DrawSheetStruct::SwapData( DrawSheetStruct* copyitem )
EXCHG( m_Label, copyitem->m_Label );
EXCHG( m_NbLabel, copyitem->m_NbLabel );
}
/****************************************************************/
void DrawSheetStruct::Place( WinEDA_DrawFrame* frame, wxDC* DC )
/****************************************************************/
@ -152,9 +162,12 @@ void DrawSheetStruct::Place( WinEDA_DrawFrame* frame, wxDC* DC )
EDA_BaseStruct::Place( frame, DC ); //puts it on the EEDrawList.
}
/********************************************************************/
void DrawSheetStruct::CleanupSheet( WinEDA_SchematicFrame* frame, wxDC* DC )
/********************************************************************/
/* Delete pinsheets which are not corresponding to a hierarchal label
* if DC != NULL, redraw Sheet
*/
@ -169,7 +182,7 @@ void DrawSheetStruct::CleanupSheet( WinEDA_SchematicFrame* frame, wxDC* DC )
{
/* Search Hlabel corresponding to this Pinsheet */
EDA_BaseStruct* DrawStruct = m_s->EEDrawList;
EDA_BaseStruct* DrawStruct = m_AssociatedScreen->EEDrawList;
DrawHierLabelStruct* HLabel = NULL;
for( ; DrawStruct != NULL; DrawStruct = DrawStruct->Pnext )
{
@ -191,6 +204,7 @@ void DrawSheetStruct::CleanupSheet( WinEDA_SchematicFrame* frame, wxDC* DC )
}
}
/**************************************************************************************/
void DrawSheetStruct::Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset,
int DrawMode, int Color )
@ -247,65 +261,85 @@ void DrawSheetStruct::Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& of
}
}
/**************************************************************************************/
void DrawSheetStruct::DeleteAnnotation( bool recurse )
/**************************************************************************************/
{
if(recurse && m_s){
EDA_BaseStruct* strct = m_s->EEDrawList;
for(; strct; strct = strct->Pnext){
if(strct->Type() == DRAW_SHEET_STRUCT_TYPE){
DrawSheetStruct* sheet = (DrawSheetStruct*)strct;
sheet->DeleteAnnotation(recurse);
if( recurse && m_AssociatedScreen )
{
EDA_BaseStruct* strct = m_AssociatedScreen->EEDrawList;
for( ; strct; strct = strct->Pnext )
{
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 )
{
( (EDA_SchComponentStruct*) comp )->ClearAnnotation();
}
}
}
/*******************************************************************/
int DrawSheetStruct::ComponentCount( )
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_s){
if( m_AssociatedScreen )
{
EDA_BaseStruct* bs;
for( bs = m_s->EEDrawList; bs != NULL; bs = bs->Pnext ){
if( bs->Type() == DRAW_LIB_ITEM_STRUCT_TYPE ){
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;
if( bs->Type() == DRAW_SHEET_STRUCT_TYPE )
{
DrawSheetStruct* sheet = (DrawSheetStruct*) bs;
n += sheet->ComponentCount();
}
}
}
return n;
}
/*******************************************************************************/
bool DrawSheetStruct::SearchHierarchy(wxString filename, SCH_SCREEN **screen)
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;
if( m_AssociatedScreen )
{
EDA_BaseStruct* strct = m_AssociatedScreen->EEDrawList;
while( strct )
{
if( strct->Type() == DRAW_SHEET_STRUCT_TYPE )
{
DrawSheetStruct* ss = (DrawSheetStruct*) strct;
if( ss->m_AssociatedScreen && ss->m_AssociatedScreen->m_FileName.CmpNoCase( filename ) == 0 )
{
*screen = ss->m_AssociatedScreen;
return true;
}
if(ss->SearchHierarchy(filename, screen))
if( ss->SearchHierarchy( filename, screen ) )
return true;
}
strct = strct->Pnext;
@ -313,8 +347,10 @@ bool DrawSheetStruct::SearchHierarchy(wxString filename, SCH_SCREEN **screen)
}
return false;
}
/*******************************************************************************/
bool DrawSheetStruct::LocatePathOfScreen(SCH_SCREEN *screen, DrawSheetList* list)
bool DrawSheetStruct::LocatePathOfScreen( SCH_SCREEN* screen, DrawSheetList* list )
/*******************************************************************************/
{
//search the existing hierarchy for an instance of screen "FileName".
@ -322,45 +358,57 @@ bool DrawSheetStruct::LocatePathOfScreen(SCH_SCREEN *screen, DrawSheetList* list
//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)
if( m_AssociatedScreen )
{
list->Push( this );
if( m_AssociatedScreen == 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))
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)
bool DrawSheetStruct::Load( WinEDA_SchematicFrame* frame )
/*******************************************************************************/
{
if(!m_s){
if( !m_AssociatedScreen )
{
SCH_SCREEN* screen = NULL;
g_RootSheet->SearchHierarchy(m_FileName, &screen);
if(screen){
m_s = screen;
m_s->m_RefCount++;
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_s = new SCH_SCREEN(SCHEMATIC_FRAME);
m_s->m_RefCount++;
if(!frame->LoadOneEEFile(m_s, m_FileName))
}
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_s->EEDrawList;
while(bs){
if(bs->Type() == DRAW_SHEET_STRUCT_TYPE){
DrawSheetStruct* ss = (DrawSheetStruct*)bs;
if(!ss->Load(frame))
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;
@ -369,16 +417,22 @@ bool DrawSheetStruct::Load(WinEDA_SchematicFrame* frame)
}
return true;
}
/*******************************************************************************/
int DrawSheetStruct::CountSheets()
/*******************************************************************************/
{
int count = 1; //1 = this!!
if(m_s){
EDA_BaseStruct* strct = m_s->EEDrawList;
for(; strct; strct = strct->Pnext){
if(strct->Type() == DRAW_SHEET_STRUCT_TYPE){
DrawSheetStruct* ss = (DrawSheetStruct*)strct;
if( m_AssociatedScreen )
{
EDA_BaseStruct* strct = m_AssociatedScreen->EEDrawList;
for( ; strct; strct = strct->Pnext )
{
if( strct->Type() == DRAW_SHEET_STRUCT_TYPE )
{
DrawSheetStruct* ss = (DrawSheetStruct*) strct;
count += ss->CountSheets();
}
}
@ -394,8 +448,8 @@ int DrawSheetStruct::CountSheets()
/*******************************************************************/
DrawSheetLabelStruct::DrawSheetLabelStruct( DrawSheetStruct* parent,
const wxPoint& pos, const wxString& text ) :
EDA_BaseStruct( DRAW_SHEETLABEL_STRUCT_TYPE ),
EDA_TextStruct( text )
EDA_BaseStruct( DRAW_SHEETLABEL_STRUCT_TYPE )
, EDA_TextStruct( text )
/*******************************************************************/
{
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 */
}
/**********************************************/
/* class to handle a series of sheets *********/
/* a 'path' so to speak.. *********************/
/**********************************************/
DrawSheetList::DrawSheetList(){
for(int i=0; i<DSLSZ ; i++)
DrawSheetList::DrawSheetList()
{
for( int i = 0; i<DSLSZ; i++ )
m_sheets[i] = NULL;
m_numSheets = 0;
}
int DrawSheetList::Cmp(DrawSheetList& d){
if(m_numSheets > d.m_numSheets)
int DrawSheetList::Cmp( DrawSheetList& d )
{
if( m_numSheets > d.m_numSheets )
return 1;
if(m_numSheets < d.m_numSheets)
if( m_numSheets < d.m_numSheets )
return -1;
//otherwise, same number of sheets.
for(int i=0; i<m_numSheets; i++){
if(m_sheets[i]->m_TimeStamp > d.m_sheets[i]->m_TimeStamp)
for( int i = 0; i<m_numSheets; i++ )
{
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)
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()
{
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()
{
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()
{
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){
void DrawSheetList::Push( DrawSheetStruct* sheet )
{
if( m_numSheets < DSLSZ )
{
m_sheets[m_numSheets] = sheet;
m_numSheets++;
}
}
DrawSheetStruct* DrawSheetList::Pop(){
if(m_numSheets > 0){
m_numSheets --;
DrawSheetStruct* DrawSheetList::Pop()
{
if( m_numSheets > 0 )
{
m_numSheets--;
return m_sheets[m_numSheets];
}
return NULL;
}
wxString DrawSheetList::Path(){
wxString DrawSheetList::Path()
{
wxString s, t;
s = wxT("/");
s = wxT( "/" );
//start at 1 to avoid the root sheet,
//which does not need to be added to the path
//it's timestamp changes anyway.
for(int i=1; i< m_numSheets; i++){
t.Printf(_("%8.8lX/"), m_sheets[i]->m_TimeStamp);
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 DrawSheetList::PathHumanReadable()
{
wxString s, t;
s = wxT("/");
s = wxT( "/" );
//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("/");
for( int i = 1; i< m_numSheets; i++ )
{
s = s + m_sheets[i]->m_SheetName + wxT( "/" );
}
return s;
}
void DrawSheetList::UpdateAllScreenReferences(){
void DrawSheetList::UpdateAllScreenReferences()
{
EDA_BaseStruct* t = LastDrawList();
while(t){
if(t->Type() == DRAW_LIB_ITEM_STRUCT_TYPE){
EDA_SchComponentStruct* d = (EDA_SchComponentStruct*)t;
d->m_Field[REFERENCE].m_Text = d->GetRef(this);
while( t )
{
if( t->Type() == DRAW_LIB_ITEM_STRUCT_TYPE )
{
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()) );
printf( "on sheet: %s \n", CONV_TO_UTF8( PathHumanReadable() ) );
}
bool DrawSheetList::operator= (const DrawSheetList& d1){
bool DrawSheetList::operator=( const DrawSheetList& d1 )
{
m_numSheets = d1.m_numSheets;
int i;
for(i=0; i<m_numSheets; i++){
for( i = 0; i<m_numSheets; i++ )
{
m_sheets[i] = d1.m_sheets[i];
}
for(; i<DSLSZ; i++){
for( ; i<DSLSZ; i++ )
{
m_sheets[i] = 0;
}
return true;
}
bool DrawSheetList::operator==(const DrawSheetList &d1){
if(m_numSheets != d1.m_numSheets)
bool DrawSheetList::operator==( const DrawSheetList& d1 )
{
if( m_numSheets != d1.m_numSheets )
return false;
for(int i=0; i<m_numSheets; i++){
if(m_sheets[i] != d1.m_sheets[i])
for( int i = 0; i<m_numSheets; i++ )
{
if( m_sheets[i] != d1.m_sheets[i] )
return false;
}
return true;
}
bool DrawSheetList::operator!=(const DrawSheetList &d1){
if(m_numSheets != d1.m_numSheets)
bool DrawSheetList::operator!=( const DrawSheetList& d1 )
{
if( m_numSheets != d1.m_numSheets )
return true;
for(int i=0; i<m_numSheets; i++){
if(m_sheets[i] != d1.m_sheets[i])
for( int i = 0; i<m_numSheets; i++ )
{
if( m_sheets[i] != d1.m_sheets[i] )
return true;
}
return false;
}

162
eeschema/class_screen.cpp
View File

@ -51,9 +51,9 @@ void EDA_BaseStruct::Place( WinEDA_DrawFrame* frame, wxDC* DC )
{
if( m_Flags & IS_NEW )
{
SCH_SCREEN* screen = (SCH_SCREEN*)frame->GetScreen();
if(!screen->CheckIfOnDrawList(this)) //don't want a loop!
screen->AddToDrawList(this);
SCH_SCREEN* screen = (SCH_SCREEN*) frame->GetScreen();
if( !screen->CheckIfOnDrawList( this ) ) //don't want a loop!
screen->AddToDrawList( this );
g_ItemToRepeat = this;
if( frame->m_Ident == SCHEMATIC_FRAME )
( (WinEDA_SchematicFrame*) frame )->SaveCopyInUndoList( this, IS_NEW );
@ -117,8 +117,9 @@ void SCH_SCREEN::FreeDrawList()
{
DrawStruct = EEDrawList;
EEDrawList = EEDrawList->Pnext;
SAFE_DELETE(DrawStruct);
SAFE_DELETE( DrawStruct );
}
EEDrawList = NULL;
}
@ -147,18 +148,25 @@ void SCH_SCREEN::RemoveFromDrawList( EDA_BaseStruct* DrawStruct )
}
}
}
/**************************************************************/
bool SCH_SCREEN::CheckIfOnDrawList( EDA_BaseStruct* st )
/**************************************************************/
{
EDA_BaseStruct* DrawList = EEDrawList;
while( DrawList ){
if( DrawList == st)
while( DrawList )
{
if( DrawList == st )
return true;
DrawList = DrawList->Pnext;
}
return false;
}
/**************************************************************/
void SCH_SCREEN::AddToDrawList( EDA_BaseStruct* st )
/**************************************************************/
@ -167,6 +175,7 @@ void SCH_SCREEN::AddToDrawList( EDA_BaseStruct* st )
EEDrawList = st;
}
/*********************************************************************/
/* Class EDA_ScreenList to handle the list of screens in a hierarchy */
/*********************************************************************/
@ -176,18 +185,19 @@ SCH_SCREEN* EDA_ScreenList::GetFirst()
/*****************************************/
{
m_Index = 0;
if(m_List.GetCount() > 0)
if( m_List.GetCount() > 0 )
return m_List[0];
return NULL;
}
/*****************************************/
SCH_SCREEN* EDA_ScreenList::GetNext()
/*****************************************/
{
if( m_Index < m_List.GetCount() )
m_Index++;
return GetScreen(m_Index);
return GetScreen( m_Index );
}
@ -202,54 +212,55 @@ SCH_SCREEN* EDA_ScreenList::GetScreen( unsigned int index )
return m_List[index];
return NULL;
}
/************************************************/
void EDA_ScreenList::AddScreenToList( SCH_SCREEN* testscreen )
/************************************************/
{
if(testscreen == NULL) return;
for(unsigned int i=0; i< m_List.GetCount(); i++){
if(m_List[i] == testscreen)
if( testscreen == NULL )
return;
for( unsigned int i = 0; i< m_List.GetCount(); i++ )
{
if( m_List[i] == testscreen )
return;
}
m_List.Add(testscreen);
m_List.Add( testscreen );
#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
}
/************************************************/
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){
DrawSheetStruct* ds = (DrawSheetStruct*)s;
s = ds->m_s;
if( s && s->Type() == DRAW_SHEET_STRUCT_TYPE )
{
DrawSheetStruct* ds = (DrawSheetStruct*) s;
s = ds->m_AssociatedScreen;
}
if(s && s->Type() == SCREEN_STRUCT_TYPE){
SCH_SCREEN* screen = (SCH_SCREEN*)s;
AddScreenToList(screen);
if( s && s->Type() == SCREEN_STRUCT_TYPE )
{
SCH_SCREEN* screen = (SCH_SCREEN*) s;
AddScreenToList( screen );
EDA_BaseStruct* strct = screen->EEDrawList;
while(strct){
if(strct->Type() == DRAW_SHEET_STRUCT_TYPE){
BuildScreenList(strct);
while( strct )
{
if( strct->Type() == DRAW_SHEET_STRUCT_TYPE )
{
BuildScreenList( strct );
}
strct = strct->Pnext;
}
}
}
/*********************************************************************/
/* Class EDA_SheetList to handle the list of Sheets in a hierarchy */
/*********************************************************************/
@ -259,23 +270,26 @@ DrawSheetList* EDA_SheetList::GetFirst()
/*****************************************/
{
m_index = 0;
if(m_count > 0)
if( m_count > 0 )
return &( m_List[0] );
return NULL;
}
/*****************************************/
DrawSheetList* EDA_SheetList::GetNext()
/*****************************************/
{
if( m_index < m_count )
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
*/
{
@ -284,32 +298,80 @@ DrawSheetList* EDA_SheetList::GetSheet(int index )
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;
m_index = 0;
if(m_List) free(m_List); m_List = NULL;
if( m_List )
free( m_List );m_List = NULL;
count *= sizeof(DrawSheetList);
m_List = (DrawSheetList*)MyZMalloc(count);
memset((void*)m_List, 0, count);
m_List = (DrawSheetList*) MyZMalloc( count );
memset( (void*) m_List, 0, count );
m_currList.Clear();
}
m_currList.Push(sheet);
m_currList.Push( sheet );
m_List[m_index] = m_currList;
m_index++;
if(sheet->m_s != NULL){
if( sheet->m_AssociatedScreen != NULL )
{
EDA_BaseStruct* strct = m_currList.LastDrawList();
while(strct){
if(strct->Type() == DRAW_SHEET_STRUCT_TYPE){
DrawSheetStruct* sht = (DrawSheetStruct*)strct;
BuildSheetList(sht);
while( strct )
{
if( strct->Type() == DRAW_SHEET_STRUCT_TYPE )
{
DrawSheetStruct* sht = (DrawSheetStruct*) strct;
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;
}

104
eeschema/class_screen.h
View File

@ -33,13 +33,14 @@ public:
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 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 );
void AddToDrawList( EDA_BaseStruct* DrawStruct );
void ClearUndoORRedoList( EDA_BaseStruct* List );
@ -54,12 +55,13 @@ public:
};
class DrawSheetLabelStruct : public EDA_BaseStruct, public EDA_TextStruct
class DrawSheetLabelStruct : public EDA_BaseStruct
, public EDA_TextStruct
{
public:
int m_Layer;
int m_Edge, m_Shape;
bool m_IsDangling; // TRUE si non connect<63>
bool m_IsDangling; // TRUE non connected
public:
DrawSheetLabelStruct( DrawSheetStruct* parent,
@ -69,9 +71,10 @@ public:
~DrawSheetLabelStruct() { }
virtual wxString GetClass() const
{
return wxT("DrawSheetLabelStruct");
return wxT( "DrawSheetLabelStruct" );
}
DrawSheetLabelStruct* GenCopy();
DrawSheetLabelStruct* Next()
@ -82,7 +85,11 @@ public:
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 */
{
@ -100,16 +107,21 @@ public:
int m_Layer;
DrawSheetLabelStruct* m_Label; /* Points de connection, linked list.*/
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:
DrawSheetStruct( const wxPoint& pos = wxPoint( 0, 0 ) );
~DrawSheetStruct();
virtual wxString GetClass() const
{
return wxT("DrawSheetStruct");
return wxT( "DrawSheetStruct" );
}
void Place( WinEDA_DrawFrame* frame, wxDC* DC );
DrawSheetStruct* GenCopy();
void Display_Infos( WinEDA_DrawFrame* frame );
@ -119,15 +131,21 @@ public:
void SwapData( DrawSheetStruct* copyitem );
void DeleteAnnotation( bool recurse );
int ComponentCount();
bool Load(WinEDA_SchematicFrame* frame);
bool SearchHierarchy(wxString filename, SCH_SCREEN **screen);
bool LocatePathOfScreen(SCH_SCREEN *screen, DrawSheetList* list);
bool Load( WinEDA_SchematicFrame* frame );
bool SearchHierarchy( wxString filename, SCH_SCREEN** screen );
bool LocatePathOfScreen( SCH_SCREEN* screen, DrawSheetList* list );
int CountSheets();
//void RemoveSheet(DrawSheetStruct* sheet);
//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
class DrawSheetList
{
@ -136,54 +154,78 @@ public:
DrawSheetStruct* m_sheets[DSLSZ];
DrawSheetList();
~DrawSheetList(){};
void Clear(){m_numSheets = 0; }
int Cmp(DrawSheetList& d);
~DrawSheetList() { };
void Clear() { m_numSheets = 0; }
int Cmp( DrawSheetList& d );
DrawSheetStruct* Last();
SCH_SCREEN* LastScreen();
EDA_BaseStruct* LastDrawList();
void Push(DrawSheetStruct* sheet);
void Push( DrawSheetStruct* sheet );
DrawSheetStruct* Pop();
wxString Path();
wxString PathHumanReadable();
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 */
/*******************************************************/
// sheets are not unique - can have many sheets with the same
// filename and the same SCH_SHEET reference.
class EDA_SheetList
{
private:
private:
DrawSheetList* m_List;
int m_count;
int m_index;
DrawSheetList m_currList;
public:
EDA_SheetList( DrawSheetStruct* sheet ){
public:
EDA_SheetList( DrawSheetStruct* sheet )
{
m_index = 0;
m_count = 0;
m_List = NULL;
if(sheet == NULL)
if( sheet == NULL )
sheet = g_RootSheet;
BuildSheetList( sheet );
}
~EDA_SheetList() {if(m_List){free(m_List);} m_List = NULL;}
~EDA_SheetList()
{
if( m_List )
{
free( m_List );
}
m_List = NULL;
}
int GetCount() { return m_count; }
DrawSheetList* GetFirst();
DrawSheetList* GetNext();
DrawSheetList* GetSheet(int index );
DrawSheetList* GetSheet( int index );
void UpdateSheetNumberAndDate(); // Update the date displayed in the sheet count
private:
private:
void BuildSheetList( DrawSheetStruct* sheet );
};
/********************************************************/
/* Class to handle the list of *screens* in a hierarchy */
/********************************************************/
// screens are unique, and correspond to .sch files.
WX_DEFINE_ARRAY( SCH_SCREEN*, ScreenGrowArray );
WX_DEFINE_ARRAY( SCH_SCREEN *, ScreenGrowArray );
class EDA_ScreenList
{
private:
@ -191,16 +233,18 @@ private:
unsigned int m_Index;
public:
EDA_ScreenList(){
EDA_ScreenList()
{
m_Index = 0;
BuildScreenList(g_RootSheet);
BuildScreenList( g_RootSheet );
}
~EDA_ScreenList() {}
~EDA_ScreenList() { }
int GetCount() { return m_List.GetCount(); }
SCH_SCREEN* GetFirst();
SCH_SCREEN* GetNext();
SCH_SCREEN* GetScreen( unsigned int index );
void UpdateScreenNumberAndDate();
private:
void AddScreenToList( SCH_SCREEN* testscreen );

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
wxString path = GetPath( sheet );
printf( "SetRef path: %s ref: %s\n",
CONV_TO_UTF8( path ),
CONV_TO_UTF8( ref ) );
// printf( "SetRef path: %s ref: %s\n", CONV_TO_UTF8( path ), CONV_TO_UTF8( ref ) ); // Debug
unsigned int i;
bool notInArray = true;
for( i = 0; i<m_Paths.GetCount(); i++ )

21
eeschema/component_class.h
View File

@ -37,7 +37,8 @@ enum NumFieldType {
* component fields are texts attached to the component (not the graphic texts)
* 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:
int m_Layer;
@ -78,7 +79,7 @@ public:
wxPoint m_Pos; /* Exact position of part. */
public:
DrawPartStruct( KICAD_T struct_type, const wxPoint &pos );
DrawPartStruct( KICAD_T struct_type, const wxPoint& pos );
~DrawPartStruct();
virtual wxString GetClass() const
@ -87,12 +88,13 @@ public:
}
};
WX_DECLARE_OBJARRAY(DrawSheetList, ArrayOfSheetLists);
WX_DECLARE_OBJARRAY( DrawSheetList, ArrayOfSheetLists );
/* the class EDA_SchComponentStruct describes a real component */
class EDA_SchComponentStruct : public DrawPartStruct
{
public:
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) */
@ -101,9 +103,9 @@ public:
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.
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:
EDA_SchComponentStruct( const wxPoint& pos = wxPoint( 0, 0 ) );
@ -146,11 +148,13 @@ public:
//returns a unique ID, in the form of a path.
wxString GetPath( DrawSheetList* sheet);
wxString GetPath( DrawSheetList* sheet );
const wxString GetRef( DrawSheetList* sheet );
void SetRef( DrawSheetList* sheet, wxString ref );
void ClearRefs();
#if defined(DEBUG)
#if defined (DEBUG)
/**
* Function Show
* is used to output the object tree, currently for debugging only.
@ -159,6 +163,7 @@ public:
* @param os The ostream& to output to.
*/
void Show( int nestLevel, std::ostream& os );
#endif
};

10
eeschema/delsheet.cpp
View File

@ -37,20 +37,20 @@ wxString msg;
}
/* 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?"),
FirstSheet->m_SheetName.GetData(),
FirstSheet->m_FileName.GetData());
if( IsOK(NULL, msg) )
{
frame->SaveEEFile(FirstSheet->m_s, FILE_SAVE_AS);
frame->SaveEEFile(FirstSheet->m_AssociatedScreen, FILE_SAVE_AS);
}
}
/* free the sub hierarchy */
if(FirstSheet->m_s){
EEDrawList = FirstSheet->m_s->EEDrawList;
if(FirstSheet->m_AssociatedScreen){
EEDrawList = FirstSheet->m_AssociatedScreen->EEDrawList;
while (EEDrawList != NULL)
{
DrawStruct = EEDrawList;
@ -61,7 +61,7 @@ wxString msg;
}
}
/* 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
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);
//need to get rid of the path.
m_ListFileName = m_ListFileName.AfterLast('/');

132
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 "common.h"
@ -18,44 +18,45 @@
/* 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();
wxPoint pos;
wxString FullFileName;
int id = event.GetId();
wxPoint pos;
wxString FullFileName;
wxGetMousePosition(&pos.x, &pos.y);
wxGetMousePosition( &pos.x, &pos.y );
pos.y += 5;
switch ( id )
switch( id )
{
case ID_COLORS_SETUP :
DisplayColorSetupFrame(this, pos);
case ID_COLORS_SETUP:
DisplayColorSetupFrame( this, pos );
break;
case ID_CONFIG_REQ : // Creation de la fenetre de configuration
InstallConfigFrame(pos);
case ID_CONFIG_REQ: // Creation de la fenetre de configuration
InstallConfigFrame( pos );
break;
case ID_OPTIONS_SETUP:
DisplayOptionFrame(this, pos);
DisplayOptionFrame( this, pos );
break;
case ID_CONFIG_SAVE:
Save_Config(this);
Save_Config( this );
break;
case ID_CONFIG_READ:
{
wxString mask( wxT("*") ); mask += g_Prj_Config_Filename_ext;
FullFileName = g_RootSheet->m_s->m_FileName;
wxString mask( wxT( "*" ) ); mask += g_Prj_Config_Filename_ext;
FullFileName = g_RootSheet->m_AssociatedScreen->m_FileName;
ChangeFileNameExt( FullFileName, g_Prj_Config_Filename_ext );
FullFileName = EDA_FileSelector(_("Read config file"),
FullFileName = EDA_FileSelector( _( "Read config file" ),
wxGetCwd(), /* Chemin par defaut */
FullFileName, /* nom fichier par defaut */
g_Prj_Config_Filename_ext, /* extension par defaut */
@ -64,13 +65,14 @@ wxString FullFileName;
wxFD_OPEN,
TRUE /* ne change pas de repertoire courant */
);
if ( FullFileName.IsEmpty() ) break;
if ( ! wxFileExists(FullFileName) )
if( FullFileName.IsEmpty() )
break;
if( !wxFileExists( FullFileName ) )
{
wxString msg = _("File ") + FullFileName +_("not found");;
DisplayError(this, msg); break;
wxString msg = _( "File " ) + FullFileName + _( "not found" );;
DisplayError( this, msg ); break;
}
Read_Config(FullFileName, TRUE );
Read_Config( FullFileName, TRUE );
}
break;
@ -78,11 +80,11 @@ wxString FullFileName;
FullFileName = ReturnHotkeyConfigFilePath( g_ConfigFileLocationChoice );
FullFileName += HOTKEY_FILENAME;
FullFileName += DEFAULT_HOTKEY_FILENAME_EXT;
WriteHotkeyConfigFile(FullFileName, s_Eeschema_Hokeys_Descr, true);
WriteHotkeyConfigFile( FullFileName, s_Eeschema_Hokeys_Descr, true );
break;
case ID_PREFERENCES_READ_CONFIG_HOTKEYS:
Read_Hotkey_Config( this, true);
Read_Hotkey_Config( this, true );
break;
case ID_PREFERENCES_EDIT_CONFIG_HOTKEYS:
@ -91,8 +93,8 @@ wxString FullFileName;
FullFileName += HOTKEY_FILENAME;
FullFileName += DEFAULT_HOTKEY_FILENAME_EXT;
wxString editorname = GetEditorName();
if ( !editorname.IsEmpty() )
ExecuteFile(this, editorname, FullFileName);
if( !editorname.IsEmpty() )
ExecuteFile( this, editorname, FullFileName );
}
break;
@ -106,90 +108,94 @@ wxString FullFileName;
break;
default:
DisplayError(this, wxT("WinEDA_SchematicFrame::Process_Config internal error") );
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
*/
*/
{
wxString FullFileName = ReturnHotkeyConfigFilePath( g_ConfigFileLocationChoice );
FullFileName += HOTKEY_FILENAME;
FullFileName += DEFAULT_HOTKEY_FILENAME_EXT;
frame->ReadHotkeyConfigFile(FullFileName, s_Eeschema_Hokeys_Descr, verbose);
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
1 - lit <nom fichier root>.pro
2 - si non trouve lit <chemin des binaires>../template/kicad.pro
3 - si non trouve: init des variables aux valeurs par defaut
Retourne TRUE si lu, FALSE si config non lue
*/
* 1 - lit <nom fichier root>.pro
* 2 - si non trouve lit <chemin des binaires>../template/kicad.pro
* 3 - si non trouve: init des variables aux valeurs par defaut
*
* Retourne TRUE si lu, FALSE si config non lue
*/
{
wxString FullFileName;
bool IsRead = TRUE;
wxArrayString liblist_tmp = g_LibName_List;
wxString FullFileName;
bool IsRead = TRUE;
wxArrayString liblist_tmp = g_LibName_List;
if ( CfgFileName.IsEmpty() ) FullFileName = g_RootSheet->m_s->m_FileName;
else FullFileName = CfgFileName;
if( CfgFileName.IsEmpty() )
FullFileName = g_RootSheet->m_AssociatedScreen->m_FileName;
else
FullFileName = CfgFileName;
g_LibName_List.Clear();
if ( ! g_EDA_Appl->ReadProjectConfig(FullFileName,
GROUP, ParamCfgList, ForceRereadConfig ? FALSE : TRUE) ) // Config non lue
if( !g_EDA_Appl->ReadProjectConfig( FullFileName,
GROUP, ParamCfgList, ForceRereadConfig ? FALSE : TRUE ) ) // Config non lue
{
g_LibName_List = liblist_tmp;
IsRead = FALSE;
}
/* Traitement des variables particulieres: */
SetRealLibraryPath( wxT("library") );
SetRealLibraryPath( wxT( "library" ) );
// 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("device") );
g_LibName_List.Add( wxT( "power" ) );
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;
}
LoadLibraries(g_EDA_Appl->m_SchematicFrame);
LoadLibraries( g_EDA_Appl->m_SchematicFrame );
return IsRead;
}
/****************************************************************/
void WinEDA_SchematicFrame::Save_Config(wxWindow * displayframe)
void WinEDA_SchematicFrame::Save_Config( wxWindow* displayframe )
/***************************************************************/
{
wxString path;
wxString FullFileName;
wxString mask( wxT("*") );
wxString path;
wxString FullFileName;
wxString mask( wxT( "*" ) );
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 );
path = wxGetCwd();
FullFileName = EDA_FileSelector(_("Save preferences"),
FullFileName = EDA_FileSelector( _( "Save preferences" ),
path, /* Chemin par defaut */
FullFileName, /* nom fichier par defaut */
g_Prj_Config_Filename_ext, /* extension par defaut */
@ -198,9 +204,9 @@ wxString mask( wxT("*") );
wxFD_SAVE,
TRUE
);
if ( FullFileName.IsEmpty() ) return;
if( FullFileName.IsEmpty() )
return;
/* 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)
/*******************************************************************************/
{
BASE_SCREEN * screen; // * oldscreen = m_Parent->GetScreen();
BASE_SCREEN * screen;
wxBeginBusyCursor();
@ -140,7 +140,6 @@ BASE_SCREEN * screen; // * oldscreen = m_Parent->GetScreen();
if ( Print_Sheet_Ref )
m_Parent->TraceWorkSheet(DC, screen, g_DrawMinimunLineWidth );
//m_Parent->m_CurrentSheet->m_s = oldscreen;
wxEndBusyCursor();
}

2
eeschema/erc.cpp
View File

@ -400,7 +400,7 @@ void WinEDA_ErcFrame::TestErc( wxCommandEvent& event )
if( WriteFichierERC == TRUE )
{
wxString ErcFullFileName;
ErcFullFileName = g_RootSheet->m_s->m_FileName;
ErcFullFileName = g_RootSheet->m_AssociatedScreen->m_FileName;
ChangeFileNameExt( ErcFullFileName, wxT( ".erc" ) );
ErcFullFileName = EDA_FileSelector( _( "ERC file:" ),
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;
FullFileName = EDA_FileSelector( _( "Schematic files:" ),
wxEmptyString, //default path
sheet->m_s->m_FileName,// default filename
sheet->m_AssociatedScreen->m_FileName,// default filename
g_SchExtBuffer, // extension par defaut
mask, // Masque d'affichage
this,
@ -111,8 +111,8 @@ int WinEDA_SchematicFrame::LoadOneEEProject( const wxString& FileName, bool IsNe
{
if( !IsOK( this, _( "Clear Schematic Hierarchy (modified!)?" ) ) )
return FALSE;
if( g_RootSheet->m_s->m_FileName != g_DefaultSchematicFileName )
SetLastProject( g_RootSheet->m_s->m_FileName );
if( g_RootSheet->m_AssociatedScreen->m_FileName != g_DefaultSchematicFileName )
SetLastProject( g_RootSheet->m_AssociatedScreen->m_FileName );
}
FullFileName = FileName;
@ -146,7 +146,7 @@ int WinEDA_SchematicFrame::LoadOneEEProject( const wxString& FileName, bool IsNe
memset( &g_EESchemaVar, 0, sizeof(g_EESchemaVar) );
GetScreen()->ClrModify();
//m_CurrentSheet->m_s->Pnext = NULL; should be by default
//m_CurrentSheet->m_AssociatedScreen->Pnext = NULL; should be by default
if( IsNew )
{
@ -190,7 +190,7 @@ int WinEDA_SchematicFrame::LoadOneEEProject( const wxString& FileName, bool IsNe
// Loading the project library cache
wxString FullLibName;
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" ) <<
g_LibExtBuffer;
if( wxFileExists( FullLibName ) )
@ -211,16 +211,16 @@ int WinEDA_SchematicFrame::LoadOneEEProject( const wxString& FileName, bool IsNe
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 ?)" ),
g_RootSheet->m_s->m_FileName.GetData() );
g_RootSheet->m_AssociatedScreen->m_FileName.GetData() );
DisplayInfo( this, msg, 20 );
return -1;
}
//load the project.
SAFE_DELETE(g_RootSheet->m_s);
SAFE_DELETE(g_RootSheet->m_AssociatedScreen);
if(!g_RootSheet->Load(this))
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
par la souris
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..)
*/
{
@ -297,11 +297,10 @@ static void UpdateScreenFromSheet(WinEDA_SchematicFrame * frame)
{
SCH_SCREEN * NewScreen;
//SCH_SCREEN * oldscreen = frame->GetScreen(); what is oldscreen used for?
NewScreen = frame->m_CurrentSheet->LastScreen();
if(!NewScreen)
NewScreen = g_RootSheet->m_s;
NewScreen = g_RootSheet->m_AssociatedScreen;
// Reinit des parametres d'affichage du nouvel ecran
// 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 );
}
DrawPanel->MouseToCursorSchema();
DrawPanel->CursorOn( &dc );
break;
@ -725,7 +726,6 @@ void WinEDA_LibeditFrame::Process_Special_Functions( wxCommandEvent& event )
break;
}
DrawPanel->MouseToCursorSchema();
DrawPanel->m_IgnoreMouseEvents = FALSE;
if( m_ID_current_state == 0 )

8
eeschema/makefile.include
View File

@ -65,7 +65,9 @@ OBJECTS = eeschema.o\
savelib.o symbtext.o \
symbdraw.o \
hierarch.o files-io.o \
annotate.o plothpgl.o \
annotate.o\
annotate_dialog.o\
plothpgl.o \
plot.o libalias.o \
plotps.o netform.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)
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

2
eeschema/netlist.cpp
View File

@ -170,7 +170,7 @@ void* WinEDA_SchematicFrame::BuildNetListBase()
g_TabObjNet = NULL; /* Init pour le 1er passage dans ListeObjetConnection */
/* count nelist items */
g_RootSheet->m_s->SetModify();
g_RootSheet->m_AssociatedScreen->SetModify();
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;
/* Calculate the netlist filename */
FullFileName = g_RootSheet->m_s->m_FileName;
FullFileName = g_RootSheet->m_AssociatedScreen->m_FileName;
switch( g_NetFormat )
{
@ -649,7 +649,7 @@ void WinEDA_NetlistFrame::RunSimulator( wxCommandEvent& event )
CommandLine = g_SimulatorCommandLine.AfterFirst( ' ' );
/* Calculate the netlist filename */
NetlistFullFileName = g_RootSheet->m_s->m_FileName;
NetlistFullFileName = g_RootSheet->m_AssociatedScreen->m_FileName;
ChangeFileNameExt( NetlistFullFileName, wxT( ".cir" ) );
AddDelimiterString( 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:
{
wxString Line;
if( g_RootSheet->m_s->m_FileName != wxEmptyString )
if( g_RootSheet->m_AssociatedScreen->m_FileName != wxEmptyString )
{
Line = GetScreen()->m_FileName;
AddDelimiterString( Line );
@ -224,9 +224,9 @@ void WinEDA_SchematicFrame::Process_Special_Functions( wxCommandEvent& event )
case ID_TO_CVPCB:
{
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 );
ChangeFileNameExt( Line, wxEmptyString );
ExecuteFile( this, CVPCB_EXE, Line );

36
eeschema/schematic_undo_redo.cpp
View File

@ -286,7 +286,7 @@ void WinEDA_SchematicFrame::SaveCopyInUndoList( EDA_BaseStruct* ItemToCopy,
GetScreen()->AddItemToUndoList( NewList );
/* 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;
}
@ -362,7 +362,7 @@ void WinEDA_SchematicFrame::PutDataInPreviousState( DrawPickedStruct* List )
while( PickedList )
{
item = PickedList->m_Image;
((SCH_SCREEN*)GetScreen())->RemoveFromDrawList( item );
( (SCH_SCREEN*) GetScreen() )->RemoveFromDrawList( item );
item->m_Flags = IS_DELETED;
PickedList->m_PickedStruct = item;
PickedList->m_Flags = IS_DELETED;
@ -372,7 +372,7 @@ void WinEDA_SchematicFrame::PutDataInPreviousState( DrawPickedStruct* List )
else
{
FirstItem = List->m_Image;
((SCH_SCREEN*)GetScreen())->RemoveFromDrawList( FirstItem );
( (SCH_SCREEN*) GetScreen() )->RemoveFromDrawList( FirstItem );
FirstItem->m_Flags = IS_DELETED;
List->m_Son = FirstItem;
}
@ -407,7 +407,7 @@ void WinEDA_SchematicFrame::PutDataInPreviousState( DrawPickedStruct* List )
case IS_WIRE_IMAGE:
/* 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 )
{
EDA_BaseStruct* nextitem = FirstItem->Pnext;
@ -437,7 +437,7 @@ void WinEDA_SchematicFrame::PutDataInPreviousState( DrawPickedStruct* List )
case IS_NEW:
item = PickedList->m_Image;
((SCH_SCREEN*)GetScreen())->RemoveFromDrawList( item );
( (SCH_SCREEN*) GetScreen() )->RemoveFromDrawList( item );
item->m_Flags = IS_DELETED;
PickedList->m_PickedStruct = item;
PickedList->m_Flags = IS_DELETED;
@ -542,16 +542,19 @@ void SCH_SCREEN::ClearUndoORRedoList( EDA_BaseStruct* List )
{
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 );
}
}
@ -583,16 +586,19 @@ void SCH_SCREEN::ClearUndoORRedoList( EDA_BaseStruct* List )
{
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 );
}
}

21
eeschema/schframe.cpp
View File

@ -215,22 +215,22 @@ wxString WinEDA_SchematicFrame::GetScreenDesc()
}
/******************************/
/*******************************************/
void WinEDA_SchematicFrame::CreateScreens()
/******************************/
/*******************************************/
{
/* creation des ecrans Sch , Lib */
if( g_RootSheet == NULL )
{
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_s->m_RefCount++;
g_RootSheet->m_AssociatedScreen = new SCH_SCREEN( SCHEMATIC_FRAME );
g_RootSheet->m_AssociatedScreen->m_RefCount++;
}
g_RootSheet->m_s->m_FileName = g_DefaultSchematicFileName;
g_RootSheet->m_s->m_Date = GenDate();
g_RootSheet->m_AssociatedScreen->m_FileName = g_DefaultSchematicFileName;
g_RootSheet->m_AssociatedScreen->m_Date = GenDate();
m_CurrentSheet->Clear();
m_CurrentSheet->Push( g_RootSheet );
@ -294,10 +294,11 @@ void WinEDA_SchematicFrame::OnCloseWindow( wxCloseEvent& Event )
}
}
if( !GetScreen()->m_FileName.IsEmpty() && (GetScreen()->EEDrawList != NULL) )
SetLastProject( GetScreen()->m_FileName );
if( !g_RootSheet->m_AssociatedScreen->m_FileName.IsEmpty() &&
(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 */
m_CurrentSheet->Clear();

43
eeschema/sheet.cpp
View File

@ -159,7 +159,8 @@ void WinEDA_SheetPropertiesFrame::CreateControls()
itemBoxSizer3->Add( itemBoxSizer4, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5 );
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):" ),
wxDefaultPosition,
wxDefaultSize, 0 );
itemBoxSizer4->Add( itemStaticText5,
0,
@ -292,25 +293,31 @@ void WinEDA_SheetPropertiesFrame::SheetPropertiesAccept( wxCommandEvent& event )
{
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( m_CurrentSheet->m_s ){
m_CurrentSheet->m_s->m_RefCount--;
if( m_CurrentSheet->m_s->m_RefCount == 0)
SAFE_DELETE(m_CurrentSheet->m_s);
if( m_CurrentSheet->m_AssociatedScreen )
{
m_CurrentSheet->m_AssociatedScreen->m_RefCount--;
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{
}
else
{
//just make a new screen if needed.
if( !m_CurrentSheet->m_s ){
m_CurrentSheet->m_s = new SCH_SCREEN(SCHEMATIC_FRAME);
m_CurrentSheet->m_s->m_RefCount++; //be careful with these
m_CurrentSheet->m_s->m_FileName = FileName;
if( !m_CurrentSheet->m_AssociatedScreen )
{
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;
}
}
}
@ -373,7 +380,7 @@ DrawSheetStruct* WinEDA_SchematicFrame::CreateSheet( wxDC* DC )
Sheet->m_Flags = IS_NEW | IS_RESIZED;
Sheet->m_TimeStamp = GetTimeStamp();
Sheet->m_Parent = GetScreen();
Sheet->m_s = NULL;
Sheet->m_AssociatedScreen = NULL;
s_SheetMindx = SHEET_MIN_WIDTH;
s_SheetMindy = SHEET_MIN_HEIGHT;
@ -496,7 +503,6 @@ static void DeplaceSheet( WinEDA_DrawPanel* panel, wxDC* DC, bool erase )
}
/****************************************/
/* Routine de sortie du Menu de Sheet */
/****************************************/
@ -514,7 +520,7 @@ static void ExitSheet( WinEDA_DrawPanel* Panel, wxDC* DC )
RedrawOneStruct( Panel, DC, Sheet, g_XorMode );
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 );
Sheet->m_Size.x = s_OldPos.x;
@ -522,7 +528,7 @@ static void ExitSheet( WinEDA_DrawPanel* Panel, wxDC* DC )
RedrawOneStruct( Panel, DC, Sheet, GR_DEFAULT_DRAWMODE );
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;
Panel->m_Parent->GetScreen()->m_Curseur = s_OldPos;
@ -540,7 +546,6 @@ static void ExitSheet( WinEDA_DrawPanel* Panel, wxDC* DC )
}
/*!
* 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;
DrawHierLabelStruct* HLabel = NULL;
if(!Sheet->m_s) return NULL;
DrawStruct = Sheet->m_s->EEDrawList;
if(!Sheet->m_AssociatedScreen) return NULL;
DrawStruct = Sheet->m_AssociatedScreen->EEDrawList;
HLabel = NULL;
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

8
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
/**********************************************/
/************************************************/
void WinEDA_DrillFrame::InitDisplayParams( void )
/**********************************************/
/************************************************/
/* some param values initialisation before display dialog window
*/
@ -121,8 +121,6 @@ void WinEDA_DrillFrame::InitDisplayParams( void )
m_MicroViasDrillSizer->Enable( m_MicroViasCount );
m_MicroViaDrillValue->Enable( m_MicroViasCount );
/* Display statistics */
// Pads holes cound:
m_PadsHoleCount = 0;
for( MODULE* module = m_Parent->m_Pcb->m_Modules; module != NULL; module = module->Next() )
@ -133,12 +131,12 @@ void WinEDA_DrillFrame::InitDisplayParams( void )
{
if( pad->m_Drill.x != 0 )
m_PadsHoleCount++;
}
else
if( MIN( pad->m_Drill.x, pad->m_Drill.y ) != 0 )
m_PadsHoleCount++;
}
}
}
msg = m_PadsCountInfoMsg->GetLabel();
msg << wxT( " " ) << m_PadsHoleCount;