AllSpiceMirrors/kicad
7
Fork 0
mirror of https://gitlab.com/kicad/code/kicad.git synced 2025-04-21 09:31:42 +00:00
Files Issues Releases Activity

Compiler warning, object name, bug, and string fixes.

Browse Source 
* Fixed EESchema options dialog focus bug so escape key now works in GTK.
* Rename schematic objects for improved readability.
* Fixed GCC compiler warnings in plot code.
* Added paragraph in UIpolicies.txt about setting dialog box sizes.
* Lots of message box string clean up.
This commit is contained in:
stambaughw 2009-12-02 21:44:03 +00:00
parent 04c7eb2916
commit 1aaa7a9bf2
60 changed files with 1677 additions and 1879 deletions

29
Documentation/guidelines/UIpolicies.txt
View File

@ -2,24 +2,24 @@
** General UI Guidelines for KICAD Development
Capitalization:
Capitalization:
For any visible text used within Kicad, follow recommendations here:
http://library.gnome.org/devel/hig-book/2.20/design-text-labels.html.en#layout-capitalization
This applies to all Menus, Titles, Labels, Tooltips, Buttons, etc.
Dialogs:
Dialogs:
Follow the recommendations here:
http://library.gnome.org/devel/hig-book/2.20/windows-dialog.html.en
paying particular attention to "initial focus", "sensible default values",
"default buttons", ESC key termination.
Use wxWidgets "sizers" in all dialogs, no matter how simple they are:
Use wxWidgets "sizers" in all dialogs, no matter how simple they are:
http://zetcode.com/tutorials/wxwidgetstutorial/layoutmanagement
and keep dialogs resizeable.
Configure the sizers so that as the dialog window is expanded, the most
sensible use of the increased dialog window occurs automatically by the
sizers. For example, in the DRC dialog of PCBNEW, sizers should be used to
@ -28,11 +28,20 @@ Dialogs:
expands the dialog window, making it easier to read more DRC error messages.
In other dialogs without one component more important than the others, the
sizers might be configured to position the controls to sensible positions
near the perimeter of the increasingly larger dialog box, not necesarily
leaving them all bundled tightly together. The dialog box should look
near the perimeter of the increasingly larger dialog box, not necessarily
leaving them all bundled tightly together. The dialog box should look
nice at any size large enough to show all the components.
Use tooltips to explain the functionality of each non-obvious control.
Use tooltips to explain the functionality of each non-obvious control.
This is important because the help files and the wiki often lag behind
the source code.
Avoid defining initial dialog sizes if possible. Let the sizers do their
job. After the dialog is fit to the sizers, set the minimum size to the
current size to prevent the dialog controls from being obscured when
resizing the dialog. If the labels or text of the dialog controls are,
set or changed at run time. Rerun wxWindow::Fit() to allow the dialog to
re-size and adjust for the new control widths. This can all be done after
the dialog is created but before it is shown or use class methods to
re-size the dialog as required. Reset the minimum size to the updated
dialog size.

2
common/common_plotDXF_functions.cpp
View File

