eagle.h

// This file is generated by kxml_compiler from /home/mm/Projektek/eagle_power_tools/qt_eagle_xml_parser/tools/eagle.xsd.
// All changes you do to this file will be lost.
#ifndef EAGLE_H
#define EAGLE_H

#include <QString>
#include <QDomElement>
#include <QList>
#include <QXmlStreamWriter>

class Layer
{
  public:
    typedef QList<Layer*> List;

    enum VisibleEnum { Visible_no, Visible_yes, Visible_Invalid };
    enum ActiveEnum { Active_no, Active_yes, Active_Invalid };

    Layer();
    ~Layer();
    void setNumber( const int v );
    int number() const;
    bool numberSet() const;
    void setName( const QString &v );
    QString name() const;
    void setColor( const int v );
    int color() const;
    bool colorSet() const;
    void setFill( const int v );
    int fill() const;
    bool fillSet() const;
    void setVisible( const VisibleEnum &v );
    Layer::VisibleEnum visible() const;
    void setActive( const ActiveEnum &v );
    Layer::ActiveEnum active() const;
    static QString visibleEnumToString( const VisibleEnum & v );
    static QString activeEnumToString( const ActiveEnum & v );
    /**
      Parse XML object from DOM element.
     */
    static Layer *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    static Layer::VisibleEnum visibleEnumFromString( const QString & v, bool *ok = NULL );
    static Layer::ActiveEnum activeEnumFromString( const QString & v, bool *ok = NULL );

    int mNumber;
    bool mNumber_set;
    QString mName;
    int mColor;
    bool mColor_set;
    int mFill;
    bool mFill_set;
    VisibleEnum mVisible;
    ActiveEnum mActive;
};

class Layers
{
  public:
    Layers();
    ~Layers();
    void addLayer( Layer* v );
    void setLayerList( const Layer::List &v );
    Layer::List *layerList();
    /**
      Parse XML object from DOM element.
     */
    static Layers *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    Layer::List mLayerList;
};

class Grid
{
  public:
    enum UnitdistEnum { Unitdist_mic, Unitdist_mm, Unitdist_mil, Unitdist_inch, Unitdist_Invalid };
    enum UnitEnum { Unit_mic, Unit_mm, Unit_mil, Unit_inch, Unit_Invalid };
    enum StyleEnum { Style_lines, Style_dots, Style_Invalid };
    enum DisplayEnum { Display_no, Display_yes, Display_Invalid };
    enum AltunitdistEnum { Altunitdist_mic, Altunitdist_mm, Altunitdist_mil, Altunitdist_inch, Altunitdist_Invalid };
    enum AltunitEnum { Altunit_mic, Altunit_mm, Altunit_mil, Altunit_inch, Altunit_Invalid };

    Grid();
    ~Grid();
    void setDistance( const double v );
    double distance() const;
    bool distanceSet() const;
    void setUnitdist( const UnitdistEnum &v );
    Grid::UnitdistEnum unitdist() const;
    void setUnit( const UnitEnum &v );
    Grid::UnitEnum unit() const;
    void setStyle( const StyleEnum &v );
    Grid::StyleEnum style() const;
    void setMultiple( const int v );
    int multiple() const;
    bool multipleSet() const;
    void setDisplay( const DisplayEnum &v );
    Grid::DisplayEnum display() const;
    void setAltdistance( const double v );
    double altdistance() const;
    bool altdistanceSet() const;
    void setAltunitdist( const AltunitdistEnum &v );
    Grid::AltunitdistEnum altunitdist() const;
    void setAltunit( const AltunitEnum &v );
    Grid::AltunitEnum altunit() const;
    static QString unitdistEnumToString( const UnitdistEnum & v );
    static QString unitEnumToString( const UnitEnum & v );
    static QString styleEnumToString( const StyleEnum & v );
    static QString displayEnumToString( const DisplayEnum & v );
    static QString altunitdistEnumToString( const AltunitdistEnum & v );
    static QString altunitEnumToString( const AltunitEnum & v );
    /**
      Parse XML object from DOM element.
     */
    static Grid *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    static Grid::UnitdistEnum unitdistEnumFromString( const QString & v, bool *ok = NULL );
    static Grid::UnitEnum unitEnumFromString( const QString & v, bool *ok = NULL );
    static Grid::StyleEnum styleEnumFromString( const QString & v, bool *ok = NULL );
    static Grid::DisplayEnum displayEnumFromString( const QString & v, bool *ok = NULL );
    static Grid::AltunitdistEnum altunitdistEnumFromString( const QString & v, bool *ok = NULL );
    static Grid::AltunitEnum altunitEnumFromString( const QString & v, bool *ok = NULL );

    double mDistance;
    bool mDistance_set;
    UnitdistEnum mUnitdist;
    UnitEnum mUnit;
    StyleEnum mStyle;
    int mMultiple;
    bool mMultiple_set;
    DisplayEnum mDisplay;
    double mAltdistance;
    bool mAltdistance_set;
    AltunitdistEnum mAltunitdist;
    AltunitEnum mAltunit;
};

class Setting
{
  public:
    typedef QList<Setting*> List;

    enum AlwaysvectorfontEnum { Alwaysvectorfont_no, Alwaysvectorfont_yes, Alwaysvectorfont_Invalid };
    enum VerticaltextEnum { Verticaltext_up, Verticaltext_down, Verticaltext_Invalid };
    enum KeepoldvectorfontEnum { Keepoldvectorfont_no, Keepoldvectorfont_yes, Keepoldvectorfont_Invalid };

    Setting();
    ~Setting();
    void setAlwaysvectorfont( const AlwaysvectorfontEnum &v );
    Setting::AlwaysvectorfontEnum alwaysvectorfont() const;
    void setVerticaltext( const VerticaltextEnum &v );
    Setting::VerticaltextEnum verticaltext() const;
    void setKeepoldvectorfont( const KeepoldvectorfontEnum &v );
    Setting::KeepoldvectorfontEnum keepoldvectorfont() const;
    static QString alwaysvectorfontEnumToString( const AlwaysvectorfontEnum & v );
    static QString verticaltextEnumToString( const VerticaltextEnum & v );
    static QString keepoldvectorfontEnumToString( const KeepoldvectorfontEnum & v );
    /**
      Parse XML object from DOM element.
     */
    static Setting *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    static Setting::AlwaysvectorfontEnum alwaysvectorfontEnumFromString( const QString & v, bool *ok = NULL );
    static Setting::VerticaltextEnum verticaltextEnumFromString( const QString & v, bool *ok = NULL );
    static Setting::KeepoldvectorfontEnum keepoldvectorfontEnumFromString( const QString & v, bool *ok = NULL );

    AlwaysvectorfontEnum mAlwaysvectorfont;
    VerticaltextEnum mVerticaltext;
    KeepoldvectorfontEnum mKeepoldvectorfont;
};

class Settings
{
  public:
    Settings();
    ~Settings();
    void addSetting( Setting* v );
    void setSettingList( const Setting::List &v );
    Setting::List *settingList();
    /**
      Parse XML object from DOM element.
     */
    static Settings *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    Setting::List mSettingList;
};

class Mfgpreviewcolor
{
  public:
    typedef QList<Mfgpreviewcolor*> List;

    Mfgpreviewcolor();
    ~Mfgpreviewcolor();
    void setName( const QString &v );
    QString name() const;
    void setColor( const QString &v );
    QString color() const;
    /**
      Parse XML object from DOM element.
     */
    static Mfgpreviewcolor *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    QString mName;
    QString mColor;
};

class Mfgpreviewcolors
{
  public:
    Mfgpreviewcolors();
    ~Mfgpreviewcolors();
    void addMfgpreviewcolor( Mfgpreviewcolor* v );
    void setMfgpreviewcolorList( const Mfgpreviewcolor::List &v );
    Mfgpreviewcolor::List *mfgpreviewcolorList();
    /**
      Parse XML object from DOM element.
     */
    static Mfgpreviewcolors *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    Mfgpreviewcolor::List mMfgpreviewcolorList;
};

class Via
{
  public:
    typedef QList<Via*> List;

    enum ShapeEnum { Shape_square, Shape_round, Shape_octagon, Shape_Invalid };
    enum AlwaysstopEnum { Alwaysstop_no, Alwaysstop_yes, Alwaysstop_Invalid };

    Via();
    ~Via();
    void setX( const double v );
    double x() const;
    bool xSet() const;
    void setY( const double v );
    double y() const;
    bool ySet() const;
    void setExtent( const QString &v );
    QString extent() const;
    void setDrill( const double v );
    double drill() const;
    bool drillSet() const;
    void setDiameter( const double v );
    double diameter() const;
    bool diameterSet() const;
    void setShape( const ShapeEnum &v );
    Via::ShapeEnum shape() const;
    void setAlwaysstop( const AlwaysstopEnum &v );
    Via::AlwaysstopEnum alwaysstop() const;
    static QString shapeEnumToString( const ShapeEnum & v );
    static QString alwaysstopEnumToString( const AlwaysstopEnum & v );
    /**
      Parse XML object from DOM element.
     */
    static Via *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    static Via::ShapeEnum shapeEnumFromString( const QString & v, bool *ok = NULL );
    static Via::AlwaysstopEnum alwaysstopEnumFromString( const QString & v, bool *ok = NULL );

    double mX;
    bool mX_set;
    double mY;
    bool mY_set;
    QString mExtent;
    double mDrill;
    bool mDrill_set;
    double mDiameter;
    bool mDiameter_set;
    ShapeEnum mShape;
    AlwaysstopEnum mAlwaysstop;
};

class Contactref
{
  public:
    typedef QList<Contactref*> List;

    enum RouteEnum { Route_all, Route_any, Route_Invalid };

    Contactref();
    ~Contactref();
    void setElement( const QString &v );
    QString element() const;
    void setPad( const QString &v );
    QString pad() const;
    void setRoute( const RouteEnum &v );
    Contactref::RouteEnum route() const;
    void setRoutetag( const QString &v );
    QString routetag() const;
    static QString routeEnumToString( const RouteEnum & v );
    /**
      Parse XML object from DOM element.
     */
    static Contactref *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    static Contactref::RouteEnum routeEnumFromString( const QString & v, bool *ok = NULL );

    QString mElement;
    QString mPad;
    RouteEnum mRoute;
    QString mRoutetag;
};

class Vertex
{
  public:
    typedef QList<Vertex*> List;

    Vertex();
    ~Vertex();
    void setX( const double v );
    double x() const;
    bool xSet() const;
    void setY( const double v );
    double y() const;
    bool ySet() const;
    void setCurve( const double v );
    double curve() const;
    bool curveSet() const;
    /**
      Parse XML object from DOM element.
     */
    static Vertex *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    double mX;
    bool mX_set;
    double mY;
    bool mY_set;
    double mCurve;
    bool mCurve_set;
};

class Polygon
{
  public:
    typedef QList<Polygon*> List;

