Added main execs

1 files changed, 773 insertions, 0 deletions

diff --git a/eeschema/class_libentry.h b/eeschema/class_libentry.h
new file mode 100644
index 0000000..b81859e
--- /dev/null
+++ b/eeschema/class_libentry.h
@@ -0,0 +1,773 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2004-2015 Jean-Pierre Charras, jp.charras at wanadoo.fr
+ * Copyright (C) 2008-2015 Wayne Stambaugh <stambaughw@verizon.net>
+ * Copyright (C) 2004-2015 KiCad Developers, see change_log.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file class_libentry.h
+ */
+
+#ifndef CLASS_LIBENTRY_H
+#define CLASS_LIBENTRY_H
+
+#include <general.h>
+#include <lib_draw_item.h>
+#include <lib_field.h>
+#include <boost/shared_ptr.hpp>
+#include <boost/weak_ptr.hpp>
+#include <vector>
+
+class LINE_READER;
+class OUTPUTFORMATTER;
+class PART_LIB;
+class LIB_ALIAS;
+class LIB_PART;
+class LIB_FIELD;
+
+
+/// Compiler controlled string compare function, either case independent or not:
+inline int Cmp_KEEPCASE( const wxString& aString1, const wxString& aString2 )
+{
+#ifdef KICAD_KEEPCASE
+    // case specificity, the normal behavior:
+    return aString1.Cmp( aString2 );
+#else
+    // case independence (only for guys who want that: not recommended)
+    return aString1.CmpNoCase( aString2 );
+#endif
+}
+
+
+typedef std::vector<LIB_ALIAS*>         LIB_ALIASES;
+typedef boost::shared_ptr<LIB_PART>     PART_SPTR;      ///< shared pointer to LIB_PART
+typedef boost::weak_ptr<LIB_PART>       PART_REF;       ///< weak pointer to LIB_PART
+
+
+/* values for member .m_options */
+enum  LIBRENTRYOPTIONS
+{
+    ENTRY_NORMAL,   // Libentry is a standard part (real or alias)
+    ENTRY_POWER     // Libentry is a power symbol
+};
+
+
+/// WXTRACE value to enable schematic library memory deletion debug output.
+extern const wxChar traceSchLibMem[];
+
+
+/**
+ * Part library alias object definition.
+ *
+ * Part aliases are not really parts.  An alias uses the part definition
+ * (graphic, pins...)  but has its own name, keywords and documentation.  Therefore, when
+ * the part is modified, alias of this part are modified.  This is a simple
+ * method to create parts that have the same physical layout with different names
+ * such as 74LS00, 74HC00 ... and many op amps.
+ */
+class LIB_ALIAS : public EDA_ITEM
+{
+    /**
+     * Actual LIB_PART referenced by [multiple] aliases.
+     *
+     * @note - Do not delete the shared part. The shared part is shared by
+     * all of the aliases associated with it. A shared LIB_PART will
+     * be deleted when all LIB_ALIASes pointing to it are deleted.
+     */
+    LIB_PART*       shared;
+
+    friend class LIB_PART;
+
+protected:
+    wxString        name;
+    wxString        description;    ///< documentation for info
+    wxString        keyWords;       ///< keyword list (used for search for parts by keyword)
+    wxString        docFileName;    ///< Associate doc file name
+
+public:
+    LIB_ALIAS( const wxString& aName, LIB_PART* aRootComponent );
+    LIB_ALIAS( const LIB_ALIAS& aAlias, LIB_PART* aRootComponent = NULL );
+
+    virtual ~LIB_ALIAS();
+
+    virtual wxString GetClass() const
+    {
+        return wxT( "LIB_ALIAS" );
+    }
+
+    /**
+     * Function GetPart
+     * gets the shared LIB_PART.
+     *
+     * @return LIB_PART* - the LIB_PART shared by
+     * this LIB_ALIAS with possibly other LIB_ALIASes.
+     */
+    LIB_PART* GetPart() const
+    {
+        return shared;
+    }
+
+    const wxString GetLibraryName();
+
+    bool IsRoot() const;
+
+    PART_LIB* GetLib();
+
+    const wxString& GetName() const         { return name; }
+
+    void SetName( const wxString& aName )   { name = aName; }
+
+    void SetDescription( const wxString& aDescription )
+    {
+        description = aDescription;
+    }
+
+    wxString GetDescription() const { return description; }
+
+    void SetKeyWords( const wxString& aKeyWords )
+    {
+        keyWords = aKeyWords;
+    }
+
+    wxString GetKeyWords() const { return keyWords; }
+
+    void SetDocFileName( const wxString& aDocFileName )
+    {
+        docFileName = aDocFileName;
+    }
+
+    wxString GetDocFileName() const { return docFileName; }
+
+    /**
+     * Function SaveDocs
+     * write the entry document information to \a aFormatter in "*.dcm" format.
+     *
+     * @param aFormatter The #OUTPUTFORMATTER to write the alias documents to.
+     * @return True if success writing else false.
+     */
+    bool SaveDoc( OUTPUTFORMATTER& aFormatter );
+
+    /**
+     * KEEPCASE sensitive comparison of the part entry name.
+     */
+    bool operator==( const wxChar* aName ) const;
+    bool operator!=( const wxChar* aName ) const
+    {
+        return !( *this == aName );
+    }
+
+    bool operator==( const LIB_ALIAS* aAlias ) const { return this == aAlias; }
+
+#if defined(DEBUG)
+    void Show( int nestLevel, std::ostream& os ) const { ShowDummy( os ); } // override
+#endif
+};
+
+extern bool operator<( const LIB_ALIAS& aItem1, const LIB_ALIAS& aItem2 );
+
+extern int LibraryEntryCompare( const LIB_ALIAS* aItem1, const LIB_ALIAS* aItem2 );
+
+
+/**
+ * Class LIB_PART
+ * defines a library part object.
+ *
+ * A library part object is typically saved and loaded in a part library file (.lib).
+ * Library parts are different from schematic components.
+ */
+class LIB_PART : public EDA_ITEM
+{
+    friend class PART_LIB;
+    friend class LIB_ALIAS;
+
+    PART_SPTR           m_me;               ///< http://www.boost.org/doc/libs/1_55_0/libs/smart_ptr/sp_techniques.html#weak_without_shared
+    wxString            m_name;
+    int                 m_pinNameOffset;    ///< The offset in mils to draw the pin name.  Set to 0
+                                            ///< to draw the pin name above the pin.
+    bool                m_unitsLocked;      ///< True if part has multiple units and changing
+                                            ///< one unit does not automatically change another unit.
+    bool                m_showPinNames;     ///< Determines if part pin names are visible.
+    bool                m_showPinNumbers;   ///< Determines if part pin numbers are visible.
+    long                m_dateModified;     ///< Date the part was last modified.
+    LIBRENTRYOPTIONS    m_options;          ///< Special part features such as POWER or NORMAL.)
+    int                 m_unitCount;        ///< Number of units (parts) per package.
+    LIB_ITEMS           drawings;           ///< How to draw this part.
+    wxArrayString       m_FootprintList;    /**< List of suitable footprint names for the
+                                                 part (wild card names accepted). */
+    LIB_ALIASES         m_aliases;          ///< List of alias object pointers associated with the
+                                            ///< part.
+    PART_LIB*           m_library;          ///< Library the part belongs to if any.
+
+    static int  m_subpartIdSeparator;       ///< the separator char between
+                                            ///< the subpart id and the reference
+                                            ///< like U1A ( m_subpartIdSeparator = 0 ) or U1.A or U1-A
+    static int  m_subpartFirstId;           ///< the ascii char value to calculate the subpart symbol id
+                                            ///< from the part number: only 'A', 'a' or '1' can be used,
+                                            ///< other values have no sense.
+private:
+    void deleteAllFields();
+
+    // LIB_PART()  { }     // not legal
+
+public:
+
+    LIB_PART( const wxString& aName, PART_LIB* aLibrary = NULL );
+    LIB_PART( LIB_PART& aPart, PART_LIB* aLibrary = NULL );
+
+    virtual ~LIB_PART();
+
+    PART_SPTR    SharedPtr()
+    {
+        // clone a shared pointer
+        return m_me;
+    }
+
+    virtual wxString GetClass() const
+    {
+        return wxT( "LIB_PART" );
+    }
+
+    virtual void SetName( const wxString& aName );
+
+    const wxString& GetName()       { return m_name; }
+
+    const wxString GetLibraryName();
+
+    PART_LIB* GetLib()              { return m_library; }
+
+    wxArrayString GetAliasNames( bool aIncludeRoot = true ) const;
+
+    size_t GetAliasCount() const    { return m_aliases.size(); }
+
+    LIB_ALIAS* GetAlias( size_t aIndex );
+
+    LIB_ALIAS* GetAlias( const wxString& aName );
+
+    /**
+     * Function AddAlias
+     *
+     * Add an alias \a aName to the part.
+     *
+     * Duplicate alias names are not added to the alias list.  Debug builds will raise an
+     * assertion.  Release builds will fail silently.
+     *
+     * @param aName - Name of alias to add.
+     */
+    void AddAlias( const wxString& aName );
+
+    /**
+     * Test if alias \a aName is in part alias list.
+     *
+     * Alias name comparisons are case insensitive.
+     *
+     * @param aName - Name of alias.
+     * @return True if alias name in alias list.
+     */
+    bool HasAlias( const wxString& aName ) const;
+
+    void SetAliases( const wxArrayString& aAliasList );
+
+    void RemoveAlias( const wxString& aName );
+    LIB_ALIAS* RemoveAlias( LIB_ALIAS* aAlias );
+
+    void RemoveAllAliases();
+
+    wxArrayString& GetFootPrints() { return m_FootprintList; }
+
+    /**
+     * Function GetBoundingBox
+     * @return the part bounding box ( in user coordinates )
+     * @param aUnit = unit selection = 0, or 1..n
+     * @param aConvert = 0, 1 or 2
+     *  If aUnit == 0, unit is not used
+     *  if aConvert == 0 Convert is non used
+     *  Invisible fields are not taken in account
+     **/
+    const EDA_RECT GetBoundingBox( int aUnit, int aConvert ) const;
+
+    /**
+     * Function GetBodyBoundingBox
+     * @return the part bounding box ( in user coordinates ) without fields
+     * @param aUnit = unit selection = 0, or 1..n
+     * @param aConvert = 0, 1 or 2
+     *  If aUnit == 0, unit is not used
+     *  if aConvert == 0 Convert is non used
+     *  Fields are not taken in account
+     **/
+    const EDA_RECT GetBodyBoundingBox( int aUnit, int aConvert ) const;
+
+    /**
+     * Function SaveDateAndTime
+     * write the date and time of part to \a aFile in the format:
+     * "Ti yy/mm/jj hh:mm:ss"
+     *
+     * @param aFormatter A reference to an #OUTPUTFORMATTER object containing the
+     *                   output format to write to.
+     * @return True if the date and time were successfully written to \a aFormatter.
+     */
+    bool SaveDateAndTime( OUTPUTFORMATTER& aFormatter );
+
+    bool LoadDateAndTime( char* aLine );
+
+    /**
+     * Function Save
+     * writes the data structures out to \a aFormatter in the part library "*.lib"
+     * format.
+     *
+     * @param aFormatter A reference to an OUTPUTFORMATTER to write to.
+     * @return True if success writing else false.
+     */
+    bool Save( OUTPUTFORMATTER& aFormatter );
+
+    /**
+     * Load part definition from \a aReader.
+     *
+     * @param aReader A LINE_READER object to load file from.
+     * @param aErrorMsg - Description of error on load failure.
+     * @return True if the load was successful, false if there was an error.
+     */
+    bool Load( LINE_READER& aReader, wxString& aErrorMsg );
+    bool LoadField( LINE_READER& aReader, wxString& aErrorMsg );
+    bool LoadDrawEntries( LINE_READER& aReader, wxString& aErrorMsg );
+    bool LoadAliases( char* aLine, wxString& aErrorMsg );
+    bool LoadFootprints( LINE_READER& aReader, wxString& aErrorMsg );
+
+    bool IsPower() const  { return m_options == ENTRY_POWER; }
+    bool IsNormal() const { return m_options == ENTRY_NORMAL; }
+
+    void SetPower()     { m_options = ENTRY_POWER; }
+    void SetNormal()    { m_options = ENTRY_NORMAL; }
+
+    void LockUnits( bool aLockUnits ) { m_unitsLocked = aLockUnits; }
+    bool UnitsLocked() const { return m_unitsLocked; }
+
+    /**
+     * Function SetFields
+     * overwrites all the existing in this part with fields supplied
+     * in \a aFieldsList.  The only known caller of this function is the
+     * library part field editor, and it establishes needed behavior.
+     *
+`     * @param aFieldsList is a set of fields to import, removing all previous fields.
+     */
+    void SetFields( const std::vector <LIB_FIELD>& aFieldsList );
+
+    /**
+     * Function GetFields
+     * returns a list of fields withing this part. The only known caller of
+     * this function is the library part field editor, and it establishes
+     * needed behavior.
+     *
+     * @param aList - List to add fields to
+     */
+    void GetFields( LIB_FIELDS& aList );
+
+    /**
+     * Function FindField
+     * finds a field within this part matching \a aFieldName and returns
+     * it or NULL if not found.
+     */
+    LIB_FIELD* FindField( const wxString& aFieldName );
+
+    /**
+     * Return pointer to the requested field.
+     *
+     * @param aId - Id of field to return.
+     * @return The field if found, otherwise NULL.
+     */
+    LIB_FIELD* GetField( int aId );
+
+    /** Return reference to the value field. */
+    LIB_FIELD& GetValueField();
+
+    /** Return reference to the reference designator field. */
+    LIB_FIELD& GetReferenceField();
+
+    /**
+     * Draw part.
+     *
+     * @param aPanel - Window to draw on. Can be NULL if not available.
+     * @param aDc - Device context to draw on.
+     * @param aOffset - Position of part.
+     * @param aMulti - unit if multiple units per part.
+     * @param aConvert - Component conversion (DeMorgan) if available.
+     * @param aDrawMode - Device context drawing mode, see wxDC.
+     * @param aColor - Color to draw part.
+     * @param aTransform - Coordinate adjustment settings.
+     * @param aShowPinText - Show pin text if true.
+     * @param aDrawFields - Draw field text if true otherwise just draw
+     *                      body items (useful to draw a body in schematic,
+     *                      because fields of schematic components replace
+     *                      the lib part fields).
+     * @param aOnlySelected - Draws only the body items that are selected.
+     *                        Used for block move redraws.
+     * @param aPinsDangling - if not NULL, this should be a pointer to
+     *              vector<bool> exactly the same length as the number of pins,
+     *              indicating whether each pin is dangling. If NULL, all pins
+     *              will be drawn as if they were dangling.
+     */
+    void Draw( EDA_DRAW_PANEL* aPanel, wxDC* aDc, const wxPoint& aOffset,
+               int aMulti, int aConvert, GR_DRAWMODE aDrawMode,
+               EDA_COLOR_T aColor = UNSPECIFIED_COLOR,
+               const TRANSFORM& aTransform = DefaultTransform,
+               bool aShowPinText = true, bool aDrawFields = true,
+               bool aOnlySelected = false,
+               const std::vector<bool>* aPinsDangling = NULL );
+
+    /**
+     * Plot lib part to plotter.
+     * Lib Fields not are plotted here, because this plot function
+     * is used to plot schematic items, which have they own fields
+     *
+     * @param aPlotter - Plotter object to plot to.
+     * @param aUnit - Component part to plot.
+     * @param aConvert - Component alternate body style to plot.
+     * @param aOffset - Distance to shift the plot coordinates.
+     * @param aTransform - Component plot transform matrix.
+     */
+    void Plot( PLOTTER* aPlotter, int aUnit, int aConvert, const wxPoint& aOffset,
+                const TRANSFORM& aTransform );
+
+    /**
+     * Plot Lib Fields only of the part to plotter.
+     * is used to plot the full lib part, outside the schematic
+     *
+     * @param aPlotter - Plotter object to plot to.
+     * @param aUnit - Component part to plot.
+     * @param aConvert - Component alternate body style to plot.
+     * @param aOffset - Distance to shift the plot coordinates.
+     * @param aTransform - Component plot transform matrix.
+     */
+    void PlotLibFields( PLOTTER* aPlotter, int aUnit, int aConvert,
+                        const wxPoint& aOffset, const TRANSFORM& aTransform );
+
+    /**
+     * Add a new draw \a aItem to the draw object list.
+     *
+     * @param aItem - New draw object to add to part.
+     */
+    void AddDrawItem( LIB_ITEM* aItem );
+
+    /**
+     * Remove draw \a aItem from list.
+     *
+     * @param aItem - Draw item to remove from list.
+     * @param aPanel - Panel to remove part from.
+     * @param aDc - Device context to remove part from.
+     */
+    void RemoveDrawItem( LIB_ITEM* aItem, EDA_DRAW_PANEL* aPanel = NULL, wxDC* aDc = NULL );
+
+    /**
+     * Return the next draw object pointer.
+     *
+     * @param aItem - Pointer to the current draw item.  Setting item NULL
+     *                with return the first item of type in the list.
+     * @param aType - type of searched item (filter).
+     *                if TYPE_NOT_INIT search for all items types
+     * @return - The next drawing object in the list if found, otherwise NULL.
+     */
+    LIB_ITEM* GetNextDrawItem( LIB_ITEM* aItem = NULL, KICAD_T aType = TYPE_NOT_INIT );
+
+    /**
+     * Return the next pin object from the draw list.
+     *
+     * This is just a pin object specific version of GetNextDrawItem().
+     *
+     * @param aItem - Pointer to the previous pin item, or NULL to get the
+     *                first pin in the draw object list.
+     * @return - The next pin object in the list if found, otherwise NULL.
+     */
+    LIB_PIN* GetNextPin( LIB_PIN* aItem = NULL )
+    {
+        return (LIB_PIN*) GetNextDrawItem( (LIB_ITEM*) aItem, LIB_PIN_T );
+    }
+
+
+    /**
+     * Return a list of pin object pointers from the draw item list.
+     *
+     * Note pin objects are owned by the draw list of the part.
+     * Deleting any of the objects will leave list in a unstable state
+     * and will likely segfault when the list is destroyed.
+     *
+     * @param aList - Pin list to place pin object pointers into.
+     * @param aUnit - Unit number of pin to add to list.  Set to 0 to
+     *                get pins from any part unit.
+     * @param aConvert - Convert number of pin to add to list.  Set to 0 to
+     *                   get pins from any convert of part.
+     */
+    void GetPins( LIB_PINS& aList, int aUnit = 0, int aConvert = 0 );
+
+    /**
+     * Return pin object with the requested pin \a aNumber.
+     *
+     * @param aNumber - Number of the pin to find.
+     * @param aUnit - Unit of the part to find.  Set to 0 if a specific
+     *                unit number is not required.
+     * @param aConvert - Alternate body style filter (DeMorgan).  Set to 0 if
+     *                   no alternate body style is required.
+     * @return The pin object if found.  Otherwise NULL.
+     */
+    LIB_PIN* GetPin( const wxString& aNumber, int aUnit = 0, int aConvert = 0 );
+
+    /**
+     * Function PinsConflictWith
+     * returns true if this part's pins do not match another part's pins. This
+     * is used to detect whether the project cache is out of sync with the
+     * system libs.
+     *
+     * @param aOtherPart - The other library part to test
+     * @param aTestNums - Whether two pins at the same point must have the same number.
+     * @param aTestNames - Whether two pins at the same point must have the same name.
+     * @param aTestType - Whether two pins at the same point must have the same electrical type.
+     * @param aTestOrientation - Whether two pins at the same point must have the same orientation.
+     * @param aTestLength - Whether two pins at the same point must have the same length.
+     */
+    bool PinsConflictWith( LIB_PART& aOtherPart, bool aTestNums, bool aTestNames,
+            bool aTestType, bool aTestOrientation, bool aTestLength );
+
+    /**
+     * Move the part \a aOffset.
+     *
+     * @param aOffset - Offset displacement.
+     */
+    void SetOffset( const wxPoint& aOffset );
+
+    /**
+     * Remove duplicate draw items from list.
+     */
+    void RemoveDuplicateDrawItems();
+
+    /**
+     * Test if part has more than one body conversion type (DeMorgan).
+     *
+     * @return True if part has more than one conversion.
+     */
+    bool HasConversion() const;
+
+    /**
+     * Clears the status flag all draw objects in this part.
+     */
+    void ClearStatus();
+
+    /**
+     * Checks all draw objects of part to see if they are with block.
+     *
+     * Use this method to mark draw objects as selected during block
+     * functions.
+     *
+     * @param aRect - The bounding rectangle to test in draw items are inside.
+     * @param aUnit - The current unit number to test against.
+     * @param aConvert - Are the draw items being selected a conversion.
+     * @param aEditPinByPin - Used to ignore pin selections when in edit pin
+     *                        by pin mode is enabled.
+     * @return The number of draw objects found inside the block select
+     *         rectangle.
+     */
+    int SelectItems( EDA_RECT& aRect, int aUnit, int aConvert, bool aEditPinByPin );
+
+    /**
+     * Clears all the draw items marked by a block select.
+     */
+    void ClearSelectedItems();
+
+    /**
+     * Deletes the select draw items marked by a block select.
+     *
+     * The name and reference field will not be deleted.  They are the
+     * minimum drawing items required for any part.  Their properties
+     * can be changed but the cannot be removed.
+     */
+    void DeleteSelectedItems();
+
+    /**
+     * Move the selected draw items marked by a block select.
+     */
+    void MoveSelectedItems( const wxPoint& aOffset );
+
+    /**
+     * Make a copy of the selected draw items marked by a block select.
+     *
+     * Fields are not copied.  Only part body items are copied.
+     * Copying fields would result in duplicate fields which does not
+     * make sense in this context.
+     */
+    void CopySelectedItems( const wxPoint& aOffset );
+
+    /**
+     * Horizontally (X axis) mirror selected draw items about a point.
+     *
+     * @param aCenter - Center point to mirror around.
+     */
+    void MirrorSelectedItemsH( const wxPoint& aCenter );
+
+    /**
+     * Vertically (Y axis) mirror selected draw items about a point.
+     *
+     * @param aCenter - Center point to mirror around.
+     */
+    void MirrorSelectedItemsV( const wxPoint& aCenter );
+
+    /**
+     * Rotate CCW selected draw items about a point.
+     *
+     * @param aCenter - Center point to mirror around.
+     */
+    void RotateSelectedItems( const wxPoint& aCenter );
+
+    /**
+     * Locate a draw object.
+     *
+     * @param aUnit - Unit number of draw item.
+     * @param aConvert - Body style of draw item.
+     * @param aType - Draw object type, set to 0 to search for any type.
+     * @param aPoint - Coordinate for hit testing.
+     * @return The draw object if found.  Otherwise NULL.
+     */
+    LIB_ITEM* LocateDrawItem( int aUnit, int aConvert, KICAD_T aType, const wxPoint& aPoint );
+
+    /**
+     * Locate a draw object (overlaid)
+     *
+     * @param aUnit - Unit number of draw item.
+     * @param aConvert - Body style of draw item.
+     * @param aType - Draw object type, set to 0 to search for any type.
+     * @param aPoint - Coordinate for hit testing.
+     * @param aTransform = the transform matrix
+     * @return The draw object if found.  Otherwise NULL.
+     */
+    LIB_ITEM* LocateDrawItem( int aUnit, int aConvert, KICAD_T aType,
+                              const wxPoint& aPoint, const TRANSFORM& aTransform );
+
+    /**
+     * Return a reference to the draw item list.
+     *
+     * @return LIB_ITEMS& - Reference to the draw item object list.
+     */
+    LIB_ITEMS& GetDrawItemList() { return drawings; }
+
+    /**
+     * Set the units per part count.
+     *
+     * If the count is greater than the current count, then the all of the
+     * current draw items are duplicated for each additional part.  If the
+     * count is less than the current count, all draw objects for units
+     * greater that count are removed from the part.
+     *
+     * @param count - Number of units per package.
+     */
+    void SetUnitCount( int count );
+
+    int GetUnitCount() const { return m_unitCount; }
+
+    /**
+     * Function IsMulti
+     * @return true if the part has multiple units per part.
+     * When happens, the reference has a sub reference ti identify part
+     */
+    bool IsMulti() const { return m_unitCount > 1; }
+
+    /**
+     * Function SubReference
+     * @return the sub reference for part having multiple units per part.
+     * The sub reference identify the part (or unit)
+     * @param aUnit = the part identifier ( 1 to max count)
+     * @param aAddSeparator = true (default) to prpebd the sub ref
+     *    by the separator symbol (if any)
+     * Note: this is a static function.
+     */
+    static wxString SubReference( int aUnit, bool aAddSeparator = true );
+
+    // Accessors to sub ref parameters
+    static int GetSubpartIdSeparator() { return m_subpartIdSeparator; }
+
+    /** return a reference to m_subpartIdSeparator,
+     * only for read/save setting functions
+     */
+    static int* SubpartIdSeparatorPtr() { return &m_subpartIdSeparator; }
+
+    static int GetSubpartFirstId() { return m_subpartFirstId; }
+
+    /** return a reference to m_subpartFirstId, only for read/save setting functions
+     */
+    static int* SubpartFirstIdPtr() { return &m_subpartFirstId; }
+
+    /** Set the separator char between the subpart id and the reference
+     * 0 (no separator) or '.' , '-' and '_'
+     * and the ascii char value to calculate the subpart symbol id from the part number:
+     * 'A' or '1' only are allowed. (to print U1.A or U1.1)
+     * if this is a digit, a number is used as id symbol
+     * Note also if the subpart symbol is a digit, the separator cannot be null.
+     * @param aSep = the separator symbol (0 (no separator) or '.' , '-' and '_')
+     * @param aFirstId = the Id of the first part ('A' or '1')
+     */
+    static void SetSubpartIdNotation( int aSep, int aFirstId );
+
+    /**
+     * Set or clear the alternate body style (DeMorgan) for the part.
+     *
+     * If the part already has an alternate body style set and a
+     * asConvert if false, all of the existing draw items for the alternate
+     * body style are remove.  If the alternate body style is not set and
+     * asConvert is true, than the base draw items are duplicated and
+     * added to the part.
+     *
+     * @param aSetConvert - Set or clear the part alternate body style.
+     */
+    void SetConversion( bool aSetConvert );
+
+    /**
+     * Set the offset in mils of the pin name text from the pin symbol.
+     *
+     * Set the offset to 0 to draw the pin name above the pin symbol.
+     *
+     * @param aOffset - The offset in mils.
+     */
+    void SetPinNameOffset( int aOffset ) { m_pinNameOffset = aOffset; }
+
+    int GetPinNameOffset() { return m_pinNameOffset; }
+
+    /**
+     * Set or clear the pin name visibility flag.
+     *
+     * @param aShow - True to make the part pin names visible.
+     */
+    void SetShowPinNames( bool aShow ) { m_showPinNames = aShow; }
+
+    bool ShowPinNames() { return m_showPinNames; }
+
+    /**
+     * Set or clear the pin number visibility flag.
+     *
+     * @param aShow - True to make the part pin numbers visible.
+     */
+    void SetShowPinNumbers( bool aShow ) { m_showPinNumbers = aShow; }
+
+    bool ShowPinNumbers() { return m_showPinNumbers; }
+
+    bool operator==( const LIB_PART*  aPart ) const { return this == aPart; }
+
+#if defined(DEBUG)
+    void Show( int nestLevel, std::ostream& os ) const { ShowDummy( os ); } // override
+#endif
+};
+
+#endif  //  CLASS_LIBENTRY_H