@ -193,7 +193,7 @@ void DXF_PLOTTER::arc( wxPoint centre, int StAngle, int EndAngle, int radius,
return;
user_to_device_coordinates( centre );
radius = user_to_device_size( radius );
radius = wxRound( user_to_device_size( radius ) );
/* DXF ARC */
wxString cname = ColorRefs[current_color].m_Name;

391
eeschema/annotate.cpp
View File

@ -17,9 +17,8 @@
#include "netlist.h"
/* Local Functions*/
static int AddComponentsInSheetToList( std::vector <OBJ_CMP_TO_LIST>& aComponentsList,
DrawSheetPath* sheet );
SCH_SHEET_PATH* sheet );
static void BreakReference( std::vector <OBJ_CMP_TO_LIST>& aComponentsList );
static void ReAnnotateComponents( std::vector <OBJ_CMP_TO_LIST>& aComponentsList );
static void ComputeReferenceNumber( std::vector <OBJ_CMP_TO_LIST>& aComponentsList );
@ -30,19 +29,17 @@ static int ExistUnit( int aObjet, int aUnit,
static int ReplaceDuplicatedTimeStamps();
/******************************************************/
void WinEDA_SchematicFrame::UpdateSheetNumberAndDate()
/******************************************************/
/* Set a sheet number, the sheet count for sheets in the whole schematic
* and update the date in all screens
*/
void WinEDA_SchematicFrame::UpdateSheetNumberAndDate()
{
wxString date = GenDate();
EDA_ScreenList s_list;
// Set the date
for( SCH_SCREEN* screen = s_list.GetFirst(); screen != NULL; screen = s_list.GetNext() )
for( SCH_SCREEN* screen = s_list.GetFirst(); screen != NULL;
screen = s_list.GetNext() )
screen->m_Date = date;
// Set sheet counts
@ -61,12 +58,13 @@ void WinEDA_SchematicFrame::UpdateSheetNumberAndDate()
void ReAnnotatePowerSymbolsOnly( void )
{
/* Build the whole sheet list in hierarchy (sheet, not screen) */
EDA_SheetList SheetList;
SCH_SHEET_LIST SheetList;
DrawSheetPath* sheet;
int CmpNumber = 1;
SCH_SHEET_PATH* sheet;
int CmpNumber = 1;
for( sheet = SheetList.GetFirst(); sheet != NULL; sheet = SheetList.GetNext() )
for( sheet = SheetList.GetFirst(); sheet != NULL;
sheet = SheetList.GetNext() )
{
EDA_BaseStruct* DrawList = sheet->LastDrawList();
for( ; DrawList != NULL; DrawList = DrawList->Next() )
@ -105,7 +103,8 @@ void ReAnnotatePowerSymbolsOnly( void )
* if same X pos, by Y pos
* if same Y pos, by time stamp
*/
static bool AnnotateBy_X_Position( const OBJ_CMP_TO_LIST& item1, const OBJ_CMP_TO_LIST& item2 )
static bool AnnotateBy_X_Position( const OBJ_CMP_TO_LIST& item1,
const OBJ_CMP_TO_LIST& item2 )
{
int ii = item1.CompareRef( item2 );
@ -130,7 +129,8 @@ static bool AnnotateBy_X_Position( const OBJ_CMP_TO_LIST& item1, const OBJ_CMP_T
* if same Y pos, by X pos
* if same X pos, by time stamp
*/
static bool AnnotateBy_Y_Position( const OBJ_CMP_TO_LIST& item1, const OBJ_CMP_TO_LIST& item2 )
static bool AnnotateBy_Y_Position( const OBJ_CMP_TO_LIST& item1,
const OBJ_CMP_TO_LIST& item2 )
{
int ii = item1.CompareRef( item2 );
@ -148,15 +148,16 @@ static bool AnnotateBy_Y_Position( const OBJ_CMP_TO_LIST& item1, const OBJ_CMP_T
/*****************************************************************************
* qsort function to annotate items by value
* Components are sorted
* by reference
* if same reference: by value
* if same value: by unit number
* if same unit number, by sheet
* if same sheet, by time stamp
*****************************************************************************/
static bool AnnotateByValue( const OBJ_CMP_TO_LIST& item1, const OBJ_CMP_TO_LIST& item2 )
* qsort function to annotate items by value
* Components are sorted
* by reference
* if same reference: by value
* if same value: by unit number
* if same unit number, by sheet
* if same sheet, by time stamp
*****************************************************************************/
static bool AnnotateByValue( const OBJ_CMP_TO_LIST& item1,
const OBJ_CMP_TO_LIST& item2 )
{
int ii = item1.CompareRef( item2 );
@ -178,10 +179,11 @@ static bool AnnotateByValue( const OBJ_CMP_TO_LIST& item1, const OBJ_CMP_TO_LIST
/*****************************************************************************
* qsort function to annotate items by value
* Components are sorted by time stamp
*****************************************************************************/
static bool SortByTimeStamp( const OBJ_CMP_TO_LIST& item1, const OBJ_CMP_TO_LIST& item2 )
* qsort function to annotate items by value
* Components are sorted by time stamp
*****************************************************************************/
static bool SortByTimeStamp( const OBJ_CMP_TO_LIST& item1,
const OBJ_CMP_TO_LIST& item2 )
{
int ii = item1.m_SheetPath.Cmp( item2.m_SheetPath );
@ -192,15 +194,14 @@ static bool SortByTimeStamp( const OBJ_CMP_TO_LIST& item1, const OBJ_CMP_TO_LIST
}
/**************************************************************************************/
void WinEDA_SchematicFrame::DeleteAnnotation( bool aCurrentSheetOnly, bool aRedraw )
/**************************************************************************************/
/** Function DeleteAnnotation
* Remove current component annotations
* @param aCurrentSheetOnly : if false: remove all annotations, else remove annotation relative to the current sheet only
* @param aCurrentSheetOnly : if false: remove all annotations, else remove
* annotation relative to the current sheet only
* @param aRedraw : true to refresh display
*/
void WinEDA_SchematicFrame::DeleteAnnotation( bool aCurrentSheetOnly,
bool aRedraw )
{
SCH_ITEM* strct;
SCH_SCREEN* screen;
@ -242,22 +243,26 @@ void WinEDA_SchematicFrame::DeleteAnnotation( bool aCurrentSheetOnly, bool aRedr
}
/*****************************************************************************
* AnnotateComponents:
*
* Compute the annotation of the components for the whole project, or the
* current sheet only. All the components or the new ones only will be
* annotated.
* @param parent = Schematic frame
* @param annotateSchematic : true = entire schematic annotation, false = current scheet only
* @param sortOption : 0 = annotate by sorting X position,
* 1 = annotate by sorting Y position,
* 2 = annotate by sorting value
* @param resetAnnotation : true = remove previous annotation false = anotate new components only
* @param repairsTimestamps : true = test for duplicate times stamps and replace duplicated
* Note: this option could change previous annotation, because time stamps are used to handle annotation
* mainly in complex hierarchies.
*****************************************************************************/
/**
* AnnotateComponents:
*
* Compute the annotation of the components for the whole project, or the
* current sheet only. All the components or the new ones only will be
* annotated.
* @param parent = Schematic frame
* @param annotateSchematic : true = entire schematic annotation,
* false = current sheet only
* @param sortOption : 0 = annotate by sorting X position,
* 1 = annotate by sorting Y position,
* 2 = annotate by sorting value
* @param resetAnnotation : true = remove previous annotation
* false = annotate new components only
* @param repairsTimestamps : true = test for duplicate times stamps and
* replace duplicated
* Note: this option could change previous annotation, because time
* stamps are used to handle annotation mainly in complex
* hierarchies.
*/
void AnnotateComponents( WinEDA_SchematicFrame* parent,
bool annotateSchematic,
int sortOption,
@ -268,15 +273,17 @@ void AnnotateComponents( WinEDA_SchematicFrame* parent,
wxBusyCursor dummy;
// Test and replace duplicte time stamps
// duplicate can happen with old schematics, or schematic conversions or manual editions of files ...
// Test and replace duplicate time stamps
// duplicate can happen with old schematics, or schematic conversions or
// manual editions of files ...
if( repairsTimestamps )
{
int ireplacecount = ReplaceDuplicatedTimeStamps();
if( ireplacecount )
{
wxString msg;
msg.Printf( _( "%d Duplicate Time stamps replaced" ), ireplacecount );
msg.Printf( _( "%d duplicate time stamps replaced." ),
ireplacecount );
DisplayInfoMessage( NULL, msg, 2 );
}
}
@ -287,7 +294,7 @@ void AnnotateComponents( WinEDA_SchematicFrame* parent,
parent->DeleteAnnotation( !annotateSchematic, false );
/* Build the sheet list */
EDA_SheetList SheetList;
SCH_SHEET_LIST SheetList;
/* Update the sheet number, sheet count and date */
parent->UpdateSheetNumberAndDate();
@ -295,7 +302,7 @@ void AnnotateComponents( WinEDA_SchematicFrame* parent,
/* Build component list */
if( annotateSchematic )
{
DrawSheetPath* sheet;
SCH_SHEET_PATH* sheet;
for( sheet = SheetList.GetFirst();
sheet != NULL;
sheet = SheetList.GetNext() )
@ -312,11 +319,13 @@ void AnnotateComponents( WinEDA_SchematicFrame* parent,
switch( sortOption )
{
case 0:
sort( ComponentsList.begin(), ComponentsList.end(), AnnotateBy_X_Position );
sort( ComponentsList.begin(), ComponentsList.end(),
AnnotateBy_X_Position );
break;
case 1:
sort( ComponentsList.begin(), ComponentsList.end(), AnnotateBy_Y_Position );
sort( ComponentsList.begin(), ComponentsList.end(),
AnnotateBy_Y_Position );
break;
case 2:
@ -334,16 +343,14 @@ void AnnotateComponents( WinEDA_SchematicFrame* parent,
}
/*******************************************************************************************************/
int AddComponentsInSheetToList( std::vector <OBJ_CMP_TO_LIST>& aComponentsList,
DrawSheetPath* aSheet )
/********************************************************************************************************/
/** function AddComponentsInSheetToList()
* Add a OBJ_CMP_TO_LIST object in aComponentsList for each component found in sheet
* Add a OBJ_CMP_TO_LIST object in aComponentsList for each component found
* in sheet
* @param aComponentsList = a std::vector list to fill
* @param the DrawSheetPath sheet to analyse
* @param the SCH_SHEET_PATH sheet to analyze
*/
int AddComponentsInSheetToList( std::vector <OBJ_CMP_TO_LIST>& aComponentsList,
SCH_SHEET_PATH* aSheet )
{
int NbrCmp = 0;
EDA_BaseStruct* DrawList = aSheet->LastDrawList();
@ -372,7 +379,8 @@ int AddComponentsInSheetToList( std::vector <OBJ_CMP_TO_LIST>& aComponentsList,
if( DrawLibItem->GetRef( aSheet ).IsEmpty() )
DrawLibItem->SetRef( aSheet, wxT( "DefRef?" ) );
strncpy( new_object.m_Reference, CONV_TO_UTF8( DrawLibItem->GetRef( aSheet ) ), 32 );
strncpy( new_object.m_Reference,
CONV_TO_UTF8( DrawLibItem->GetRef( aSheet ) ), 32 );
new_object.m_NumRef = -1;
@ -390,10 +398,10 @@ int AddComponentsInSheetToList( std::vector <OBJ_CMP_TO_LIST>& aComponentsList,
}
/*****************************************************************************
* Update the reference component for the schematic project (or the current
* sheet)
*****************************************************************************/
/*
* Update the reference component for the schematic project (or the current
* sheet)
*/
static void ReAnnotateComponents( std::vector <OBJ_CMP_TO_LIST>& aComponentsList )
{
/* update the reference numbers */
@ -407,7 +415,8 @@ static void ReAnnotateComponents( std::vector <OBJ_CMP_TO_LIST>& aComponentsList
else
sprintf( Text + strlen( Text ), "%d", aComponentsList[ii].m_NumRef );
component->SetRef( &(aComponentsList[ii].m_SheetPath), CONV_FROM_UTF8( Text ) );
component->SetRef( &(aComponentsList[ii].m_SheetPath),
CONV_FROM_UTF8( Text ) );
component->m_Multi = aComponentsList[ii].m_Unit;
component->SetUnitSelection( &(aComponentsList[ii].m_SheetPath),
aComponentsList[ii].m_Unit );
@ -415,15 +424,15 @@ static void ReAnnotateComponents( std::vector <OBJ_CMP_TO_LIST>& aComponentsList
}
/*****************************************************************************
* Split component reference designators into a name (prefix) and number.
* Example: IC1 becomes IC and 1 in the .m_NumRef member.
* For multi part per package components not already annotated, set .m_Unit
* to a max value (0x7FFFFFFF).
*
* @param aComponentsList = list of component
* @param NbOfCmp = item count in the list
*****************************************************************************/
/**
* Split component reference designators into a name (prefix) and number.
* Example: IC1 becomes IC and 1 in the .m_NumRef member.
* For multi part per package components not already annotated, set .m_Unit
* to a max value (0x7FFFFFFF).
*
* @param aComponentsList = list of component
* @param NbOfCmp = item count in the list
*/
void BreakReference( std::vector <OBJ_CMP_TO_LIST>& aComponentsList )
{
char* Text;
@ -466,16 +475,16 @@ void BreakReference( std::vector <OBJ_CMP_TO_LIST>& aComponentsList )
}
/*****************************************************************************
* Compute the reference number for components without reference number
* Compute .m_NumRef member
*****************************************************************************/
/*
* Compute the reference number for components without reference number
* Compute .m_NumRef member
*/
static void ComputeReferenceNumber( std::vector <OBJ_CMP_TO_LIST>& aComponentsList )
{
int LastReferenceNumber, NumberOfUnits, Unit;
/* Components with an invisible reference (power...) always are re-annotated.
* So set theirs .m_IsNew member to true
/* Components with an invisible reference (power...) always are
* re-annotated. So set their .m_IsNew member to true
*/
for( unsigned ii = 0; ii < aComponentsList.size(); ii++ )
{
@ -486,9 +495,10 @@ static void ComputeReferenceNumber( std::vector <OBJ_CMP_TO_LIST>& aComponentsLi
}
}
/* calculate index of the first component with the same reference prefix than the current component.
* all of component having the same reference prefix will receive a reference number with consecutives values:
* IC .. will be set to IC4, IC4, IC5 ...
/* calculate index of the first component with the same reference prefix
* than the current component. All components having the same reference
* prefix will receive a reference number with consecutive values:
* IC .. will be set to IC4, IC4, IC5 ...
*/
unsigned first = 0;
/* calculate the last used number for this reference prefix: */
@ -498,8 +508,10 @@ static void ComputeReferenceNumber( std::vector <OBJ_CMP_TO_LIST>& aComponentsLi
if( aComponentsList[ii].m_Flag )
continue;
if( aComponentsList[first].CompareRef( aComponentsList[ii] ) != 0 ) /* New reference found: we need a new ref number for this reference */
if( aComponentsList[first].CompareRef( aComponentsList[ii] ) != 0 )
{
/* New reference found: we need a new ref number for this
* reference */
first = ii;
LastReferenceNumber = GetLastReferenceNumber( ii, aComponentsList );
}
@ -533,7 +545,8 @@ static void ComputeReferenceNumber( std::vector <OBJ_CMP_TO_LIST>& aComponentsLi
}
/* search for others units of this component.
* we search for others parts that have the same value and the same reference prefix (ref without ref number)
* we search for others parts that have the same value and the same
* reference prefix (ref without ref number)
*/
for( Unit = 1; Unit <= NumberOfUnits; Unit++ )
{
@ -541,23 +554,27 @@ static void ComputeReferenceNumber( std::vector <OBJ_CMP_TO_LIST>& aComponentsLi
continue;
int found = ExistUnit( ii, Unit, aComponentsList );
if( found >= 0 )
continue; /* this unit exists for this reference (unit already annotated) */
continue; /* this unit exists for this reference (unit
* already annotated) */
/* Search a component to annotate ( same prefix, same value, not annotated) */
/* Search a component to annotate ( same prefix, same value,
* not annotated) */
for( unsigned jj = ii + 1; jj < aComponentsList.size(); jj++ )
{
if( aComponentsList[jj].m_Flag ) // already tested
continue;
if( aComponentsList[ii].CompareRef( aComponentsList[jj] ) != 0 ) // references are different
if( aComponentsList[ii].CompareRef( aComponentsList[jj] ) != 0 )
continue;
if( aComponentsList[jj].CompareValue( aComponentsList[ii] ) != 0 )
continue; // values are different
continue;
if( !aComponentsList[jj].m_IsNew )
continue;
/* Component without reference number found, annotate it if possible */
if( !aComponentsList[jj].IsPartsLocked() || (aComponentsList[jj].m_Unit == Unit) )
/* Component without reference number found, annotate it
* if possible */
if( !aComponentsList[jj].IsPartsLocked()
|| ( aComponentsList[jj].m_Unit == Unit ) )
{
aComponentsList[jj].m_NumRef = aComponentsList[ii].m_NumRef;
aComponentsList[jj].m_Unit = Unit;
@ -571,21 +588,23 @@ static void ComputeReferenceNumber( std::vector <OBJ_CMP_TO_LIST>& aComponentsLi
}
/*****************************************************************************
* Search the last used (greatest) reference number in the component list
* for the prefix reference given by Objet
* The component list must be sorted.
*
* @param aObjet = reference item ( aComponentsList[aObjet].m_TextRef is the search pattern)
* @param aComponentsList = list of items
*****************************************************************************/
int GetLastReferenceNumber( int aObjet, std::vector <OBJ_CMP_TO_LIST>& aComponentsList )
/**
* Search the last used (greatest) reference number in the component list
* for the prefix reference given by Objet
* The component list must be sorted.
*
* @param aObjet = reference item ( aComponentsList[aObjet].m_TextRef is
* the search pattern)
* @param aComponentsList = list of items
*/
int GetLastReferenceNumber( int aObjet,
std::vector <OBJ_CMP_TO_LIST>& aComponentsList )
{
int LastNumber = 0;
for( unsigned ii = 0; ii < aComponentsList.size(); ii++ )
{
/* Nouveau Identificateur */
/* New identifier. */
if( aComponentsList[aObjet].CompareRef( aComponentsList[ii] ) != 0 )
continue;
if( LastNumber < aComponentsList[ii].m_NumRef )
@ -596,15 +615,16 @@ int GetLastReferenceNumber( int aObjet, std::vector <OBJ_CMP_TO_LIST>& aComponen
}
/*****************************************************************************
* Search in the sorted list of components, for a given componen,t an other component
* with the same reference and a given part unit.
* Mainly used to manage multiple parts per package components
* @param aObjet = index in aComponentsList for the given OBJ_CMP_TO_LIST item to test
* @param Unit = the given unit number to search
* @param aComponentsList = list of items to examine
* @return index in aComponentsList if found or -1 if not found
*****************************************************************************/
/**
* Search in the sorted list of components, for a given component an other
* component with the same reference and a given part unit. Mainly used to
* manage multiple parts per package components.
* @param aObjet = index in aComponentsList for the given OBJ_CMP_TO_LIST
* item to test
* @param Unit = the given unit number to search
* @param aComponentsList = list of items to examine
* @return index in aComponentsList if found or -1 if not found
*/
static int ExistUnit( int aObjet, int Unit,
std::vector <OBJ_CMP_TO_LIST>& aComponentsList )
{
@ -613,16 +633,21 @@ static int ExistUnit( int aObjet, int Unit,
NumRef = aComponentsList[aObjet].m_NumRef;
for( unsigned ii = 0; ii < aComponentsList.size(); ii++ )
{
if( aObjet == (int) ii ) // Do not compare with itself !
if( aObjet == (int) ii )
// Do not compare with itself !
continue;
if( aComponentsList[ii].m_IsNew ) // Not already with an updated reference
if( aComponentsList[ii].m_IsNew )
// Not already with an updated reference
continue;
if( aComponentsList[ii].m_NumRef != NumRef ) // Not the same reference number (like 35 in R35)
if( aComponentsList[ii].m_NumRef != NumRef )
// Not the same reference number (like 35 in R35)
continue;
if( aComponentsList[aObjet].CompareRef( aComponentsList[ii] ) != 0 ) // Not the same reference prefix
if( aComponentsList[aObjet].CompareRef( aComponentsList[ii] ) != 0 )
// Not the same reference prefix
continue;
if( aComponentsList[ii].m_Unit == Unit ) // A part with the same reference and the given unit is found
if( aComponentsList[ii].m_Unit == Unit )
{
// A part with the same reference and the given unit is found
return ii;
}
}
@ -631,10 +656,6 @@ static int ExistUnit( int aObjet, int Unit,
}
/***************************************************************************************/
int WinEDA_SchematicFrame::CheckAnnotate( wxArrayString* aMessageList, bool aOneSheetOnly )
/***************************************************************************************/
/**
* Function CheckAnnotate
* Check errors relatives to annotation:
@ -643,26 +664,30 @@ int WinEDA_SchematicFrame::CheckAnnotate( wxArrayString* aMessageList, bool aOne
* for multiple parts per package components :
* part number > number of parts
* different values between parts
* @return errors count
* @param aMessageList = a wxArrayString to store messages. If NULL, they are displayed in a wxMessageBox
* @param aMessageList = a wxArrayString to store messages. If NULL, they
* are displayed in a wxMessageBox
* @param aOneSheetOnly : true = search is made only in the current sheet
* false = search in whole hierarchy (usual search).
* false = search in whole hierarchy (usual search).
* @return errors count
*/
int WinEDA_SchematicFrame::CheckAnnotate( wxArrayString* aMessageList,
bool aOneSheetOnly )
{
int error;
wxString Buff;
wxString msg, cmpref;
int error;
wxString Buff;
wxString msg, cmpref;
/* build the screen list */
EDA_SheetList SheetList;
SCH_SHEET_LIST SheetList;
std::vector <OBJ_CMP_TO_LIST> ComponentsList;
/* Build the list of components */
if( !aOneSheetOnly )
{
DrawSheetPath* sheet;
for( sheet = SheetList.GetFirst(); sheet != NULL; sheet = SheetList.GetNext() )
SCH_SHEET_PATH* sheet;
for( sheet = SheetList.GetFirst(); sheet != NULL;
sheet = SheetList.GetNext() )
AddComponentsInSheetToList( ComponentsList, sheet );
}
else
@ -693,23 +718,28 @@ int WinEDA_SchematicFrame::CheckAnnotate( wxArrayString* aMessageList, bool aOne
msg.Printf( _( "item not annotated: %s%s" ),
cmpref.GetData(), Buff.GetData() );
if( (ComponentsList[ii].m_Unit > 0) && (ComponentsList[ii].m_Unit < 0x7FFFFFFF) )
if( ( ComponentsList[ii].m_Unit > 0 )
&& ( ComponentsList[ii].m_Unit < 0x7FFFFFFF ) )
{
Buff.Printf( _( "( unit %d)" ), ComponentsList[ii].m_Unit );
msg << Buff;
}
if( aMessageList )
{
aMessageList->Add( msg + wxT( "\n" ) );
}
else
{
DisplayError( NULL, msg );
}
error++;
break;
}
// Annotate error
if( MAX( ComponentsList[ii].m_Entry->GetPartCount(), 1 ) < ComponentsList[ii].m_Unit )
if( MAX( ComponentsList[ii].m_Entry->GetPartCount(), 1 )
< ComponentsList[ii].m_Unit )
{
if( ComponentsList[ii].m_NumRef >= 0 )
Buff << ComponentsList[ii].m_NumRef;
@ -721,7 +751,8 @@ int WinEDA_SchematicFrame::CheckAnnotate( wxArrayString* aMessageList, bool aOne
Buff.GetData() );
Buff.Printf( _( " unit %d and no more than %d parts" ),
ComponentsList[ii].m_Unit, ComponentsList[ii].m_Entry->GetPartCount() );
ComponentsList[ii].m_Unit,
ComponentsList[ii].m_Entry->GetPartCount() );
msg << Buff;
if( aMessageList )
{
@ -743,7 +774,7 @@ int WinEDA_SchematicFrame::CheckAnnotate( wxArrayString* aMessageList, bool aOne
msg.Empty();
Buff.Empty();
if( (ComponentsList[ii].CompareRef( ComponentsList[ii + 1] ) != 0)
if( ( ComponentsList[ii].CompareRef( ComponentsList[ii + 1] ) != 0 )
|| ( ComponentsList[ii].m_NumRef != ComponentsList[ii + 1].m_NumRef ) )
continue;
@ -760,7 +791,8 @@ int WinEDA_SchematicFrame::CheckAnnotate( wxArrayString* aMessageList, bool aOne
msg.Printf( _( "Multiple item %s%s" ),
cmpref.GetData(), Buff.GetData() );
if( (ComponentsList[ii].m_Unit > 0) && (ComponentsList[ii].m_Unit < 0x7FFFFFFF) )
if( ( ComponentsList[ii].m_Unit > 0 )
&& ( ComponentsList[ii].m_Unit < 0x7FFFFFFF ) )
{
Buff.Printf( _( " (unit %d)" ), ComponentsList[ii].m_Unit );
msg << Buff;
@ -776,8 +808,9 @@ int WinEDA_SchematicFrame::CheckAnnotate( wxArrayString* aMessageList, bool aOne
}
/* Test error if units are different but number of parts per package
* too hight (ex U3 ( 1 part) and we find U3B this is an error) */
if( ComponentsList[ii].m_Entry->GetPartCount() != ComponentsList[ii + 1].m_Entry->GetPartCount() )
* too high (ex U3 ( 1 part) and we find U3B this is an error) */
if( ComponentsList[ii].m_Entry->GetPartCount()
!= ComponentsList[ii + 1].m_Entry->GetPartCount() )
{
if( ComponentsList[ii].m_NumRef >= 0 )
Buff << ComponentsList[ii].m_NumRef;
@ -788,7 +821,8 @@ int WinEDA_SchematicFrame::CheckAnnotate( wxArrayString* aMessageList, bool aOne
msg.Printf( _( "Multiple item %s%s" ),
cmpref.GetData(), Buff.GetData() );
if( (ComponentsList[ii].m_Unit > 0) && (ComponentsList[ii].m_Unit < 0x7FFFFFFF) )
if( ( ComponentsList[ii].m_Unit > 0 )
&& ( ComponentsList[ii].m_Unit < 0x7FFFFFFF ) )
{
Buff.Printf( _( " (unit %d)" ), ComponentsList[ii].m_Unit );
msg << Buff;
@ -799,11 +833,14 @@ int WinEDA_SchematicFrame::CheckAnnotate( wxArrayString* aMessageList, bool aOne
aMessageList->Add( msg + wxT( "\n" ));
}
else
{
DisplayError( NULL, msg );
}
error++;
}
/* Error if values are different between units, for the same reference */
/* Error if values are different between units, for the same
* reference */
int next = ii + 1;
if( ComponentsList[ii].CompareValue( ComponentsList[next] ) != 0 )
{
@ -812,40 +849,47 @@ int WinEDA_SchematicFrame::CheckAnnotate( wxArrayString* aMessageList, bool aOne
nextcmpref = CONV_FROM_UTF8( ComponentsList[next].m_Reference );
#if defined(KICAD_GOST)
msg.Printf( _( "Diff values for %s%d.%c (%s) and %s%d.%c (%s)" ),
cmpref.GetData(),
ComponentsList[ii].m_NumRef,
ComponentsList[ii].m_Unit + '1' - 1,
ComponentsList[ii].m_Value->GetData(), nextcmpref.GetData(),
ComponentsList[next].m_NumRef,
ComponentsList[next].m_Unit + '1' - 1,
ComponentsList[next].m_Value->GetData() );
cmpref.GetData(),
ComponentsList[ii].m_NumRef,
ComponentsList[ii].m_Unit + '1' - 1,
ComponentsList[ii].m_Value->GetData(),
nextcmpref.GetData(),
ComponentsList[next].m_NumRef,
ComponentsList[next].m_Unit + '1' - 1,
ComponentsList[next].m_Value->GetData() );
#else
msg.Printf( _( "Diff values for %s%d%c (%s) and %s%d%c (%s)" ),
cmpref.GetData(),
ComponentsList[ii].m_NumRef,
ComponentsList[ii].m_Unit + 'A' - 1,
ComponentsList[ii].m_Value->GetData(), nextcmpref.GetData(),
ComponentsList[next].m_NumRef,
ComponentsList[next].m_Unit + 'A' - 1,
ComponentsList[next].m_Value->GetData() );
cmpref.GetData(),
ComponentsList[ii].m_NumRef,
ComponentsList[ii].m_Unit + 'A' - 1,
ComponentsList[ii].m_Value->GetData(),
nextcmpref.GetData(),
ComponentsList[next].m_NumRef,
ComponentsList[next].m_Unit + 'A' - 1,
ComponentsList[next].m_Value->GetData() );
#endif
if( aMessageList )
{
aMessageList->Add( msg + wxT( "\n" ));
}
}
else
{
DisplayError( NULL, msg );
}
error++;
}
}
// count the duplicated time stamps
sort( ComponentsList.begin(), ComponentsList.end(), SortByTimeStamp );
for( int ii = 0; (ii < imax) && (error < 4); ii++ )
for( int ii = 0; ( ii < imax ) && ( error < 4 ); ii++ )
{
if( (ComponentsList[ii].m_TimeStamp != ComponentsList[ii + 1].m_TimeStamp)
|| ( ComponentsList[ii].m_SheetPath != ComponentsList[ii + 1].m_SheetPath ) )
if( (ComponentsList[ii].m_TimeStamp
!= ComponentsList[ii + 1].m_TimeStamp)
|| ( ComponentsList[ii].m_SheetPath
!= ComponentsList[ii + 1].m_SheetPath ) )
continue;
/* Same time stamp found. */
@ -862,10 +906,13 @@ int WinEDA_SchematicFrame::CheckAnnotate( wxArrayString* aMessageList, bool aOne
nextcmpref.GetData(), ComponentsList[ii + 1].m_NumRef );
if( aMessageList )
{
aMessageList->Add( msg + wxT( "\n" ));
}
aMessageList->Add( msg + wxT( "\n" ));
}
else
{
DisplayError( NULL, msg );
}
error++;
}
@ -896,7 +943,8 @@ static bool SortItemByTimeStamp( const SCH_ITEM* item1, const SCH_ITEM* item2 )
/** Function ReplaceDuplicatedTimeStamps
* Search for duplicate time stamps in the whole hierarchy, and replace duplicae by new time stamps
* Search for duplicate time stamps in the whole hierarchy, and replace
* duplicate by new time stamps
*/
int ReplaceDuplicatedTimeStamps()
{
@ -904,19 +952,22 @@ int ReplaceDuplicatedTimeStamps()
EDA_ScreenList ScreenList;
/* Build the list of items with time stamps (components and sheets)
* note: if all items have a different time stamp, this ensure also different paths in complex hierarchy
* this is the reason we have differant time stamps for components AND sheets
* note: if all items have a different time stamp, this ensure also
* different paths in complex hierarchy
* this is the reason we have different time stamps for components AND
* sheets
*/
std::vector <SCH_ITEM*> itemlist;
SCH_SCREEN* screen;
SCH_ITEM* item;
for( screen = ScreenList.GetFirst(); screen != NULL; screen = ScreenList.GetNext() )
for( screen = ScreenList.GetFirst(); screen != NULL;
screen = ScreenList.GetNext() )
{
item = screen->EEDrawList;
while( item )
{
if( (item->Type() == DRAW_SHEET_STRUCT_TYPE)
|| (item->Type() == TYPE_SCH_COMPONENT) )
if( ( item->Type() == DRAW_SHEET_STRUCT_TYPE )
|| ( item->Type() == TYPE_SCH_COMPONENT ) )
itemlist.push_back( item );
item = item->Next();
@ -924,7 +975,6 @@ int ReplaceDuplicatedTimeStamps()
}
// Test and replace duplicated time stamps
int imax = itemlist.size() - 1;
int errcount = 0;
sort( itemlist.begin(), itemlist.end(), SortItemByTimeStamp );
@ -936,12 +986,15 @@ int ReplaceDuplicatedTimeStamps()
{
errcount++;
// for a component, update its Time stamp and its paths (m_PathsAndReferences field)
// for a component, update its Time stamp and its paths
// (m_PathsAndReferences field)
if( item->Type() == TYPE_SCH_COMPONENT )
( (SCH_COMPONENT*) item )->SetTimeStamp( GetTimeStamp() );
// for a sheet, update only its time stamp (annotation of its components will be lost)
// TODO: see how to change sheet paths for its cmp list (can be possible in most cases)
// for a sheet, update only its time stamp (annotation of its
// components will be lost)
// @todo: see how to change sheet paths for its cmp list (can
// be possible in most cases)
else
item->m_TimeStamp = GetTimeStamp();
}

42
eeschema/backanno.cpp
View File

@ -1,7 +1,7 @@
/****************************************************************
* EESchema: backanno.cpp
* (functions for backannotating Footprint info
****************************************************************/
* EESchema: backanno.cpp
* (functions for backannotating Footprint info
****************************************************************/
#include "fctsys.h"
#include "common.h"
@ -14,15 +14,10 @@
#include "general.h"
bool WinEDA_SchematicFrame::FillFootprintFieldForAllInstancesofComponent(
const wxString& aReference,
const wxString& aFootPrint,
bool aSetVisible )
{
/** function FillFootprintFieldForAllInstancesofComponent
* Search for component "aReference", and place a Footprint in Footprint field
* @param aReference = reference of the component to initialize
* @param aFootPrint = new value for the filed Fottprint component
* @param aFootPrint = new value for the filed Footprint component
* @param aSetVisible = true to have the field visible, false to set the
* invisible flag
* @return true if the given component is found
@ -33,11 +28,16 @@ bool WinEDA_SchematicFrame::FillFootprintFieldForAllInstancesofComponent(
* the search is not stopped when a reference is found (all instances must be
* found).
*/
DrawSheetPath* sheet;
SCH_ITEM* DrawList = NULL;
EDA_SheetList SheetList;
SCH_COMPONENT* Cmp;
bool found = false;
bool WinEDA_SchematicFrame::FillFootprintFieldForAllInstancesofComponent(
const wxString& aReference,
const wxString& aFootPrint,
bool aSetVisible )
{
SCH_SHEET_PATH* sheet;
SCH_ITEM* DrawList = NULL;
SCH_SHEET_LIST SheetList;
SCH_COMPONENT* Cmp;
bool found = false;
for( sheet = SheetList.GetFirst();
sheet != NULL;
@ -82,9 +82,6 @@ bool WinEDA_SchematicFrame::FillFootprintFieldForAllInstancesofComponent(
}
bool WinEDA_SchematicFrame::ProcessStuffFile( FILE* aStuffFile, bool
aSetFielsAttributeToVisible )
{
/** Function ProcessStuffFile
* Read a "stuff" file created by cvpcb.
* That file has lines like:
@ -99,6 +96,9 @@ bool WinEDA_SchematicFrame::ProcessStuffFile( FILE* aStuffFile, bool
* visible
* @return true if OK.
*/
bool WinEDA_SchematicFrame::ProcessStuffFile( FILE* aStuffFile, bool
aSetFielsAttributeToVisible )
{
int LineNum = 0;
char* cp, Ref[256], FootPrint[256], Line[1024];
@ -127,10 +127,10 @@ bool WinEDA_SchematicFrame::ProcessStuffFile( FILE* aStuffFile, bool
}
bool WinEDA_SchematicFrame::ReadInputStuffFile()
{
/* Backann footprint info to schematic.
*/
bool WinEDA_SchematicFrame::ReadInputStuffFile()
{
wxString Line, filename;
FILE* StuffFile;
wxString msg;
@ -157,7 +157,7 @@ bool WinEDA_SchematicFrame::ReadInputStuffFile()
return FALSE;
int diag = wxMessageBox(
_( "Set the Footprint Field to Visible ?" ),
_( "Set the foot print field to visible?" ),
_( "Field Display Option" ),
wxYES_NO | wxICON_QUESTION | wxCANCEL, this );
@ -171,7 +171,7 @@ bool WinEDA_SchematicFrame::ReadInputStuffFile()
StuffFile = wxFopen( filename, wxT( "rt" ) );
if( StuffFile == NULL )
{
msg.Printf( _( "Failed to open Stuff File <%s>" ), filename.GetData() );
msg.Printf( _( "Failed to open stuff file <%s>" ), filename.GetData() );
DisplayError( this, msg, 20 );
return FALSE;
}

96
eeschema/block.cpp
View File

@ -1,5 +1,5 @@
/****************************************************/
/* BLOCK.CPP */
/* BLOCK.CPP */
/****************************************************/
#include "fctsys.h"
@ -39,13 +39,11 @@ static void DrawMovingBlockOutlines( WinEDA_DrawPanel* panel,
static void SaveStructListForPaste( PICKED_ITEMS_LIST& aItemsList );
/*************************************************************************/
int WinEDA_SchematicFrame::ReturnBlockCommand( int key )
{
/*************************************************************************/
/* Return the block command (BLOCK_MOVE, BLOCK_COPY...) corresponding to
* the key (ALT, SHIFT ALT ..)
*/
int WinEDA_SchematicFrame::ReturnBlockCommand( int key )
{
int cmd;
switch( key )
@ -80,12 +78,10 @@ int WinEDA_SchematicFrame::ReturnBlockCommand( int key )
}
/*************************************************/
void WinEDA_SchematicFrame::InitBlockPasteInfos()
{
/*************************************************/
/* Init the parameters used by the block paste command
*/
void WinEDA_SchematicFrame::InitBlockPasteInfos()
{
BLOCK_SELECTOR* block = &GetScreen()->m_BlockLocate;
block->m_ItemsSelection.CopyList( g_BlockSaveDataList.m_ItemsSelection );
@ -93,15 +89,13 @@ void WinEDA_SchematicFrame::InitBlockPasteInfos()
}
/******************************************************/
void WinEDA_SchematicFrame::HandleBlockPlace( wxDC* DC )
{
/******************************************************/
/* Routine to handle the BLOCK PLACE command
* Last routine for block operation for:
* - block move & drag
* - block copy & paste
*/
void WinEDA_SchematicFrame::HandleBlockPlace( wxDC* DC )
{
bool err = FALSE;
BLOCK_SELECTOR* block = &GetScreen()->m_BlockLocate;
@ -208,16 +202,14 @@ void WinEDA_SchematicFrame::HandleBlockPlace( wxDC* DC )
}
/****************************************************/
int WinEDA_SchematicFrame::HandleBlockEnd( wxDC* DC )
{
/****************************************************/
/* Manage end block command
* Returns:
* 0 if no features selected
* 1 otherwise
* -1 If control ended and components selection (block delete, block save)
*/
int WinEDA_SchematicFrame::HandleBlockEnd( wxDC* DC )
{
int ii = 0;
bool zoom_command = FALSE;
BLOCK_SELECTOR* block = &GetScreen()->m_BlockLocate;
@ -244,7 +236,7 @@ int WinEDA_SchematicFrame::HandleBlockEnd( wxDC* DC )
DisplayError( this, wxT( "Error in HandleBlockPLace()" ) );
break;
case BLOCK_DRAG: /* Drag */
case BLOCK_DRAG: /* Drag */
BreakSegmentOnJunction( (SCH_SCREEN*) GetScreen() );
case BLOCK_MOVE: /* Move */
@ -283,7 +275,7 @@ int WinEDA_SchematicFrame::HandleBlockEnd( wxDC* DC )
DrawPanel->Refresh();
break;
case BLOCK_SAVE: /* Save */
case BLOCK_SAVE: /* Save */
PickItemsInBlock( GetScreen()->m_BlockLocate, GetScreen() );
DrawAndSizingBlockOutlines( DrawPanel, DC, FALSE );
if( block->GetCount() )
@ -349,14 +341,12 @@ int WinEDA_SchematicFrame::HandleBlockEnd( wxDC* DC )
}
/***********************************************************************/
void WinEDA_SchematicFrame::HandleBlockEndByPopUp( int Command, wxDC* DC )
{
/***********************************************************************/
/* Manage end block command from context menu.
* Called after HandleBlockEnd.
* From the command block move can execute a command other than block move.
*/
void WinEDA_SchematicFrame::HandleBlockEndByPopUp( int Command, wxDC* DC )
{
int ii = 0;
BLOCK_SELECTOR* block = &GetScreen()->m_BlockLocate;
@ -476,14 +466,12 @@ void WinEDA_SchematicFrame::HandleBlockEndByPopUp( int Command, wxDC* DC )
}
/************************************************************************/
static void DrawMovingBlockOutlines( WinEDA_DrawPanel* panel, wxDC* DC,
bool erase )
{
/************************************************************************/
/* Traces the outline of the search block structures
* The entire block follows the cursor
*/
static void DrawMovingBlockOutlines( WinEDA_DrawPanel* panel, wxDC* DC,
bool erase )
{
BLOCK_SELECTOR* block = &panel->GetScreen()->m_BlockLocate;;
BASE_SCREEN* screen = panel->GetScreen();
@ -513,15 +501,13 @@ static void DrawMovingBlockOutlines( WinEDA_DrawPanel* panel, wxDC* DC,
}
/*****************************************************************/
void SaveStructListForPaste( PICKED_ITEMS_LIST& aItemsList )
{
/*****************************************************************/
/* Routine to Save an object from global drawing object list.
* This routine is the same as delete but:
* - the original list is NOT removed.
* - List is saved in g_BlockSaveDataList
*/
void SaveStructListForPaste( PICKED_ITEMS_LIST& aItemsList )
{
g_BlockSaveDataList.ClearListAndDeleteItems(); // delete previous
// saved list, if
// exists
@ -542,7 +528,7 @@ void SaveStructListForPaste( PICKED_ITEMS_LIST& aItemsList )
/*****************************************************************************
* Routine to paste a structure from the g_BlockSaveDataList stack.
* This routine is the same as undelete but original list is NOT removed.
* This routine is the same as undelete but original list is NOT removed.
*****************************************************************************/
void WinEDA_SchematicFrame::PasteListOfItems( wxDC* DC )
{
@ -594,16 +580,14 @@ void WinEDA_SchematicFrame::PasteListOfItems( wxDC* DC )
}
/****************************************************/
static void CollectStructsToDrag( SCH_SCREEN* screen )
{
/****************************************************/
/* creates the list of items found when a drag block is initiated.
* items are those selected in window block an some items outside this area but
* connected to a selected item (connected wires to a component or an entry )
*/
SCH_ITEM* Struct;
EDA_DrawLineStruct* SegmStruct;
static void CollectStructsToDrag( SCH_SCREEN* screen )
{
SCH_ITEM* Struct;
SCH_LINE* SegmStruct;
PICKED_ITEMS_LIST* pickedlist = &screen->m_BlockLocate.m_ItemsSelection;
@ -645,7 +629,7 @@ static void CollectStructsToDrag( SCH_SCREEN* screen )
Struct = (SCH_ITEM*) (SCH_ITEM*) pickedlist->GetPickedItem( ii );
if( Struct->Type() == DRAW_SEGMENT_STRUCT_TYPE )
{
SegmStruct = (EDA_DrawLineStruct*) Struct;
SegmStruct = (SCH_LINE*) Struct;
if( !screen->m_BlockLocate.Inside( SegmStruct->m_Start ) )
SegmStruct->m_Flags |= STARTPOINT;
@ -698,7 +682,7 @@ static void CollectStructsToDrag( SCH_SCREEN* screen )
if( Struct->Type() == DRAW_BUSENTRY_STRUCT_TYPE )
{
DrawBusEntryStruct* item = (DrawBusEntryStruct*) Struct;
SCH_BUS_ENTRY* item = (SCH_BUS_ENTRY*) Struct;
AddPickedItem( screen, item->m_Pos );
AddPickedItem( screen, item->m_End() );
}
@ -706,16 +690,14 @@ static void CollectStructsToDrag( SCH_SCREEN* screen )
}
/******************************************************************/
static void AddPickedItem( SCH_SCREEN* screen, wxPoint position )
{
/******************************************************************/
/** AddPickedItem
* add to the picked list in screen->m_BlockLocate items found at location
* position
* @param screen = the screen to consider
* @param position = the wxPoint where items must be located to be select
*/
static void AddPickedItem( SCH_SCREEN* screen, wxPoint position )
{
SCH_ITEM* Struct;
/* Review the list of already selected elements. */
@ -729,7 +711,7 @@ static void AddPickedItem( SCH_SCREEN* screen, wxPoint position )
{
case DRAW_SEGMENT_STRUCT_TYPE:
#undef STRUCT
#define STRUCT ( (EDA_DrawLineStruct*) Struct )
#define STRUCT ( (SCH_LINE*) Struct )
if( STRUCT->m_Start == position )
STRUCT->m_Flags &= ~STARTPOINT;
@ -765,7 +747,7 @@ static void AddPickedItem( SCH_SCREEN* screen, wxPoint position )
case DRAW_JUNCTION_STRUCT_TYPE:
#undef STRUCT
#define STRUCT ( (DrawJunctionStruct*) Struct )
#define STRUCT ( (SCH_JUNCTION*) Struct )
if( Struct->m_Flags & SELECTED )
break;
if( STRUCT->m_Pos != position )
@ -775,7 +757,7 @@ static void AddPickedItem( SCH_SCREEN* screen, wxPoint position )
case DRAW_SEGMENT_STRUCT_TYPE:
#undef STRUCT
#define STRUCT ( (EDA_DrawLineStruct*) Struct )
#define STRUCT ( (SCH_LINE*) Struct )
if( Struct->m_Flags & SELECTED )
break;
if( STRUCT->m_Start == position )
@ -832,9 +814,9 @@ static void AddPickedItem( SCH_SCREEN* screen, wxPoint position )
case DRAW_HIERARCHICAL_PIN_SHEET_STRUCT_TYPE:
break;
case TYPE_MARKER_SCH:
case TYPE_SCH_MARKER:
#undef STRUCT
#define STRUCT ( (MARKER_SCH*) Struct )
#define STRUCT ( (SCH_MARKER*) Struct )
if( Struct->m_Flags & SELECTED )
break; /* Already in list */
if( STRUCT->m_Pos != position )
@ -845,7 +827,7 @@ static void AddPickedItem( SCH_SCREEN* screen, wxPoint position )
case DRAW_NOCONNECT_STRUCT_TYPE:
#undef STRUCT
#define STRUCT ( (DrawNoConnectStruct*) Struct )
#define STRUCT ( (SCH_NO_CONNECT*) Struct )
if( Struct->m_Flags & SELECTED )
break; /* Already in list */
if( STRUCT->m_Pos != position )
@ -862,12 +844,6 @@ static void AddPickedItem( SCH_SCREEN* screen, wxPoint position )
}
/****************************************************************************/
static LIB_PIN* GetNextPinPosition( SCH_COMPONENT* aDrawLibItem,
wxPoint& aPosition,
bool aSearchFirst )
{
/****************************************************************************/
/** GetNextPinPosition()
* calculate position of the "next" pin of the aDrawLibItem component
* @param aDrawLibItem = component to test.
@ -876,6 +852,10 @@ static LIB_PIN* GetNextPinPosition( SCH_COMPONENT* aDrawLibItem,
* @param aSearchFirst = if true, search for the first pin
* @return a pointer to the pin
*/
static LIB_PIN* GetNextPinPosition( SCH_COMPONENT* aDrawLibItem,
wxPoint& aPosition,
bool aSearchFirst )
{
static LIB_COMPONENT* Entry;
static int Multi, convert, TransMat[2][2];
static wxPoint CmpPosition;
@ -908,7 +888,7 @@ static LIB_PIN* GetNextPinPosition( SCH_COMPONENT* aDrawLibItem,
continue;
/* Calculate the pin position (according to the component orientation)
**/
*/
aPosition = TransformCoordinate( TransMat, Pin->m_Pos ) + CmpPosition;
return Pin;
}

140
eeschema/build_BOM.cpp
View File

@ -1,9 +1,8 @@
/////////////////////////////////////////////////////////////////////////////
// Name: build_BOM.cpp
// Purpose:
// Author: jean-pierre Charras
// License: GPL license
// License: GPL license
/////////////////////////////////////////////////////////////////////////////
#include <algorithm> // to use sort vector
@ -25,6 +24,11 @@
#include "dialog_build_BOM.h"
/**
* @bug - Every instance of fprintf() and fputs() in this file fails to check
* the return value for an error.
*/
/* object used in build BOM to handle the list of labels in schematic
* because in a complex hierarchy, a label is used more than once,
* and had more than one sheet path, so we must create a flat list of labels
@ -32,11 +36,11 @@
class LABEL_OBJECT
{
public:
int m_LabelType;
SCH_ITEM* m_Label;
int m_LabelType;
SCH_ITEM* m_Label;
//have to store it here since the object references will be duplicated.
DrawSheetPath m_SheetPath; //composed of UIDs
SCH_SHEET_PATH m_SheetPath; //composed of UIDs
public: LABEL_OBJECT()
{
@ -51,7 +55,6 @@ static const wxString BomFileExtension( wxT( "lst" ) );
#define BomFileWildcard _( "Bill of Materials file (*.lst)|*.lst" )
/* Local functions */
static void BuildComponentsListFromSchematic(
std::vector <OBJ_CMP_TO_LIST>& aList );
static void GenListeGLabels( std::vector <LABEL_OBJECT>& aList );
@ -73,19 +76,16 @@ int SplitString( wxString strToSplit,
wxString* strDigits,
wxString* strEnd );
/* Local variables */
/* separator used in bom export to spreadsheet */
static char s_ExportSeparatorSymbol;
/**************************************************************************/
void DIALOG_BUILD_BOM::Create_BOM_Lists( bool aTypeFileIsExport,
bool aIncludeSubComponents,
char aExportSeparatorSymbol,
bool aRunBrowser )
{
/**************************************************************************/
wxFileName fn;
s_ExportSeparatorSymbol = aExportSeparatorSymbol;
@ -122,16 +122,14 @@ void DIALOG_BUILD_BOM::Create_BOM_Lists( bool aTypeFileIsExport,
}
/****************************************************************************/
void DIALOG_BUILD_BOM::CreateExportList( const wxString& aFullFileName,
bool aIncludeSubComponents )
{
/****************************************************************************/
/*
* Print a list of components, in a form which can be imported by a spreadsheet
* form is:
* cmp name; cmp val; fields;
*/
void DIALOG_BUILD_BOM::CreateExportList( const wxString& aFullFileName,
bool aIncludeSubComponents )
{
FILE* f;
wxString msg;
@ -159,17 +157,13 @@ void DIALOG_BUILD_BOM::CreateExportList( const wxString& aFullFileName,
}
/****************************************************************************/
void DIALOG_BUILD_BOM::GenereListeOfItems(
const wxString& aFullFileName,
bool
aIncludeSubComponents )
{
/****************************************************************************/
/** GenereListeOfItems()
* Main function to create the list of components and/or labels
* (global labels and pin sheets" )
*/
void DIALOG_BUILD_BOM::GenereListeOfItems( const wxString& aFullFileName,
bool aIncludeSubComponents )
{
FILE* f;
int itemCount;
char Line[1024];
@ -212,7 +206,7 @@ void DIALOG_BUILD_BOM::GenereListeOfItems(
}
/*************************************************/
/* Create list of global labels and pins sheets */
/* Create list of global labels and pins sheets */
/*************************************************/
std::vector <LABEL_OBJECT> listOfLabels;
GenListeGLabels( listOfLabels );
@ -246,10 +240,6 @@ order = Alphab. ) count = %d\n\n" ),
}
/***************************************************************************/
void BuildComponentsListFromSchematic( std::vector <OBJ_CMP_TO_LIST>& aList )
{
/***************************************************************************/
/* Creates the list of components found in the whole schematic
*
* if List == null, just returns the count. if not, fills the list.
@ -257,12 +247,14 @@ void BuildComponentsListFromSchematic( std::vector <OBJ_CMP_TO_LIST>& aList )
* multiple instances of a given screen.
* Also Initialize m_Father as pointer of the SCH_SCREEN parent
*/
void BuildComponentsListFromSchematic( std::vector <OBJ_CMP_TO_LIST>& aList )
{
EDA_BaseStruct* SchItem;
SCH_COMPONENT* DrawLibItem;
DrawSheetPath* sheet;
SCH_SHEET_PATH* sheet;
/* Build the sheet (not screen) list */
EDA_SheetList SheetList;
SCH_SHEET_LIST SheetList;
for( sheet = SheetList.GetFirst();
sheet != NULL;
@ -293,20 +285,18 @@ void BuildComponentsListFromSchematic( std::vector <OBJ_CMP_TO_LIST>& aList )
}
/****************************************************************/
static void GenListeGLabels( std::vector <LABEL_OBJECT>& aList )
{
/****************************************************************/
/* Fill aList with Glabel info
*/
SCH_ITEM* DrawList;
SCH_SHEET_PIN* PinLabel;
DrawSheetPath* sheet;
static void GenListeGLabels( std::vector <LABEL_OBJECT>& aList )
{
SCH_ITEM* DrawList;
SCH_SHEET_PIN* PinLabel;
SCH_SHEET_PATH* sheet;
/* Build the sheet list */
EDA_SheetList SheetList;
SCH_SHEET_LIST SheetList;
LABEL_OBJECT labet_object;
LABEL_OBJECT labet_object;
for( sheet = SheetList.GetFirst();
sheet != NULL;
@ -350,22 +340,20 @@ static void GenListeGLabels( std::vector <LABEL_OBJECT>& aList )
}
/*****************************************************************************/
bool SortComponentsByValue( const OBJ_CMP_TO_LIST& obj1,
const OBJ_CMP_TO_LIST& obj2 )
{
/*****************************************************************************/
/* Compare function for sort()
* components are sorted
* by value
* if same value: by reference
* if same reference: by unit number
*/
bool SortComponentsByValue( const OBJ_CMP_TO_LIST& obj1,
const OBJ_CMP_TO_LIST& obj2 )
{
int ii;
const wxString* Text1, * Text2;
Text1 = &(obj1.m_RootCmp->GetField( VALUE )->m_Text);
Text2 = &(obj2.m_RootCmp->GetField( VALUE )->m_Text);
Text1 = &( obj1.m_RootCmp->GetField( VALUE )->m_Text );
Text2 = &( obj2.m_RootCmp->GetField( VALUE )->m_Text );
ii = Text1->CmpNoCase( *Text2 );
if( ii == 0 )
@ -382,17 +370,15 @@ bool SortComponentsByValue( const OBJ_CMP_TO_LIST& obj1,
}
/*****************************************************************************/
bool SortComponentsByReference( const OBJ_CMP_TO_LIST& obj1,
const OBJ_CMP_TO_LIST& obj2 )
{
/*****************************************************************************/
/* compare function for sorting
* components are sorted
* by reference
* if same reference: by value
* if same value: by unit number
*/
bool SortComponentsByReference( const OBJ_CMP_TO_LIST& obj1,
const OBJ_CMP_TO_LIST& obj2 )
{
int ii;
const wxString* Text1, * Text2;
@ -414,15 +400,13 @@ bool SortComponentsByReference( const OBJ_CMP_TO_LIST& obj1,
}
/******************************************************************/
bool SortLabelsByValue( const LABEL_OBJECT& obj1, const LABEL_OBJECT& obj2 )
{
/*******************************************************************/
/* compare function for sorting labels
* sort by
* value
* if same value: by sheet
*/
bool SortLabelsByValue( const LABEL_OBJECT& obj1, const LABEL_OBJECT& obj2 )
{
int ii;
wxString* Text1, * Text2;
@ -447,14 +431,12 @@ bool SortLabelsByValue( const LABEL_OBJECT& obj1, const LABEL_OBJECT& obj2 )
}
/*****************************************************************************/
bool SortLabelsBySheet( const LABEL_OBJECT& obj1, const LABEL_OBJECT& obj2 )
{
/*****************************************************************************/
/* compare function for sorting labels
* by sheet
* in a sheet, by alphabetic order
*/
bool SortLabelsBySheet( const LABEL_OBJECT& obj1, const LABEL_OBJECT& obj2 )
{
int ii;
wxString Text1, Text2;
@ -480,14 +462,12 @@ bool SortLabelsBySheet( const LABEL_OBJECT& obj1, const LABEL_OBJECT& obj2 )
}
/**************************************************************/
static void DeleteSubCmp( std::vector <OBJ_CMP_TO_LIST>& aList )
{
/**************************************************************/
/* Remove sub components from the list, when multiples parts per package are
* found in this list
* The component list **MUST** be sorted by reference and by unit number
*/
static void DeleteSubCmp( std::vector <OBJ_CMP_TO_LIST>& aList )
{
SCH_COMPONENT* libItem;
wxString oldName;
wxString currName;
@ -515,11 +495,9 @@ static void DeleteSubCmp( std::vector <OBJ_CMP_TO_LIST>& aList )
}
/****************************************************************************/
void DIALOG_BUILD_BOM::PrintFieldData( FILE* f, SCH_COMPONENT* DrawLibItem,
bool CompactForm )
{
/****************************************************************************/
// @todo make this variable length
const wxCheckBox* FieldListCtrl[] =
{
@ -544,8 +522,10 @@ void DIALOG_BUILD_BOM::PrintFieldData( FILE* f, SCH_COMPONENT* DrawLibItem,
CONV_TO_UTF8( DrawLibItem->GetField( FOOTPRINT )->m_Text ) );
}
else
{
fprintf( f, "; %-12s",
CONV_TO_UTF8( DrawLibItem->GetField( FOOTPRINT )->m_Text ) );
}
}
for( ii = FIELD1; ii < DrawLibItem->GetFieldCount(); ii++ )
@ -574,16 +554,14 @@ void DIALOG_BUILD_BOM::PrintFieldData( FILE* f, SCH_COMPONENT* DrawLibItem,
}
/****************************************************************************/
/* Print the B.O.M sorted by reference
*/
int DIALOG_BUILD_BOM::PrintComponentsListByRef(
FILE* f,
std::vector <OBJ_CMP_TO_LIST>& aList,
bool CompactForm,
bool aIncludeSubComponents )
{
/****************************************************************************/
/* Print the B.O.M sorted by reference
*/
int Multi, Unit;
EDA_BaseStruct* DrawList;
SCH_COMPONENT* DrawLibItem;
@ -665,10 +643,8 @@ int DIALOG_BUILD_BOM::PrintComponentsListByRef(
if( ( Multi > 1 ) && aIncludeSubComponents )
#if defined(KICAD_GOST)
Unit = aList[ii].m_Unit + '1' - 1;
#else
Unit = aList[ii].m_Unit + 'A' - 1;
#endif
@ -688,7 +664,8 @@ int DIALOG_BUILD_BOM::PrintComponentsListByRef(
msg = aList[ii].m_SheetPath.PathHumanReadable();
if( CompactForm )
{
fprintf( f, "%c%s", s_ExportSeparatorSymbol, CONV_TO_UTF8( msg ) );
fprintf( f, "%c%s", s_ExportSeparatorSymbol,
CONV_TO_UTF8( msg ) );
msg = m_Parent->GetXYSheetReferences(
(BASE_SCREEN*) DrawLibItem->GetParent(),
DrawLibItem->m_Pos );
@ -715,17 +692,16 @@ int DIALOG_BUILD_BOM::PrintComponentsListByRef(
msg = _( "#End Cmp\n" );
fputs( CONV_TO_UTF8( msg ), f );
}
return 0;
}
/*****************************************************************************/
int DIALOG_BUILD_BOM::PrintComponentsListByVal(
FILE* f,
std::vector <OBJ_CMP_TO_LIST>& aList,
bool aIncludeSubComponents )
{
/*****************************************************************************/
int Multi;
wxChar Unit;
EDA_BaseStruct* DrawList;
@ -799,10 +775,8 @@ int DIALOG_BUILD_BOM::PrintComponentsListByVal(
}
/************************************************************************/
static int PrintListeGLabel( FILE* f, std::vector <LABEL_OBJECT>& aList )
{
/************************************************************************/
SCH_LABEL* DrawTextItem;
SCH_SHEET_PIN* DrawSheetLabel;
wxString msg, sheetpath;
@ -864,16 +838,14 @@ static int PrintListeGLabel( FILE* f, std::vector <LABEL_OBJECT>& aList )
}
/********************************************/
int RefDesStringCompare( const char* obj1, const char* obj2 )
{
/********************************************/
/* This function will act just like the strcmp function but correctly sort
* the numerical order in the string
* return -1 if first string is less than the second
* return 0 if the strings are equal
* return 1 if the first string is greater than the second
*/
int RefDesStringCompare( const char* obj1, const char* obj2 )
{
/* The strings we are going to compare */
wxString strFWord;
wxString strSWord;
@ -932,19 +904,17 @@ int RefDesStringCompare( const char* obj1, const char* obj2 )
}
/****************************************************************************/
int SplitString( wxString strToSplit,
wxString* strBeginning,
wxString* strDigits,
wxString* strEnd )
{
/****************************************************************************/
/* This is the function that breaks a string into three parts.
* The alphabetic preamble
* The numeric part
* Any alphabetic ending
* For example C10A is split to C 10 A
*/
int SplitString( wxString strToSplit,
wxString* strBeginning,
wxString* strDigits,
wxString* strEnd )
{
/* Clear all the return strings */
strBeginning->Clear();
strDigits->Clear();

175
eeschema/bus-wire-junction.cpp
View File

@ -22,16 +22,12 @@ static void Segment_in_Ghost( WinEDA_DrawPanel* panel, wxDC* DC, bool erase );
static void AbortCreateNewLine( WinEDA_DrawPanel* Panel, wxDC* DC );
static bool IsTerminalPoint( SCH_SCREEN* screen, const wxPoint& pos, int layer );
static bool IsJunctionNeeded( WinEDA_SchematicFrame* frame, wxPoint& pos );
static void ComputeBreakPoint( EDA_DrawLineStruct* segment,
const wxPoint& new_pos );
static void ComputeBreakPoint( SCH_LINE* segment, const wxPoint& new_pos );
SCH_ITEM* s_OldWiresList;
wxPoint s_ConnexionStartPoint;
/*********************************************************/
SCH_ITEM* SCH_SCREEN::ExtractWires( bool CreateCopy )
{
/*********************************************************/
/* Extract the old wires, junctions and buses, an if CreateCopy replace them
* by a copy. Old ones must be put in undo list, and the new ones can be
* modified by clean up safely.
@ -43,6 +39,8 @@ SCH_ITEM* SCH_SCREEN::ExtractWires( bool CreateCopy )
* Because cleanup delete and/or modify bus and wires, the more easy is to put
* all wires in undo list and use a new copy of wires for cleanup.
*/
SCH_ITEM* SCH_SCREEN::ExtractWires( bool CreateCopy )
{
SCH_ITEM* item, * next_item, * new_item, * List = NULL;
for( item = EEDrawList; item != NULL; item = next_item )
@ -59,9 +57,9 @@ SCH_ITEM* SCH_SCREEN::ExtractWires( bool CreateCopy )
if( CreateCopy )
{
if( item->Type() == DRAW_JUNCTION_STRUCT_TYPE )
new_item = ( (DrawJunctionStruct*) item )->GenCopy();
new_item = ( (SCH_JUNCTION*) item )->GenCopy();
else
new_item = ( (EDA_DrawLineStruct*) item )->GenCopy();
new_item = ( (SCH_LINE*) item )->GenCopy();
new_item->SetNext( EEDrawList );
EEDrawList = new_item;
}
@ -76,12 +74,10 @@ SCH_ITEM* SCH_SCREEN::ExtractWires( bool CreateCopy )
}
/*************************************************/
static void RestoreOldWires( SCH_SCREEN* screen )
{
/*************************************************/
/* Replace the wires in screen->EEDrawList by s_OldWiresList wires.
*/
static void RestoreOldWires( SCH_SCREEN* screen )
{
SCH_ITEM* item;
SCH_ITEM* next_item;
@ -113,10 +109,6 @@ static void RestoreOldWires( SCH_SCREEN* screen )
}
/*************************************************************/
void WinEDA_SchematicFrame::BeginSegment( wxDC* DC, int type )
{
/*************************************************************/
/* Creates a new segment ( WIRE, BUS ),
* or terminates the current segment
* If the end of the current segment is on an other segment, place a junction
@ -124,8 +116,10 @@ void WinEDA_SchematicFrame::BeginSegment( wxDC* DC, int type )
* If the end of the current segment is on a pin, terminates the command
* In others cases starts a new segment
*/
EDA_DrawLineStruct* oldsegment, * newsegment, * nextsegment;
wxPoint cursorpos = GetScreen()->m_Curseur;
void WinEDA_SchematicFrame::BeginSegment( wxDC* DC, int type )
{
SCH_LINE* oldsegment, * newsegment, * nextsegment;
wxPoint cursorpos = GetScreen()->m_Curseur;
if( GetScreen()->GetCurItem() && (GetScreen()->GetCurItem()->m_Flags == 0) )
GetScreen()->SetCurItem( NULL );
@ -143,8 +137,7 @@ void WinEDA_SchematicFrame::BeginSegment( wxDC* DC, int type )
}
}
oldsegment = newsegment =
(EDA_DrawLineStruct*) GetScreen()->GetCurItem();
oldsegment = newsegment = (SCH_LINE*) GetScreen()->GetCurItem();
if( !newsegment ) /* first point : Create first wire or bus */
{
@ -155,18 +148,18 @@ void WinEDA_SchematicFrame::BeginSegment( wxDC* DC, int type )
switch( type )
{
default:
newsegment = new EDA_DrawLineStruct( cursorpos, LAYER_NOTES );
newsegment = new SCH_LINE( cursorpos, LAYER_NOTES );
break;
case LAYER_WIRE:
newsegment = new EDA_DrawLineStruct( cursorpos, LAYER_WIRE );
newsegment = new SCH_LINE( cursorpos, LAYER_WIRE );
/* A junction will be created later, when we'll know the
* segment end position, and if the junction is really needed */
break;
case LAYER_BUS:
newsegment = new EDA_DrawLineStruct( cursorpos, LAYER_BUS );
newsegment = new SCH_LINE( cursorpos, LAYER_BUS );
break;
}
@ -251,30 +244,27 @@ void WinEDA_SchematicFrame::BeginSegment( wxDC* DC, int type )
}
/***********************************************/
void WinEDA_SchematicFrame::EndSegment( wxDC* DC )
{
/***********************************************/
/* Called to terminate a bus, wire, or line creation
*/
EDA_DrawLineStruct* firstsegment =
(EDA_DrawLineStruct*) GetScreen()->GetCurItem();
EDA_DrawLineStruct* lastsegment = firstsegment;
EDA_DrawLineStruct* segment;
void WinEDA_SchematicFrame::EndSegment( wxDC* DC )
{
SCH_LINE* firstsegment = (SCH_LINE*) GetScreen()->GetCurItem();
SCH_LINE* lastsegment = firstsegment;
SCH_LINE* segment;
if( firstsegment == NULL )
return;
if( (firstsegment->m_Flags & IS_NEW) == 0 )
if( ( firstsegment->m_Flags & IS_NEW ) == 0 )
return;
/* Delete Null segments and Put line it in Drawlist */
lastsegment = firstsegment;
while( lastsegment )
{
EDA_DrawLineStruct* nextsegment = lastsegment->Next();
SCH_LINE* nextsegment = lastsegment->Next();
if( lastsegment->IsNull() )
{
EDA_DrawLineStruct* previous_segment = lastsegment->Back();
SCH_LINE* previous_segment = lastsegment->Back();
if( firstsegment == lastsegment )
firstsegment = nextsegment;
if( nextsegment )
@ -316,7 +306,7 @@ void WinEDA_SchematicFrame::EndSegment( wxDC* DC )
( (SCH_SCREEN*) GetScreen() )->SchematicCleanUp( NULL );
/* clear flags and find last segment entered, for repeat function */
segment = (EDA_DrawLineStruct*) GetScreen()->EEDrawList;
segment = (SCH_LINE*) GetScreen()->EEDrawList;
while( segment )
{
if( segment->m_Flags )
@ -375,17 +365,14 @@ void WinEDA_SchematicFrame::EndSegment( wxDC* DC )
}
/****************************************************************************/
static void Segment_in_Ghost( WinEDA_DrawPanel* panel, wxDC* DC, bool erase )
{
/****************************************************************************/
/* Redraw the segment (g_HVLines == FALSE ) or the two segments (g_HVLines ==
/* Redraw the segment (g_HVLines == FALSE ) or the two segments (g_HVLines ==
* TRUE )
* from the start point to the cursor, when moving the mouse
*/
EDA_DrawLineStruct* CurrentLine =
(EDA_DrawLineStruct*) panel->GetScreen()->GetCurItem();
EDA_DrawLineStruct* segment;
static void Segment_in_Ghost( WinEDA_DrawPanel* panel, wxDC* DC, bool erase )
{
SCH_LINE* CurrentLine = (SCH_LINE*) panel->GetScreen()->GetCurItem();
SCH_LINE* segment;
int color;
if( CurrentLine == NULL )
@ -422,23 +409,20 @@ static void Segment_in_Ghost( WinEDA_DrawPanel* panel, wxDC* DC, bool erase )
}
/***************************************************************************/
static void ComputeBreakPoint( EDA_DrawLineStruct* segment,
const wxPoint& new_pos )
{
/***************************************************************************/
/* compute the middle coordinate for 2 segments, from the start point to
* new_pos
* with the 2 segments kept H or V only
*/
EDA_DrawLineStruct* nextsegment = segment->Next();
wxPoint middle_position = new_pos;
static void ComputeBreakPoint( SCH_LINE* segment, const wxPoint& new_pos )
{
SCH_LINE* nextsegment = segment->Next();
wxPoint middle_position = new_pos;
if( nextsegment == NULL )
return;
#if 0
if( ABS( middle_position.x - segment->m_Start.x ) <
ABS( middle_position.y - segment->m_Start.y ) )
ABS( middle_position.y - segment->m_Start.y ) )
middle_position.x = segment->m_Start.x;
else
middle_position.y = segment->m_Start.y;
@ -458,7 +442,7 @@ static void ComputeBreakPoint( EDA_DrawLineStruct* segment,
else
{
if( ABS( middle_position.x - segment->m_Start.x ) <
ABS( middle_position.y - segment->m_Start.y ) )
ABS( middle_position.y - segment->m_Start.y ) )
middle_position.x = segment->m_Start.x;
else
middle_position.y = segment->m_Start.y;
@ -472,18 +456,15 @@ static void ComputeBreakPoint( EDA_DrawLineStruct* segment,
}
/*****************************************************************************/
/* Drawing Polyline phantom at the displacement of the cursor
*/
static void Show_Polyline_in_Ghost( WinEDA_DrawPanel* panel,
wxDC* DC,
bool erase )
{
/*****************************************************************************/
/* Drawing Polyline phantom at the displacement of the cursor
*/
DrawPolylineStruct* NewPoly =
(DrawPolylineStruct*) panel->GetScreen()->GetCurItem();
int color;
wxPoint endpos;
SCH_POLYLINE* NewPoly = (SCH_POLYLINE*) panel->GetScreen()->GetCurItem();
int color;
wxPoint endpos;
endpos = panel->GetScreen()->m_Curseur;
color = ReturnLayerColor( NewPoly->GetLayer() );
@ -509,17 +490,15 @@ static void Show_Polyline_in_Ghost( WinEDA_DrawPanel* panel,
}
/**********************************************************/
void WinEDA_SchematicFrame::DeleteCurrentSegment( wxDC* DC )
{
/**********************************************************/
/*
* Erase the last trace or the element at the current mouse position.
*/
void WinEDA_SchematicFrame::DeleteCurrentSegment( wxDC* DC )
{
g_ItemToRepeat = NULL;
if( (GetScreen()->GetCurItem() == NULL)
|| ( (GetScreen()->GetCurItem()->m_Flags & IS_NEW) == 0 ) )
if( ( GetScreen()->GetCurItem() == NULL )
|| ( ( GetScreen()->GetCurItem()->m_Flags & IS_NEW ) == 0 ) )
{
return;
}
@ -541,16 +520,14 @@ void WinEDA_SchematicFrame::DeleteCurrentSegment( wxDC* DC )
}
/***************************************************************************/
DrawJunctionStruct* WinEDA_SchematicFrame::CreateNewJunctionStruct(
wxDC* DC, const wxPoint& pos, bool PutInUndoList )
{
/***************************************************************************/
/* Routine to create new connection struct.
*/
DrawJunctionStruct* NewJunction;
SCH_JUNCTION* WinEDA_SchematicFrame::CreateNewJunctionStruct(
wxDC* DC, const wxPoint& pos, bool PutInUndoList )
{
SCH_JUNCTION* NewJunction;
NewJunction = new DrawJunctionStruct( pos );
NewJunction = new SCH_JUNCTION( pos );
g_ItemToRepeat = NewJunction;
@ -567,14 +544,12 @@ DrawJunctionStruct* WinEDA_SchematicFrame::CreateNewJunctionStruct(
}
/*******************************************************************************/
DrawNoConnectStruct* WinEDA_SchematicFrame::CreateNewNoConnectStruct( wxDC* DC )
{
/*******************************************************************************/
/* Routine to create new NoConnect struct. */
DrawNoConnectStruct* NewNoConnect;
SCH_NO_CONNECT* WinEDA_SchematicFrame::CreateNewNoConnectStruct( wxDC* DC )
{
SCH_NO_CONNECT* NewNoConnect;
NewNoConnect = new DrawNoConnectStruct( GetScreen()->m_Curseur );
NewNoConnect = new SCH_NO_CONNECT( GetScreen()->m_Curseur );
g_ItemToRepeat = NewNoConnect;
DrawPanel->CursorOff( DC ); // Erase schematic cursor
@ -589,12 +564,10 @@ DrawNoConnectStruct* WinEDA_SchematicFrame::CreateNewNoConnectStruct( wxDC* DC )
}
/*****************************************************************/
static void AbortCreateNewLine( WinEDA_DrawPanel* Panel, wxDC* DC )
{
/*****************************************************************/
/* Abort function for wire, bus or line creation
*/
static void AbortCreateNewLine( WinEDA_DrawPanel* Panel, wxDC* DC )
{
SCH_SCREEN* Screen = (SCH_SCREEN*) Panel->GetScreen();
if( Screen->GetCurItem() )
@ -619,14 +592,12 @@ static void AbortCreateNewLine( WinEDA_DrawPanel* Panel, wxDC* DC )
}
/***************************************************/
void WinEDA_SchematicFrame::RepeatDrawItem( wxDC* DC )
{
/***************************************************/
/* Repeat the last item placement.
* Bus lines, text, labels
* Labels that end with a number will be incremented.
*/
void WinEDA_SchematicFrame::RepeatDrawItem( wxDC* DC )
{
wxPoint new_pos;
if( g_ItemToRepeat == NULL )
@ -636,7 +607,7 @@ void WinEDA_SchematicFrame::RepeatDrawItem( wxDC* DC )
{
case DRAW_JUNCTION_STRUCT_TYPE:
#undef STRUCT
#define STRUCT ( (DrawJunctionStruct*) g_ItemToRepeat )
#define STRUCT ( (SCH_JUNCTION*) g_ItemToRepeat )
g_ItemToRepeat = STRUCT->GenCopy();
STRUCT->m_Pos += g_RepeatStep;
new_pos = STRUCT->m_Pos;
@ -644,7 +615,7 @@ void WinEDA_SchematicFrame::RepeatDrawItem( wxDC* DC )
case DRAW_NOCONNECT_STRUCT_TYPE:
#undef STRUCT
#define STRUCT ( (DrawNoConnectStruct*) g_ItemToRepeat )
#define STRUCT ( (SCH_NO_CONNECT*) g_ItemToRepeat )
g_ItemToRepeat = STRUCT->GenCopy();
STRUCT->m_Pos += g_RepeatStep;
new_pos = STRUCT->m_Pos;
@ -690,7 +661,7 @@ void WinEDA_SchematicFrame::RepeatDrawItem( wxDC* DC )
case DRAW_SEGMENT_STRUCT_TYPE:
#undef STRUCT
#define STRUCT ( (EDA_DrawLineStruct*) g_ItemToRepeat )
#define STRUCT ( (SCH_LINE*) g_ItemToRepeat )
g_ItemToRepeat = STRUCT->GenCopy();
STRUCT->m_Start += g_RepeatStep;
new_pos = STRUCT->m_Start;
@ -699,7 +670,7 @@ void WinEDA_SchematicFrame::RepeatDrawItem( wxDC* DC )
case DRAW_BUSENTRY_STRUCT_TYPE:
#undef STRUCT
#define STRUCT ( (DrawBusEntryStruct*) g_ItemToRepeat )
#define STRUCT ( (SCH_BUS_ENTRY*) g_ItemToRepeat )
g_ItemToRepeat = STRUCT->GenCopy();
STRUCT->m_Pos += g_RepeatStep;
new_pos = STRUCT->m_Pos;
@ -749,13 +720,11 @@ void WinEDA_SchematicFrame::RepeatDrawItem( wxDC* DC )
}
/******************************************/
void IncrementLabelMember( wxString& name )
{
/******************************************/
/* Routine incrementing labels, ie for the text ending with a number, adding
* that a number <RepeatDeltaLabel>
*/
void IncrementLabelMember( wxString& name )
{
int ii, nn;
long number = 0;
@ -778,10 +747,6 @@ void IncrementLabelMember( wxString& name )
}
/***************************************************************************/
static bool IsTerminalPoint( SCH_SCREEN* screen, const wxPoint& pos, int layer )
{
/***************************************************************************/
/* Return TRUE if pos can be a terminal point for a wire or a bus
* i.e. :
* for a WIRE, if at pos is found:
@ -792,6 +757,8 @@ static bool IsTerminalPoint( SCH_SCREEN* screen, const wxPoint& pos, int layer )
* - for a BUS, if at pos is found:
* - a BUS
*/
static bool IsTerminalPoint( SCH_SCREEN* screen, const wxPoint& pos, int layer )
{
EDA_BaseStruct* item;
LIB_PIN* pin;
SCH_COMPONENT* LibItem = NULL;
@ -832,7 +799,7 @@ static bool IsTerminalPoint( SCH_SCREEN* screen, const wxPoint& pos, int layer )
itempos = LibItem->GetScreenCoord( pin->m_Pos );
itempos.x += LibItem->m_Pos.x;
itempos.y += LibItem->m_Pos.y;
if( (itempos.x == pos.x) && (itempos.y == pos.y) )
if( ( itempos.x == pos.x ) && ( itempos.y == pos.y ) )
return TRUE;
}
@ -850,7 +817,7 @@ static bool IsTerminalPoint( SCH_SCREEN* screen, const wxPoint& pos, int layer )
if( pinsheet && !IsBusLabel( pinsheet->m_Text ) )
{
itempos = pinsheet->m_Pos;
if( (itempos.x == pos.x) && (itempos.y == pos.y) )
if( ( itempos.x == pos.x ) && ( itempos.y == pos.y ) )
return TRUE;
}
@ -864,10 +831,6 @@ static bool IsTerminalPoint( SCH_SCREEN* screen, const wxPoint& pos, int layer )
}
/****************************************************************/
bool IsJunctionNeeded( WinEDA_SchematicFrame* frame, wxPoint& pos )
{
/****************************************************************/
/* Return True when a wire is located at pos "pos" if
* - there is no junction.
* - The wire has no ends at pos "pos",
@ -876,6 +839,8 @@ bool IsJunctionNeeded( WinEDA_SchematicFrame* frame, wxPoint& pos )
* or
* - a pin is on location pos
*/
bool IsJunctionNeeded( WinEDA_SchematicFrame* frame, wxPoint& pos )
{
if( PickStruct( pos, frame->GetScreen(), JUNCTIONITEM ) )
return FALSE;

54
eeschema/busentry.cpp
View File

@ -16,13 +16,12 @@
static int s_LastShape = '\\';
static wxPoint ItemInitialPosition;
/**************************************************************/
static void ExitBusEntry( WinEDA_DrawPanel* Panel, wxDC* DC )
{
/**************************************************************/
/* Exit bus entry mode. */
DrawBusEntryStruct* BusEntry =
(DrawBusEntryStruct*) Panel->GetScreen()->GetCurItem();
/* Exit bus entry mode. */
SCH_BUS_ENTRY* BusEntry =
(SCH_BUS_ENTRY*) Panel->GetScreen()->GetCurItem();
if( BusEntry )
{
@ -46,13 +45,11 @@ static void ExitBusEntry( WinEDA_DrawPanel* Panel, wxDC* DC )
}
/************************************************************************/
static void ShowWhileMoving( WinEDA_DrawPanel* panel, wxDC* DC, bool erase )
{
/************************************************************************/
/* Drawing of the bus entry segment" while moving the cursor. */
BASE_SCREEN* screen = panel->GetScreen();
DrawBusEntryStruct* BusEntry = (DrawBusEntryStruct*) screen->GetCurItem();
/* Drawing of the bus entry segment" while moving the cursor. */
BASE_SCREEN* screen = panel->GetScreen();
SCH_BUS_ENTRY* BusEntry = (SCH_BUS_ENTRY*) screen->GetCurItem();
if( BusEntry == NULL )
return;
@ -67,17 +64,14 @@ static void ShowWhileMoving( WinEDA_DrawPanel* panel, wxDC* DC, bool erase )
}
/**********************************************************************************/
DrawBusEntryStruct* WinEDA_SchematicFrame::CreateBusEntry( wxDC* DC,
int entry_type )
SCH_BUS_ENTRY* WinEDA_SchematicFrame::CreateBusEntry( wxDC* DC,
int entry_type )
{
/**********************************************************************************/
/* Create a new bus entry, and prepare moving function (for later place it)
*/
DrawBusEntryStruct* BusEntry = new DrawBusEntryStruct(
GetScreen()->m_Curseur,
s_LastShape,
entry_type );
/* Create a new bus entry, and prepare moving function (for later place it)
*/
SCH_BUS_ENTRY* BusEntry = new SCH_BUS_ENTRY( GetScreen()->m_Curseur,
s_LastShape,
entry_type );
BusEntry->m_Flags = IS_NEW;
@ -92,11 +86,9 @@ DrawBusEntryStruct* WinEDA_SchematicFrame::CreateBusEntry( wxDC* DC,
}
/**************************************************************************/
void WinEDA_SchematicFrame::StartMoveBusEntry( DrawBusEntryStruct* BusEntry,
wxDC* DC )
void WinEDA_SchematicFrame::StartMoveBusEntry( SCH_BUS_ENTRY* BusEntry,
wxDC* DC )
{
/**************************************************************************/
if( BusEntry == NULL )
return;
@ -123,14 +115,12 @@ void WinEDA_SchematicFrame::StartMoveBusEntry( DrawBusEntryStruct* BusEntry,
}
/************************************************************/
void WinEDA_SchematicFrame::SetBusEntryShape( wxDC* DC,
DrawBusEntryStruct* BusEntry,
int entry_shape )
{
/************************************************************/
/* set the shape of BusEntry (shape = / or \ )
*/
void WinEDA_SchematicFrame::SetBusEntryShape( wxDC* DC,
SCH_BUS_ENTRY* BusEntry,
int entry_shape )
{
if( BusEntry == NULL )
return;
@ -165,10 +155,8 @@ void WinEDA_SchematicFrame::SetBusEntryShape( wxDC* DC,
}
/************************************************************************/
int WinEDA_SchematicFrame::GetBusEntryShape( DrawBusEntryStruct* BusEntry )
int WinEDA_SchematicFrame::GetBusEntryShape( SCH_BUS_ENTRY* BusEntry )
{
/************************************************************************/
int entry_shape = '\\';
if( BusEntry->m_Size.y < 0 )

145
eeschema/class_drawsheet.cpp
View File

@ -1,5 +1,4 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_drawsheet.cpp
// Purpose: member functions for SCH_SHEET
// header = class_drawsheet.h
@ -23,11 +22,9 @@
#include "protos.h"
/***********************************************************/
SCH_SHEET::SCH_SHEET( const wxPoint& pos ) :
SCH_ITEM( NULL, DRAW_SHEET_STRUCT_TYPE )
{
/***********************************************************/
m_Label = NULL;
m_NbLabel = 0;
m_Layer = LAYER_SHEET;
@ -40,10 +37,8 @@ SCH_SHEET::SCH_SHEET( const wxPoint& pos ) :
}
/**************************************/
SCH_SHEET::~SCH_SHEET()
{
/**************************************/
SCH_SHEET_PIN* label = m_Label, * next_label;
while( label )
@ -53,8 +48,8 @@ SCH_SHEET::~SCH_SHEET()
label = next_label;
}
//also, look at the associated sheet & its reference count
//perhaps it should be deleted also.
// also, look at the associated sheet & its reference count
// perhaps it should be deleted also.
if( m_AssociatedScreen )
{
m_AssociatedScreen->m_RefCount--;
@ -64,51 +59,37 @@ SCH_SHEET::~SCH_SHEET()
}
/**********************************************/
bool SCH_SHEET::Save( FILE* aFile ) const
/***********************************************/
/** Function Save
* writes the data structures for this object out to a FILE in "*.brd" format.
* @param aFile The FILE to write to.
* @return bool - true if success writing else false.
*/
bool SCH_SHEET::Save( FILE* aFile ) const
{
bool Success = true;
SCH_SHEET_PIN* SheetLabel;
fprintf( aFile, "$Sheet\n" );
if( fprintf( aFile, "S %-4d %-4d %-4d %-4d\n",
m_Pos.x, m_Pos.y,
m_Size.x, m_Size.y ) == EOF )
{
Success = false;
return Success;
}
if( fprintf( aFile, "$Sheet\n" ) == EOF
|| fprintf( aFile, "S %-4d %-4d %-4d %-4d\n",
m_Pos.x, m_Pos.y, m_Size.x, m_Size.y ) == EOF )
return false;
//save the unique timestamp, like other schematic parts.
if( fprintf( aFile, "U %8.8lX\n", m_TimeStamp ) == EOF )
{
Success = false; return Success;
}
if( fprintf( aFile, "U %8.8lX\n", m_TimeStamp ) == EOF )
return false;
/* Save schematic sheetname and filename. */
if( !m_SheetName.IsEmpty() )
{
if( fprintf( aFile, "F0 \"%s\" %d\n", CONV_TO_UTF8( m_SheetName ),
m_SheetNameSize ) == EOF )
{
Success = false; return Success;
}
return false;
}
if( !m_FileName.IsEmpty() )
{
if( fprintf( aFile, "F1 \"%s\" %d\n", CONV_TO_UTF8( m_FileName ),
m_FileNameSize ) == EOF )
{
Success = false; return Success;
}
return false;
}
/* Create the list of labels in the sheet. */
@ -122,18 +103,18 @@ bool SCH_SHEET::Save( FILE* aFile ) const
SheetLabel = SheetLabel->Next();
}
fprintf( aFile, "$EndSheet\n" );
return Success;
if( fprintf( aFile, "$EndSheet\n" ) == EOF )
return false;
return true;
}
/***********************************************/
SCH_SHEET* SCH_SHEET::GenCopy()
{
/***********************************************/
/* creates a copy of a sheet
* The linked data itself (EEDrawList) is not duplicated
*/
SCH_SHEET* SCH_SHEET::GenCopy()
{
SCH_SHEET* newitem = new SCH_SHEET( m_Pos );
@ -179,13 +160,11 @@ SCH_SHEET* SCH_SHEET::GenCopy()
}
/**********************************************************/
void SCH_SHEET::SwapData( SCH_SHEET* copyitem )
{
/**********************************************************/
/* Used if undo / redo command:
* swap data between this and copyitem
*/
void SCH_SHEET::SwapData( SCH_SHEET* copyitem )
{
EXCHG( m_Pos, copyitem->m_Pos );
EXCHG( m_Size, copyitem->m_Size );
EXCHG( m_SheetName, copyitem->m_SheetName );
@ -194,7 +173,7 @@ void SCH_SHEET::SwapData( SCH_SHEET* copyitem )
EXCHG( m_Label, copyitem->m_Label );
EXCHG( m_NbLabel, copyitem->m_NbLabel );
// Ensure sheet labels have their .m_Parent member poiuntin really on their
// Ensure sheet labels have their .m_Parent member pointing really on their
// parent, after swapping.
SCH_SHEET_PIN* label = m_Label;
while( label )
@ -212,12 +191,10 @@ void SCH_SHEET::SwapData( SCH_SHEET* copyitem )
}
/********************************************************************/
void SCH_SHEET::Place( WinEDA_SchematicFrame* frame, wxDC* DC )
{
/********************************************************************/
/* Place list structures for new sheet. */
bool isnew = (m_Flags & IS_NEW) ? true : false;
bool isnew = ( m_Flags & IS_NEW ) ? true : false;
if( isnew )
{
@ -240,16 +217,14 @@ void SCH_SHEET::Place( WinEDA_SchematicFrame* frame, wxDC* DC )
}
/********************************************************************/
void SCH_SHEET::CleanupSheet( WinEDA_SchematicFrame* aFrame,
bool aRedraw )
{
/********************************************************************/
/** Function CleanupSheet
* Delete pinsheets which are not corresponding to a hierarchical label
* @param aRedraw = true to redraw Sheet
* @param aFrame = the schematic frame
*/
void SCH_SHEET::CleanupSheet( WinEDA_SchematicFrame* aFrame,
bool aRedraw )
{
SCH_SHEET_PIN* Pinsheet, * NextPinsheet;
if( !IsOK( aFrame, _( "Ok to cleanup this sheet" ) ) )
@ -297,11 +272,6 @@ int SCH_SHEET::GetPenSize()
}
/*****************************************************************************/
void SCH_SHEET::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
const wxPoint& aOffset, int aDrawMode, int aColor )
{
/*****************************************************************************/
/** Function Draw
* Draw the hierarchical sheet shape
* @param aPanel = the current DrawPanel
@ -311,6 +281,9 @@ void SCH_SHEET::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
* @param aColor = color used to draw sheet. Usually -1 to use the normal
* color for sheet items
*/
void SCH_SHEET::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
const wxPoint& aOffset, int aDrawMode, int aColor )
{
SCH_SHEET_PIN* SheetLabelStruct;
int txtcolor;
wxString Text;
@ -364,13 +337,11 @@ void SCH_SHEET::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
}
/*****************************************/
EDA_Rect SCH_SHEET::GetBoundingBox()
{
/*****************************************/
/** Function GetBoundingBox
* @return an EDA_Rect giving the bounding box of the sheet
*/
EDA_Rect SCH_SHEET::GetBoundingBox()
{
int dx, dy;
// Determine length of texts
@ -389,28 +360,24 @@ EDA_Rect SCH_SHEET::GetBoundingBox()
}
/************************************************/
bool SCH_SHEET::HitTest( const wxPoint& aPosRef )
{
/************************************************/
/** Function HitTest
* @return true if the point aPosRef is within item area
* @param aPosRef = a wxPoint to test
*/
bool SCH_SHEET::HitTest( const wxPoint& aPosRef )
{
EDA_Rect rect = GetBoundingBox();
return rect.Inside( aPosRef );
}
/************************************/
int SCH_SHEET::ComponentCount()
{
/************************************/
/** Function ComponentCount
* count our own components, without the power components.
* @return the component count.
*/
int SCH_SHEET::ComponentCount()
{
int n = 0;
if( m_AssociatedScreen )
@ -431,20 +398,19 @@ int SCH_SHEET::ComponentCount()
}
}
}
return n;
}
/*****************************************************************************/
bool SCH_SHEET::SearchHierarchy( wxString aFilename, SCH_SCREEN** aScreen )
{
/*****************************************************************************/
/** Function SearchHierarchy
* search the existing hierarchy for an instance of screen "FileName".
* @param aFilename = the filename to find
* @param aFilename = a location to return a pointer to the screen (if found)
* @return bool if found, and a pointer to the screen
*/
bool SCH_SHEET::SearchHierarchy( wxString aFilename, SCH_SCREEN** aScreen )
{
if( m_AssociatedScreen )
{
EDA_BaseStruct* strct = m_AssociatedScreen->EEDrawList;
@ -459,20 +425,18 @@ bool SCH_SHEET::SearchHierarchy( wxString aFilename, SCH_SCREEN** aScreen )
*aScreen = ss->m_AssociatedScreen;
return true;
}
if( ss->SearchHierarchy( aFilename, aScreen ) )
return true;
}
strct = strct->Next();
}
}
return false;
}
/*******************************************************************************/
bool SCH_SHEET::LocatePathOfScreen( SCH_SCREEN* aScreen, DrawSheetPath* aList )
{
/*******************************************************************************/
/** Function LocatePathOfScreen
* search the existing hierarchy for an instance of screen "FileName".
* don't bother looking at the root sheet - it must be unique,
@ -480,9 +444,11 @@ bool SCH_SHEET::LocatePathOfScreen( SCH_SCREEN* aScreen, DrawSheetPath* aList )
* loops
* in the hierarchy.
* @param aScreen = the SCH_SCREEN* screen that we search for
* @param aList = the DrawSheetPath* that must be used
* @param aList = the SCH_SHEET_PATH* that must be used
* @return true if found
*/
bool SCH_SHEET::LocatePathOfScreen( SCH_SCREEN* aScreen, SCH_SHEET_PATH* aList )
{
if( m_AssociatedScreen )
{
aList->Push( this );
@ -506,10 +472,6 @@ bool SCH_SHEET::LocatePathOfScreen( SCH_SCREEN* aScreen, DrawSheetPath* aList )
}
/**********************************************************/
bool SCH_SHEET::Load( WinEDA_SchematicFrame* aFrame )
{
/***********************************************************/
/** Function Load.
* for the sheet: load the file m_FileName
* if a screen already exists, the file is already read.
@ -518,6 +480,8 @@ bool SCH_SHEET::Load( WinEDA_SchematicFrame* aFrame )
* @param aFrame = a WinEDA_SchematicFrame pointer to the maim schematic frame
* @return true if OK
*/
bool SCH_SHEET::Load( WinEDA_SchematicFrame* aFrame )
{
bool success = true;
if( !m_AssociatedScreen )
@ -552,19 +516,18 @@ bool SCH_SHEET::Load( WinEDA_SchematicFrame* aFrame )
}
}
}
return success;
}
/**********************************/
int SCH_SHEET::CountSheets()
{
/**********************************/
/** Function CountSheets
* calculates the number of sheets found in "this"
* this number includes the full subsheets count
* @return the full count of sheets+subsheets contained by "this"
*/
int SCH_SHEET::CountSheets()
{
int count = 1; //1 = this!!
if( m_AssociatedScreen )
@ -583,19 +546,12 @@ int SCH_SHEET::CountSheets()
}
/******************************************/
wxString SCH_SHEET::GetFileName( void )
{
/******************************************/
return m_FileName;
}
/************************************************************************/
bool SCH_SHEET::ChangeFileName( WinEDA_SchematicFrame* aFrame,
const wxString& aFileName )
{
/************************************************************************/
/** Function ChangeFileName
* Set a new filename and manage data and associated screen
* The main difficulty is the filename change in a complex hierarchy.
@ -606,7 +562,10 @@ bool SCH_SHEET::ChangeFileName( WinEDA_SchematicFrame* aFrame,
* @param aFileName = the new filename
* @param aFrame = the schematic frame
*/
if( (GetFileName() == aFileName) && m_AssociatedScreen )
bool SCH_SHEET::ChangeFileName( WinEDA_SchematicFrame* aFrame,
const wxString& aFileName )
{
if( ( GetFileName() == aFileName ) && m_AssociatedScreen )
return true;
SCH_SCREEN* Screen_to_use = NULL;
@ -706,7 +665,6 @@ otherwise delete current sheet data)" );
}
/***********************************************************/
void SCH_SHEET::DisplayInfo( WinEDA_DrawFrame* frame )
{
frame->ClearMsgPanel();
@ -743,7 +701,8 @@ void SCH_SHEET::Show( int nestLevel, std::ostream& os )
wxString s = GetClass();
NestedSpace( nestLevel, os ) << '<' << s.Lower().mb_str() << ">"
<< " sheet_name=\"" << CONV_TO_UTF8( m_SheetName )
<< " sheet_name=\""
<< CONV_TO_UTF8( m_SheetName )
<< '"' << ">\n";
// show all the pins, and check the linked list integrity

16
eeschema/class_drawsheet.h
View File

@ -13,8 +13,8 @@ extern SCH_SHEET* g_RootSheet;
* Pin (label) used in sheets to create hierarchical schematics.
*
* A SCH_SHEET_PIN is used to create a hierarchical sheet in the same way a
* pin is used in a component. It connects the ojects in the sheet object
* to the objects in the schecmitic page to the objects in the page that is
* pin is used in a component. It connects the objects in the sheet object
* to the objects in the schematic page to the objects in the page that is
* represented by the sheet. In a sheet object, a SCH_SHEET_PIN must be
* connected to a wire, bus, or label. In the schematic page represented by
* the sheet, it corresponds to a hierarchical label.
@ -238,14 +238,14 @@ public:
* 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_AssociatedScreen otherwise there would be
* loops
* loops
* in the hierarchy.
* @param aScreen = the SCH_SCREEN* screen that we search for
* @param aList = the DrawSheetPath* that must be used
* @param aList = the SCH_SHEET_PATH* that must be used
* @return true if found
*/
bool LocatePathOfScreen( SCH_SCREEN* aScreen,
DrawSheetPath* aList );
bool LocatePathOfScreen( SCH_SCREEN* aScreen,
SCH_SHEET_PATH* aList );
/** Function CountSheets
* calculates the number of sheets found in "this"
@ -271,9 +271,9 @@ public:
* Set a new filename and manage data and associated screen
* The main difficulty is the filename change in a complex hierarchy.
* - if new filename is not already used: change to the new name (and if an
* existing file is found, load it on request)
* existing file is found, load it on request)
* - if new filename is already used (a complex hierarchy) : reference the
* sheet.
* sheet.
* @param aFileName = the new filename
* @param aFrame = the schematic frame
*/

99
eeschema/class_drawsheetpath.cpp
View File

@ -19,7 +19,7 @@
/* class to handle a series of sheets *********/
/* a 'path' so to speak.. *********************/
/**********************************************/
DrawSheetPath::DrawSheetPath()
SCH_SHEET_PATH::SCH_SHEET_PATH()
{
for( int i = 0; i<DSLSZ; i++ )
m_sheets[i] = NULL;
@ -28,18 +28,16 @@ DrawSheetPath::DrawSheetPath()
}
/****************************************************************************/
bool DrawSheetPath::BuildSheetPathInfoFromSheetPathValue(
const wxString& aPath,
bool aFound )
{
/****************************************************************************/
/** Function BuildSheetPathInfoFromSheetPathValue
* Fill this with data to access to the hierarchical sheet known by its path
* aPath
* @param aPath = path of the sheet to reach (in non human readable format)
* @return true if success else false
*/
bool SCH_SHEET_PATH::BuildSheetPathInfoFromSheetPathValue(
const wxString& aPath,
bool aFound )
{
if( aFound )
return true;
@ -69,14 +67,12 @@ bool DrawSheetPath::BuildSheetPathInfoFromSheetPathValue(
}
/*******************************************************************/
int DrawSheetPath::Cmp( const DrawSheetPath& aSheetPathToTest ) const
/********************************************************************/
/** Function Cmp
* Compare if this is the same sheet path as aSheetPathToTest
* @param aSheetPathToTest = sheet path to compare
* @return -1 if different, 0 if same
*/
int SCH_SHEET_PATH::Cmp( const SCH_SHEET_PATH& aSheetPathToTest ) const
{
if( m_numSheets > aSheetPathToTest.m_numSheets )
return 1;
@ -102,7 +98,7 @@ int DrawSheetPath::Cmp( const DrawSheetPath& aSheetPathToTest ) const
* returns a pointer to the last sheet of the list
* One can see the others sheet as the "path" to reach this last sheet
*/
SCH_SHEET* DrawSheetPath::Last()
SCH_SHEET* SCH_SHEET_PATH::Last()
{
if( m_numSheets )
return m_sheets[m_numSheets - 1];
@ -113,7 +109,7 @@ SCH_SHEET* DrawSheetPath::Last()
/** Function LastScreen
* @return the SCH_SCREEN relative to the last sheet in list
*/
SCH_SCREEN* DrawSheetPath::LastScreen()
SCH_SCREEN* SCH_SHEET_PATH::LastScreen()
{
if( m_numSheets )
return m_sheets[m_numSheets - 1]->m_AssociatedScreen;
@ -125,7 +121,7 @@ SCH_SCREEN* DrawSheetPath::LastScreen()
* @return a pointer to the first schematic item handled by the
* SCH_SCREEN relative to the last sheet in list
*/
SCH_ITEM* DrawSheetPath::LastDrawList()
SCH_ITEM* SCH_SHEET_PATH::LastDrawList()
{
if( m_numSheets && m_sheets[m_numSheets - 1]->m_AssociatedScreen )
return m_sheets[m_numSheets - 1]->m_AssociatedScreen->EEDrawList;
@ -133,16 +129,14 @@ SCH_ITEM* DrawSheetPath::LastDrawList()
}
/**************************************************/
void DrawSheetPath::Push( SCH_SHEET* aSheet )
{
/**************************************************/
/** Function Push
* store (push) aSheet in list
* @param aSheet = pointer to the SCH_SHEET to store in list
*/
void SCH_SHEET_PATH::Push( SCH_SHEET* aSheet )
{
if( m_numSheets > DSLSZ )
wxMessageBox( wxT( "DrawSheetPath::Push() error: no room in buffer \
wxMessageBox( wxT( "SCH_SHEET_PATH::Push() error: no room in buffer \
to store sheet" ) );
if( m_numSheets < DSLSZ )
@ -153,12 +147,12 @@ to store sheet" ) );
}
SCH_SHEET* DrawSheetPath::Pop()
{
/** Function Pop
* retrieves (pop) the last entered sheet and remove it from list
* @return a SCH_SHEET* pointer to the removed sheet in list
*/
SCH_SHEET* SCH_SHEET_PATH::Pop()
{
if( m_numSheets > 0 )
{
m_numSheets--;
@ -168,13 +162,13 @@ SCH_SHEET* DrawSheetPath::Pop()
}
wxString DrawSheetPath::Path()
{
/** Function Path
* the path uses the time stamps which do not changes even when editing sheet
* parameters
* a path is something like / (root) or /34005677 or /34005677/00AE4523
*/
wxString SCH_SHEET_PATH::Path()
{
wxString s, t;
s = wxT( "/" ); // This is the root path
@ -192,16 +186,14 @@ wxString DrawSheetPath::Path()
}
/******************************************/
wxString DrawSheetPath::PathHumanReadable()
{
/******************************************/
/** Function PathHumanReadable
* Return the sheet path in a readable form, i.e.
* as a path made from sheet names.
* (the "normal" path uses the time stamps which do not changes even when
* editing sheet parameters)
*/
wxString SCH_SHEET_PATH::PathHumanReadable()
{
wxString s, t;
s = wxT( "/" );
@ -216,10 +208,8 @@ wxString DrawSheetPath::PathHumanReadable()
}
/***********************************************/
void DrawSheetPath::UpdateAllScreenReferences()
void SCH_SHEET_PATH::UpdateAllScreenReferences()
{
/***********************************************/
EDA_BaseStruct* t = LastDrawList();
while( t )
@ -235,7 +225,7 @@ void DrawSheetPath::UpdateAllScreenReferences()
}
bool DrawSheetPath::operator=( const DrawSheetPath& d1 )
bool SCH_SHEET_PATH::operator=( const SCH_SHEET_PATH& d1 )
{
m_numSheets = d1.m_numSheets;
unsigned i;
@ -253,7 +243,7 @@ bool DrawSheetPath::operator=( const DrawSheetPath& d1 )
}
bool DrawSheetPath::operator==( const DrawSheetPath& d1 )
bool SCH_SHEET_PATH::operator==( const SCH_SHEET_PATH& d1 )
{
if( m_numSheets != d1.m_numSheets )
return false;
@ -267,7 +257,7 @@ bool DrawSheetPath::operator==( const DrawSheetPath& d1 )
}
bool DrawSheetPath::operator!=( const DrawSheetPath& d1 )
bool SCH_SHEET_PATH::operator!=( const SCH_SHEET_PATH& d1 )
{
if( m_numSheets != d1.m_numSheets )
return true;
@ -282,18 +272,16 @@ bool DrawSheetPath::operator!=( const DrawSheetPath& d1 )
/*********************************************************************/
/* Class EDA_SheetList to handle the list of Sheets in a hierarchy */
/* Class SCH_SHEET_LIST to handle the list of Sheets in a hierarchy */
/*********************************************************************/
/*******************************************************/
EDA_SheetList::EDA_SheetList( SCH_SHEET* aSheet )
{
/*******************************************************/
/* The constructor: build the list of sheets from aSheet.
* If aSheet == NULL (default) build the whole list of sheets in hierarchy
* So usually call it with no param.
*/
SCH_SHEET_LIST::SCH_SHEET_LIST( SCH_SHEET* aSheet )
{
m_index = 0;
m_count = 0;
m_List = NULL;
@ -303,13 +291,11 @@ EDA_SheetList::EDA_SheetList( SCH_SHEET* aSheet )
}
/*****************************************/
DrawSheetPath* EDA_SheetList::GetFirst()
{
/*****************************************/
/** Function GetFirst
* @return the first item (sheet) in m_List and prepare calls to GetNext()
*/
SCH_SHEET_PATH* SCH_SHEET_LIST::GetFirst()
{
m_index = 0;
if( GetCount() > 0 )
return &( m_List[0] );
@ -317,57 +303,58 @@ DrawSheetPath* EDA_SheetList::GetFirst()
}
/*****************************************/
DrawSheetPath* EDA_SheetList::GetNext()
{
/*****************************************/
/** Function GetNext
* @return the next item (sheet) in m_List or NULL if no more item in sheet
* list
*/
SCH_SHEET_PATH* SCH_SHEET_LIST::GetNext()
{
if( m_index < GetCount() )
m_index++;
return GetSheet( m_index );
}
/************************************************/
DrawSheetPath* EDA_SheetList::GetSheet( int aIndex )
{
/************************************************/
/** Function GetSheet
* @return the item (sheet) in aIndex position in m_List or NULL if less than
* index items
* @param aIndex = index in sheet list to get the sheet
*/
SCH_SHEET_PATH* SCH_SHEET_LIST::GetSheet( int aIndex )
{
if( aIndex < GetCount() )
return &( m_List[aIndex] );
return NULL;
}
/************************************************************************/
void EDA_SheetList::BuildSheetList( SCH_SHEET* aSheet )
{
/************************************************************************/
/** Function BuildSheetList
* Build the list of sheets and their sheet path from the aSheet sheet
* if aSheet = g_RootSheet, the full sheet path list (and full sheet list) is
* built
* @param aSheet = the starting sheet to build list
*/
void SCH_SHEET_LIST::BuildSheetList( SCH_SHEET* aSheet )
{
if( m_List == NULL )
{
int count = aSheet->CountSheets();
m_count = count;
m_index = 0;
count *= sizeof(DrawSheetPath);
m_List = (DrawSheetPath*) MyZMalloc( count );
count *= sizeof(SCH_SHEET_PATH);
/* @bug - MyZMalloc() can return a NULL pointer if there is not enough
* memory. This code continues on it's merry way with out
* checking to see if the memory was actually allocated.
*/
m_List = (SCH_SHEET_PATH*) MyZMalloc( count );
m_currList.Clear();
}
m_currList.Push( aSheet );
m_List[m_index] = m_currList;
m_index++;
if( aSheet->m_AssociatedScreen != NULL )
{
EDA_BaseStruct* strct = m_currList.LastDrawList();
@ -378,8 +365,10 @@ void EDA_SheetList::BuildSheetList( SCH_SHEET* aSheet )
SCH_SHEET* sheet = (SCH_SHEET*) strct;
BuildSheetList( sheet );
}
strct = strct->Next();
}
}
m_currList.Pop();
}

61
eeschema/class_drawsheetpath.h
View File

@ -9,7 +9,7 @@
/** Info about complex hierarchies handling:
* A hierarchical schematic uses sheets (hierarchical sheets) included in a
* given sheet. Rach sheet corresponds to a schematic drawing handled by a
* given sheet. Each sheet corresponds to a schematic drawing handled by a
* SCH_SCREEN structure. A SCH_SCREEN structure contains drawings, and have
* a filename to write it's data. Also a SCH_SCREEN display a sheet number
* and the name of the sheet.
@ -41,8 +41,8 @@
* 2) When acceded by a given selected sheet, display (update) the
* corresponding references and sheet path
*
* The class DrawSheetPath handles paths used to access a sheet. The class
* EDA_SheetList allows to handle the full (or partial) list of sheets and
* The class SCH_SHEET_PATH handles paths used to access a sheet. The class
* SCH_SHEET_LIST allows to handle the full (or partial) list of sheets and
* their paths in a complex hierarchy. The class EDA_ScreenList allow to
* handle the list of SCH_SCREEN. It is useful to clear or save data,
* but is not suitable to handle the full complex hierarchy possibilities
@ -63,7 +63,7 @@
* return this last sheet
* Others sheets are the "path" from the first to the last sheet
*/
class DrawSheetPath
class SCH_SHEET_PATH
{
private:
unsigned m_numSheets;
@ -72,8 +72,8 @@ public:
#define DSLSZ 32 // Max number of levels for a sheet path
SCH_SHEET * m_sheets[DSLSZ];
public: DrawSheetPath();
~DrawSheetPath() { };
public: SCH_SHEET_PATH();
~SCH_SHEET_PATH() { };
void Clear()
{
m_numSheets = 0;
@ -91,7 +91,7 @@ public: DrawSheetPath();
* @param aSheetPathToTest = sheet path to compare
* @return -1 if different, 0 if same
*/
int Cmp( const DrawSheetPath& aSheetPathToTest ) const;
int Cmp( const SCH_SHEET_PATH& aSheetPathToTest ) const;
/** Function Last
* returns a pointer to the last sheet of the list
@ -147,9 +147,8 @@ public: DrawSheetPath();
* @param aPath = path of the sheet to reach (in non human readable format)
* @return true if success else false
*/
bool BuildSheetPathInfoFromSheetPathValue(
const wxString& aPath,
bool aFound = false );
bool BuildSheetPathInfoFromSheetPathValue( const wxString& aPath,
bool aFound = false );
/**
* Function UpdateAllScreenReferences
@ -162,11 +161,11 @@ public: DrawSheetPath();
*/
void UpdateAllScreenReferences();
bool operator =( const DrawSheetPath& d1 );
bool operator=( const SCH_SHEET_PATH& d1 );
bool operator ==( const DrawSheetPath& d1 );
bool operator==( const SCH_SHEET_PATH& d1 );
bool operator !=( const DrawSheetPath& d1 );
bool operator!=( const SCH_SHEET_PATH& d1 );
};
@ -180,31 +179,31 @@ public: DrawSheetPath();
* and component references are specific to a sheet path.
* When a sheet is entered, component references and sheet number are updated
*/
class EDA_SheetList
class SCH_SHEET_LIST
{
private:
DrawSheetPath* m_List;
int m_count; /* Number of sheets included in hierarchy,
* starting at the given sheet in constructor .
* the given sheet is counted
SCH_SHEET_PATH* m_List;
int m_count; /* Number of sheets included in hierarchy,
* starting at the given sheet in constructor .
* the given sheet is counted
*/
int m_index; /* internal variable to handle GetNext():
* cleared by GetFirst()
* and incremented by GetNext() after
* returning the next item in m_List
* Also used for internal calculations in
* BuildSheetList()
*/
DrawSheetPath m_currList;
int m_index; /* internal variable to handle GetNext():
* cleared by GetFirst()
* and incremented by GetNext() after
* returning the next item in m_List
* Also used for internal calculations in
* BuildSheetList()
*/
SCH_SHEET_PATH m_currList;
public:
/* The constructor: build the list of sheets from aSheet.
* If aSheet == NULL (default) build the whole list of sheets in hierarchy
* So usually call it with no param.
*/
EDA_SheetList( SCH_SHEET* aSheet = NULL );
SCH_SHEET_LIST( SCH_SHEET* aSheet = NULL );
~EDA_SheetList()
~SCH_SHEET_LIST()
{
if( m_List )
free( m_List );
@ -221,20 +220,20 @@ public:
/** Function GetFirst
* @return the first item (sheet) in m_List and prepare calls to GetNext()
*/
DrawSheetPath* GetFirst();
SCH_SHEET_PATH* GetFirst();
/** Function GetNext
* @return the next item (sheet) in m_List or NULL if no more item in
* sheet list
*/
DrawSheetPath* GetNext();
SCH_SHEET_PATH* GetNext();
/** Function GetSheet
* @return the item (sheet) in aIndex position in m_List or NULL if less
* than index items
* @param aIndex = index in sheet list to get the sheet
*/
DrawSheetPath* GetSheet( int aIndex );
SCH_SHEET_PATH* GetSheet( int aIndex );
private:

41
eeschema/class_marker_sch.cpp
View File

@ -1,6 +1,6 @@
/***********************************************************************/
/* Methodes de base de gestion des classes des elements de schematique */
/***********************************************************************/
/*******************************************/
/* Schematic marker object implementation. */
/*******************************************/
#include "fctsys.h"
#include "class_drawpanel.h"
@ -13,7 +13,7 @@
#include "erc.h"
/* Marker are mainly used to show an ERC error
* but they could be used to give a specifi info
* but they could be used to give a specific info
*/
@ -28,31 +28,30 @@ const wxChar* NameMarqueurType[] =
/**************************/
/* class MARKER_SCH */
/* class SCH_MARKER */
/**************************/
MARKER_SCH::MARKER_SCH() :
SCH_ITEM( NULL, TYPE_MARKER_SCH ),
MARKER_BASE()
SCH_MARKER::SCH_MARKER() : SCH_ITEM( NULL, TYPE_SCH_MARKER ), MARKER_BASE()
{
}
MARKER_SCH::MARKER_SCH( const wxPoint& pos, const wxString& text ) :
SCH_ITEM( NULL, TYPE_MARKER_SCH ),
SCH_MARKER::SCH_MARKER( const wxPoint& pos, const wxString& text ) :
SCH_ITEM( NULL, TYPE_SCH_MARKER ),
MARKER_BASE( 0, pos, text, pos )
{
}
MARKER_SCH::~MARKER_SCH()
SCH_MARKER::~SCH_MARKER()
{
}
MARKER_SCH* MARKER_SCH::GenCopy()
SCH_MARKER* SCH_MARKER::GenCopy()
{
MARKER_SCH* newitem = new MARKER_SCH( GetPos(), GetReporter().GetMainText() );
SCH_MARKER* newitem = new SCH_MARKER( GetPos(),
GetReporter().GetMainText() );
newitem->SetMarkerType( GetMarkerType() );
newitem->SetErrorLevel( GetErrorLevel() );
@ -70,11 +69,11 @@ MARKER_SCH* MARKER_SCH::GenCopy()
* of nesting of this object within the overall tree.
* @param os The ostream& to output to.
*/
void MARKER_SCH::Show( int nestLevel, std::ostream& os )
void SCH_MARKER::Show( int nestLevel, std::ostream& os )
{
// for now, make it look like XML:
NestedSpace( nestLevel, os ) << '<' << GetClass().Lower().mb_str() << GetPos()
<< "/>\n";
NestedSpace( nestLevel, os ) << '<' << GetClass().Lower().mb_str()
<< GetPos() << "/>\n";
}
@ -86,23 +85,21 @@ void MARKER_SCH::Show( int nestLevel, std::ostream& os )
* @param aFile The FILE to write to.
* @return bool - true if success writing else false.
*/
bool MARKER_SCH::Save( FILE* aFile ) const
bool SCH_MARKER::Save( FILE* aFile ) const
{
return true;
}
/****************************************************************************/
void MARKER_SCH::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
void SCH_MARKER::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
const wxPoint& aOffset, int aDrawMode, int aColor )
/****************************************************************************/
{
EDA_Colors color = (EDA_Colors) m_Color;
EDA_Colors tmp = color;
if( GetMarkerType() == MARK_ERC )
{
color = (GetErrorLevel() == WAR ) ?
color = ( GetErrorLevel() == WAR ) ?
(EDA_Colors) g_LayerDescr.LayerColor[LAYER_ERC_WARN] :
(EDA_Colors) g_LayerDescr.LayerColor[LAYER_ERC_ERR];
}
@ -124,7 +121,7 @@ void MARKER_SCH::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
* object, and the units should be in the pcb or schematic coordinate system.
* It is OK to overestimate the size by a few counts.
*/
EDA_Rect MARKER_SCH::GetBoundingBox()
EDA_Rect SCH_MARKER::GetBoundingBox()
{
return GetBoundingBoxMarker();
}

23
eeschema/class_marker_sch.h
View File

@ -2,8 +2,8 @@
/* classes to handle markers used in schematic ... */
/***************************************************/
#ifndef _TYPE_MARKER_SCH_H_
#define _TYPE_MARKER_SCH_H_
#ifndef _TYPE_SCH_MARKER_H_
#define _TYPE_SCH_MARKER_H_
#include "sch_item_struct.h"
#include "class_marker_base.h"
@ -24,19 +24,19 @@ enum TypeMarker { /* Markers type */
extern const wxChar* NameMarqueurType[];
class MARKER_SCH : public SCH_ITEM , public MARKER_BASE
class SCH_MARKER : public SCH_ITEM , public MARKER_BASE
{
public:
MARKER_SCH( );
MARKER_SCH( const wxPoint& aPos, const wxString& aText );
~MARKER_SCH();
SCH_MARKER( );
SCH_MARKER( const wxPoint& aPos, const wxString& aText );
~SCH_MARKER();
virtual wxString GetClass() const
{
return wxT( "MARKER_SCH" );
return wxT( "SCH_MARKER" );
}
MARKER_SCH* GenCopy();
SCH_MARKER* GenCopy();
virtual void Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
const wxPoint& aOffset, int aDraw_mode,
@ -54,7 +54,8 @@ public:
/** Function GetPenSize
* @return the size of the "pen" that be used to draw or plot this item
* for a marker, has no meaning, but it is necessary to satisfy the SCH_ITEM class requirements
* for a marker, has no meaning, but it is necessary to satisfy the
* SCH_ITEM class requirements
*/
virtual int GetPenSize( ) { return 0; };
@ -80,7 +81,7 @@ public:
// Geometric transforms (used in block operations):
/** virtual function Move
* move item to a new position.
* @param aMoveVector = the deplacement vector
* @param aMoveVector = the displacement vector
*/
virtual void Move(const wxPoint& aMoveVector)
{
@ -103,4 +104,4 @@ public:
#endif
};
#endif /* _TYPE_MARKER_SCH_H_ */
#endif /* _TYPE_SCH_MARKER_H_ */

103
eeschema/class_netlist_object.h
View File

@ -1,6 +1,7 @@
/*************************************************************************************/
/* Class NETLIST_OBJECT to handle 1 item connected (in netlist and erc calculations) */
/*************************************************************************************/
/***********************************************************************/
/* Class NETLIST_OBJECT to handle 1 item connected (in netlist and erc */
/* calculations) */
/***********************************************************************/
#ifndef _CLASS_NETLIST_OBJECT_H_
#define _CLASS_NETLIST_OBJECT_H_
@ -10,59 +11,85 @@ enum NetObjetType {
NET_ITEM_UNSPECIFIED, // only for not yet initialized instances
NET_SEGMENT, // connection by wire
NET_BUS, // connection by bus
NET_JONCTION, // connection by junction: can connect to or more crossing wires
NET_JONCTION, // connection by junction: can connect to
// or more crossing wires
NET_LABEL, // this is a local label
NET_GLOBLABEL, // this is a global label that connect all others global label in whole hierrachy
NET_HIERLABEL, // element to indicate connection to a higher-level sheet
NET_SHEETLABEL, // element to indicate connection to a lower-level sheet.
NET_BUSLABELMEMBER, /* created when a bus label is found:
* the bus label (like DATA[0..7] is converted to n single labels like DATA0, DATA1 ...
*/
NET_GLOBBUSLABELMEMBER, // see NET_BUSLABELMEMBER, used when a global bus label is found
NET_HIERBUSLABELMEMBER, // see NET_BUSLABELMEMBER, used when a hierarchical bus label is found
NET_SHEETBUSLABELMEMBER, // see NET_BUSLABELMEMBER, used when a pin sheet label using bus notation is found
NET_PINLABEL, /* created when a pin is POWER (IN or OUT) with invisible attribute is found:
* these pins are equivalent to a global label and are automatically connected
*/
NET_GLOBLABEL, // this is a global label that connect all
// others global label in whole hierarchy
NET_HIERLABEL, // element to indicate connection to a
// higher-level sheet
NET_SHEETLABEL, // element to indicate connection to a
// lower-level sheet.
NET_BUSLABELMEMBER, /* created when a bus label is found:
* the bus label (like DATA[0..7] is
* converted to n single labels like
* DATA0, DATA1 ...
*/
NET_GLOBBUSLABELMEMBER, // see NET_BUSLABELMEMBER, used when a
// global bus label is found
NET_HIERBUSLABELMEMBER, // see NET_BUSLABELMEMBER, used when a
// hierarchical bus label is found
NET_SHEETBUSLABELMEMBER, // see NET_BUSLABELMEMBER, used when a
// pin sheet label using bus notation
// is found
NET_PINLABEL, /* created when a pin is POWER (IN or
* OUT) with invisible attribute is found:
* these pins are equivalent to a global
* label and are automatically connected
*/
NET_PIN, // this is an usual pin
NET_NOCONNECT // this is a no connect symbol
};
/* Values for .m_FlagOfConnection member */
enum ConnectType {
UNCONNECTED = 0, /* Pin or Label not connected (error) */
NOCONNECT_SYMBOL_PRESENT, /* Pin not connected but have a NoConnect symbol on it (no error) */
PAD_CONNECT /* Normal connection (no error) */
UNCONNECTED = 0, /* Pin or Label not connected (error) */
NOCONNECT_SYMBOL_PRESENT, /* Pin not connected but have a NoConnect
* symbol on it (no error) */
PAD_CONNECT /* Normal connection (no error) */
};
class NETLIST_OBJECT
{
public:
NetObjetType m_Type; /* Type of this item (see NetObjetType enum) */
EDA_BaseStruct* m_Comp; /* Pointer on the library item that created this net object (the parent)*/
SCH_ITEM* m_Link; /* For SCH_SHEET_PIN:
* Pointer to the hierarchy sheet that contains this SCH_SHEET_PIN
* For Pins: pointer to the component that contains this pin
*/
int m_Flag; /* flag used in calculations */
DrawSheetPath m_SheetList;
int m_ElectricalType; /* Has meaning only for Pins and hierachical pins: electrical type */
NetObjetType m_Type; /* Type of item (see NetObjetType
* enum) */
EDA_BaseStruct* m_Comp; /* Pointer on the library item that
* created this net object (the parent)
*/
SCH_ITEM* m_Link; /* For SCH_SHEET_PIN:
* Pointer to the hierarchy sheet that
* contains this SCH_SHEET_PIN
* For Pins: pointer to the component
* that contains this pin
*/
int m_Flag; /* flag used in calculations */
SCH_SHEET_PATH m_SheetList;
int m_ElectricalType; /* Has meaning only for Pins and
* hierarchical pins: electrical type */
private:
int m_NetCode; /* net code for all items except BUS labels because a BUS label has
* as many net codes as bus members
int m_NetCode; /* net code for all items except BUS
* labels because a BUS label has
* as many net codes as bus members
*/
public:
int m_BusNetCode; /* Used for BUS connections */
int m_Member; /* for labels type NET_BUSLABELMEMBER ( bus member created from the BUS label )
* member number
*/
int m_Member; /* for labels type NET_BUSLABELMEMBER
* ( bus member created from the BUS
* label ) member number
*/
ConnectType m_FlagOfConnection;
DrawSheetPath m_SheetListInclude; /* sheet that the hierarchal label connects to.*/
long m_PinNum; /* pin number ( 1 long = 4 bytes -> 4 ascii codes) */
const wxString* m_Label; /* For all labels:pointer on the text label */
wxPoint m_Start; // Position of object or for segments: starting point
wxPoint m_End; // For segments (wire and busses): ending point
SCH_SHEET_PATH m_SheetListInclude; /* sheet that the hierarchical label
* connects to.*/
long m_PinNum; /* pin number ( 1 long = 4 bytes ->
* 4 ascii codes) */
const wxString* m_Label; /* For all labels:pointer on the text
* label */
wxPoint m_Start; // Position of object or for segments:
// starting point
wxPoint m_End; // For segments (wire and buses):
// ending point
#if defined(DEBUG)
void Show( std::ostream& out, int ndx );

67
eeschema/class_sch_cmp_field.cpp
View File

@ -1,8 +1,8 @@
/**************************************************************/
/* class_sch_cmp_field.cpp : handle the class SCH_CMP_FIELD */
/* class_sch_cmp_field.cpp : handle the class SCH_FIELD */
/**************************************************************/
/* Fields are texts attached to a component, having a specuial meaning
/* Fields are texts attached to a component, having a special meaning
* Fields 0 and 1 are very important: reference and value
* Field 2 is used as default footprint name.
* Field 3 is reserved (not currently used
@ -24,8 +24,8 @@
#include "class_library.h"
SCH_CMP_FIELD::SCH_CMP_FIELD( const wxPoint& aPos, int aFieldId,
SCH_COMPONENT* aParent, wxString aName ) :
SCH_FIELD::SCH_FIELD( const wxPoint& aPos, int aFieldId,
SCH_COMPONENT* aParent, wxString aName ) :
SCH_ITEM( aParent, DRAW_PART_TEXT_STRUCT_TYPE ),
EDA_TextStruct()
{
@ -39,7 +39,7 @@ SCH_CMP_FIELD::SCH_CMP_FIELD( const wxPoint& aPos, int aFieldId,
}
SCH_CMP_FIELD::~SCH_CMP_FIELD()
SCH_FIELD::~SCH_FIELD()
{
}
@ -47,7 +47,7 @@ SCH_CMP_FIELD::~SCH_CMP_FIELD()
/** Function GetPenSize
* @return the size of the "pen" that be used to draw or plot this item
*/
int SCH_CMP_FIELD::GetPenSize()
int SCH_FIELD::GetPenSize()
{
int pensize = m_Width;
@ -68,8 +68,8 @@ int SCH_CMP_FIELD::GetPenSize()
/**
* Draw schematic component fields.
*/
void SCH_CMP_FIELD::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
const wxPoint& offset, int DrawMode, int Color )
void SCH_FIELD::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
const wxPoint& offset, int DrawMode, int Color )
{
int orient;
EDA_Colors color;
@ -94,7 +94,8 @@ void SCH_CMP_FIELD::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
GRSetDrawMode( DC, DrawMode );
/* Calculate the text orientation, according to the component orientation/mirror */
/* Calculate the text orientation, according to the component
* orientation/mirror */
orient = m_Orient;
if( parentComponent->m_Transform[0][1] ) // Rotate component 90 degrees.
{
@ -104,13 +105,14 @@ void SCH_CMP_FIELD::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
orient = TEXT_ORIENT_HORIZ;
}
/* Calculate the text justification, according to the component orientation/mirror
* this is a bit complicated due to cumulative calculations:
/* Calculate the text justification, according to the component
* orientation/mirror this is a bit complicated due to cumulative
* calculations:
* - numerous cases (mirrored or not, rotation)
* - the DrawGraphicText function recalculate also H and H vustifications
* according to the text orienation.
* - When a component is mirrored, the text is not mirrored and justifications
* are complicated to calculate
* - the DrawGraphicText function recalculate also H and H justifications
* according to the text orientation.
* - When a component is mirrored, the text is not mirrored and
* justifications are complicated to calculate
* so the more easily way is to use no justifications ( Centered text )
* and use GetBoundaryBox to know the text coordinate considered as centered
*/
@ -126,7 +128,7 @@ void SCH_CMP_FIELD::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
else
color = ReturnLayerColor( LAYER_FIELDS );
if( !m_AddExtraText || (m_FieldId != REFERENCE) )
if( !m_AddExtraText || ( m_FieldId != REFERENCE ) )
{
DrawGraphicText( panel, DC, textpos, color, m_Text,
orient,
@ -156,6 +158,7 @@ void SCH_CMP_FIELD::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
/* Enable this to draw the bounding box around the text field to validate
* the bounding box calculations.
*/
#if 0
// Draw boundary box:
int x1 = BoundaryBox.GetX();
@ -164,7 +167,8 @@ void SCH_CMP_FIELD::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
int y2 = BoundaryBox.GetBottom();
GRRect( &panel->m_ClipBox, DC, x1, y1, x2, y2, BROWN );
// Draw the text anchor point
/* Calculate the text position, according to the component orientation/mirror */
/* Calculate the text position, according to the component
* orientation/mirror */
textpos = m_Pos - parentComponent->m_Pos;
textpos = parentComponent->GetScreenCoord( textpos );
textpos += parentComponent->m_Pos;
@ -173,7 +177,6 @@ void SCH_CMP_FIELD::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
int len = 10;
GRLine( &panel->m_ClipBox, DC, x1 - len, y1, x1 + len, y1, 0, BLUE );
GRLine( &panel->m_ClipBox, DC, x1, y1 - len, x1, y1 +len, 0, BLUE );
#endif
}
@ -185,7 +188,7 @@ void SCH_CMP_FIELD::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
* used to init a field from the model read from a lib entry
* @param aSource = the LIB_FIELD to read
*/
void SCH_CMP_FIELD::ImportValues( const LIB_FIELD& aSource )
void SCH_FIELD::ImportValues( const LIB_FIELD& aSource )
{
m_Orient = aSource.m_Orient;
m_Size = aSource.m_Size;
@ -203,7 +206,7 @@ void SCH_CMP_FIELD::ImportValues( const LIB_FIELD& aSource )
* Used if undo / redo command:
* swap data between this and copyitem
*/
void SCH_CMP_FIELD::SwapData( SCH_CMP_FIELD* copyitem )
void SCH_FIELD::SwapData( SCH_FIELD* copyitem )
{
EXCHG( m_Text, copyitem->m_Text );
EXCHG( m_Layer, copyitem->m_Layer );
@ -224,7 +227,7 @@ void SCH_CMP_FIELD::SwapData( SCH_CMP_FIELD* copyitem )
* return True if the field is void, i.e.:
* contains "~" or ""
*/
bool SCH_CMP_FIELD::IsVoid()
bool SCH_FIELD::IsVoid()
{
if( m_Text.IsEmpty() || m_Text == wxT( "~" ) )
return true;
@ -238,7 +241,7 @@ bool SCH_CMP_FIELD::IsVoid()
* a text field,
* according to the component position, rotation, mirror ...
*/
EDA_Rect SCH_CMP_FIELD::GetBoundaryBox() const
EDA_Rect SCH_FIELD::GetBoundaryBox() const
{
EDA_Rect BoundaryBox;
int hjustify, vjustify;
@ -257,12 +260,13 @@ EDA_Rect SCH_CMP_FIELD::GetBoundaryBox() const
hjustify = m_HJustify;
vjustify = m_VJustify;
x2 = pos.x + (parentComponent->m_Transform[0][0] *x1)
+ (parentComponent->m_Transform[0][1] *y1);
y2 = pos.y + (parentComponent->m_Transform[1][0] *x1)
+ (parentComponent->m_Transform[1][1] *y1);
x2 = pos.x + ( parentComponent->m_Transform[0][0] * x1 )
+ ( parentComponent->m_Transform[0][1] * y1 );
y2 = pos.y + ( parentComponent->m_Transform[1][0] * x1 )
+ ( parentComponent->m_Transform[1][1] * y1 );
/* Calculate the text orientation, according to the component orientation/mirror */
/* Calculate the text orientation, according to the component
* orientation/mirror */
if( parentComponent->m_Transform[0][1] )
{
if( orient == TEXT_ORIENT_HORIZ )
@ -271,7 +275,8 @@ EDA_Rect SCH_CMP_FIELD::GetBoundaryBox() const
orient = TEXT_ORIENT_HORIZ;
}
/* Calculate the text justification, according to the component orientation/mirror */
/* Calculate the text justification, according to the component
* orientation/mirror */
if( parentComponent->m_Transform[0][1] )
{
/* is it mirrored (for text justify)*/
@ -328,14 +333,14 @@ EDA_Rect SCH_CMP_FIELD::GetBoundaryBox() const
BoundaryBox.SetHeight( dy );
// Take thickness in account:
int linewidth = (m_Width == 0) ? g_DrawDefaultLineThickness : m_Width;
int linewidth = ( m_Width == 0 ) ? g_DrawDefaultLineThickness : m_Width;
BoundaryBox.Inflate( linewidth, linewidth );
return BoundaryBox;
}
bool SCH_CMP_FIELD::Save( FILE* aFile ) const
bool SCH_FIELD::Save( FILE* aFile ) const
{
char hjustify = 'C';
@ -382,7 +387,7 @@ bool SCH_CMP_FIELD::Save( FILE* aFile ) const
}
void SCH_CMP_FIELD::Place( WinEDA_SchematicFrame* frame, wxDC* DC )
void SCH_FIELD::Place( WinEDA_SchematicFrame* frame, wxDC* DC )
{
int fieldNdx;
LIB_COMPONENT* Entry;

39
eeschema/class_sch_cmp_field.h
View File

@ -2,10 +2,10 @@
/* Definitions for the component fields classes for EESchema */
/*************************************************************/
#ifndef CLASS_SCH_CMP_FIELD_H
#define CLASS_SCH_CMP_FIELD_H
#ifndef CLASS_SCH_FIELD_H
#define CLASS_SCH_FIELD_H
/* Fields are texts attached to a component, having a specuial meaning
/* Fields are texts attached to a component, having a special meaning
* Fields 0 and 1 are very important: reference and value
* Field 2 is used as default footprint name.
* Field 3 is reserved (not currently used
@ -19,29 +19,33 @@ class LIB_FIELD;
/**
* Class SCH_CMP_FIELD
* instances are attached to a component and provide a place for the component's value,
* Class SCH_FIELD
* instances are attached to a component and provide a place for the
* component's value,
* reference designator, footprint, and user definable name-value pairs of
* arbitrary purpose.
*/
class SCH_CMP_FIELD : public SCH_ITEM, public EDA_TextStruct
class SCH_FIELD : public SCH_ITEM, public EDA_TextStruct
{
public:
int m_FieldId; // Field indicator type (REFERENCE, VALUE or other id)
int m_FieldId; /* Field indicator type (REFERENCE, VALUE or
* other id) */
wxString m_Name; /* Field name (ref, value,pcb, sheet, filed 1..
* and for fields 1 to 8 the name is editable
*/
bool m_AddExtraText; // Mainly for REFERENCE, add extra info (for REFERENCE: add part selection text
bool m_AddExtraText; /* Mainly for REFERENCE, add extra info
* (for REFERENCE: add part selection text */
public:
SCH_CMP_FIELD( const wxPoint& aPos, int aFieldId, SCH_COMPONENT* aParent, wxString aName = wxEmptyString );
~SCH_CMP_FIELD();
SCH_FIELD( const wxPoint& aPos, int aFieldId, SCH_COMPONENT* aParent,
wxString aName = wxEmptyString );
~SCH_FIELD();
virtual wxString GetClass() const
{
return wxT( "SCH_CMP_FIELD" );
return wxT( "SCH_FIELD" );
}
@ -49,7 +53,7 @@ public:
EDA_Rect GetBoundaryBox() const;
bool IsVoid();
void SwapData( SCH_CMP_FIELD* copyitem );
void SwapData( SCH_FIELD* copyitem );
/** Function ImportValues
* copy parameters from a source.
@ -74,7 +78,8 @@ public:
/**
* Function Save
* writes the data structures for this object out to a FILE in "*.sch" format.
* writes the data structures for this object out to a FILE in "*.sch"
* format.
* @param aFile The FILE to write to.
* @return bool - true if success writing else false.
*/
@ -83,7 +88,7 @@ public:
// Geometric transforms (used in block operations):
/** virtual function Move
* move item to a new position.
* @param aMoveVector = the deplacement vector
* @param aMoveVector = the displacement vector
*/
virtual void Move(const wxPoint& aMoveVector)
{
@ -98,10 +103,10 @@ public:
{
/* Do Nothing: fields are never mirrored alone.
* they are moved when the parent component is mirrored
* this function is only needed by the virtual pure function of the master class
*/
* this function is only needed by the virtual pure function of the
* master class */
}
};
#endif /* CLASS_SCH_CMP_FIELD_H */
#endif /* CLASS_SCH_FIELD_H */

136
eeschema/class_sch_component.cpp
View File

@ -16,9 +16,9 @@
#include <wx/tokenzr.h>
/* Local variables */
static LIB_COMPONENT* DummyCmp;
/* Descr component <DUMMY> used when a component is not found in library,
* to draw a dummy shape
* This component is a 400 mils square with the text ??
@ -50,7 +50,6 @@ void CreateDummyCmp()
}
/*******************************************************************/
SCH_COMPONENT::SCH_COMPONENT( const wxPoint& aPos, SCH_ITEM* aParent ) :
SCH_ITEM( aParent, TYPE_SCH_COMPONENT )
{
@ -58,9 +57,9 @@ SCH_COMPONENT::SCH_COMPONENT( const wxPoint& aPos, SCH_ITEM* aParent ) :
}
SCH_COMPONENT::SCH_COMPONENT( LIB_COMPONENT& libComponent, DrawSheetPath* sheet,
int unit, int convert, const wxPoint& pos,
bool setNewItemFlag ) :
SCH_COMPONENT::SCH_COMPONENT( LIB_COMPONENT& libComponent,
SCH_SHEET_PATH* sheet, int unit, int convert,
const wxPoint& pos, bool setNewItemFlag ) :
SCH_ITEM( NULL, TYPE_SCH_COMPONENT )
{
size_t i;
@ -90,13 +89,13 @@ SCH_COMPONENT::SCH_COMPONENT( LIB_COMPONENT& libComponent, DrawSheetPath* sheet,
{
while( (int) i >= GetFieldCount() )
{
SCH_CMP_FIELD field( wxPoint( 0, 0 ), GetFieldCount(), this,
ReturnDefaultFieldName( i ) );
SCH_FIELD field( wxPoint( 0, 0 ), GetFieldCount(), this,
ReturnDefaultFieldName( i ) );
AddField( field );
}
}
SCH_CMP_FIELD* schField = GetField( i );
SCH_FIELD* schField = GetField( i );
schField->m_Pos = m_Pos + libFields[i].m_Pos;
schField->ImportValues( libFields[i] );
@ -160,16 +159,16 @@ void SCH_COMPONENT::Init( const wxPoint& pos )
for( int i = 0; i < NUMBER_OF_FIELDS; ++i )
{
SCH_CMP_FIELD field( pos, i, this, ReturnDefaultFieldName( i ) );
SCH_FIELD field( pos, i, this, ReturnDefaultFieldName( i ) );
if( i==REFERENCE )
field.SetLayer( LAYER_REFERENCEPART );
else if( i==VALUE )
field.SetLayer( LAYER_VALUEPART );
// else keep LAYER_FIELDS from SCH_CMP_FIELD constructor
// else keep LAYER_FIELDS from SCH_FIELD constructor
// SCH_CMP_FIELD's implicitly created copy constructor is called in here
// SCH_FIELD's implicitly created copy constructor is called in here
AddField( field );
}
@ -204,7 +203,7 @@ void SCH_COMPONENT::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
dummy ? 0 : m_Convert, DrawMode, Color, m_Transform,
DrawPinText, false );
SCH_CMP_FIELD* field = GetField( REFERENCE );
SCH_FIELD* field = GetField( REFERENCE );
if( ( ( field->m_Attributs & TEXT_NO_VISIBLE ) == 0 )
&& !( field->m_Flags & IS_MOVED ) )
@ -295,11 +294,9 @@ void SCH_COMPONENT::AddHierarchicalReference( const wxString& aPath,
}
/****************************************************************/
wxString SCH_COMPONENT::ReturnFieldName( int aFieldNdx ) const
/****************************************************************/
{
SCH_CMP_FIELD* field = GetField( aFieldNdx );
SCH_FIELD* field = GetField( aFieldNdx );
if( field )
{
@ -313,9 +310,7 @@ wxString SCH_COMPONENT::ReturnFieldName( int aFieldNdx ) const
}
/****************************************************************/
wxString SCH_COMPONENT::GetPath( DrawSheetPath* sheet )
/****************************************************************/
wxString SCH_COMPONENT::GetPath( SCH_SHEET_PATH* sheet )
{
wxString str;
@ -324,9 +319,7 @@ wxString SCH_COMPONENT::GetPath( DrawSheetPath* sheet )
}
/********************************************************************/
const wxString SCH_COMPONENT::GetRef( DrawSheetPath* sheet )
/********************************************************************/
const wxString SCH_COMPONENT::GetRef( SCH_SHEET_PATH* sheet )
{
wxString path = GetPath( sheet );
wxString h_path, h_ref;
@ -362,9 +355,7 @@ const wxString SCH_COMPONENT::GetRef( DrawSheetPath* sheet )
}
/***********************************************************************/
void SCH_COMPONENT::SetRef( DrawSheetPath* sheet, const wxString& ref )
/***********************************************************************/
void SCH_COMPONENT::SetRef( SCH_SHEET_PATH* sheet, const wxString& ref )
{
wxString path = GetPath( sheet );
@ -374,14 +365,14 @@ void SCH_COMPONENT::SetRef( DrawSheetPath* sheet, const wxString& ref )
wxStringTokenizer tokenizer;
wxString separators( wxT( " " ) );
//check to see if it is already there before inserting it
// check to see if it is already there before inserting it
for( unsigned ii = 0; ii < m_PathsAndReferences.GetCount(); ii++ )
{
tokenizer.SetString( m_PathsAndReferences[ii], separators );
h_path = tokenizer.GetNextToken();
if( h_path.Cmp( path ) == 0 )
{
//just update the reference text, not the timestamp.
// just update the reference text, not the timestamp.
h_ref = h_path + wxT( " " ) + ref;
h_ref += wxT( " " );
tokenizer.GetNextToken(); // Skip old reference
@ -395,7 +386,7 @@ void SCH_COMPONENT::SetRef( DrawSheetPath* sheet, const wxString& ref )
if( notInArray )
AddHierarchicalReference( path, ref, m_Multi );
SCH_CMP_FIELD* rf = GetField( REFERENCE );
SCH_FIELD* rf = GetField( REFERENCE );
if( rf->m_Text.IsEmpty()
|| ( abs( rf->m_Pos.x - m_Pos.x ) +
@ -430,7 +421,8 @@ void SCH_COMPONENT::SetTimeStamp( long aNewTimeStamp)
m_TimeStamp = aNewTimeStamp;
for( unsigned ii = 0; ii < m_PathsAndReferences.GetCount(); ii++ )
{
m_PathsAndReferences[ii].Replace(string_oldtimestamp.GetData(), string_timestamp.GetData());
m_PathsAndReferences[ii].Replace( string_oldtimestamp.GetData(),
string_timestamp.GetData() );
}
}
@ -438,7 +430,7 @@ void SCH_COMPONENT::SetTimeStamp( long aNewTimeStamp)
/***********************************************************/
//returns the unit selection, for the given sheet path.
/***********************************************************/
int SCH_COMPONENT::GetUnitSelection( DrawSheetPath* aSheet )
int SCH_COMPONENT::GetUnitSelection( SCH_SHEET_PATH* aSheet )
{
wxString path = GetPath( aSheet );
wxString h_path, h_multi;
@ -469,7 +461,8 @@ int SCH_COMPONENT::GetUnitSelection( DrawSheetPath* aSheet )
/****************************************************************************/
//Set the unit selection, for the given sheet path.
/****************************************************************************/
void SCH_COMPONENT::SetUnitSelection( DrawSheetPath* aSheet, int aUnitSelection )
void SCH_COMPONENT::SetUnitSelection( SCH_SHEET_PATH* aSheet,
int aUnitSelection )
{
wxString path = GetPath( aSheet );
@ -503,9 +496,9 @@ void SCH_COMPONENT::SetUnitSelection( DrawSheetPath* aSheet, int aUnitSelection
}
SCH_CMP_FIELD* SCH_COMPONENT::GetField( int aFieldNdx ) const
SCH_FIELD* SCH_COMPONENT::GetField( int aFieldNdx ) const
{
const SCH_CMP_FIELD* field;
const SCH_FIELD* field;
if( (unsigned) aFieldNdx < m_Fields.size() )
field = &m_Fields[aFieldNdx];
@ -515,11 +508,11 @@ SCH_CMP_FIELD* SCH_COMPONENT::GetField( int aFieldNdx ) const
wxASSERT( field );
// use case to remove const-ness
return (SCH_CMP_FIELD*) field;
return (SCH_FIELD*) field;
}
void SCH_COMPONENT::AddField( const SCH_CMP_FIELD& aField )
void SCH_COMPONENT::AddField( const SCH_FIELD& aField )
{
m_Fields.push_back( aField );
}
@ -585,11 +578,9 @@ EDA_Rect SCH_COMPONENT::GetBoundaryBox() const
}
/**************************************************************************/
/* Used if undo / redo command:
* swap data between this and copyitem
*/
/**************************************************************************/
void SCH_COMPONENT::SwapData( SCH_COMPONENT* copyitem )
{
EXCHG( m_ChipName, copyitem->m_ChipName );
@ -617,9 +608,7 @@ void SCH_COMPONENT::SwapData( SCH_COMPONENT* copyitem )
}
/***********************************************************************/
void SCH_COMPONENT::Place( WinEDA_SchematicFrame* frame, wxDC* DC )
/***********************************************************************/
{
/* save old text in undo list */
if( g_ItemToUndoCopy
@ -644,10 +633,10 @@ void SCH_COMPONENT::Place( WinEDA_SchematicFrame* frame, wxDC* DC )
/**
* Suppress annotation ( i.i IC23 changed to IC? and part reset to 1)
* @param aSheet: DrawSheetPath value: if NULL remove all annotations,
* @param aSheet: SCH_SHEET_PATH value: if NULL remove all annotations,
* else remove annotation relative to this sheetpath
*/
void SCH_COMPONENT::ClearAnnotation( DrawSheetPath* aSheet )
void SCH_COMPONENT::ClearAnnotation( SCH_SHEET_PATH* aSheet )
{
wxString defRef = m_PrefixString;
bool KeepMulti = false;
@ -770,42 +759,42 @@ void SCH_COMPONENT::SetRotationMiroir( int type_rotate )
SetRotationMiroir( CMP_ROTATE_CLOCKWISE );
break;
case (CMP_ORIENT_0 + CMP_MIROIR_X):
case ( CMP_ORIENT_0 + CMP_MIROIR_X ):
SetRotationMiroir( CMP_ORIENT_0 );
SetRotationMiroir( CMP_MIROIR_X );
break;
case (CMP_ORIENT_0 + CMP_MIROIR_Y):
case ( CMP_ORIENT_0 + CMP_MIROIR_Y ):
SetRotationMiroir( CMP_ORIENT_0 );
SetRotationMiroir( CMP_MIROIR_Y );
break;
case (CMP_ORIENT_90 + CMP_MIROIR_X):
case ( CMP_ORIENT_90 + CMP_MIROIR_X ):
SetRotationMiroir( CMP_ORIENT_90 );
SetRotationMiroir( CMP_MIROIR_X );
break;
case (CMP_ORIENT_90 + CMP_MIROIR_Y):
case ( CMP_ORIENT_90 + CMP_MIROIR_Y ):
SetRotationMiroir( CMP_ORIENT_90 );
SetRotationMiroir( CMP_MIROIR_Y );
break;
case (CMP_ORIENT_180 + CMP_MIROIR_X):
case ( CMP_ORIENT_180 + CMP_MIROIR_X ):
SetRotationMiroir( CMP_ORIENT_180 );
SetRotationMiroir( CMP_MIROIR_X );
break;
case (CMP_ORIENT_180 + CMP_MIROIR_Y):
case ( CMP_ORIENT_180 + CMP_MIROIR_Y ):
SetRotationMiroir( CMP_ORIENT_180 );
SetRotationMiroir( CMP_MIROIR_Y );
break;
case (CMP_ORIENT_270 + CMP_MIROIR_X):
case ( CMP_ORIENT_270 + CMP_MIROIR_X ):
SetRotationMiroir( CMP_ORIENT_270 );
SetRotationMiroir( CMP_MIROIR_X );
break;
case (CMP_ORIENT_270 + CMP_MIROIR_Y):
case ( CMP_ORIENT_270 + CMP_MIROIR_Y ):
SetRotationMiroir( CMP_ORIENT_270 );
SetRotationMiroir( CMP_MIROIR_Y );
break;
@ -850,30 +839,35 @@ void SCH_COMPONENT::SetRotationMiroir( int type_rotate )
}
int SCH_COMPONENT::GetRotationMiroir()
/** function GetRotationMiroir()
* Used to display component orientation (in dialog editor or info)
* @return the orientation and mirror
* Note: Because there are different ways to have a given orientation/mirror,
* the orientation/mirror is not necessary wht the used does
* the orientation/mirror is not necessary what the used does
* (example : a mirrorX then a mirrorY give no mirror but rotate the component).
* So this function find a rotation and a mirror value
* ( CMP_MIROIR_X because this is the first mirror option tested)
* but can differs from the orientation made by an user
* ( a CMP_MIROIR_Y is find as a CMP_MIROIR_X + orientation 180, because they are equivalent)
* ( a CMP_MIROIR_Y is find as a CMP_MIROIR_X + orientation 180, because they
* are equivalent)
*
*/
*/
int SCH_COMPONENT::GetRotationMiroir()
{
int type_rotate = CMP_ORIENT_0;
int ComponentMatOrient[2][2];
int ii;
#define ROTATE_VALUES_COUNT 12
int rotate_value[ROTATE_VALUES_COUNT] = // list of all possibilities, but only the first 8 are actually used
// list of all possibilities, but only the first 8 are actually used
int rotate_value[ROTATE_VALUES_COUNT] =
{
CMP_ORIENT_0, CMP_ORIENT_90, CMP_ORIENT_180, CMP_ORIENT_270,
CMP_MIROIR_X + CMP_ORIENT_0, CMP_MIROIR_X + CMP_ORIENT_90, CMP_MIROIR_X + CMP_ORIENT_180, CMP_MIROIR_X + CMP_ORIENT_270,
CMP_MIROIR_Y + CMP_ORIENT_0, CMP_MIROIR_Y + CMP_ORIENT_90, CMP_MIROIR_Y + CMP_ORIENT_180, CMP_MIROIR_Y + CMP_ORIENT_270
CMP_MIROIR_X + CMP_ORIENT_0, CMP_MIROIR_X + CMP_ORIENT_90,
CMP_MIROIR_X + CMP_ORIENT_180, CMP_MIROIR_X + CMP_ORIENT_270,
CMP_MIROIR_Y + CMP_ORIENT_0, CMP_MIROIR_Y + CMP_ORIENT_90,
CMP_MIROIR_Y + CMP_ORIENT_180, CMP_MIROIR_Y + CMP_ORIENT_270
};
// Try to find the current transform option:
@ -883,7 +877,8 @@ int SCH_COMPONENT::GetRotationMiroir()
{
type_rotate = rotate_value[ii];
SetRotationMiroir( type_rotate );
if( memcmp( ComponentMatOrient, m_Transform, sizeof(ComponentMatOrient) ) == 0 )
if( memcmp( ComponentMatOrient, m_Transform,
sizeof(ComponentMatOrient) ) == 0 )
return type_rotate;
}
@ -921,10 +916,12 @@ wxPoint SCH_COMPONENT::GetScreenCoord( const wxPoint& coord )
void SCH_COMPONENT::Show( int nestLevel, std::ostream& os )
{
// for now, make it look like XML:
NestedSpace( nestLevel, os ) << '<' << GetClass().Lower().mb_str() <<
" ref=\"" << ReturnFieldName( 0 ) << '"' << " chipName=\"" <<
m_ChipName.mb_str() << '"' << m_Pos << " layer=\"" << m_Layer <<
'"' << "/>\n";
NestedSpace( nestLevel, os ) << '<' << GetClass().Lower().mb_str()
<< " ref=\"" << ReturnFieldName( 0 )
<< '"' << " chipName=\""
<< m_ChipName.mb_str() << '"' << m_Pos
<< " layer=\"" << m_Layer
<< '"' << "/>\n";
// skip the reference, it's been output already.
for( int i = 1; i < GetFieldCount(); ++i )
@ -933,13 +930,15 @@ void SCH_COMPONENT::Show( int nestLevel, std::ostream& os )
if( !value.IsEmpty() )
{
NestedSpace( nestLevel + 1, os ) << "<field" << " name=\"" <<
ReturnFieldName( i ).mb_str() << '"' << " value=\"" <<
value.mb_str() << "\"/>\n";
NestedSpace( nestLevel + 1, os ) << "<field" << " name=\""
<< ReturnFieldName( i ).mb_str()
<< '"' << " value=\""
<< value.mb_str() << "\"/>\n";
}
}
NestedSpace( nestLevel, os ) << "</" << GetClass().Lower().mb_str() << ">\n";
NestedSpace( nestLevel, os ) << "</" << GetClass().Lower().mb_str()
<< ">\n";
}
#endif
@ -1037,8 +1036,8 @@ bool SCH_COMPONENT::Save( FILE* f ) const
for( int fieldNdx = 0; fieldNdx < GetFieldCount(); ++fieldNdx )
{
SCH_CMP_FIELD* field = GetField( fieldNdx );
wxString defaultName = ReturnDefaultFieldName( fieldNdx );
SCH_FIELD* field = GetField( fieldNdx );
wxString defaultName = ReturnDefaultFieldName( fieldNdx );
// only save the field if there is a value in the field or if field name
// is different than the default field name
@ -1049,7 +1048,7 @@ bool SCH_COMPONENT::Save( FILE* f ) const
return false;
}
/* Generation du num unit, position, box ( ancienne norme )*/
/* Unit number, position, box ( old standard ) */
if( fprintf( f, "\t%-4d %-4d %-4d\n", m_Multi, m_Pos.x, m_Pos.y ) == EOF )
return false;
@ -1130,7 +1129,8 @@ void SCH_COMPONENT::Mirror_Y(int aYaxis_position)
for( int ii = 0; ii < GetFieldCount(); ii++ )
{
/* move the fields to the new position because the component itself has moved */
/* move the fields to the new position because the component itself
* has moved */
GetField( ii )->m_Pos.x -= dx;
}
}

67
eeschema/class_sch_component.h
View File

@ -7,13 +7,10 @@
#include "class_sch_screen.h"
#include <wx/arrstr.h>
#include <wx/dynarray.h>
#include "class_sch_cmp_field.h"
WX_DECLARE_OBJARRAY( DrawSheetPath, ArrayOfSheetLists );
class SCH_SHEET_PATH;
/**
@ -58,8 +55,8 @@ enum NumFieldType {
};
/// A container for several SCH_CMP_FIELD items
typedef std::vector<SCH_CMP_FIELD> SCH_CMP_FIELDS;
/// A container for several SCH_FIELD items
typedef std::vector<SCH_FIELD> SCH_FIELDS;
/**
@ -93,7 +90,7 @@ public:
private:
SCH_CMP_FIELDS m_Fields; ///< variable length list of fields
SCH_FIELDS m_Fields; ///< variable length list of fields
/* Hierarchical references.
@ -102,7 +99,8 @@ private:
* with:
* path = /<timestamp1>/<timestamp2> (subsheet path, = / for the root sheet)
* reference = reference for this path (C23, R5, U78 ... )
* multi = part selection in multi parts per package (0 or 1 for one part per package)
* multi = part selection in multi parts per package (0 or 1 for one part
* per package)
*/
wxArrayString m_PathsAndReferences;
@ -125,7 +123,7 @@ public:
* @param pos - Position to place new component.
* @param setNewItemFlag - Set the component IS_NEW and IS_MOVED flags.
*/
SCH_COMPONENT( LIB_COMPONENT& libComponent, DrawSheetPath* sheet,
SCH_COMPONENT( LIB_COMPONENT& libComponent, SCH_SHEET_PATH* sheet,
int unit = 0, int convert = 0,
const wxPoint& pos = wxPoint( 0, 0 ),
bool setNewItemFlag = false );
@ -134,7 +132,7 @@ public:
* Copy Constructor
* clones \a aTemplate into this object. All fields are copied as is except
* for the linked list management pointers which are set to NULL, and the
* SCH_CMP_FIELD's m_Parent pointers which are set to the new parent,
* SCH_FIELD's m_Parent pointers which are set to the new parent,
* i.e. this new object.
*/
SCH_COMPONENT( const SCH_COMPONENT& aTemplate );
@ -164,7 +162,7 @@ public:
* @param aFile The FILE to read from.
* @throw Error containing the error message text if there is a file format
* error or if the disk read has failed.
void Load( FILE* aFile ) throw( Error );
* void Load( FILE* aFile ) throw( Error );
*/
/**
@ -183,12 +181,14 @@ public:
* Used to display component orientation (in dialog editor or info)
* @return the orientation and mirror
* Note: Because there are different ways to have a given orientation/mirror,
* the orientation/mirror is not necessary wht the used does
* (example : a mirrorX then a mirrorY give no mirror but rotate the component).
* the orientation/mirror is not necessary what the used does
* (example : a mirrorX then a mirrorY give no mirror but rotate the
* component).
* So this function find a rotation and a mirror value
* ( CMP_MIROIR_X because this is the first mirror option tested)
* but can differs from the orientation made by an user
* ( a CMP_MIROIR_Y is find as a CMP_MIROIR_X + orientation 180, because they are equivalent)
* ( a CMP_MIROIR_Y is find as a CMP_MIROIR_X + orientation 180, because
* they are equivalent)
*/
int GetRotationMiroir();
@ -197,10 +197,10 @@ public:
/**
* Suppress annotation ( i.i IC23 changed to IC? and part reset to 1)
* @param aSheet: DrawSheetPath value: if NULL remove all annotations,
* @param aSheet: SCH_SHEET_PATH value: if NULL remove all annotations,
* else remove annotation relative to this sheetpath
*/
void ClearAnnotation( DrawSheetPath* aSheet );
void ClearAnnotation( SCH_SHEET_PATH* aSheet );
/** function SetTimeStamp
* Change the old time stamp to the new time stamp.
@ -232,19 +232,19 @@ public:
* Function GetField
* returns a field.
* @param aFieldNdx An index into the array of fields
* @return SCH_CMP_FIELD* - the field value or NULL if does not exist
* @return SCH_FIELD* - the field value or NULL if does not exist
*/
SCH_CMP_FIELD* GetField( int aFieldNdx ) const;
SCH_FIELD* GetField( int aFieldNdx ) const;
/**
* Function AddField
* adds a field to the component. The field is copied as it is put into
* the component.
* @param aField A const reference to the SCH_CMP_FIELD to add.
* @param aField A const reference to the SCH_FIELD to add.
*/
void AddField( const SCH_CMP_FIELD& aField );
void AddField( const SCH_FIELD& aField );
void SetFields( const SCH_CMP_FIELDS& aFields )
void SetFields( const SCH_FIELDS& aFields )
{
m_Fields = aFields; // vector copying, length is changed possibly
}
@ -285,20 +285,20 @@ public:
void Place( WinEDA_SchematicFrame* frame, wxDC* DC );
// returns a unique ID, in the form of a path.
wxString GetPath( DrawSheetPath* sheet );
wxString GetPath( SCH_SHEET_PATH* sheet );
/**
* Function GetRef
* returns the reference, for the given sheet path.
*/
const wxString GetRef( DrawSheetPath* sheet );
const wxString GetRef( SCH_SHEET_PATH* sheet );
// Set the reference, for the given sheet path.
void SetRef( DrawSheetPath* sheet, const wxString& ref );
void SetRef( SCH_SHEET_PATH* sheet, const wxString& ref );
/**
* Function AddHierarchicalReference
* adds a full hierachical reference (path + local reference)
* adds a full hierarchical reference (path + local reference)
* @param aPath = hierarchical path (/<sheet timestamp>/component
* timestamp> like /05678E50/A23EF560)
* @param aRef = local reference like C45, R56
@ -309,16 +309,17 @@ public:
const wxString& aRef,
int aMulti );
//returns the unit selection, for the given sheet path.
int GetUnitSelection( DrawSheetPath* aSheet );
// returns the unit selection, for the given sheet path.
int GetUnitSelection( SCH_SHEET_PATH* aSheet );
//Set the unit selection, for the given sheet path.
void SetUnitSelection( DrawSheetPath* aSheet,
// Set the unit selection, for the given sheet path.
void SetUnitSelection( SCH_SHEET_PATH* aSheet,
int aUnitSelection );
/** Function GetPenSize
* @return the size of the "pen" that be used to draw or plot this item
* for a component, has no meaning, but it is necessary to satisfy the SCH_ITEM class requirements
* for a component, has no meaning, but it is necessary to satisfy the
* SCH_ITEM class requirements.
*/
virtual int GetPenSize( ) { return 0; }
@ -327,11 +328,11 @@ public:
* move item to a new position.
* @param aMoveVector = the displacement vector
*/
virtual void Move(const wxPoint& aMoveVector)
virtual void Move( const wxPoint& aMoveVector )
{
m_Pos += aMoveVector;
for( int ii = 0; ii < GetFieldCount(); ii++ )
GetField( ii )->Move(aMoveVector);
GetField( ii )->Move( aMoveVector );
}
/** virtual function Mirror_Y
@ -349,7 +350,7 @@ public:
* of nesting of this object within the overall tree.
* @param os The ostream& to output to.
*/
void Show( int nestLevel, std::ostream& os );
void Show( int nestLevel, std::ostream& os );
#endif
};

54
eeschema/class_sch_screen.cpp
View File

@ -10,9 +10,7 @@
#include "protos.h"
/******************************************************************/
void SetaParent( EDA_BaseStruct* Struct, BASE_SCREEN* Screen )
/******************************************************************/
{
switch( Struct->Type() )
{
@ -26,7 +24,7 @@ void SetaParent( EDA_BaseStruct* Struct, BASE_SCREEN* Screen )
case DRAW_SEGMENT_STRUCT_TYPE:
case DRAW_BUSENTRY_STRUCT_TYPE:
case DRAW_SHEET_STRUCT_TYPE:
case TYPE_MARKER_SCH:
case TYPE_SCH_MARKER:
case DRAW_NOCONNECT_STRUCT_TYPE:
Struct->SetParent( Screen );
break;
@ -40,12 +38,9 @@ void SetaParent( EDA_BaseStruct* Struct, BASE_SCREEN* Screen )
}
/***********************************************************************/
/* Class SCH_SCREEN: classe de gestion d'un affichage pour schematique */
/***********************************************************************/
/* Default EESchema zoom values. Limited to 17 values to keep a decent size to menus
*/
/* Default EESchema zoom values. Limited to 17 values to keep a decent size
* to menus
*/
static int SchematicZoomList[] =
{
5, 7, 10, 15, 20, 30, 40, 60, 80, 120, 160, 230, 320, 480, 640, 800, 1280
@ -82,7 +77,6 @@ static GRID_TYPE SchematicGridList[] = {
sizeof( GRID_TYPE ) )
/* Constructeur de SCREEN */
SCH_SCREEN::SCH_SCREEN( KICAD_T type ) : BASE_SCREEN( type )
{
size_t i;
@ -96,27 +90,25 @@ SCH_SCREEN::SCH_SCREEN( KICAD_T type ) : BASE_SCREEN( type )
for( i = 0; i < SCHEMATIC_GRID_LIST_CNT; i++ )
AddGrid( SchematicGridList[i] );
SetGrid( wxRealPoint( 50, 50 ) ); /* usual grid size */
SetGrid( wxRealPoint( 50, 50 ) ); /* Default grid size. */
m_RefCount = 0;
m_Center = false; // Suitable for schematic only. for libedit and viewlib, must be set to true
m_Center = false; /* Suitable for schematic only. For
* libedit and viewlib, must be set
* to true */
InitDatas();
}
/****************************/
SCH_SCREEN::~SCH_SCREEN()
/****************************/
{
ClearUndoRedoList();
FreeDrawList();
}
/***********************************/
void SCH_SCREEN::FreeDrawList()
/***********************************/
/* Routine to clear (free) EESchema drawing list of a screen.
*/
void SCH_SCREEN::FreeDrawList()
{
SCH_ITEM* DrawStruct;
@ -131,13 +123,10 @@ void SCH_SCREEN::FreeDrawList()
}
/**************************************************************/
void SCH_SCREEN::RemoveFromDrawList( SCH_ITEM * DrawStruct )
/**************************************************************/
/* If found in EEDrawList, remove DrawStruct from EEDrawList.
* DrawStruct is not deleted or modified
*/
void SCH_SCREEN::RemoveFromDrawList( SCH_ITEM * DrawStruct )
{
if( DrawStruct == EEDrawList )
EEDrawList = EEDrawList->Next();
@ -157,9 +146,7 @@ void SCH_SCREEN::RemoveFromDrawList( SCH_ITEM * DrawStruct )
}
/**************************************************************/
bool SCH_SCREEN::CheckIfOnDrawList( SCH_ITEM* st )
/**************************************************************/
{
SCH_ITEM * DrawList = EEDrawList;
@ -174,10 +161,8 @@ bool SCH_SCREEN::CheckIfOnDrawList( SCH_ITEM* st )
}
/**************************************************************/
void SCH_SCREEN::AddToDrawList( SCH_ITEM* st )
/**************************************************************/
{ //simple function to add to the head of the drawlist.
{
st->SetNext( EEDrawList );
EEDrawList = st;
}
@ -187,17 +172,14 @@ void SCH_SCREEN::AddToDrawList( SCH_ITEM* st )
/* Class EDA_ScreenList to handle the list of screens in a hierarchy */
/*********************************************************************/
/********************************/
EDA_ScreenList::EDA_ScreenList()
/********************************/
{
m_Index = 0;
BuildScreenList( g_RootSheet );
}
/*****************************************/
SCH_SCREEN* EDA_ScreenList::GetFirst()
/*****************************************/
{
m_Index = 0;
if( m_List.GetCount() > 0 )
@ -206,9 +188,7 @@ SCH_SCREEN* EDA_ScreenList::GetFirst()
}
/*****************************************/
SCH_SCREEN* EDA_ScreenList::GetNext()
/*****************************************/
{
if( m_Index < m_List.GetCount() )
m_Index++;
@ -216,12 +196,9 @@ SCH_SCREEN* EDA_ScreenList::GetNext()
}
/************************************************/
SCH_SCREEN* EDA_ScreenList::GetScreen( unsigned int index )
/************************************************/
/* return the m_List[index] item
*/
SCH_SCREEN* EDA_ScreenList::GetScreen( unsigned int index )
{
if( index < m_List.GetCount() )
return m_List[index];
@ -229,9 +206,7 @@ SCH_SCREEN* EDA_ScreenList::GetScreen( unsigned int index )
}
/************************************************/
void EDA_ScreenList::AddScreenToList( SCH_SCREEN* testscreen )
/************************************************/
{
if( testscreen == NULL )
return;
@ -245,9 +220,7 @@ void EDA_ScreenList::AddScreenToList( SCH_SCREEN* testscreen )
}
/************************************************************************/
void EDA_ScreenList::BuildScreenList( EDA_BaseStruct* s )
/************************************************************************/
{
if( s && s->Type() == DRAW_SHEET_STRUCT_TYPE )
{
@ -269,4 +242,3 @@ void EDA_ScreenList::BuildScreenList( EDA_BaseStruct* s )
}
}
}

177
eeschema/class_schematic_items.cpp
View File

@ -16,11 +16,11 @@
*/
#define BUS_WIDTH_EXPAND 1.4
/****************************/
/* class DrawBusEntryStruct */
/***************************/
/***********************/
/* class SCH_BUS_ENTRY */
/***********************/
DrawBusEntryStruct::DrawBusEntryStruct( const wxPoint& pos, int shape, int id ) :
SCH_BUS_ENTRY::SCH_BUS_ENTRY( const wxPoint& pos, int shape, int id ) :
SCH_ITEM( NULL, DRAW_BUSENTRY_STRUCT_TYPE )
{
m_Pos = pos;
@ -39,15 +39,15 @@ DrawBusEntryStruct::DrawBusEntryStruct( const wxPoint& pos, int shape, int id )
}
wxPoint DrawBusEntryStruct::m_End() const
wxPoint SCH_BUS_ENTRY::m_End() const
{
return wxPoint( m_Pos.x + m_Size.x, m_Pos.y + m_Size.y );
}
DrawBusEntryStruct* DrawBusEntryStruct::GenCopy()
SCH_BUS_ENTRY* SCH_BUS_ENTRY::GenCopy()
{
DrawBusEntryStruct* newitem = new DrawBusEntryStruct( m_Pos, 0, 0 );
SCH_BUS_ENTRY* newitem = new SCH_BUS_ENTRY( m_Pos, 0, 0 );
newitem->m_Layer = m_Layer;
newitem->m_Width = m_Width;
@ -64,7 +64,7 @@ DrawBusEntryStruct* DrawBusEntryStruct::GenCopy()
* @param aFile The FILE to write to.
* @return bool - true if success writing else false.
*/
bool DrawBusEntryStruct::Save( FILE* aFile ) const
bool SCH_BUS_ENTRY::Save( FILE* aFile ) const
{
bool success = true;
@ -90,14 +90,14 @@ bool DrawBusEntryStruct::Save( FILE* aFile ) const
}
EDA_Rect DrawBusEntryStruct::GetBoundingBox()
EDA_Rect SCH_BUS_ENTRY::GetBoundingBox()
{
int dx = m_Pos.x - m_End().x;
int dy = m_Pos.y - m_End().y;
EDA_Rect box( wxPoint( m_Pos.x, m_Pos.y ), wxSize( dx, dy ) );
box.Normalize();
int width = (m_Width == 0) ? g_DrawDefaultLineThickness : m_Width;
int width = ( m_Width == 0 ) ? g_DrawDefaultLineThickness : m_Width;
box.Inflate( width / 2, width / 2 );
return box;
@ -107,9 +107,9 @@ EDA_Rect DrawBusEntryStruct::GetBoundingBox()
/** Function GetPenSize
* @return the size of the "pen" that be used to draw or plot this item
*/
int DrawBusEntryStruct::GetPenSize()
int SCH_BUS_ENTRY::GetPenSize()
{
int pensize = (m_Width == 0) ? g_DrawDefaultLineThickness : m_Width;
int pensize = ( m_Width == 0 ) ? g_DrawDefaultLineThickness : m_Width;
if( m_Layer == LAYER_BUS && m_Width == 0 )
{
@ -121,8 +121,8 @@ int DrawBusEntryStruct::GetPenSize()
}
void DrawBusEntryStruct::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
const wxPoint& offset, int DrawMode, int Color )
void SCH_BUS_ENTRY::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
const wxPoint& offset, int DrawMode, int Color )
{
int color;
@ -137,14 +137,14 @@ void DrawBusEntryStruct::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
}
/****************************/
/* class DrawJunctionStruct */
/***************************/
/**********************/
/* class SCH_JUNCTION */
/**********************/
DrawJunctionStruct::DrawJunctionStruct( const wxPoint& pos ) :
SCH_JUNCTION::SCH_JUNCTION( const wxPoint& pos ) :
SCH_ITEM( NULL, DRAW_JUNCTION_STRUCT_TYPE )
{
#define DRAWJUNCTION_DIAMETER 32 /* Diameter of junction symbol between wires */
#define DRAWJUNCTION_DIAMETER 32 /* Diameter of junction symbol between wires */
m_Pos = pos;
m_Layer = LAYER_JUNCTION;
m_Size.x = m_Size.y = DRAWJUNCTION_DIAMETER;
@ -153,9 +153,9 @@ DrawJunctionStruct::DrawJunctionStruct( const wxPoint& pos ) :
DrawJunctionStruct* DrawJunctionStruct::GenCopy()
SCH_JUNCTION* SCH_JUNCTION::GenCopy()
{
DrawJunctionStruct* newitem = new DrawJunctionStruct( m_Pos );
SCH_JUNCTION* newitem = new SCH_JUNCTION( m_Pos );
newitem->m_Size = m_Size;
newitem->m_Layer = m_Layer;
@ -171,7 +171,7 @@ DrawJunctionStruct* DrawJunctionStruct::GenCopy()
* @param aFile The FILE to write to.
* @return bool - true if success writing else false.
*/
bool DrawJunctionStruct::Save( FILE* aFile ) const
bool SCH_JUNCTION::Save( FILE* aFile ) const
{
bool success = true;
@ -184,13 +184,11 @@ bool DrawJunctionStruct::Save( FILE* aFile ) const
}
EDA_Rect DrawJunctionStruct::GetBoundingBox()
// return a bounding box
EDA_Rect SCH_JUNCTION::GetBoundingBox()
{
EDA_Rect rect;
rect.SetOrigin(m_Pos);
rect.Inflate( (GetPenSize() + m_Size.x)/2);
rect.SetOrigin( m_Pos );
rect.Inflate( ( GetPenSize() + m_Size.x ) / 2 );
return rect;
};
@ -200,20 +198,20 @@ EDA_Rect DrawJunctionStruct::GetBoundingBox()
* @return true if the point aPosRef is within item area
* @param aPosRef = a wxPoint to test
*/
bool DrawJunctionStruct::HitTest( const wxPoint& aPosRef )
bool SCH_JUNCTION::HitTest( const wxPoint& aPosRef )
{
wxPoint dist = aPosRef - m_Pos;
return sqrt( ( (double) ( dist.x * dist.x ) ) +
( (double) ( dist.y * dist.y ) ) ) < (m_Size.x/2);
( (double) ( dist.y * dist.y ) ) ) < ( m_Size.x / 2 );
}
/** Function GetPenSize
* @return the size of the "pen" that be used to draw or plot this item
* has no meaning for DrawJunctionStruct
* has no meaning for SCH_JUNCTION
*/
int DrawJunctionStruct::GetPenSize()
int SCH_JUNCTION::GetPenSize()
{
return 0;
}
@ -222,8 +220,8 @@ int DrawJunctionStruct::GetPenSize()
/*****************************************************************************
* Routine to redraw connection struct. *
*****************************************************************************/
void DrawJunctionStruct::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
const wxPoint& offset, int DrawMode, int Color )
void SCH_JUNCTION::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
const wxPoint& offset, int DrawMode, int Color )
{
int color;
@ -240,7 +238,7 @@ void DrawJunctionStruct::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
#if defined(DEBUG)
void DrawJunctionStruct::Show( int nestLevel, std::ostream& os )
void SCH_JUNCTION::Show( int nestLevel, std::ostream& os )
{
// XML output:
wxString s = GetClass();
@ -253,11 +251,11 @@ void DrawJunctionStruct::Show( int nestLevel, std::ostream& os )
#endif
/*****************************/
/* class DrawNoConnectStruct */
/*****************************/
/************************/
/* class SCH_NO_CONNECT */
/************************/
DrawNoConnectStruct::DrawNoConnectStruct( const wxPoint& pos ) :
SCH_NO_CONNECT::SCH_NO_CONNECT( const wxPoint& pos ) :
SCH_ITEM( NULL, DRAW_NOCONNECT_STRUCT_TYPE )
{
#define DRAWNOCONNECT_SIZE 48 /* No symbol connection range. */
@ -267,9 +265,9 @@ DrawNoConnectStruct::DrawNoConnectStruct( const wxPoint& pos ) :
}
DrawNoConnectStruct* DrawNoConnectStruct::GenCopy()
SCH_NO_CONNECT* SCH_NO_CONNECT::GenCopy()
{
DrawNoConnectStruct* newitem = new DrawNoConnectStruct( m_Pos );
SCH_NO_CONNECT* newitem = new SCH_NO_CONNECT( m_Pos );
newitem->m_Size = m_Size;
newitem->m_Flags = m_Flags;
@ -278,12 +276,12 @@ DrawNoConnectStruct* DrawNoConnectStruct::GenCopy()
}
EDA_Rect DrawNoConnectStruct::GetBoundingBox()
EDA_Rect SCH_NO_CONNECT::GetBoundingBox()
{
int delta = (GetPenSize() + m_Size.x)/2;
int delta = ( GetPenSize() + m_Size.x ) / 2;
EDA_Rect box;
box.SetOrigin( m_Pos );
box.Inflate(delta);
box.Inflate( delta );
return box;
}
@ -294,14 +292,14 @@ EDA_Rect DrawNoConnectStruct::GetBoundingBox()
* @return true if the point aPosRef is within item area
* @param aPosRef = a wxPoint to test
*/
bool DrawNoConnectStruct::HitTest( const wxPoint& aPosRef )
bool SCH_NO_CONNECT::HitTest( const wxPoint& aPosRef )
{
int width = g_DrawDefaultLineThickness;
int delta = ( m_Size.x + width) / 2;
int delta = ( m_Size.x + width ) / 2;
wxPoint dist = aPosRef - m_Pos;
if( (ABS( dist.x ) <= delta) && (ABS( dist.y ) <= delta) )
if( ( ABS( dist.x ) <= delta ) && ( ABS( dist.y ) <= delta ) )
return true;
return false;
}
@ -313,7 +311,7 @@ bool DrawNoConnectStruct::HitTest( const wxPoint& aPosRef )
* @param aFile The FILE to write to.
* @return bool - true if success writing else false.
*/
bool DrawNoConnectStruct::Save( FILE* aFile ) const
bool SCH_NO_CONNECT::Save( FILE* aFile ) const
{
bool success = true;
@ -329,20 +327,21 @@ bool DrawNoConnectStruct::Save( FILE* aFile ) const
/** Function GetPenSize
* @return the size of the "pen" that be used to draw or plot this item
*/
int DrawNoConnectStruct::GetPenSize()
int SCH_NO_CONNECT::GetPenSize()
{
return g_DrawDefaultLineThickness;
}
void DrawNoConnectStruct::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
const wxPoint& offset, int DrawMode, int Color )
void SCH_NO_CONNECT::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
const wxPoint& offset, int DrawMode, int Color )
{
int delta = m_Size.x / 2;
int pX, pY, color;
int delta = m_Size.x / 2;
int width = g_DrawDefaultLineThickness;
pX = m_Pos.x + offset.x; pY = m_Pos.y + offset.y;
pX = m_Pos.x + offset.x;
pY = m_Pos.y + offset.y;
if( Color >= 0 )
color = Color;
@ -357,11 +356,11 @@ void DrawNoConnectStruct::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
}
/***************************/
/* Class EDA_DrawLineStruct */
/***************************/
/******************/
/* Class SCH_LINE */
/******************/
EDA_DrawLineStruct::EDA_DrawLineStruct( const wxPoint& pos, int layer ) :
SCH_LINE::SCH_LINE( const wxPoint& pos, int layer ) :
SCH_ITEM( NULL, DRAW_SEGMENT_STRUCT_TYPE )
{
m_Start = pos;
@ -386,9 +385,9 @@ EDA_DrawLineStruct::EDA_DrawLineStruct( const wxPoint& pos, int layer ) :
}
EDA_DrawLineStruct* EDA_DrawLineStruct::GenCopy()
SCH_LINE* SCH_LINE::GenCopy()
{
EDA_DrawLineStruct* newitem = new EDA_DrawLineStruct( m_Start, m_Layer );
SCH_LINE* newitem = new SCH_LINE( m_Start, m_Layer );
newitem->m_End = m_End;
@ -396,11 +395,11 @@ EDA_DrawLineStruct* EDA_DrawLineStruct::GenCopy()
}
bool EDA_DrawLineStruct::IsOneEndPointAt( const wxPoint& pos )
bool SCH_LINE::IsOneEndPointAt( const wxPoint& pos )
{
if( (pos.x == m_Start.x) && (pos.y == m_Start.y) )
if( ( pos.x == m_Start.x ) && ( pos.y == m_Start.y ) )
return TRUE;
if( (pos.x == m_End.x) && (pos.y == m_End.y) )
if( ( pos.x == m_End.x ) && ( pos.y == m_End.y ) )
return TRUE;
return FALSE;
}
@ -415,23 +414,23 @@ bool EDA_DrawLineStruct::IsOneEndPointAt( const wxPoint& pos )
* of nesting of this object within the overall tree.
* @param os The ostream& to output to.
*/
void EDA_DrawLineStruct::Show( int nestLevel, std::ostream& os )
void SCH_LINE::Show( int nestLevel, std::ostream& os )
{
NestedSpace( nestLevel, os ) << '<' << GetClass().Lower().mb_str() <<
" layer=\"" << m_Layer << '"' <<
" width=\"" << m_Width << '"' <<
" startIsDangling=\"" << m_StartIsDangling << '"' <<
" endIsDangling=\"" << m_EndIsDangling << '"' << ">" <<
" <start" << m_Start << "/>" <<
" <end" << m_End << "/>" <<
"</" << GetClass().Lower().mb_str() << ">\n";
NestedSpace( nestLevel, os ) << '<' << GetClass().Lower().mb_str()
<< " layer=\"" << m_Layer << '"'
<< " width=\"" << m_Width << '"'
<< " startIsDangling=\"" << m_StartIsDangling
<< '"' << " endIsDangling=\""
<< m_EndIsDangling << '"' << ">"
<< " <start" << m_Start << "/>"
<< " <end" << m_End << "/>" << "</"
<< GetClass().Lower().mb_str() << ">\n";
}
#endif
EDA_Rect EDA_DrawLineStruct::GetBoundingBox()
EDA_Rect SCH_LINE::GetBoundingBox()
{
int width = 25;
@ -455,7 +454,7 @@ EDA_Rect EDA_DrawLineStruct::GetBoundingBox()
* @param aFile The FILE to write to.
* @return bool - true if success writing else false.
*/
bool EDA_DrawLineStruct::Save( FILE* aFile ) const
bool SCH_LINE::Save( FILE* aFile ) const
{
bool success = true;
@ -483,9 +482,9 @@ bool EDA_DrawLineStruct::Save( FILE* aFile ) const
/** Function GetPenSize
* @return the size of the "pen" that be used to draw or plot this item
*/
int EDA_DrawLineStruct::GetPenSize()
int SCH_LINE::GetPenSize()
{
int pensize = (m_Width == 0) ? g_DrawDefaultLineThickness : m_Width;
int pensize = ( m_Width == 0 ) ? g_DrawDefaultLineThickness : m_Width;
if( m_Layer == LAYER_BUS && m_Width == 0 )
{
@ -497,8 +496,8 @@ int EDA_DrawLineStruct::GetPenSize()
}
void EDA_DrawLineStruct::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
const wxPoint& offset, int DrawMode, int Color )
void SCH_LINE::Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset,
int DrawMode, int Color )
{
int color;
int width = GetPenSize();
@ -527,11 +526,11 @@ void EDA_DrawLineStruct::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
}
/****************************/
/* Class DrawPolylineStruct */
/****************************/
/***********************/
/* Class SCH_POLYLINE */
/***********************/
DrawPolylineStruct::DrawPolylineStruct( int layer ) :
SCH_POLYLINE::SCH_POLYLINE( int layer ) :
SCH_ITEM( NULL, DRAW_POLYLINE_STRUCT_TYPE )
{
m_Width = 0;
@ -551,14 +550,14 @@ DrawPolylineStruct::DrawPolylineStruct( int layer ) :
}
DrawPolylineStruct::~DrawPolylineStruct()
SCH_POLYLINE::~SCH_POLYLINE()
{
}
DrawPolylineStruct* DrawPolylineStruct::GenCopy()
SCH_POLYLINE* SCH_POLYLINE::GenCopy()
{
DrawPolylineStruct* newitem = new DrawPolylineStruct( m_Layer );
SCH_POLYLINE* newitem = new SCH_POLYLINE( m_Layer );
newitem->m_PolyPoints = m_PolyPoints; // std::vector copy
return newitem;
@ -571,7 +570,7 @@ DrawPolylineStruct* DrawPolylineStruct::GenCopy()
* @param aFile The FILE to write to.
* @return bool - true if success writing else false.
*/
bool DrawPolylineStruct::Save( FILE* aFile ) const
bool SCH_POLYLINE::Save( FILE* aFile ) const
{
bool success = true;
@ -604,16 +603,16 @@ bool DrawPolylineStruct::Save( FILE* aFile ) const
/** Function GetPenSize
* @return the size of the "pen" that be used to draw or plot this item
*/
int DrawPolylineStruct::GetPenSize()
int SCH_POLYLINE::GetPenSize()
{
int pensize = (m_Width == 0) ? g_DrawDefaultLineThickness : m_Width;
int pensize = ( m_Width == 0 ) ? g_DrawDefaultLineThickness : m_Width;
return pensize;
}
void DrawPolylineStruct::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
const wxPoint& offset, int DrawMode, int Color )
void SCH_POLYLINE::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
const wxPoint& offset, int DrawMode, int Color )
{
int color;
int width = GetPenSize();

118
eeschema/class_schematic_items.h
View File

@ -11,11 +11,11 @@
/**
* Class EDA_DrawLineStruct
* Class SCH_LINE
* is a segment description base class to describe items which have 2 end
* points (track, wire, draw line ...)
*/
class EDA_DrawLineStruct : public SCH_ITEM
class SCH_LINE : public SCH_ITEM
{
public:
int m_Width; // 0 = line, > 0 = tracks, bus ...
@ -26,20 +26,20 @@ public:
bool m_EndIsDangling; // TRUE if not connected (wires, tracks...)
public:
EDA_DrawLineStruct( const wxPoint& pos, int layer );
~EDA_DrawLineStruct() { }
SCH_LINE( const wxPoint& pos, int layer );
~SCH_LINE() { }
EDA_DrawLineStruct* Next() const { return (EDA_DrawLineStruct*) Pnext; }
EDA_DrawLineStruct* Back() const { return (EDA_DrawLineStruct*) Pback; }
SCH_LINE* Next() const { return (SCH_LINE*) Pnext; }
SCH_LINE* Back() const { return (SCH_LINE*) Pback; }
virtual wxString GetClass() const
{
return wxT( "EDA_DrawLine" );
return wxT( "SCH_LINE" );
}
bool IsOneEndPointAt( const wxPoint& pos );
EDA_DrawLineStruct* GenCopy();
bool IsOneEndPointAt( const wxPoint& pos );
SCH_LINE* GenCopy();
bool IsNull()
{
@ -106,22 +106,22 @@ public:
};
class DrawNoConnectStruct : public SCH_ITEM
class SCH_NO_CONNECT : public SCH_ITEM
{
public:
wxPoint m_Pos; /* XY coordinates of NoConnect. */
wxSize m_Size; // size of this symbol
public:
DrawNoConnectStruct( const wxPoint& pos );
~DrawNoConnectStruct() { }
SCH_NO_CONNECT( const wxPoint& pos );
~SCH_NO_CONNECT() { }
virtual wxString GetClass() const
{
return wxT( "DrawNoConnect" );
return wxT( "SCH_NO_CONNECT" );
}
DrawNoConnectStruct* GenCopy();
SCH_NO_CONNECT* GenCopy();
/** Function GetPenSize
* @return the size of the "pen" that be used to draw or plot this item
@ -149,10 +149,11 @@ public:
/**
* Function GetBoundingBox
* returns the orthogonal, bounding box of this object for display purposes.
* This box should be an enclosing perimeter for visible components of this
* object, and the units should be in the pcb or schematic coordinate system.
* It is OK to overestimate the size by a few counts.
* returns the orthogonal, bounding box of this object for display
* purposes. This box should be an enclosing perimeter for visible
* components of this object, and the units should be in the pcb or
* schematic coordinate system. It is OK to overestimate the size
* by a few counts.
*/
EDA_Rect GetBoundingBox();
@ -180,11 +181,11 @@ public:
/**
* Class DrawBusEntryStruct
* Class SCH_BUS_ENTRY
*
* Defines a bus or wire entry.
*/
class DrawBusEntryStruct : public SCH_ITEM
class SCH_BUS_ENTRY : public SCH_ITEM
{
public:
int m_Width;
@ -192,20 +193,20 @@ public:
wxSize m_Size;
public:
DrawBusEntryStruct( const wxPoint& pos, int shape, int id );
~DrawBusEntryStruct() { }
SCH_BUS_ENTRY( const wxPoint& pos, int shape, int id );
~SCH_BUS_ENTRY() { }
virtual wxString GetClass() const
{
return wxT( "DrawBusEntry" );
return wxT( "SCH_BUS_ENTRY" );
}
DrawBusEntryStruct* GenCopy();
wxPoint m_End() const;
virtual void Draw( WinEDA_DrawPanel* panel, wxDC* DC,
const wxPoint& offset, int draw_mode,
int Color = -1 );
SCH_BUS_ENTRY* GenCopy();
wxPoint m_End() const;
virtual void Draw( WinEDA_DrawPanel* panel, wxDC* DC,
const wxPoint& offset, int draw_mode,
int Color = -1 );
/**
* Function Save
@ -214,16 +215,17 @@ public:
* @param aFile The FILE to write to.
* @return bool - true if success writing else false.
*/
bool Save( FILE* aFile ) const;
bool Save( FILE* aFile ) const;
/**
* Function GetBoundingBox
* returns the orthogonal, bounding box of this object for display purposes.
* This box should be an enclosing perimeter for visible components of this
* object, and the units should be in the pcb or schematic coordinate system.
* It is OK to overestimate the size by a few counts.
* returns the orthogonal, bounding box of this object for display
* purposes. This box should be an enclosing perimeter for visible
* components of this object, and the units should be in the pcb or
* schematic coordinate system. It is OK to overestimate the size
* by a few counts.
*/
EDA_Rect GetBoundingBox();
EDA_Rect GetBoundingBox();
/** Function GetPenSize
* @return the size of the "pen" that be used to draw or plot this item
@ -253,26 +255,26 @@ public:
}
};
class DrawPolylineStruct : public SCH_ITEM
class SCH_POLYLINE : public SCH_ITEM
{
public:
int m_Width; /* Thickness */
std::vector<wxPoint> m_PolyPoints; // list of points (>= 2)
public:
DrawPolylineStruct( int layer );
~DrawPolylineStruct();
SCH_POLYLINE( int layer );
~SCH_POLYLINE();
virtual wxString GetClass() const
{
return wxT( "DrawPolyline" );
return wxT( "SCH_POLYLINE" );
}
DrawPolylineStruct* GenCopy();
virtual void Draw( WinEDA_DrawPanel* panel, wxDC* DC,
const wxPoint& offset, int draw_mode,
int Color = -1 );
SCH_POLYLINE* GenCopy();
virtual void Draw( WinEDA_DrawPanel* panel, wxDC* DC,
const wxPoint& offset, int draw_mode,
int Color = -1 );
/**
* Function Save
@ -281,12 +283,12 @@ public:
* @param aFile The FILE to write to.
* @return bool - true if success writing else false.
*/
bool Save( FILE* aFile ) const;
bool Save( FILE* aFile ) const;
/** Function AddPoint
* add a corner to m_PolyPoints
*/
void AddPoint( const wxPoint& point )
void AddPoint( const wxPoint& point )
{
m_PolyPoints.push_back( point );
}
@ -328,19 +330,19 @@ public:
};
class DrawJunctionStruct : public SCH_ITEM
class SCH_JUNCTION : public SCH_ITEM
{
public:
wxPoint m_Pos; /* XY coordinates of connection. */
wxSize m_Size;
public:
DrawJunctionStruct( const wxPoint& pos );
~DrawJunctionStruct() { }
SCH_JUNCTION( const wxPoint& pos );
~SCH_JUNCTION() { }
virtual wxString GetClass() const
{
return wxT( "DrawJunction" );
return wxT( "SCH_JUNCTION" );
}
@ -352,23 +354,23 @@ public:
/**
* Function GetBoundingBox
* returns the orthogonal, bounding box of this object for display purposes.
* This box should be an enclosing perimeter for visible components of this
* object, and the units should be in the pcb or schematic coordinate system.
* It is OK to overestimate the size by a few counts.
* returns the orthogonal, bounding box of this object for display
* purposes. This box should be an enclosing perimeter for visible
* components of this object, and the units should be in the pcb or
* schematic coordinate system. It is OK to overestimate the size
* by a few counts.
*/
EDA_Rect GetBoundingBox();
DrawJunctionStruct* GenCopy();
SCH_JUNCTION* GenCopy();
/** Function GetPenSize
* @return the size of the "pen" that be used to draw or plot this item
*/
virtual int GetPenSize( );
virtual void Draw( WinEDA_DrawPanel* panel, wxDC* DC,
const wxPoint& offset, int draw_mode,
int Color = -1 );
virtual void Draw( WinEDA_DrawPanel* panel, wxDC* DC,
const wxPoint& offset, int draw_mode, int Color = -1 );
/**
* Function Save
* writes the data structures for this object out to a FILE in "*.sch"
@ -376,7 +378,7 @@ public:
* @param aFile The FILE to write to.
* @return bool - true if success writing else false.
*/
bool Save( FILE* aFile ) const;
bool Save( FILE* aFile ) const;
// Geometric transforms (used in block operations):
/** virtual function Move
@ -400,7 +402,7 @@ public:
}
#if defined(DEBUG)
void Show( int nestLevel, std::ostream& os );
void Show( int nestLevel, std::ostream& os );
#endif
};

40
eeschema/cleanup.cpp
View File

@ -15,18 +15,15 @@
#include "netlist.h"
static int TstAlignSegment( EDA_DrawLineStruct* RefSegm,
EDA_DrawLineStruct* TstSegm );
static int TstAlignSegment( SCH_LINE* RefSegm, SCH_LINE* TstSegm );
/*******************************************/
bool SCH_SCREEN::SchematicCleanUp( wxDC* DC )
{
/*******************************************/
/* Routine cleaning:
* - Includes segments or buses aligned in only 1 segment
* - Detects identical objects superimposed
*/
bool SCH_SCREEN::SchematicCleanUp( wxDC* DC )
{
SCH_ITEM* DrawList, * TstDrawList;
int flag;
bool Modify = FALSE;
@ -45,8 +42,8 @@ bool SCH_SCREEN::SchematicCleanUp( wxDC* DC )
{
if( TstDrawList->Type() == DRAW_SEGMENT_STRUCT_TYPE )
{
flag = TstAlignSegment( (EDA_DrawLineStruct*) DrawList,
(EDA_DrawLineStruct*) TstDrawList );
flag = TstAlignSegment( (SCH_LINE*) DrawList,
(SCH_LINE*) TstDrawList );
if( flag )
{
/* keep the bits set in .m_Flags, because the deleted
@ -71,12 +68,10 @@ bool SCH_SCREEN::SchematicCleanUp( wxDC* DC )
}
/***********************************************/
void BreakSegmentOnJunction( SCH_SCREEN* Screen )
{
/************************************************/
/* Routine to start/end segment (BUS or wires) on junctions.
*/
void BreakSegmentOnJunction( SCH_SCREEN* Screen )
{
SCH_ITEM* DrawList;
if( Screen == NULL )
@ -93,13 +88,13 @@ void BreakSegmentOnJunction( SCH_SCREEN* Screen )
{
case DRAW_JUNCTION_STRUCT_TYPE:
#undef STRUCT
#define STRUCT ( (DrawJunctionStruct*) DrawList )
#define STRUCT ( (SCH_JUNCTION*) DrawList )
BreakSegment( Screen, STRUCT->m_Pos );
break;
case DRAW_BUSENTRY_STRUCT_TYPE:
#undef STRUCT
#define STRUCT ( (DrawBusEntryStruct*) DrawList )
#define STRUCT ( (SCH_BUS_ENTRY*) DrawList )
BreakSegment( Screen, STRUCT->m_Pos );
BreakSegment( Screen, STRUCT->m_End() );
break;
@ -111,7 +106,7 @@ void BreakSegmentOnJunction( SCH_SCREEN* Screen )
case TYPE_SCH_HIERLABEL:
case TYPE_SCH_COMPONENT:
case DRAW_POLYLINE_STRUCT_TYPE:
case TYPE_MARKER_SCH:
case TYPE_SCH_MARKER:
case TYPE_SCH_TEXT:
case DRAW_SHEET_STRUCT_TYPE:
case DRAW_HIERARCHICAL_PIN_SHEET_STRUCT_TYPE:
@ -132,7 +127,7 @@ void BreakSegmentOnJunction( SCH_SCREEN* Screen )
*/
void BreakSegment( SCH_SCREEN* aScreen, wxPoint aBreakpoint )
{
EDA_DrawLineStruct* segment, * NewSegment;
SCH_LINE* segment, * NewSegment;
for( SCH_ITEM* DrawList = aScreen->EEDrawList; DrawList;
DrawList = DrawList->Next() )
@ -140,7 +135,7 @@ void BreakSegment( SCH_SCREEN* aScreen, wxPoint aBreakpoint )
if( DrawList->Type() != DRAW_SEGMENT_STRUCT_TYPE )
continue;
segment = (EDA_DrawLineStruct*) DrawList;
segment = (SCH_LINE*) DrawList;
if( !TestSegmentHit( aBreakpoint, segment->m_Start, segment->m_End, 0 ) )
continue;
@ -163,15 +158,12 @@ void BreakSegment( SCH_SCREEN* aScreen, wxPoint aBreakpoint )
}
/***********************************************************/
static int TstAlignSegment( EDA_DrawLineStruct* RefSegm,
EDA_DrawLineStruct* TstSegm )
{
/***********************************************************/
/* Search if the 2 segments RefSegm and TstSegm are on a line.
* Return 0 if no
* 1 if yes, and RefSegm is modified to be the equivalent segment
*/
static int TstAlignSegment( SCH_LINE* RefSegm, SCH_LINE* TstSegm )
{
if( RefSegm == TstSegm )
return 0;
if( RefSegm->GetLayer() != TstSegm->GetLayer() )
@ -219,8 +211,8 @@ static int TstAlignSegment( EDA_DrawLineStruct* RefSegm,
{
if( atan2( (double) ( RefSegm->m_Start.x - RefSegm->m_End.x ),
(double) ( RefSegm->m_Start.y - RefSegm->m_End.y ) ) ==
atan2( (double) ( TstSegm->m_Start.x - TstSegm->m_End.x ),
(double) ( TstSegm->m_Start.y - TstSegm->m_End.y ) ) )
atan2( (double) ( TstSegm->m_Start.x - TstSegm->m_End.x ),
(double) ( TstSegm->m_Start.y - TstSegm->m_End.y ) ) )
{
RefSegm->m_End = TstSegm->m_End;
return 1;

31
eeschema/controle.cpp
View File

@ -18,11 +18,6 @@
#include "class_marker_sch.h"
/*****************************************************************************/
SCH_ITEM* WinEDA_SchematicFrame:: SchematicGeneralLocateAndDisplay(
bool IncludePin )
{
/*****************************************************************************/
/** Function SchematicGeneralLocateAndDisplay
* Overlaid function
* Find the schematic item at cursor position
@ -39,6 +34,9 @@ SCH_ITEM* WinEDA_SchematicFrame:: SchematicGeneralLocateAndDisplay(
*
* For some items, characteristics are displayed on the screen.
*/
SCH_ITEM* WinEDA_SchematicFrame:: SchematicGeneralLocateAndDisplay(
bool IncludePin )
{
SCH_ITEM* DrawStruct;
wxString msg;
wxPoint mouse_position = GetScreen()->m_MousePosition;
@ -99,13 +97,6 @@ SCH_ITEM* WinEDA_SchematicFrame:: SchematicGeneralLocateAndDisplay(
}
/*****************************************************************************/
SCH_ITEM* WinEDA_SchematicFrame::SchematicGeneralLocateAndDisplay(
const wxPoint& refpoint,
bool
IncludePin )
{
/*****************************************************************************/
/** Function SchematicGeneralLocateAndDisplay
* Overlaid function
* Find the schematic item at a given position
@ -123,6 +114,11 @@ SCH_ITEM* WinEDA_SchematicFrame::SchematicGeneralLocateAndDisplay(
*
* For some items, characteristics are displayed on the screen.
*/
SCH_ITEM* WinEDA_SchematicFrame::SchematicGeneralLocateAndDisplay(
const wxPoint& refpoint,
bool
IncludePin )
{
SCH_ITEM* DrawStruct;
LIB_PIN* Pin;
SCH_COMPONENT* LibItem;
@ -155,8 +151,8 @@ SCH_ITEM* WinEDA_SchematicFrame::SchematicGeneralLocateAndDisplay(
if( DrawStruct ) // We have found a wire: Search for a connected pin at
// the same location
{
Pin = LocateAnyPin(
(SCH_ITEM*) m_CurrentSheet->LastDrawList(), refpoint, &LibItem );
Pin = LocateAnyPin( (SCH_ITEM*) m_CurrentSheet->LastDrawList(),
refpoint, &LibItem );
if( Pin )
{
Pin->DisplayInfo( this );
@ -166,13 +162,14 @@ SCH_ITEM* WinEDA_SchematicFrame::SchematicGeneralLocateAndDisplay(
}
else
ClearMsgPanel();
return DrawStruct;
}
DrawStruct = (SCH_ITEM*) PickStruct( refpoint, GetScreen(), FIELDCMPITEM );
if( DrawStruct )
{
SCH_CMP_FIELD* Field = (SCH_CMP_FIELD*) DrawStruct;
SCH_FIELD* Field = (SCH_FIELD*) DrawStruct;
LibItem = (SCH_COMPONENT*) Field->GetParent();
LibItem->DisplayInfo( this );
@ -181,7 +178,7 @@ SCH_ITEM* WinEDA_SchematicFrame::SchematicGeneralLocateAndDisplay(
/* search for a pin */
Pin = LocateAnyPin( (SCH_ITEM*) m_CurrentSheet->LastDrawList(), refpoint,
&LibItem );
&LibItem );
if( Pin )
{
Pin->DisplayInfo( this );
@ -463,7 +460,7 @@ void WinEDA_ViewlibFrame::GeneralControle( wxDC* DC,
screen->m_Curseur = curpos;
/* Snap cursor to grid. */
PutOnGrid( &(screen->m_Curseur) );
PutOnGrid( &screen->m_Curseur );
if( screen->IsRefreshReq() )
{

32
eeschema/dangling_ends.cpp
View File

@ -44,21 +44,21 @@ public:
DanglingEndHandle* ItemList;
static void TestWireForDangling( EDA_DrawLineStruct* DrawRef,
WinEDA_SchematicFrame* frame, wxDC* DC );
static void TestWireForDangling( SCH_LINE* DrawRef,
WinEDA_SchematicFrame* frame,
wxDC* DC );
void TestLabelForDangling( SCH_TEXT* label,
WinEDA_SchematicFrame* frame,
wxDC* DC );
DanglingEndHandle* RebuildEndList( EDA_BaseStruct* DrawList );
/**********************************************************/
bool SegmentIntersect( int Sx1, int Sy1, int Sx2, int Sy2,
int Px1, int Py1 )
{
/**********************************************************/
/* Returns TRUE if the point P is on the segment S.
* The segment is assumed horizontal or vertical.
*/
bool SegmentIntersect( int Sx1, int Sy1, int Sx2, int Sy2,
int Px1, int Py1 )
{
int Sxmin, Sxmax, Symin, Symax;
if( Sx1 == Sx2 ) /* Line S is vertical. */
@ -122,7 +122,7 @@ void WinEDA_SchematicFrame::TestDanglingEnds( SCH_ITEM* DrawList, wxDC* DC )
case DRAW_SEGMENT_STRUCT_TYPE:
#undef STRUCT
#define STRUCT ( (EDA_DrawLineStruct*) item )
#define STRUCT ( (SCH_LINE*) item )
if( STRUCT->GetLayer() == LAYER_WIRE )
{
TestWireForDangling( STRUCT, this, DC );
@ -176,11 +176,9 @@ LIB_PIN* WinEDA_SchematicFrame::LocatePinEnd( SCH_ITEM* DrawList,
}
/****************************************************************************/
void TestWireForDangling( EDA_DrawLineStruct* DrawRef,
WinEDA_SchematicFrame* frame, wxDC* DC )
void TestWireForDangling( SCH_LINE* DrawRef, WinEDA_SchematicFrame* frame,
wxDC* DC )
{
/****************************************************************************/
DanglingEndHandle* terminal_item;
bool Sdangstate = TRUE, Edangstate = TRUE;
@ -216,11 +214,9 @@ void TestWireForDangling( EDA_DrawLineStruct* DrawRef,
}
/********************************************************/
void TestLabelForDangling( SCH_TEXT* label, WinEDA_SchematicFrame* frame,
wxDC* DC )
{
/********************************************************/
DanglingEndHandle* terminal_item;
bool dangstate = TRUE;
@ -290,10 +286,8 @@ wxPoint ReturnPinPhysicalPosition( LIB_PIN* Pin, SCH_COMPONENT* DrawLibItem )
}
/***********************************************************/
DanglingEndHandle* RebuildEndList( EDA_BaseStruct* DrawList )
{
/***********************************************************/
DanglingEndHandle* StartList = NULL, * item, * lastitem = NULL;
EDA_BaseStruct* DrawItem;
@ -319,7 +313,7 @@ DanglingEndHandle* RebuildEndList( EDA_BaseStruct* DrawList )
case DRAW_SEGMENT_STRUCT_TYPE:
#undef STRUCT
#define STRUCT ( (EDA_DrawLineStruct*) DrawItem )
#define STRUCT ( (SCH_LINE*) DrawItem )
if( STRUCT->GetLayer() == LAYER_NOTES )
break;
if( ( STRUCT->GetLayer() == LAYER_BUS )
@ -349,7 +343,7 @@ DanglingEndHandle* RebuildEndList( EDA_BaseStruct* DrawList )
case DRAW_JUNCTION_STRUCT_TYPE:
#undef STRUCT
#define STRUCT ( (DrawJunctionStruct*) DrawItem )
#define STRUCT ( (SCH_JUNCTION*) DrawItem )
item = new DanglingEndHandle( JUNCTION_END );
item->m_Item = DrawItem;
@ -363,7 +357,7 @@ DanglingEndHandle* RebuildEndList( EDA_BaseStruct* DrawList )
case DRAW_BUSENTRY_STRUCT_TYPE:
#undef STRUCT
#define STRUCT ( (DrawBusEntryStruct*) DrawItem )
#define STRUCT ( (SCH_BUS_ENTRY*) DrawItem )
item = new DanglingEndHandle( ENTRY_END );
item->m_Item = DrawItem;

Some files were not shown because too many files have changed in this diff Show More