    enum PourEnum { Pour_solid, Pour_hatch, Pour_cutout, Pour_Invalid };
    enum OrphansEnum { Orphans_no, Orphans_yes, Orphans_Invalid };
    enum ThermalsEnum { Thermals_no, Thermals_yes, Thermals_Invalid };

    Polygon();
    ~Polygon();
    void setWidth( const double v );
    double width() const;
    bool widthSet() const;
    void setLayer( const int v );
    int layer() const;
    bool layerSet() const;
    void setSpacing( const double v );
    double spacing() const;
    bool spacingSet() const;
    void setPour( const PourEnum &v );
    Polygon::PourEnum pour() const;
    void setIsolate( const double v );
    double isolate() const;
    bool isolateSet() const;
    void setOrphans( const OrphansEnum &v );
    Polygon::OrphansEnum orphans() const;
    void setThermals( const ThermalsEnum &v );
    Polygon::ThermalsEnum thermals() const;
    void setRank( const int v );
    int rank() const;
    bool rankSet() const;
    void addVertex( Vertex* v );
    void setVertexList( const Vertex::List &v );
    Vertex::List *vertexList();
    static QString pourEnumToString( const PourEnum & v );
    static QString orphansEnumToString( const OrphansEnum & v );
    static QString thermalsEnumToString( const ThermalsEnum & v );
    /**
      Parse XML object from DOM element.
     */
    static Polygon *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    static Polygon::PourEnum pourEnumFromString( const QString & v, bool *ok = NULL );
    static Polygon::OrphansEnum orphansEnumFromString( const QString & v, bool *ok = NULL );
    static Polygon::ThermalsEnum thermalsEnumFromString( const QString & v, bool *ok = NULL );

    double mWidth;
    bool mWidth_set;
    int mLayer;
    bool mLayer_set;
    double mSpacing;
    bool mSpacing_set;
    PourEnum mPour;
    double mIsolate;
    bool mIsolate_set;
    OrphansEnum mOrphans;
    ThermalsEnum mThermals;
    int mRank;
    bool mRank_set;
    Vertex::List mVertexList;
};

class Wire
{
  public:
    typedef QList<Wire*> List;

    enum StyleEnum { Style_continuous, Style_longdash, Style_shortdash, Style_dashdot, Style_Invalid };
    enum CapEnum { Cap_flat, Cap_round, Cap_Invalid };

    Wire();
    ~Wire();
    void setX1( const double v );
    double x1() const;
    bool x1Set() const;
    void setY1( const double v );
    double y1() const;
    bool y1Set() const;
    void setX2( const double v );
    double x2() const;
    bool x2Set() const;
    void setY2( const double v );
    double y2() const;
    bool y2Set() const;
    void setWidth( const double v );
    double width() const;
    bool widthSet() const;
    void setLayer( const int v );
    int layer() const;
    bool layerSet() const;
    void setExtent( const QString &v );
    QString extent() const;
    void setStyle( const StyleEnum &v );
    Wire::StyleEnum style() const;
    void setCurve( const double v );
    double curve() const;
    bool curveSet() const;
    void setCap( const CapEnum &v );
    Wire::CapEnum cap() const;
    static QString styleEnumToString( const StyleEnum & v );
    static QString capEnumToString( const CapEnum & v );
    /**
      Parse XML object from DOM element.
     */
    static Wire *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    static Wire::StyleEnum styleEnumFromString( const QString & v, bool *ok = NULL );
    static Wire::CapEnum capEnumFromString( const QString & v, bool *ok = NULL );

    double mX1;
    bool mX1_set;
    double mY1;
    bool mY1_set;
    double mX2;
    bool mX2_set;
    double mY2;
    bool mY2_set;
    double mWidth;
    bool mWidth_set;
    int mLayer;
    bool mLayer_set;
    QString mExtent;
    StyleEnum mStyle;
    double mCurve;
    bool mCurve_set;
    CapEnum mCap;
};

class Signal
{
  public:
    typedef QList<Signal*> List;

    enum AirwireshiddenEnum { Airwireshidden_no, Airwireshidden_yes, Airwireshidden_Invalid };

    Signal();
    ~Signal();
    void setName( const QString &v );
    QString name() const;
    void setClass( const int v );
    int class_() const;
    bool classSet() const;
    void setAirwireshidden( const AirwireshiddenEnum &v );
    Signal::AirwireshiddenEnum airwireshidden() const;
    void addContactref( Contactref* v );
    void setContactrefList( const Contactref::List &v );
    Contactref::List *contactrefList();
    void addPolygon( Polygon* v );
    void setPolygonList( const Polygon::List &v );
    Polygon::List *polygonList();
    void addWire( Wire* v );
    void setWireList( const Wire::List &v );
    Wire::List *wireList();
    void addVia( Via* v );
    void setViaList( const Via::List &v );
    Via::List *viaList();
    static QString airwireshiddenEnumToString( const AirwireshiddenEnum & v );
    /**
      Parse XML object from DOM element.
     */
    static Signal *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    static Signal::AirwireshiddenEnum airwireshiddenEnumFromString( const QString & v, bool *ok = NULL );

    QString mName;
    int mClass;
    bool mClass_set;
    AirwireshiddenEnum mAirwireshidden;
    Contactref::List mContactrefList;
    Polygon::List mPolygonList;
    Wire::List mWireList;
    Via::List mViaList;
};

class Signals
{
  public:
    Signals();
    ~Signals();
    void addSignal( Signal* v );
    void setSignalList( const Signal::List &v );
    Signal::List *signalList();
    /**
      Parse XML object from DOM element.
     */
    static Signals *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    Signal::List mSignalList;
};

class Attribute
{
  public:
    typedef QList<Attribute*> List;

    enum FontEnum { Font_vector, Font_proportional, Font_fixed, Font_Invalid };
    enum DisplayEnum { Display_off, Display_value, Display_name, Display_both, Display_Invalid };
    enum ConstantEnum { Constant_no, Constant_yes, Constant_Invalid };
    enum AlignEnum { Align_bottom_left, Align_bottom_center, Align_bottom_right, Align_center_left, Align_center, Align_center_right, Align_top_left, Align_top_center, Align_top_right, Align_Invalid };

    Attribute();
    ~Attribute();
    void setName( const QString &v );
    QString name() const;
    void setValue( const QString &v );
    QString value() const;
    void setX( const double v );
    double x() const;
    bool xSet() const;
    void setY( const double v );
    double y() const;
    bool ySet() const;
    void setSize( const double v );
    double size() const;
    bool sizeSet() const;
    void setLayer( const int v );
    int layer() const;
    bool layerSet() const;
    void setFont( const FontEnum &v );
    Attribute::FontEnum font() const;
    void setRatio( const int v );
    int ratio() const;
    bool ratioSet() const;
    void setRot( const QString &v );
    QString rot() const;
    void setDisplay( const DisplayEnum &v );
    Attribute::DisplayEnum display() const;
    void setConstant( const ConstantEnum &v );
    Attribute::ConstantEnum constant() const;
    void setAlign( const AlignEnum &v );
    Attribute::AlignEnum align() const;
    static QString fontEnumToString( const FontEnum & v );
    static QString displayEnumToString( const DisplayEnum & v );
    static QString constantEnumToString( const ConstantEnum & v );
    static QString alignEnumToString( const AlignEnum & v );
    /**
      Parse XML object from DOM element.
     */
    static Attribute *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    static Attribute::FontEnum fontEnumFromString( const QString & v, bool *ok = NULL );
    static Attribute::DisplayEnum displayEnumFromString( const QString & v, bool *ok = NULL );
    static Attribute::ConstantEnum constantEnumFromString( const QString & v, bool *ok = NULL );
    static Attribute::AlignEnum alignEnumFromString( const QString & v, bool *ok = NULL );

    QString mName;
    QString mValue;
    double mX;
    bool mX_set;
    double mY;
    bool mY_set;
    double mSize;
    bool mSize_set;
    int mLayer;
    bool mLayer_set;
    FontEnum mFont;
    int mRatio;
    bool mRatio_set;
    QString mRot;
    DisplayEnum mDisplay;
    ConstantEnum mConstant;
    AlignEnum mAlign;
};

class Variant
{
  public:
    typedef QList<Variant*> List;

    enum PopulateEnum { Populate_no, Populate_yes, Populate_Invalid };

    Variant();
    ~Variant();
    void setName( const QString &v );
    QString name() const;
    void setPopulate( const PopulateEnum &v );
    Variant::PopulateEnum populate() const;
    void setValue( const QString &v );
    QString value() const;
    void setTechnology( const QString &v );
    QString technology() const;
    static QString populateEnumToString( const PopulateEnum & v );
    /**
      Parse XML object from DOM element.
     */
    static Variant *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    static Variant::PopulateEnum populateEnumFromString( const QString & v, bool *ok = NULL );

    QString mName;
    PopulateEnum mPopulate;
    QString mValue;
    QString mTechnology;
};

class Element
{
  public:
    typedef QList<Element*> List;

    enum LockedEnum { Locked_no, Locked_yes, Locked_Invalid };
    enum PopulateEnum { Populate_no, Populate_yes, Populate_Invalid };
    enum SmashedEnum { Smashed_no, Smashed_yes, Smashed_Invalid };

    Element();
    ~Element();
    void setName( const QString &v );
    QString name() const;
    void setLibrary( const QString &v );
    QString library() const;
    void setLibraryUrn( const QString &v );
    QString libraryUrn() const;
    void setPackage( const QString &v );
    QString package() const;
    void setPackage3dUrn( const QString &v );
    QString package3dUrn() const;
    void setValue( const QString &v );
    QString value() const;
    void setX( const double v );
    double x() const;
    bool xSet() const;
    void setY( const double v );
    double y() const;
    bool ySet() const;
    void setLocked( const LockedEnum &v );
    Element::LockedEnum locked() const;
    void setPopulate( const PopulateEnum &v );
    Element::PopulateEnum populate() const;
    void setSmashed( const SmashedEnum &v );
    Element::SmashedEnum smashed() const;
    void setRot( const QString &v );
    QString rot() const;
    void addAttribute( Attribute* v );
    void setAttributeList( const Attribute::List &v );
    Attribute::List *attributeList();
    void addVariant( Variant* v );
    void setVariantList( const Variant::List &v );
    Variant::List *variantList();
    static QString lockedEnumToString( const LockedEnum & v );
    static QString populateEnumToString( const PopulateEnum & v );
    static QString smashedEnumToString( const SmashedEnum & v );
    /**
      Parse XML object from DOM element.
     */
    static Element *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    static Element::LockedEnum lockedEnumFromString( const QString & v, bool *ok = NULL );
    static Element::PopulateEnum populateEnumFromString( const QString & v, bool *ok = NULL );
    static Element::SmashedEnum smashedEnumFromString( const QString & v, bool *ok = NULL );

