idf_outlines.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2014-2017  Cirilo Bernardo
 * Copyright The KiCad Developers, see AUTHORS.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, see <https://www.gnu.org/licenses/>.
 */
 
 
#ifndef IDF_OUTLINES_H
#define IDF_OUTLINES_H
 
#include <string>
#include <list>
#include <map>
 
#include <io/idf/idf_common.h>
 
/*
 *  NOTES ON OUTLINE TYPES:
 *
 *  BOARD_OUTLINE (PANEL_OUTLINE)
 *      .BOARD_OUTLINE  [OWNER]
 *      [thickness]
 *      [outlines]
 *
 *  OTHER_OUTLINE
 *      .OTHER_OUTLINE  [OWNER]
 *      [outline identifier] [thickness] [board side: Top/Bot]
 *      [outline]
 *
 *  ROUTE_OUTLINE
 *      .ROUTE_OUTLINE [OWNER]
 *      [layers]
 *      [outline]
 *
 *  PLACE_OUTLINE
 *      .PLACE_OUTLINE [OWNER]
 *      [board side: Top/Bot/Both] [height]
 *      [outline]
 *
 *  ROUTE_KEEPOUT
 *      .ROUTE_KEEPOUT [OWNER]
 *      [layers]
 *      [outline]
 *
 *  VIA_KEEPOUT
 *      .VIA_KEEPOUT [OWNER]
 *      [outline]
 *
 *  PLACE_KEEPOUT
 *      .PLACE_KEEPOUT [OWNER]
 *      [board side: Top/Bot/Both] [height]
 *      [outline]
 *
 *  Placement Group
 *      .PLACE_REGION [OWNER]
 *      [side: Top/Bot/Both ] [component group name]
 *      [outline]
 *
 *  Component Outline:
 *      .ELECTRICAL/.MECHANICAL
 *      [GEOM] [PART] [UNIT] [HEIGHT]
 *      [outline]
 *      [PROP] [prop name] [prop value]
 */
 
class IDF3_BOARD;
 

class BOARD_OUTLINE
{
public:
    BOARD_OUTLINE();
    virtual ~BOARD_OUTLINE();

    virtual bool SetUnit( IDF3::IDF_UNIT aUnit );

    virtual IDF3::IDF_UNIT GetUnit( void );

    virtual bool SetThickness( double aThickness );

    virtual double GetThickness( void );

    virtual bool Clear( void );

    IDF3::OUTLINE_TYPE GetOutlineType( void );

    IDF3_BOARD* GetParent( void );
 

    bool AddOutline( IDF_OUTLINE* aOutline );

    bool DelOutline( IDF_OUTLINE* aOutline );

    bool DelOutline( size_t aIndex );

    const std::list<IDF_OUTLINE*>* GetOutlines( void );

    size_t OutlinesSize( void );

    IDF_OUTLINE* GetOutline( size_t aIndex );

    IDF3::KEY_OWNER GetOwner( void );

    bool SetOwner( IDF3::KEY_OWNER aOwner );

    bool IsSingle( void );

    void ClearOutlines( void );

    void AddComment( const std::string& aComment );

    size_t CommentsSize( void );

    std::list< std::string >* GetComments( void );

    const std::string* GetComment( size_t aIndex );

    bool DeleteComment( size_t aIndex );

    void ClearComments( void );
 
    const std::string& GetError( void )
    {
        return errormsg;
    }
 
protected:
    // Read outline data from a BOARD or LIBRARY file's outline section
    void readOutlines( std::istream& aBoardFile, IDF3::IDF_VERSION aIdfVersion );
 
    // Write comments to a BOARD or LIBRARY file (must not be within a SECTION as per IDFv3 spec)
    bool writeComments( std::ostream& aBoardFile );
 
    // Write the outline owner to a BOARD file
    bool writeOwner( std::ostream& aBoardFile );
 
    // Write the data of a single outline object
    void writeOutline( std::ostream& aBoardFile, IDF_OUTLINE* aOutline, size_t aIndex );
 
    // Iterate through the outlines and write out all data
    void writeOutlines( std::ostream& aBoardFile );  // write outline data (no headers)
 
    // Clear internal list of outlines
    void clearOutlines( void );

    void setParent( IDF3_BOARD* aParent );
 
    // Shadow routines used by friends to bypass ownership checks
    bool addOutline( IDF_OUTLINE* aOutline );
    virtual bool setThickness( double aThickness );
    virtual void clear( void );

    virtual void readData( std::istream& aBoardFile, const std::string& aHeader,
                           IDF3::IDF_VERSION aIdfVersion );

    virtual void writeData( std::ostream& aBoardFile );
 
    std::string                 errormsg;
    std::list< IDF_OUTLINE* >   outlines;
 
    // indicates the owner of this outline (MCAD, ECAD, UNOWNED).
    IDF3::KEY_OWNER             owner;
    IDF3::OUTLINE_TYPE          outlineType;  // type of IDF outline
    bool                        single;       // true if only a single outline is accepted
    std::list< std::string >    comments;     // associated comment list
    IDF3::IDF_UNIT              unit;         // outline's native unit (MM or THOU)
    IDF3_BOARD*                 parent;       // BOARD which contains this outline
    double                      thickness;    // Board/Extrude Thickness or Height (IDF spec)
 
private:
    friend class IDF3_BOARD;
};
 