    QString mName;
    QString mLibrary;
    QString mLibraryUrn;
    QString mPackage;
    QString mPackage3dUrn;
    QString mValue;
    double mX;
    bool mX_set;
    double mY;
    bool mY_set;
    LockedEnum mLocked;
    PopulateEnum mPopulate;
    SmashedEnum mSmashed;
    QString mRot;
    Attribute::List mAttributeList;
    Variant::List mVariantList;
};

class Elements
{
  public:
    Elements();
    ~Elements();
    void addElement( Element* v );
    void setElementList( const Element::List &v );
    Element::List *elementList();
    /**
      Parse XML object from DOM element.
     */
    static Elements *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    Element::List mElementList;
};

class Param
{
  public:
    typedef QList<Param*> List;

    Param();
    ~Param();
    void setName( const QString &v );
    QString name() const;
    void setValue( const QString &v );
    QString value() const;
    /**
      Parse XML object from DOM element.
     */
    static Param *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    QString mName;
    QString mValue;
};

class Pass
{
  public:
    typedef QList<Pass*> List;

    enum ActiveEnum { Active_no, Active_yes, Active_Invalid };

    Pass();
    ~Pass();
    void setName( const QString &v );
    QString name() const;
    void setRefer( const QString &v );
    QString refer() const;
    void setActive( const ActiveEnum &v );
    Pass::ActiveEnum active() const;
    void addParam( Param* v );
    void setParamList( const Param::List &v );
    Param::List *paramList();
    static QString activeEnumToString( const ActiveEnum & v );
    /**
      Parse XML object from DOM element.
     */
    static Pass *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    static Pass::ActiveEnum activeEnumFromString( const QString & v, bool *ok = NULL );

    QString mName;
    QString mRefer;
    ActiveEnum mActive;
    Param::List mParamList;
};

class Autorouter
{
  public:
    Autorouter();
    ~Autorouter();
    void addPass( Pass* v );
    void setPassList( const Pass::List &v );
    Pass::List *passList();
    /**
      Parse XML object from DOM element.
     */
    static Autorouter *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    Pass::List mPassList;
};

class Description
{
  public:
    typedef QList<Description*> List;

    Description();
    ~Description();
    void setLanguage( const QString &v );
    QString language() const;
    void setValue( const QString &v );
    QString value() const;
    /**
      Parse XML object from DOM element.
     */
    static Description *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    QString mLanguage;
    QString mValue;
};

class Designrules
{
  public:
    Designrules();
    ~Designrules();
    void setName( const QString &v );
    QString name() const;
    void addDescription( Description* v );
    void setDescriptionList( const Description::List &v );
    Description::List *descriptionList();
    void addParam( Param* v );
    void setParamList( const Param::List &v );
    Param::List *paramList();
    /**
      Parse XML object from DOM element.
     */
    static Designrules *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    QString mName;
    Description::List mDescriptionList;
    Param::List mParamList;
};

class Fusionsync
{
  public:
    Fusionsync();
    ~Fusionsync();
    void setHuburn( const QString &v );
    QString huburn() const;
    void setProjecturn( const QString &v );
    QString projecturn() const;
    void setF3durn( const QString &v );
    QString f3durn() const;
    void setPcbguid( const QString &v );
    QString pcbguid() const;
    void setLastsyncedchangeguid( const QString &v );
    QString lastsyncedchangeguid() const;
    void setLastpulledtime( const QString &v );
    QString lastpulledtime() const;
    /**
      Parse XML object from DOM element.
     */
    static Fusionsync *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    QString mHuburn;
    QString mProjecturn;
    QString mF3durn;
    QString mPcbguid;
    QString mLastsyncedchangeguid;
    QString mLastpulledtime;
};

class Text
{
  public:
    typedef QList<Text*> List;

    enum FontEnum { Font_vector, Font_proportional, Font_fixed, Font_Invalid };
    enum AlignEnum { Align_bottom_left, Align_bottom_center, Align_bottom_right, Align_center_left, Align_center, Align_center_right, Align_top_left, Align_top_center, Align_top_right, Align_Invalid };

    Text();
    ~Text();
    void setX( const double v );
    double x() const;
    bool xSet() const;
    void setY( const double v );
    double y() const;
    bool ySet() const;
    void setSize( const double v );
    double size() const;
    bool sizeSet() const;
    void setLayer( const int v );
    int layer() const;
    bool layerSet() const;
    void setFont( const FontEnum &v );
    Text::FontEnum font() const;
    void setRatio( const int v );
    int ratio() const;
    bool ratioSet() const;
    void setRot( const QString &v );
    QString rot() const;
    void setAlign( const AlignEnum &v );
    Text::AlignEnum align() const;
    void setDistance( const int v );
    int distance() const;
    bool distanceSet() const;
    void setValue( const QString &v );
    QString value() const;
    static QString fontEnumToString( const FontEnum & v );
    static QString alignEnumToString( const AlignEnum & v );
    /**
      Parse XML object from DOM element.
     */
    static Text *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    static Text::FontEnum fontEnumFromString( const QString & v, bool *ok = NULL );
    static Text::AlignEnum alignEnumFromString( const QString & v, bool *ok = NULL );

    double mX;
    bool mX_set;
    double mY;
    bool mY_set;
    double mSize;
    bool mSize_set;
    int mLayer;
    bool mLayer_set;
    FontEnum mFont;
    int mRatio;
    bool mRatio_set;
    QString mRot;
    AlignEnum mAlign;
    int mDistance;
    bool mDistance_set;
    QString mValue;
};

class Dimension
{
  public:
    typedef QList<Dimension*> List;

    enum DtypeEnum { Dtype_parallel, Dtype_horizontal, Dtype_vertical, Dtype_radius, Dtype_diameter, Dtype_leader, Dtype_Invalid };
    enum UnitEnum { Unit_mic, Unit_mm, Unit_mil, Unit_inch, Unit_Invalid };
    enum VisibleEnum { Visible_no, Visible_yes, Visible_Invalid };

    Dimension();
    ~Dimension();
    void setX1( const double v );
    double x1() const;
    bool x1Set() const;
    void setY1( const double v );
    double y1() const;
    bool y1Set() const;
    void setX2( const double v );
    double x2() const;
    bool x2Set() const;
    void setY2( const double v );
    double y2() const;
    bool y2Set() const;
    void setX3( const double v );
    double x3() const;
    bool x3Set() const;
    void setY3( const double v );
    double y3() const;
    bool y3Set() const;
    void setLayer( const int v );
    int layer() const;
    bool layerSet() const;
    void setDtype( const DtypeEnum &v );
    Dimension::DtypeEnum dtype() const;
    void setWidth( const double v );
    double width() const;
    bool widthSet() const;
    void setExtwidth( const double v );
    double extwidth() const;
    bool extwidthSet() const;
    void setExtlength( const double v );
    double extlength() const;
    bool extlengthSet() const;
    void setExtoffset( const double v );
    double extoffset() const;
    bool extoffsetSet() const;
    void setTextsize( const double v );
    double textsize() const;
    bool textsizeSet() const;
    void setTextratio( const int v );
    int textratio() const;
    bool textratioSet() const;
    void setUnit( const UnitEnum &v );
    Dimension::UnitEnum unit() const;
    void setPrecision( const int v );
    int precision() const;
    bool precisionSet() const;
    void setVisible( const VisibleEnum &v );
    Dimension::VisibleEnum visible() const;
    static QString dtypeEnumToString( const DtypeEnum & v );
    static QString unitEnumToString( const UnitEnum & v );
    static QString visibleEnumToString( const VisibleEnum & v );
    /**
      Parse XML object from DOM element.
     */
    static Dimension *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    static Dimension::DtypeEnum dtypeEnumFromString( const QString & v, bool *ok = NULL );
    static Dimension::UnitEnum unitEnumFromString( const QString & v, bool *ok = NULL );
    static Dimension::VisibleEnum visibleEnumFromString( const QString & v, bool *ok = NULL );

    double mX1;
    bool mX1_set;
    double mY1;
    bool mY1_set;
    double mX2;
    bool mX2_set;
    double mY2;
    bool mY2_set;
    double mX3;
    bool mX3_set;
    double mY3;
    bool mY3_set;
    int mLayer;
    bool mLayer_set;
    DtypeEnum mDtype;
    double mWidth;
    bool mWidth_set;
    double mExtwidth;
    bool mExtwidth_set;
    double mExtlength;
    bool mExtlength_set;
    double mExtoffset;
    bool mExtoffset_set;
    double mTextsize;
    bool mTextsize_set;
    int mTextratio;
    bool mTextratio_set;
    UnitEnum mUnit;
    int mPrecision;
    bool mPrecision_set;
    VisibleEnum mVisible;
};

class Circle
{
  public:
    typedef QList<Circle*> List;

    Circle();
    ~Circle();
    void setX( const double v );
    double x() const;
    bool xSet() const;
    void setY( const double v );
    double y() const;
    bool ySet() const;
    void setRadius( const double v );
    double radius() const;
    bool radiusSet() const;
    void setWidth( const double v );
    double width() const;
    bool widthSet() const;
    void setLayer( const int v );
    int layer() const;
    bool layerSet() const;
    /**
      Parse XML object from DOM element.
     */
    static Circle *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    double mX;
    bool mX_set;
    double mY;
    bool mY_set;
    double mRadius;
    bool mRadius_set;
    double mWidth;
    bool mWidth_set;
    int mLayer;
    bool mLayer_set;
};

class Rectangle
{
  public:
    typedef QList<Rectangle*> List;

    Rectangle();
    ~Rectangle();
    void setX1( const double v );
    double x1() const;
    bool x1Set() const;
    void setY1( const double v );
    double y1() const;
    bool y1Set() const;
    void setX2( const double v );
    double x2() const;
    bool x2Set() const;
    void setY2( const double v );
    double y2() const;
    bool y2Set() const;
    void setLayer( const int v );
    int layer() const;
    bool layerSet() const;
    void setRot( const QString &v );
    QString rot() const;
    /**
      Parse XML object from DOM element.
     */
    static Rectangle *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    double mX1;
    bool mX1_set;
    double mY1;
    bool mY1_set;
    double mX2;
    bool mX2_set;
    double mY2;
    bool mY2_set;
    int mLayer;
    bool mLayer_set;
    QString mRot;
};

class Frame
{
  public:
    typedef QList<Frame*> List;

    enum BorderLeftEnum { BorderLeft_no, BorderLeft_yes, BorderLeft_Invalid };
    enum BorderTopEnum { BorderTop_no, BorderTop_yes, BorderTop_Invalid };
    enum BorderRightEnum { BorderRight_no, BorderRight_yes, BorderRight_Invalid };
    enum BorderBottomEnum { BorderBottom_no, BorderBottom_yes, BorderBottom_Invalid };

    Frame();
    ~Frame();
    void setX1( const double v );
    double x1() const;
    bool x1Set() const;
    void setY1( const double v );
    double y1() const;
    bool y1Set() const;
    void setX2( const double v );
    double x2() const;
    bool x2Set() const;
    void setY2( const double v );
    double y2() const;
    bool y2Set() const;
    void setColumns( const int v );
    int columns() const;
    bool columnsSet() const;
    void setRows( const int v );
    int rows() const;
    bool rowsSet() const;
    void setLayer( const int v );
    int layer() const;
    bool layerSet() const;
    void setBorderLeft( const BorderLeftEnum &v );
    Frame::BorderLeftEnum borderLeft() const;
    void setBorderTop( const BorderTopEnum &v );
    Frame::BorderTopEnum borderTop() const;
    void setBorderRight( const BorderRightEnum &v );
    Frame::BorderRightEnum borderRight() const;
    void setBorderBottom( const BorderBottomEnum &v );
    Frame::BorderBottomEnum borderBottom() const;
    static QString borderLeftEnumToString( const BorderLeftEnum & v );
    static QString borderTopEnumToString( const BorderTopEnum & v );
    static QString borderRightEnumToString( const BorderRightEnum & v );
    static QString borderBottomEnumToString( const BorderBottomEnum & v );
    /**
      Parse XML object from DOM element.
     */
    static Frame *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    static Frame::BorderLeftEnum borderLeftEnumFromString( const QString & v, bool *ok = NULL );
    static Frame::BorderTopEnum borderTopEnumFromString( const QString & v, bool *ok = NULL );
    static Frame::BorderRightEnum borderRightEnumFromString( const QString & v, bool *ok = NULL );
    static Frame::BorderBottomEnum borderBottomEnumFromString( const QString & v, bool *ok = NULL );

    double mX1;
    bool mX1_set;
    double mY1;
    bool mY1_set;
    double mX2;
    bool mX2_set;
    double mY2;
    bool mY2_set;
    int mColumns;
    bool mColumns_set;
    int mRows;
    bool mRows_set;
    int mLayer;
    bool mLayer_set;
    BorderLeftEnum mBorderLeft;
    BorderTopEnum mBorderTop;
    BorderRightEnum mBorderRight;
    BorderBottomEnum mBorderBottom;
};

class Hole
{
  public:
    typedef QList<Hole*> List;

    Hole();
    ~Hole();
    void setX( const double v );
    double x() const;
    bool xSet() const;
    void setY( const double v );
    double y() const;
    bool ySet() const;
    void setDrill( const double v );
    double drill() const;
    bool drillSet() const;
    /**
      Parse XML object from DOM element.
     */
    static Hole *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    double mX;
    bool mX_set;
    double mY;
    bool mY_set;
    double mDrill;
    bool mDrill_set;
};

class Plain
{
  public:
    Plain();
    ~Plain();
    void addPolygon( Polygon* v );
    void setPolygonList( const Polygon::List &v );
    Polygon::List *polygonList();
    void addWire( Wire* v );
    void setWireList( const Wire::List &v );
    Wire::List *wireList();
    void addText( Text* v );
    void setTextList( const Text::List &v );
    Text::List *textList();
    void addDimension( Dimension* v );
    void setDimensionList( const Dimension::List &v );
    Dimension::List *dimensionList();
    void addCircle( Circle* v );
    void setCircleList( const Circle::List &v );
    Circle::List *circleList();
    void addRectangle( Rectangle* v );
    void setRectangleList( const Rectangle::List &v );
    Rectangle::List *rectangleList();
    void addFrame( Frame* v );
    void setFrameList( const Frame::List &v );
    Frame::List *frameList();
    void addHole( Hole* v );
    void setHoleList( const Hole::List &v );
    Hole::List *holeList();
    /**
      Parse XML object from DOM element.
     */
    static Plain *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    Polygon::List mPolygonList;
    Wire::List mWireList;
    Text::List mTextList;
    Dimension::List mDimensionList;
    Circle::List mCircleList;
    Rectangle::List mRectangleList;
    Frame::List mFrameList;
    Hole::List mHoleList;
};

class Pad
{
  public:
    typedef QList<Pad*> List;

    enum ShapeEnum { Shape_square, Shape_round, Shape_octagon, Shape_long, Shape_offset, Shape_Invalid };
    enum StopEnum { Stop_no, Stop_yes, Stop_Invalid };
    enum ThermalsEnum { Thermals_no, Thermals_yes, Thermals_Invalid };
    enum FirstEnum { First_no, First_yes, First_Invalid };

    Pad();
    ~Pad();
    void setName( const QString &v );
    QString name() const;
    void setX( const double v );
    double x() const;
    bool xSet() const;
    void setY( const double v );
    double y() const;
    bool ySet() const;
    void setDrill( const double v );
    double drill() const;
    bool drillSet() const;
    void setDiameter( const double v );
    double diameter() const;
    bool diameterSet() const;
    void setShape( const ShapeEnum &v );
    Pad::ShapeEnum shape() const;
    void setRot( const QString &v );
    QString rot() const;
    void setStop( const StopEnum &v );
    Pad::StopEnum stop() const;
    void setThermals( const ThermalsEnum &v );
    Pad::ThermalsEnum thermals() const;
    void setFirst( const FirstEnum &v );
    Pad::FirstEnum first() const;
    static QString shapeEnumToString( const ShapeEnum & v );
    static QString stopEnumToString( const StopEnum & v );
    static QString thermalsEnumToString( const ThermalsEnum & v );
    static QString firstEnumToString( const FirstEnum & v );
    /**
      Parse XML object from DOM element.
     */
    static Pad *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    static Pad::ShapeEnum shapeEnumFromString( const QString & v, bool *ok = NULL );
    static Pad::StopEnum stopEnumFromString( const QString & v, bool *ok = NULL );
    static Pad::ThermalsEnum thermalsEnumFromString( const QString & v, bool *ok = NULL );
    static Pad::FirstEnum firstEnumFromString( const QString & v, bool *ok = NULL );

    QString mName;
    double mX;
    bool mX_set;
    double mY;
    bool mY_set;
    double mDrill;
    bool mDrill_set;
    double mDiameter;
    bool mDiameter_set;
    ShapeEnum mShape;
    QString mRot;
    StopEnum mStop;
    ThermalsEnum mThermals;
    FirstEnum mFirst;
};

class Smd
{
  public:
    typedef QList<Smd*> List;

    enum StopEnum { Stop_no, Stop_yes, Stop_Invalid };
    enum ThermalsEnum { Thermals_no, Thermals_yes, Thermals_Invalid };
    enum CreamEnum { Cream_no, Cream_yes, Cream_Invalid };

    Smd();
    ~Smd();
    void setName( const QString &v );
    QString name() const;
    void setX( const double v );
    double x() const;
    bool xSet() const;
    void setY( const double v );
    double y() const;
    bool ySet() const;
    void setDx( const double v );
    double dx() const;
    bool dxSet() const;
    void setDy( const double v );
    double dy() const;
    bool dySet() const;
    void setLayer( const int v );
    int layer() const;
    bool layerSet() const;
    void setRoundness( const int v );
    int roundness() const;
    bool roundnessSet() const;
    void setRot( const QString &v );
    QString rot() const;
    void setStop( const StopEnum &v );
    Smd::StopEnum stop() const;
    void setThermals( const ThermalsEnum &v );
    Smd::ThermalsEnum thermals() const;
    void setCream( const CreamEnum &v );
    Smd::CreamEnum cream() const;
    static QString stopEnumToString( const StopEnum & v );
    static QString thermalsEnumToString( const ThermalsEnum & v );
    static QString creamEnumToString( const CreamEnum & v );
    /**
      Parse XML object from DOM element.
     */
    static Smd *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    static Smd::StopEnum stopEnumFromString( const QString & v, bool *ok = NULL );
    static Smd::ThermalsEnum thermalsEnumFromString( const QString & v, bool *ok = NULL );
    static Smd::CreamEnum creamEnumFromString( const QString & v, bool *ok = NULL );

    QString mName;
    double mX;
    bool mX_set;
    double mY;
    bool mY_set;
    double mDx;
    bool mDx_set;
    double mDy;
    bool mDy_set;
    int mLayer;
    bool mLayer_set;
    int mRoundness;
    bool mRoundness_set;
    QString mRot;
    StopEnum mStop;
    ThermalsEnum mThermals;
    CreamEnum mCream;
};

class Package
{
  public:
    typedef QList<Package*> List;

    enum LocallyModifiedEnum { LocallyModified_no, LocallyModified_yes, LocallyModified_Invalid };
    enum LibraryLocallyModifiedEnum { LibraryLocallyModified_no, LibraryLocallyModified_yes, LibraryLocallyModified_Invalid };

    Package();
    ~Package();
    void setName( const QString &v );
    QString name() const;
    void setUrn( const QString &v );
    QString urn() const;
    void setLocallyModified( const LocallyModifiedEnum &v );
    Package::LocallyModifiedEnum locallyModified() const;
    void setLibraryVersion( const int v );
    int libraryVersion() const;
    bool libraryVersionSet() const;
    void setLibraryLocallyModified( const LibraryLocallyModifiedEnum &v );
    Package::LibraryLocallyModifiedEnum libraryLocallyModified() const;
    void addPolygon( Polygon* v );
    void setPolygonList( const Polygon::List &v );
    Polygon::List *polygonList();
    void addWire( Wire* v );
    void setWireList( const Wire::List &v );
    Wire::List *wireList();
    void addText( Text* v );
    void setTextList( const Text::List &v );
    Text::List *textList();
    void addDimension( Dimension* v );
    void setDimensionList( const Dimension::List &v );
    Dimension::List *dimensionList();
    void addCircle( Circle* v );
    void setCircleList( const Circle::List &v );
    Circle::List *circleList();
    void addRectangle( Rectangle* v );
    void setRectangleList( const Rectangle::List &v );
    Rectangle::List *rectangleList();
    void addFrame( Frame* v );
    void setFrameList( const Frame::List &v );
    Frame::List *frameList();
    void addHole( Hole* v );
    void setHoleList( const Hole::List &v );
    Hole::List *holeList();
    void addPad( Pad* v );
    void setPadList( const Pad::List &v );
    Pad::List *padList();
    void addSmd( Smd* v );
    void setSmdList( const Smd::List &v );
    Smd::List *smdList();
    void setDescription( Description *v );
    Description *description();
    static QString locallyModifiedEnumToString( const LocallyModifiedEnum & v );
    static QString libraryLocallyModifiedEnumToString( const LibraryLocallyModifiedEnum & v );
    /**
      Parse XML object from DOM element.
     */
    static Package *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    static Package::LocallyModifiedEnum locallyModifiedEnumFromString( const QString & v, bool *ok = NULL );
    static Package::LibraryLocallyModifiedEnum libraryLocallyModifiedEnumFromString( const QString & v, bool *ok = NULL );