class OTHER_OUTLINE : public BOARD_OUTLINE
{
public:
    OTHER_OUTLINE( IDF3_BOARD* aParent );

    virtual bool SetOutlineIdentifier( const std::string& aUniqueID );

    virtual const std::string& GetOutlineIdentifier( void );

    virtual bool SetSide( IDF3::IDF_LAYER aSide );

    virtual IDF3::IDF_LAYER GetSide( void );

    virtual bool Clear( void ) override;
 
private:
    virtual void readData( std::istream& aBoardFile, const std::string& aHeader,
                           IDF3::IDF_VERSION aIdfVersion ) override;

    virtual void writeData( std::ostream& aBoardFile ) override;
 
    friend class IDF3_BOARD;
 
    std::string uniqueID;   // Outline Identifier (IDF spec)
    IDF3::IDF_LAYER side;   // Board Side [TOP/BOTTOM ONLY] (IDF spec)
};
 

class ROUTE_OUTLINE : public BOARD_OUTLINE
{
public:
    ROUTE_OUTLINE( IDF3_BOARD* aParent );

    virtual bool SetLayers( IDF3::IDF_LAYER aLayer );

    virtual IDF3::IDF_LAYER GetLayers( void );

    virtual bool Clear( void ) override;
 
private:
    friend class IDF3_BOARD;

    virtual void readData( std::istream& aBoardFile, const std::string& aHeader,
                           IDF3::IDF_VERSION aIdfVersion ) override;

    virtual void writeData( std::ostream& aBoardFile ) override;
 
protected:
    IDF3::IDF_LAYER layers; // Routing layers (IDF spec)
};
 

class PLACE_OUTLINE : public BOARD_OUTLINE
{
public:
    PLACE_OUTLINE( IDF3_BOARD* aParent );

    virtual bool SetSide( IDF3::IDF_LAYER aSide );

    virtual IDF3::IDF_LAYER GetSide( void );

    virtual bool SetMaxHeight( double aHeight );

    virtual double GetMaxHeight( void );

    virtual bool Clear( void ) override;
 
private:
    friend class IDF3_BOARD;

    virtual void readData( std::istream& aBoardFile, const std::string& aHeader,
                           IDF3::IDF_VERSION aIdfVersion ) override;

    virtual void writeData( std::ostream& aBoardFile ) override;
 
protected:
    IDF3::IDF_LAYER side;   // Board Side [TOP/BOTTOM/BOTH ONLY] (IDF spec)
};
 

class ROUTE_KO_OUTLINE : public ROUTE_OUTLINE
{
public:
    ROUTE_KO_OUTLINE( IDF3_BOARD* aParent );
};
 

class VIA_KO_OUTLINE : public OTHER_OUTLINE
{
public:
    VIA_KO_OUTLINE( IDF3_BOARD* aParent );
};
 

class PLACE_KO_OUTLINE : public PLACE_OUTLINE
{
public:
    PLACE_KO_OUTLINE( IDF3_BOARD* aParent );
};
 

class GROUP_OUTLINE : public BOARD_OUTLINE
{
public:
    GROUP_OUTLINE( IDF3_BOARD* aParent );

    virtual bool SetSide( IDF3::IDF_LAYER aSide );

    virtual IDF3::IDF_LAYER GetSide( void );

    virtual bool SetGroupName( std::string aGroupName );

    virtual const std::string& GetGroupName( void );

    virtual bool Clear( void ) override;
 
private:
    friend class IDF3_BOARD;

    virtual void readData( std::istream& aBoardFile, const std::string& aHeader,
                           IDF3::IDF_VERSION aIdfVersion ) override;

    virtual void writeData( std::ostream& aBoardFile ) override;
 
    IDF3::IDF_LAYER side;   // Board Side [TOP/BOTTOM/BOTH ONLY] (IDF spec)
    std::string groupName;  // non-unique string
};
 

class IDF3_COMP_OUTLINE : public BOARD_OUTLINE
{
public:
    IDF3_COMP_OUTLINE( IDF3_BOARD* aParent );

    virtual bool Clear( void ) override;

    bool SetComponentClass( IDF3::COMP_TYPE aCompClass );

    IDF3::COMP_TYPE GetComponentClass( void );

    void SetGeomName( const std::string& aGeomName );

    const std::string& GetGeomName( void );

    void SetPartName( const std::string& aPartName );

    const std::string& GetPartName( void );

    const std::string& GetUID( void );

    bool CreateDefaultOutline( const std::string &aGeom, const std::string &aPart );
 
    // XXX: property manipulators
 
private:
    friend class IDF3_BOARD;
    friend class IDF3_COMP_OUTLINE_DATA;
 
    void readProperties( std::istream& aLibFile );
    bool writeProperties( std::ostream& aLibFile );

    virtual void readData( std::istream& aLibFile, const std::string& aHeader,
                           IDF3::IDF_VERSION aIdfVersion ) override;

    virtual void writeData( std::ostream& aLibFile ) override;

    int incrementRef( void );

    int decrementRef( void );
 
    std::string     uid;        // unique ID
    std::string     geometry;   // geometry name (IDF)
    std::string     part;       // part name (IDF)
    IDF3::COMP_TYPE compType;   // component type
    int             refNum;     // number of components referring to this outline
 
    std::map< std::string, std::string >    props;      // properties list
};
 
#endif // IDF_OUTLINES_H