    QString mName;
    QString mUrn;
    LocallyModifiedEnum mLocallyModified;
    int mLibraryVersion;
    bool mLibraryVersion_set;
    LibraryLocallyModifiedEnum mLibraryLocallyModified;
    Polygon::List mPolygonList;
    Wire::List mWireList;
    Text::List mTextList;
    Dimension::List mDimensionList;
    Circle::List mCircleList;
    Rectangle::List mRectangleList;
    Frame::List mFrameList;
    Hole::List mHoleList;
    Pad::List mPadList;
    Smd::List mSmdList;
    Description *mDescription;
};

class Packages
{
  public:
    Packages();
    ~Packages();
    void addPackage( Package* v );
    void setPackageList( const Package::List &v );
    Package::List *packageList();
    /**
      Parse XML object from DOM element.
     */
    static Packages *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    Package::List mPackageList;
};

class Packageinstance
{
  public:
    typedef QList<Packageinstance*> List;

    Packageinstance();
    ~Packageinstance();
    void setName( const QString &v );
    QString name() const;
    /**
      Parse XML object from DOM element.
     */
    static Packageinstance *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    QString mName;
};

class Packageinstances
{
  public:
    Packageinstances();
    ~Packageinstances();
    void addPackageinstance( Packageinstance* v );
    void setPackageinstanceList( const Packageinstance::List &v );
    Packageinstance::List *packageinstanceList();
    /**
      Parse XML object from DOM element.
     */
    static Packageinstances *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    Packageinstance::List mPackageinstanceList;
};

class Package3d
{
  public:
    typedef QList<Package3d*> List;

    enum TypeEnum { Type_model, Type_box, Type_Invalid };
    enum LibraryLocallyModifiedEnum { LibraryLocallyModified_no, LibraryLocallyModified_yes, LibraryLocallyModified_Invalid };

    Package3d();
    ~Package3d();
    void setName( const QString &v );
    QString name() const;
    void setUrn( const QString &v );
    QString urn() const;
    void setType( const TypeEnum &v );
    Package3d::TypeEnum type() const;
    void setLibraryVersion( const int v );
    int libraryVersion() const;
    bool libraryVersionSet() const;
    void setLibraryLocallyModified( const LibraryLocallyModifiedEnum &v );
    Package3d::LibraryLocallyModifiedEnum libraryLocallyModified() const;
    void setDescription( Description *v );
    Description *description();
    void setPackageinstances( Packageinstances *v );
    Packageinstances *packageinstances();
    static QString typeEnumToString( const TypeEnum & v );
    static QString libraryLocallyModifiedEnumToString( const LibraryLocallyModifiedEnum & v );
    /**
      Parse XML object from DOM element.
     */
    static Package3d *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    static Package3d::TypeEnum typeEnumFromString( const QString & v, bool *ok = NULL );
    static Package3d::LibraryLocallyModifiedEnum libraryLocallyModifiedEnumFromString( const QString & v, bool *ok = NULL );

    QString mName;
    QString mUrn;
    TypeEnum mType;
    int mLibraryVersion;
    bool mLibraryVersion_set;
    LibraryLocallyModifiedEnum mLibraryLocallyModified;
    Description *mDescription;
    Packageinstances *mPackageinstances;
};

class Packages3d
{
  public:
    Packages3d();
    ~Packages3d();
    void addPackage3d( Package3d* v );
    void setPackage3dList( const Package3d::List &v );
    Package3d::List *package3dList();
    /**
      Parse XML object from DOM element.
     */
    static Packages3d *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    Package3d::List mPackage3dList;
};

class Pin
{
  public:
    typedef QList<Pin*> List;

    enum VisibleEnum { Visible_off, Visible_pad, Visible_pin, Visible_both, Visible_Invalid };
    enum LengthEnum { Length_point, Length_short, Length_middle, Length_long, Length_Invalid };
    enum DirectionEnum { Direction_nc, Direction_in, Direction_out, Direction_io, Direction_oc, Direction_pwr, Direction_pas, Direction_hiz, Direction_sup, Direction_Invalid };
    enum FunctionEnum { Function_none, Function_dot, Function_clk, Function_dotclk, Function_Invalid };

    Pin();
    ~Pin();
    void setName( const QString &v );
    QString name() const;
    void setX( const double v );
    double x() const;
    bool xSet() const;
    void setY( const double v );
    double y() const;
    bool ySet() const;
    void setVisible( const VisibleEnum &v );
    Pin::VisibleEnum visible() const;
    void setLength( const LengthEnum &v );
    Pin::LengthEnum length() const;
    void setDirection( const DirectionEnum &v );
    Pin::DirectionEnum direction() const;
    void setFunction( const FunctionEnum &v );
    Pin::FunctionEnum function() const;
    void setSwaplevel( const int v );
    int swaplevel() const;
    bool swaplevelSet() const;
    void setRot( const QString &v );
    QString rot() const;
    static QString visibleEnumToString( const VisibleEnum & v );
    static QString lengthEnumToString( const LengthEnum & v );
    static QString directionEnumToString( const DirectionEnum & v );
    static QString functionEnumToString( const FunctionEnum & v );
    /**
      Parse XML object from DOM element.
     */
    static Pin *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    static Pin::VisibleEnum visibleEnumFromString( const QString & v, bool *ok = NULL );
    static Pin::LengthEnum lengthEnumFromString( const QString & v, bool *ok = NULL );
    static Pin::DirectionEnum directionEnumFromString( const QString & v, bool *ok = NULL );
    static Pin::FunctionEnum functionEnumFromString( const QString & v, bool *ok = NULL );

    QString mName;
    double mX;
    bool mX_set;
    double mY;
    bool mY_set;
    VisibleEnum mVisible;
    LengthEnum mLength;
    DirectionEnum mDirection;
    FunctionEnum mFunction;
    int mSwaplevel;
    bool mSwaplevel_set;
    QString mRot;
};

class Symbol
{
  public:
    typedef QList<Symbol*> List;

    enum LocallyModifiedEnum { LocallyModified_no, LocallyModified_yes, LocallyModified_Invalid };
    enum LibraryLocallyModifiedEnum { LibraryLocallyModified_no, LibraryLocallyModified_yes, LibraryLocallyModified_Invalid };

    Symbol();
    ~Symbol();
    void setName( const QString &v );
    QString name() const;
    void setUrn( const QString &v );
    QString urn() const;
    void setLocallyModified( const LocallyModifiedEnum &v );
    Symbol::LocallyModifiedEnum locallyModified() const;
    void setLibraryVersion( const int v );
    int libraryVersion() const;
    bool libraryVersionSet() const;
    void setLibraryLocallyModified( const LibraryLocallyModifiedEnum &v );
    Symbol::LibraryLocallyModifiedEnum libraryLocallyModified() const;
    void addPolygon( Polygon* v );
    void setPolygonList( const Polygon::List &v );
    Polygon::List *polygonList();
    void addWire( Wire* v );
    void setWireList( const Wire::List &v );
    Wire::List *wireList();
    void addText( Text* v );
    void setTextList( const Text::List &v );
    Text::List *textList();
    void addDimension( Dimension* v );
    void setDimensionList( const Dimension::List &v );
    Dimension::List *dimensionList();
    void addPin( Pin* v );
    void setPinList( const Pin::List &v );
    Pin::List *pinList();
    void addCircle( Circle* v );
    void setCircleList( const Circle::List &v );
    Circle::List *circleList();
    void addRectangle( Rectangle* v );
    void setRectangleList( const Rectangle::List &v );
    Rectangle::List *rectangleList();
    void addFrame( Frame* v );
    void setFrameList( const Frame::List &v );
    Frame::List *frameList();
    void setDescription( Description *v );
    Description *description();
    static QString locallyModifiedEnumToString( const LocallyModifiedEnum & v );
    static QString libraryLocallyModifiedEnumToString( const LibraryLocallyModifiedEnum & v );
    /**
      Parse XML object from DOM element.
     */
    static Symbol *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    static Symbol::LocallyModifiedEnum locallyModifiedEnumFromString( const QString & v, bool *ok = NULL );
    static Symbol::LibraryLocallyModifiedEnum libraryLocallyModifiedEnumFromString( const QString & v, bool *ok = NULL );

    QString mName;
    QString mUrn;
    LocallyModifiedEnum mLocallyModified;
    int mLibraryVersion;
    bool mLibraryVersion_set;
    LibraryLocallyModifiedEnum mLibraryLocallyModified;
    Polygon::List mPolygonList;
    Wire::List mWireList;
    Text::List mTextList;
    Dimension::List mDimensionList;
    Pin::List mPinList;
    Circle::List mCircleList;
    Rectangle::List mRectangleList;
    Frame::List mFrameList;
    Description *mDescription;
};

class Symbols
{
  public:
    Symbols();
    ~Symbols();
    void addSymbol( Symbol* v );
    void setSymbolList( const Symbol::List &v );
    Symbol::List *symbolList();
    /**
      Parse XML object from DOM element.
     */
    static Symbols *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    Symbol::List mSymbolList;
};

class Gate
{
  public:
    typedef QList<Gate*> List;

    enum AddlevelEnum { Addlevel_must, Addlevel_can, Addlevel_next, Addlevel_request, Addlevel_always, Addlevel_Invalid };

    Gate();
    ~Gate();
    void setName( const QString &v );
    QString name() const;
    void setSymbol( const QString &v );
    QString symbol() const;
    void setX( const double v );
    double x() const;
    bool xSet() const;
    void setY( const double v );
    double y() const;
    bool ySet() const;
    void setAddlevel( const AddlevelEnum &v );
    Gate::AddlevelEnum addlevel() const;
    void setSwaplevel( const int v );
    int swaplevel() const;
    bool swaplevelSet() const;
    static QString addlevelEnumToString( const AddlevelEnum & v );
    /**
      Parse XML object from DOM element.
     */
    static Gate *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    static Gate::AddlevelEnum addlevelEnumFromString( const QString & v, bool *ok = NULL );

    QString mName;
    QString mSymbol;
    double mX;
    bool mX_set;
    double mY;
    bool mY_set;
    AddlevelEnum mAddlevel;
    int mSwaplevel;
    bool mSwaplevel_set;
};

class Gates
{
  public:
    Gates();
    ~Gates();
    void addGate( Gate* v );
    void setGateList( const Gate::List &v );
    Gate::List *gateList();
    /**
      Parse XML object from DOM element.
     */
    static Gates *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    Gate::List mGateList;
};

class Connect
{
  public:
    typedef QList<Connect*> List;

    enum RouteEnum { Route_all, Route_any, Route_Invalid };

    Connect();
    ~Connect();
    void setGate( const QString &v );
    QString gate() const;
    void setPin( const QString &v );
    QString pin() const;
    void setPad( const QString &v );
    QString pad() const;
    void setRoute( const RouteEnum &v );
    Connect::RouteEnum route() const;
    static QString routeEnumToString( const RouteEnum & v );
    /**
      Parse XML object from DOM element.
     */
    static Connect *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    static Connect::RouteEnum routeEnumFromString( const QString & v, bool *ok = NULL );

    QString mGate;
    QString mPin;
    QString mPad;
    RouteEnum mRoute;
};

class Connects
{
  public:
    Connects();
    ~Connects();
    void addConnect( Connect* v );
    void setConnectList( const Connect::List &v );
    Connect::List *connectList();
    /**
      Parse XML object from DOM element.
     */
    static Connects *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    Connect::List mConnectList;
};

class Package3dinstance
{
  public:
    typedef QList<Package3dinstance*> List;

    Package3dinstance();
    ~Package3dinstance();
    void setPackage3dUrn( const QString &v );
    QString package3dUrn() const;
    /**
      Parse XML object from DOM element.
     */
    static Package3dinstance *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    QString mPackage3dUrn;
};

class Package3dinstances
{
  public:
    Package3dinstances();
    ~Package3dinstances();
    void addPackage3dinstance( Package3dinstance* v );
    void setPackage3dinstanceList( const Package3dinstance::List &v );
    Package3dinstance::List *package3dinstanceList();
    /**
      Parse XML object from DOM element.
     */
    static Package3dinstances *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    Package3dinstance::List mPackage3dinstanceList;
};

class Technology
{
  public:
    typedef QList<Technology*> List;

    Technology();
    ~Technology();
    void setName( const QString &v );
    QString name() const;
    void addAttribute( Attribute* v );
    void setAttributeList( const Attribute::List &v );
    Attribute::List *attributeList();
    /**
      Parse XML object from DOM element.
     */
    static Technology *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    QString mName;
    Attribute::List mAttributeList;
};

class Technologies
{
  public:
    Technologies();
    ~Technologies();
    void addTechnology( Technology* v );
    void setTechnologyList( const Technology::List &v );
    Technology::List *technologyList();
    /**
      Parse XML object from DOM element.
     */
    static Technologies *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    Technology::List mTechnologyList;
};

class Device
{
  public:
    typedef QList<Device*> List;

    Device();
    ~Device();
    void setName( const QString &v );
    QString name() const;
    void setPackage( const QString &v );
    QString package() const;
    void setConnects( Connects *v );
    Connects *connects();
    void setPackage3dinstances( Package3dinstances *v );
    Package3dinstances *package3dinstances();
    void setTechnologies( Technologies *v );
    Technologies *technologies();
    /**
      Parse XML object from DOM element.
     */
    static Device *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    QString mName;
    QString mPackage;
    Connects *mConnects;
    Package3dinstances *mPackage3dinstances;
    Technologies *mTechnologies;
};

class Devices
{
  public:
    Devices();
    ~Devices();
    void addDevice( Device* v );
    void setDeviceList( const Device::List &v );
    Device::List *deviceList();
    /**
      Parse XML object from DOM element.
     */
    static Devices *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    Device::List mDeviceList;
};

class Pinmap
{
  public:
    typedef QList<Pinmap*> List;

    Pinmap();
    ~Pinmap();
    void setGate( const QString &v );
    QString gate() const;
    void setPin( const QString &v );
    QString pin() const;
    void setPinorder( const QString &v );
    QString pinorder() const;
    /**
      Parse XML object from DOM element.
     */
    static Pinmap *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    QString mGate;
    QString mPin;
    QString mPinorder;
};

class Pinmapping
{
  public:
    enum IsusermapEnum { Isusermap_no, Isusermap_yes, Isusermap_Invalid };
    enum IddevicewideEnum { Iddevicewide_no, Iddevicewide_yes, Iddevicewide_Invalid };

    Pinmapping();
    ~Pinmapping();
    void setIsusermap( const IsusermapEnum &v );
    Pinmapping::IsusermapEnum isusermap() const;
    void setIddevicewide( const IddevicewideEnum &v );
    Pinmapping::IddevicewideEnum iddevicewide() const;
    void setSpiceprefix( const QString &v );
    QString spiceprefix() const;
    void addPinmap( Pinmap* v );
    void setPinmapList( const Pinmap::List &v );
    Pinmap::List *pinmapList();
    static QString isusermapEnumToString( const IsusermapEnum & v );
    static QString iddevicewideEnumToString( const IddevicewideEnum & v );
    /**
      Parse XML object from DOM element.
     */
    static Pinmapping *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    static Pinmapping::IsusermapEnum isusermapEnumFromString( const QString & v, bool *ok = NULL );
    static Pinmapping::IddevicewideEnum iddevicewideEnumFromString( const QString & v, bool *ok = NULL );

    IsusermapEnum mIsusermap;
    IddevicewideEnum mIddevicewide;
    QString mSpiceprefix;
    Pinmap::List mPinmapList;
};

class Model
{
  public:
    Model();
    ~Model();
    void setName( const QString &v );
    QString name() const;
    void setValue( const QString &v );
    QString value() const;
    /**
      Parse XML object from DOM element.
     */
    static Model *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    QString mName;
    QString mValue;
};

class Spice
{
  public:
    Spice();
    ~Spice();
    void setPinmapping( Pinmapping *v );
    Pinmapping *pinmapping();
    void setModel( Model *v );
    Model *model();
    /**
      Parse XML object from DOM element.
     */
    static Spice *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    Pinmapping *mPinmapping;
    Model *mModel;
};

class Deviceset
{
  public:
    typedef QList<Deviceset*> List;

    enum LocallyModifiedEnum { LocallyModified_no, LocallyModified_yes, LocallyModified_Invalid };
    enum UservalueEnum { Uservalue_no, Uservalue_yes, Uservalue_Invalid };
    enum LibraryLocallyModifiedEnum { LibraryLocallyModified_no, LibraryLocallyModified_yes, LibraryLocallyModified_Invalid };

    Deviceset();
    ~Deviceset();
    void setName( const QString &v );
    QString name() const;
    void setUrn( const QString &v );
    QString urn() const;
    void setLocallyModified( const LocallyModifiedEnum &v );
    Deviceset::LocallyModifiedEnum locallyModified() const;
    void setPrefix( const QString &v );
    QString prefix() const;
    void setUservalue( const UservalueEnum &v );
    Deviceset::UservalueEnum uservalue() const;
    void setLibraryVersion( const int v );
    int libraryVersion() const;
    bool libraryVersionSet() const;
    void setLibraryLocallyModified( const LibraryLocallyModifiedEnum &v );
    Deviceset::LibraryLocallyModifiedEnum libraryLocallyModified() const;
    void setDescription( Description *v );
    Description *description();
    void setGates( Gates *v );
    Gates *gates();
    void setDevices( Devices *v );
    Devices *devices();
    void setSpice( Spice *v );
    Spice *spice();
    static QString locallyModifiedEnumToString( const LocallyModifiedEnum & v );
    static QString uservalueEnumToString( const UservalueEnum & v );
    static QString libraryLocallyModifiedEnumToString( const LibraryLocallyModifiedEnum & v );
    /**
      Parse XML object from DOM element.
     */
    static Deviceset *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    static Deviceset::LocallyModifiedEnum locallyModifiedEnumFromString( const QString & v, bool *ok = NULL );
    static Deviceset::UservalueEnum uservalueEnumFromString( const QString & v, bool *ok = NULL );
    static Deviceset::LibraryLocallyModifiedEnum libraryLocallyModifiedEnumFromString( const QString & v, bool *ok = NULL );

    QString mName;
    QString mUrn;
    LocallyModifiedEnum mLocallyModified;
    QString mPrefix;
    UservalueEnum mUservalue;
    int mLibraryVersion;
    bool mLibraryVersion_set;
    LibraryLocallyModifiedEnum mLibraryLocallyModified;
    Description *mDescription;
    Gates *mGates;
    Devices *mDevices;
    Spice *mSpice;
};

class Devicesets
{
  public:
    Devicesets();
    ~Devicesets();
    void addDeviceset( Deviceset* v );
    void setDevicesetList( const Deviceset::List &v );
    Deviceset::List *devicesetList();
    /**
      Parse XML object from DOM element.
     */
    static Devicesets *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    Deviceset::List mDevicesetList;
};

class Library
{
  public:
    typedef QList<Library*> List;

    Library();
    ~Library();
    void setName( const QString &v );
    QString name() const;
    void setUrn( const QString &v );
    QString urn() const;
    void setDescription( Description *v );
    Description *description();
    void setPackages( Packages *v );
    Packages *packages();
    void setPackages3d( Packages3d *v );
    Packages3d *packages3d();
    void setSymbols( Symbols *v );
    Symbols *symbols();
    void setDevicesets( Devicesets *v );
    Devicesets *devicesets();
    /**
      Parse XML object from DOM element.
     */
    static Library *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    QString mName;
    QString mUrn;
    Description *mDescription;
    Packages *mPackages;
    Packages3d *mPackages3d;
    Symbols *mSymbols;
    Devicesets *mDevicesets;
};

class Libraries
{
  public:
    Libraries();
    ~Libraries();
    void addLibrary( Library* v );
    void setLibraryList( const Library::List &v );
    Library::List *libraryList();
    /**
      Parse XML object from DOM element.
     */
    static Libraries *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    Library::List mLibraryList;
};

class Attributes
{
  public:
    Attributes();
    ~Attributes();
    void addAttribute( Attribute* v );
    void setAttributeList( const Attribute::List &v );
    Attribute::List *attributeList();
    /**
      Parse XML object from DOM element.
     */
    static Attributes *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    Attribute::List mAttributeList;
};

class Variantdef
{
  public:
    typedef QList<Variantdef*> List;

    enum CurrentEnum { Current_no, Current_yes, Current_Invalid };

    Variantdef();
    ~Variantdef();
    void setName( const QString &v );
    QString name() const;
    void setCurrent( const CurrentEnum &v );
    Variantdef::CurrentEnum current() const;
    static QString currentEnumToString( const CurrentEnum & v );
    /**
      Parse XML object from DOM element.
     */
    static Variantdef *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    static Variantdef::CurrentEnum currentEnumFromString( const QString & v, bool *ok = NULL );

    QString mName;
    CurrentEnum mCurrent;
};

class Variantdefs
{
  public:
    Variantdefs();
    ~Variantdefs();
    void addVariantdef( Variantdef* v );
    void setVariantdefList( const Variantdef::List &v );
    Variantdef::List *variantdefList();
    /**
      Parse XML object from DOM element.
     */
    static Variantdefs *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    Variantdef::List mVariantdefList;
};

class Clearance
{
  public:
    typedef QList<Clearance*> List;

    Clearance();
    ~Clearance();
    void setClass( const int v );
    int class_() const;
    bool classSet() const;
    void setValue( const double v );
    double value() const;
    bool valueSet() const;
    /**
      Parse XML object from DOM element.
     */
    static Clearance *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    int mClass;
    bool mClass_set;
    double mValue;
    bool mValue_set;
};

class Class
{
  public:
    typedef QList<Class*> List;

    Class();
    ~Class();
    void setNumber( const int v );
    int number() const;
    bool numberSet() const;
    void setName( const QString &v );
    QString name() const;
    void setWidth( const double v );
    double width() const;
    bool widthSet() const;
    void setDrill( const double v );
    double drill() const;
    bool drillSet() const;
    void addClearance( Clearance* v );
    void setClearanceList( const Clearance::List &v );
    Clearance::List *clearanceList();
    /**
      Parse XML object from DOM element.
     */
    static Class *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    int mNumber;
    bool mNumber_set;
    QString mName;
    double mWidth;
    bool mWidth_set;
    double mDrill;
    bool mDrill_set;
    Clearance::List mClearanceList;
};

class Classes
{
  public:
    Classes();
    ~Classes();
    void addClass( Class* v );
    void setClassList( const Class::List &v );
    Class::List *classList();
    /**
      Parse XML object from DOM element.
     */
    static Classes *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    Class::List mClassList;
};

class Approved
{
  public:
    typedef QList<Approved*> List;

    Approved();
    ~Approved();
    void setHash( const QString &v );
    QString hash() const;
    /**
      Parse XML object from DOM element.
     */
    static Approved *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    QString mHash;
};

class Errors
{
  public:
    Errors();
    ~Errors();
    void addApproved( Approved* v );
    void setApprovedList( const Approved::List &v );
    Approved::List *approvedList();
    /**
      Parse XML object from DOM element.
     */
    static Errors *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    Approved::List mApprovedList;
};

class Board
{
  public:
    Board();
    ~Board();
    void setLimitedwidth( const double v );
    double limitedwidth() const;
    bool limitedwidthSet() const;
    void setDescription( Description *v );
    Description *description();
    void setFusionsync( Fusionsync *v );
    Fusionsync *fusionsync();
    void setPlain( Plain *v );
    Plain *plain();
    void setLibraries( Libraries *v );
    Libraries *libraries();
    void setAttributes( Attributes *v );
    Attributes *attributes();
    void setVariantdefs( Variantdefs *v );
    Variantdefs *variantdefs();
    void setClasses( Classes *v );
    Classes *classes();
    void setDesignrules( Designrules *v );
    Designrules *designrules();
    void setAutorouter( Autorouter *v );
    Autorouter *autorouter();
    void setElements( Elements *v );
    Elements *elements();
    void setSignals( Signals *v );
    Signals *signals_();
    void setMfgpreviewcolors( Mfgpreviewcolors *v );
    Mfgpreviewcolors *mfgpreviewcolors();
    void setErrors( Errors *v );
    Errors *errors();
    /**
      Parse XML object from DOM element.
     */
    static Board *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    double mLimitedwidth;
    bool mLimitedwidth_set;
    Description *mDescription;
    Fusionsync *mFusionsync;
    Plain *mPlain;
    Libraries *mLibraries;
    Attributes *mAttributes;
    Variantdefs *mVariantdefs;
    Classes *mClasses;
    Designrules *mDesignrules;
    Autorouter *mAutorouter;
    Elements *mElements;
    Signals *mSignals;
    Mfgpreviewcolors *mMfgpreviewcolors;
    Errors *mErrors;
};

class Pinref
{
  public:
    typedef QList<Pinref*> List;

    Pinref();
    ~Pinref();
    void setPart( const QString &v );
    QString part() const;
    void setGate( const QString &v );
    QString gate() const;
    void setPin( const QString &v );
    QString pin() const;
    /**
      Parse XML object from DOM element.
     */
    static Pinref *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    QString mPart;
    QString mGate;
    QString mPin;
};

class Portref
{
  public:
    typedef QList<Portref*> List;

    Portref();
    ~Portref();
    void setModuleinst( const QString &v );
    QString moduleinst() const;
    void setPort( const QString &v );
    QString port() const;
    /**
      Parse XML object from DOM element.
     */
    static Portref *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    QString mModuleinst;
    QString mPort;
};

class Junction
{
  public:
    typedef QList<Junction*> List;

    Junction();
    ~Junction();
    void setX( const double v );
    double x() const;
    bool xSet() const;
    void setY( const double v );
    double y() const;
    bool ySet() const;
    /**
      Parse XML object from DOM element.
     */
    static Junction *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    double mX;
    bool mX_set;
    double mY;
    bool mY_set;
};

class Label
{
  public:
    typedef QList<Label*> List;

    enum FontEnum { Font_vector, Font_proportional, Font_fixed, Font_Invalid };
    enum XrefEnum { Xref_no, Xref_yes, Xref_Invalid };
    enum AlignEnum { Align_bottom_left, Align_bottom_center, Align_bottom_right, Align_center_left, Align_center, Align_center_right, Align_top_left, Align_top_center, Align_top_right, Align_Invalid };

    Label();
    ~Label();
    void setX( const double v );
    double x() const;
    bool xSet() const;
    void setY( const double v );
    double y() const;
    bool ySet() const;
    void setSize( const double v );
    double size() const;
    bool sizeSet() const;
    void setLayer( const int v );
    int layer() const;
    bool layerSet() const;
    void setFont( const FontEnum &v );
    Label::FontEnum font() const;
    void setRatio( const int v );
    int ratio() const;
    bool ratioSet() const;
    void setRot( const QString &v );
    QString rot() const;
    void setXref( const XrefEnum &v );
    Label::XrefEnum xref() const;
    void setAlign( const AlignEnum &v );
    Label::AlignEnum align() const;
    static QString fontEnumToString( const FontEnum & v );
    static QString xrefEnumToString( const XrefEnum & v );
    static QString alignEnumToString( const AlignEnum & v );
    /**
      Parse XML object from DOM element.
     */
    static Label *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    static Label::FontEnum fontEnumFromString( const QString & v, bool *ok = NULL );
    static Label::XrefEnum xrefEnumFromString( const QString & v, bool *ok = NULL );
    static Label::AlignEnum alignEnumFromString( const QString & v, bool *ok = NULL );

    double mX;
    bool mX_set;
    double mY;
    bool mY_set;
    double mSize;
    bool mSize_set;
    int mLayer;
    bool mLayer_set;
    FontEnum mFont;
    int mRatio;
    bool mRatio_set;
    QString mRot;
    XrefEnum mXref;
    AlignEnum mAlign;
};

class Probe
{
  public:
    typedef QList<Probe*> List;

    enum FontEnum { Font_vector, Font_proportional, Font_fixed, Font_Invalid };
    enum XrefEnum { Xref_no, Xref_yes, Xref_Invalid };

    Probe();
    ~Probe();
    void setX( const double v );
    double x() const;
    bool xSet() const;
    void setY( const double v );
    double y() const;
    bool ySet() const;
    void setSize( const double v );
    double size() const;
    bool sizeSet() const;
    void setLayer( const int v );
    int layer() const;
    bool layerSet() const;
    void setFont( const FontEnum &v );
    Probe::FontEnum font() const;
    void setRatio( const int v );
    int ratio() const;
    bool ratioSet() const;
    void setRot( const QString &v );
    QString rot() const;
    void setXref( const XrefEnum &v );
    Probe::XrefEnum xref() const;
    static QString fontEnumToString( const FontEnum & v );
    static QString xrefEnumToString( const XrefEnum & v );
    /**
      Parse XML object from DOM element.
     */
    static Probe *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    static Probe::FontEnum fontEnumFromString( const QString & v, bool *ok = NULL );
    static Probe::XrefEnum xrefEnumFromString( const QString & v, bool *ok = NULL );

    double mX;
    bool mX_set;
    double mY;
    bool mY_set;
    double mSize;
    bool mSize_set;
    int mLayer;
    bool mLayer_set;
    FontEnum mFont;
    int mRatio;
    bool mRatio_set;
    QString mRot;
    XrefEnum mXref;
};

class Segment
{
  public:
    typedef QList<Segment*> List;

    Segment();
    ~Segment();
    void addPinref( Pinref* v );
    void setPinrefList( const Pinref::List &v );
    Pinref::List *pinrefList();
    void addPortref( Portref* v );
    void setPortrefList( const Portref::List &v );
    Portref::List *portrefList();
    void addWire( Wire* v );
    void setWireList( const Wire::List &v );
    Wire::List *wireList();
    void addJunction( Junction* v );
    void setJunctionList( const Junction::List &v );
    Junction::List *junctionList();
    void addLabel( Label* v );
    void setLabelList( const Label::List &v );
    Label::List *labelList();
    void addProbe( Probe* v );
    void setProbeList( const Probe::List &v );
    Probe::List *probeList();
    /**
      Parse XML object from DOM element.
     */
    static Segment *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    Pinref::List mPinrefList;
    Portref::List mPortrefList;
    Wire::List mWireList;
    Junction::List mJunctionList;
    Label::List mLabelList;
    Probe::List mProbeList;
};

class Net
{
  public:
    typedef QList<Net*> List;

    Net();
    ~Net();
    void setName( const QString &v );
    QString name() const;
    void setClass( const int v );
    int class_() const;
    bool classSet() const;
    void addSegment( Segment* v );
    void setSegmentList( const Segment::List &v );
    Segment::List *segmentList();
    /**
      Parse XML object from DOM element.
     */
    static Net *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    QString mName;
    int mClass;
    bool mClass_set;
    Segment::List mSegmentList;
};

class Nets
{
  public:
    Nets();
    ~Nets();
    void addNet( Net* v );
    void setNetList( const Net::List &v );
    Net::List *netList();
    /**
      Parse XML object from DOM element.
     */
    static Nets *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    Net::List mNetList;
};

class Bus
{
  public:
    typedef QList<Bus*> List;

    Bus();
    ~Bus();
    void setName( const QString &v );
    QString name() const;
    void addSegment( Segment* v );
    void setSegmentList( const Segment::List &v );
    Segment::List *segmentList();
    /**
      Parse XML object from DOM element.
     */
    static Bus *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    QString mName;
    Segment::List mSegmentList;
};

class Busses
{
  public:
    Busses();
    ~Busses();
    void addBus( Bus* v );
    void setBusList( const Bus::List &v );
    Bus::List *busList();
    /**
      Parse XML object from DOM element.
     */
    static Busses *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    Bus::List mBusList;
};

class Instance
{
  public:
    typedef QList<Instance*> List;

    enum SmashedEnum { Smashed_no, Smashed_yes, Smashed_Invalid };

    Instance();
    ~Instance();
    void setPart( const QString &v );
    QString part() const;
    void setGate( const QString &v );
    QString gate() const;
    void setX( const double v );
    double x() const;
    bool xSet() const;
    void setY( const double v );
    double y() const;
    bool ySet() const;
    void setSmashed( const SmashedEnum &v );
    Instance::SmashedEnum smashed() const;
    void setRot( const QString &v );
    QString rot() const;
    void addAttribute( Attribute* v );
    void setAttributeList( const Attribute::List &v );
    Attribute::List *attributeList();
    static QString smashedEnumToString( const SmashedEnum & v );
    /**
      Parse XML object from DOM element.
     */
    static Instance *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    static Instance::SmashedEnum smashedEnumFromString( const QString & v, bool *ok = NULL );

    QString mPart;
    QString mGate;
    double mX;
    bool mX_set;
    double mY;
    bool mY_set;
    SmashedEnum mSmashed;
    QString mRot;
    Attribute::List mAttributeList;
};

class Instances
{
  public:
    Instances();
    ~Instances();
    void addInstance( Instance* v );
    void setInstanceList( const Instance::List &v );
    Instance::List *instanceList();
    /**
      Parse XML object from DOM element.
     */
    static Instances *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    Instance::List mInstanceList;
};

class Moduleinst
{
  public:
    typedef QList<Moduleinst*> List;

    enum SmashedEnum { Smashed_no, Smashed_yes, Smashed_Invalid };

    Moduleinst();
    ~Moduleinst();
    void setName( const QString &v );
    QString name() const;
    void setModule( const QString &v );
    QString module_() const;
    void setModulevariant( const QString &v );
    QString modulevariant() const;
    void setX( const double v );
    double x() const;
    bool xSet() const;
    void setY( const double v );
    double y() const;
    bool ySet() const;
    void setOffset( const int v );
    int offset() const;
    bool offsetSet() const;
    void setSmashed( const SmashedEnum &v );
    Moduleinst::SmashedEnum smashed() const;
    void setRot( const QString &v );
    QString rot() const;
    void addAttribute( Attribute* v );
    void setAttributeList( const Attribute::List &v );
    Attribute::List *attributeList();
    static QString smashedEnumToString( const SmashedEnum & v );
    /**
      Parse XML object from DOM element.
     */
    static Moduleinst *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    static Moduleinst::SmashedEnum smashedEnumFromString( const QString & v, bool *ok = NULL );

    QString mName;
    QString mModule;
    QString mModulevariant;
    double mX;
    bool mX_set;
    double mY;
    bool mY_set;
    int mOffset;
    bool mOffset_set;
    SmashedEnum mSmashed;
    QString mRot;
    Attribute::List mAttributeList;
};

class Moduleinsts
{
  public:
    Moduleinsts();
    ~Moduleinsts();
    void addModuleinst( Moduleinst* v );
    void setModuleinstList( const Moduleinst::List &v );
    Moduleinst::List *moduleinstList();
    /**
      Parse XML object from DOM element.
     */
    static Moduleinsts *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    Moduleinst::List mModuleinstList;
};

class Sheet
{
  public:
    typedef QList<Sheet*> List;

    Sheet();
    ~Sheet();
    void setDescription( Description *v );
    Description *description();
    void setPlain( Plain *v );
    Plain *plain();
    void setModuleinsts( Moduleinsts *v );
    Moduleinsts *moduleinsts();
    void setInstances( Instances *v );
    Instances *instances();
    void setBusses( Busses *v );
    Busses *busses();
    void setNets( Nets *v );
    Nets *nets();
    /**
      Parse XML object from DOM element.
     */
    static Sheet *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    Description *mDescription;
    Plain *mPlain;
    Moduleinsts *mModuleinsts;
    Instances *mInstances;
    Busses *mBusses;
    Nets *mNets;
};

class Sheets
{
  public:
    Sheets();
    ~Sheets();
    void addSheet( Sheet* v );
    void setSheetList( const Sheet::List &v );
    Sheet::List *sheetList();
    /**
      Parse XML object from DOM element.
     */
    static Sheets *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    Sheet::List mSheetList;
};

class Part
{
  public:
    typedef QList<Part*> List;

    Part();
    ~Part();
    void setName( const QString &v );
    QString name() const;
    void setLibrary( const QString &v );
    QString library() const;
    void setLibraryUrn( const QString &v );
    QString libraryUrn() const;
    void setDeviceset( const QString &v );
    QString deviceset() const;
    void setDevice( const QString &v );
    QString device() const;
    void setPackage3dUrn( const QString &v );
    QString package3dUrn() const;
    void setTechnology( const QString &v );
    QString technology() const;
    void setValue( const QString &v );
    QString value() const;
    void addAttribute( Attribute* v );
    void setAttributeList( const Attribute::List &v );
    Attribute::List *attributeList();
    void addVariant( Variant* v );
    void setVariantList( const Variant::List &v );
    Variant::List *variantList();
    void setSpice( Spice *v );
    Spice *spice();
    /**
      Parse XML object from DOM element.
     */
    static Part *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    QString mName;
    QString mLibrary;
    QString mLibraryUrn;
    QString mDeviceset;
    QString mDevice;
    QString mPackage3dUrn;
    QString mTechnology;
    QString mValue;
    Attribute::List mAttributeList;
    Variant::List mVariantList;
    Spice *mSpice;
};

class Parts
{
  public:
    Parts();
    ~Parts();
    void addPart( Part* v );
    void setPartList( const Part::List &v );
    Part::List *partList();
    /**
      Parse XML object from DOM element.
     */
    static Parts *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    Part::List mPartList;
};

class Port
{
  public:
    typedef QList<Port*> List;

    enum DirectionEnum { Direction_nc, Direction_in, Direction_out, Direction_io, Direction_oc, Direction_pwr, Direction_pas, Direction_hiz, Direction_Invalid };

    Port();
    ~Port();
    void setName( const QString &v );
    QString name() const;
    void setSide( const int v );
    int side() const;
    bool sideSet() const;
    void setCoord( const double v );
    double coord() const;
    bool coordSet() const;
    void setDirection( const DirectionEnum &v );
    Port::DirectionEnum direction() const;
    static QString directionEnumToString( const DirectionEnum & v );
    /**
      Parse XML object from DOM element.
     */
    static Port *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    static Port::DirectionEnum directionEnumFromString( const QString & v, bool *ok = NULL );

    QString mName;
    int mSide;
    bool mSide_set;
    double mCoord;
    bool mCoord_set;
    DirectionEnum mDirection;
};

class Ports
{
  public:
    Ports();
    ~Ports();
    void addPort( Port* v );
    void setPortList( const Port::List &v );
    Port::List *portList();
    /**
      Parse XML object from DOM element.
     */
    static Ports *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    Port::List mPortList;
};

class Module
{
  public:
    typedef QList<Module*> List;

    Module();
    ~Module();
    void setName( const QString &v );
    QString name() const;
    void setPrefix( const QString &v );
    QString prefix() const;
    void setDx( const double v );
    double dx() const;
    bool dxSet() const;
    void setDy( const double v );
    double dy() const;
    bool dySet() const;
    void setDescription( Description *v );
    Description *description();
    void setPorts( Ports *v );
    Ports *ports();
    void setVariantdefs( Variantdefs *v );
    Variantdefs *variantdefs();
    void setParts( Parts *v );
    Parts *parts();
    void setSheets( Sheets *v );
    Sheets *sheets();
    /**
      Parse XML object from DOM element.
     */
    static Module *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    QString mName;
    QString mPrefix;
    double mDx;
    bool mDx_set;
    double mDy;
    bool mDy_set;
    Description *mDescription;
    Ports *mPorts;
    Variantdefs *mVariantdefs;
    Parts *mParts;
    Sheets *mSheets;
};

class Modules
{
  public:
    Modules();
    ~Modules();
    void addModule( Module* v );
    void setModuleList( const Module::List &v );
    Module::List *moduleList();
    /**
      Parse XML object from DOM element.
     */
    static Modules *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    Module::List mModuleList;
};

class Schematic
{
  public:
    Schematic();
    ~Schematic();
    void setXreflabel( const QString &v );
    QString xreflabel() const;
    void setXrefpart( const QString &v );
    QString xrefpart() const;
    void setDescription( Description *v );
    Description *description();
    void setLibraries( Libraries *v );
    Libraries *libraries();
    void setAttributes( Attributes *v );
    Attributes *attributes();
    void setVariantdefs( Variantdefs *v );
    Variantdefs *variantdefs();
    void setClasses( Classes *v );
    Classes *classes();
    void setModules( Modules *v );
    Modules *modules();
    void setParts( Parts *v );
    Parts *parts();
    void setSheets( Sheets *v );
    Sheets *sheets();
    void setErrors( Errors *v );
    Errors *errors();
    /**
      Parse XML object from DOM element.
     */
    static Schematic *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    QString mXreflabel;
    QString mXrefpart;
    Description *mDescription;
    Libraries *mLibraries;
    Attributes *mAttributes;
    Variantdefs *mVariantdefs;
    Classes *mClasses;
    Modules *mModules;
    Parts *mParts;
    Sheets *mSheets;
    Errors *mErrors;
};

class Drawing
{
  public:
    Drawing();
    ~Drawing();
    void setLibrary( Library *v );
    Library *library();
    void setSchematic( Schematic *v );
    Schematic *schematic();
    void setBoard( Board *v );
    Board *board();
    void setSettings( Settings *v );
    Settings *settings();
    void setGrid( Grid *v );
    Grid *grid();
    void setLayers( Layers *v );
    Layers *layers();
    /**
      Parse XML object from DOM element.
     */
    static Drawing *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    Library *mLibrary;
    Schematic *mSchematic;
    Board *mBoard;
    Settings *mSettings;
    Grid *mGrid;
    Layers *mLayers;
};

class Note
{
  public:
    typedef QList<Note*> List;

    enum SeverityEnum { Severity_info, Severity_warning, Severity_error, Severity_Invalid };

    Note();
    ~Note();
    void setVersion( const double v );
    double version() const;
    bool versionSet() const;
    void setSeverity( const SeverityEnum &v );
    Note::SeverityEnum severity() const;
    void setValue( const QString &v );
    QString value() const;
    static QString severityEnumToString( const SeverityEnum & v );
    /**
      Parse XML object from DOM element.
     */
    static Note *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    static Note::SeverityEnum severityEnumFromString( const QString & v, bool *ok = NULL );

    double mVersion;
    bool mVersion_set;
    SeverityEnum mSeverity;
    QString mValue;
};

class Compatibility
{
  public:
    Compatibility();
    ~Compatibility();
    void addNote( Note* v );
    void setNoteList( const Note::List &v );
    Note::List *noteList();
    /**
      Parse XML object from DOM element.
     */
    static Compatibility *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;

  private:
    Note::List mNoteList;
};

class Eagle
{
  public:
    Eagle();
    ~Eagle();
    void setVersion( const QString &v );
    QString version() const;
    void setCompatibility( Compatibility *v );
    Compatibility *compatibility();
    void setDrawing( Drawing *v );
    Drawing *drawing();
    /**
      Parse XML object from DOM element.
     */
    static Eagle *parseElement( const QDomElement &element, bool *ok );
    void writeElement( QXmlStreamWriter &xml ) const;
    static Eagle *parseFile( const QString &filename, bool *ok );
    static Eagle *parseString( const QString &xml, bool *ok );
    bool writeFile( const QString &filename ) const;

  private:
    QString mVersion;
    Compatibility *mCompatibility;
    Drawing *mDrawing;
};

#endif