chore: first add

bindings.h

+#ifndef BINDINGS_H
+#define BINDINGS_H
+#include "lib/core/abstractdataio.h"
+#include "lib/core/attrdefine.h"
+#include "lib/core/common.h"
+#include "lib/core/config.h"
+#include "lib/core/core.h"
+#include "lib/core/feature.h"
+#include "lib/core/font.h"
+#include "lib/core/fontcharline.h"
+#include "lib/core/job.h"
+#include "lib/core/layer.h"
+#include "lib/core/math.h"
+#include "lib/core/matrixlayer.h"
+#include "lib/core/step.h"
+#include "lib/core/steprepeat.h"
+#include "lib/core/symbol.h"
+#include "lib/core/symbolfactory.h"
+#include "lib/core/util.h"
+#include "lib/parser/odbfeatureparser.h"
+#include "lib/parser/odbmatrixparser.h"
+#include "lib/parser/parserhelper.h"
+#include "lib/widget/canvas.h"
+#include "lib/widget/popviewwindow.h"
+#endif // BINDINGS_H

bindings.xml

+<?xml version="1.0" encoding="UTF-8"?>
+
+<typesystem package="pcbcam">
+    <load-typesystem name="typesystem_core.xml" generate="no"/>
+    <load-typesystem name="typesystem_gui.xml" generate="no"/>
+    <load-typesystem name="typesystem_widgets.xml" generate="no"/>
+
+	<!--abstractdataio-->
+    <object-type name="PcbCamAbstractDataIo"/>
+
+	<!--attrdefine-->
+    <object-type name="PcbCamAttrDefine">
+		<enum-type name="DataType"/>
+		<enum-type name="EntityFlag" flags="Entity"/>
+		<enum-type name="Units"/>
+	</object-type>
+
+	<!--common-->
+    <object-type name="PcbCam">
+		<enum-type name="LayerContext" flags="LayerContexts"/>
+		<enum-type name="FeatureType" flags="FeatureTypes"/>
+		<enum-type name="Polarity" flags="Polarities"/>
+		<enum-type name="ProfileRegion" flags="ProfileRegions"/>
+		<enum-type name="Orient"/>
+		<enum-type name="SymbolType"/>
+		<enum-type name="BarcodeTextPos"/>
+		<enum-type name="FeatureSelectionOperation"/>
+		<enum-type name="FeatureSelectionMode"/>
+		<enum-type name="UnitsType"/>
+		<enum-type name="LogicOperator"/>
+		<enum-type name="SnapMode" flags="SnapModes"/>
+		<enum-type name="DisplayOption" flags="DisplayOptions"/>
+		<enum-type name="MessageType"/>
+		<object-type name="FeatureSelectionFilter"/>
+		<object-type name="AttrCompareInfo"/>
+	</object-type>
+
+
+	<!--config-->
+	<object-type name="PcbCamConfig"/>
+
+	<!--core-->
+	<object-type name="PcbCamCore"/>
+
+	<!--feature-->
+	<object-type name="PcbCamFeature"/>
+	<object-type name="PcbCamFeatureLine"/>
+	<object-type name="PcbCamFeaturePad"/>
+	<object-type name="PcbCamFeatureArc"/>
+	<object-type name="PcbCamFeatureText"/>
+	<object-type name="PcbCamFeatureBarcode"/>
+	<object-type name="PcbCamFeatureSurface"/>
+
+	<!--font-->
+	<object-type name="PcbCamFont"/>
+
+	<!--fontcharline-->
+	<object-type name="PcbCamFontCharLine">
+		<enum-type name="LineShape"/>
+	</object-type>
+
+	<!--job-->
+	<object-type name="PcbCamJob"/>
+
+	<!--layer-->
+	<object-type name="PcbCamLayer"/>
+
+	<!--math-->
+	<object-type name="PcbCamMath"/>
+
+	<!--matrixlayer-->
+	<value-type name="PcbCamMatrixLayer"/>
+
+	<!--step-->
+	<object-type name="PcbCamStep"/>
+
+	<!--steprepeat-->
+	<object-type name="PcbCamStepRepeat"/>
+
+	<!--symbol-->
+	<object-type name="PcbCamSymbol"/>
+	<object-type name="PcbCamSymbolR"/>
+	<object-type name="PcbCamSymbolS"/>
+	<object-type name="PcbCamSymbolRect"/>
+	<object-type name="PcbCamSymbolRectR"/>
+	<object-type name="PcbCamSymbolRectC"/>
+	<object-type name="PcbCamSymbolOval"/>
+	<object-type name="PcbCamSymbolDi"/>
+	<object-type name="PcbCamSymbolOct"/>
+	<object-type name="PcbCamSymbolDonutR"/>
+	<object-type name="PcbCamSymbolDonutS"/>
+	<object-type name="PcbCamSymbolHexL"/>
+	<object-type name="PcbCamSymbolHexS"/>
+	<object-type name="PcbCamSymbolBfr"/>
+	<object-type name="PcbCamSymbolBfs"/>
+	<object-type name="PcbCamSymbolTri"/>
+	<object-type name="PcbCamSymbolOvalH"/>
+	<object-type name="PcbCamSymbolThr"/>
+	<object-type name="PcbCamSymbolThs"/>
+	<object-type name="PcbCamSymbolSThs"/>
+	<object-type name="PcbCamSymbolSTho"/>
+	<object-type name="PcbCamSymbolSrThs"/>
+	<object-type name="PcbCamSymbolRcThs"/>
+	<object-type name="PcbCamSymbolRcTho"/>
+	<object-type name="PcbCamSymbolEl"/>
+	<object-type name="PcbCamSymbolMoire"/>
+	<object-type name="PcbCamSymbolUser"/>
+
+	<!--symbolfactory-->
+	<object-type name="PcbCamSymbolFactory"/>
+
+	<!--util-->
+	<rejection class="PcbCamUtil" function-name="point2segDist"/>
+	<rejection class="PcbCamUtil" function-name="point2polylineDist"/>
+	<object-type name="PcbCamUtil"/>
+
+	<!--odbfeatureparser-->
+	<object-type name="PcbCamOdbFeatureParser"/>
+
+	<!--odbmatrixparser-->
+	<object-type name="PcbCamOdbMatrixParser"/>
+
+	<!--parserhelper-->
+	<object-type name="PcbCamParserHelper"/>
+
+	<!--canvas-->
+	<object-type name="PcbCamCanvas">
+		<enum-type name="MouseMode"/>
+		<enum-type name="LayerScope" flags="LayerScopes"/>
+	</object-type>
+
+	<!--popviewwindow-->
+	<object-type name="PcbCamPopViewWindow"/>
+</typesystem>
\ No newline at end of file

lib/core/abstractdataio.h

+#ifndef TITAN_PCBCAM_ABSTRACTDATAIO_H
+#define TITAN_PCBCAM_ABSTRACTDATAIO_H
+#include "../titanpcbcamglobal.h"
+#include <QObject>
+
+TITAN_BEGIN_NAMESPACE
+
+class TITAN_PCBCAM_EXPORT PcbCamAbstractDataIo : public QObject
+{
+    Q_OBJECT
+public:
+    explicit PcbCamAbstractDataIo(QObject *parent = nullptr):QObject(parent){}
+    ~PcbCamAbstractDataIo(){}
+    virtual void clearJobDataCache(const QString &/*iJobPath*/) {}
+    virtual QVariantList getDbList() = 0;
+    virtual QVariantList getJobList(const QString &iDb = "") = 0;
+    virtual QByteArray readJobData(const QString &iJobPath, const QString &iRealtivePath, QString *oError = nullptr) = 0;
+    virtual bool writeJobData(const QString &iJobPath, const QString &iRealtivePath, const QByteArray &iData, const QString *oError = nullptr) = 0;
+};
+
+TITAN_END_NAMESPACE
+
+#endif // TITAN_PCBCAM_ABSTRACTDATAIO_H

lib/core/arcpainterinfo.cpp

+#include "arcpainterinfo.h"
+#include <QtMath>
+#include <QDebug>
+
+TITAN_BEGIN_NAMESPACE
+
+class PcbCamArcPainterInfoData : public QSharedData
+{
+public:
+    PcbCamArcPainterInfoData() { }
+    PcbCamArcPainterInfoData(const PcbCamArcPainterInfoData &other): QSharedData(other){ }
+    ~PcbCamArcPainterInfoData() { }
+
+    QRectF rect;
+    qreal startAngle {0.0};
+    qreal spanAngle {0.0};
+};
+
+PcbCamArcPainterInfo::PcbCamArcPainterInfo(qreal xs, qreal ys, qreal xe, qreal ye, qreal xc, qreal yc, bool cw) : d(new PcbCamArcPainterInfoData)
+{
+    qreal sax = xs - xc, say = ys - yc;
+    qreal eax = xe - xc, eay = ye - yc;
+
+    qreal r = qSqrt(sax * sax + say * say);
+
+    qreal sa = qAtan2(-say, sax);
+    qreal ea = qAtan2(-eay, eax);
+
+    if (cw) {
+        if (ea <= sa) {
+            ea += 2.0 * M_PI;
+        }
+    }
+    else {
+        if (sa <= ea) {
+            sa += 2.0 * M_PI;
+        }
+    }
+
+    d->rect = QRectF(xc - r, yc - r, r * 2.0, r * 2.0);
+    d->startAngle = sa * (180.0 / M_PI) *16;
+    d->spanAngle = (ea - sa) * (180.0 / M_PI) * 16;
+
+}
+
+PcbCamArcPainterInfo::PcbCamArcPainterInfo(const PcbCamArcPainterInfo &rhs) : d(rhs.d)
+{
+
+}
+
+PcbCamArcPainterInfo &PcbCamArcPainterInfo::operator=(const PcbCamArcPainterInfo &rhs)
+{
+    if (this != &rhs)
+        d.operator=(rhs.d);
+    return *this;
+}
+
+PcbCamArcPainterInfo::~PcbCamArcPainterInfo()
+{
+
+}
+
+QRectF PcbCamArcPainterInfo::rect() const
+{
+    return d->rect;
+}
+
+qreal PcbCamArcPainterInfo::startAngle() const
+{
+    return d->startAngle;
+}
+
+qreal PcbCamArcPainterInfo::spanAngle() const
+{
+    return d->spanAngle;
+}
+
+TITAN_END_NAMESPACE

lib/core/arcpainterinfo.h

+#ifndef TITAN_PCBCAM_ARCPAINTERINFO_H
+#define TITAN_PCBCAM_ARCPAINTERINFO_H
+#include "titanpcbcamglobal.h"
+#include <QSharedDataPointer>
+#include <QRectF>
+
+TITAN_BEGIN_NAMESPACE
+
+class PcbCamArcPainterInfoData;
+class TITAN_PCBCAM_EXPORT PcbCamArcPainterInfo
+{
+public:
+    PcbCamArcPainterInfo(qreal xs, qreal ys, qreal xe, qreal ye, qreal xc, qreal yc, bool cw);
+    PcbCamArcPainterInfo(const PcbCamArcPainterInfo &);
+    PcbCamArcPainterInfo &operator=(const PcbCamArcPainterInfo &);
+    ~PcbCamArcPainterInfo();
+
+    QRectF rect() const;
+    qreal startAngle() const;
+    qreal spanAngle() const;
+
+private:
+    QSharedDataPointer<PcbCamArcPainterInfoData> d;
+};
+
+TITAN_END_NAMESPACE
+
+#endif // TITAN_PCBCAM_ARCPAINTERINFO_H
+

lib/core/attrdefine.cpp

+#include "attrdefine.h"
+
+TITAN_BEGIN_NAMESPACE
+
+class PcbCamAttrDefineData : public QSharedData
+{
+public:
+    PcbCamAttrDefineData() { }
+    PcbCamAttrDefineData(const PcbCamAttrDefineData &other): QSharedData(other),
+        dataType(other.dataType),
+        name(other.name),
+        prompt(other.prompt),
+        entity(other.entity),
+        defaultValue(other.defaultValue),
+        minLength(other.minLength),
+        maxLength(other.maxLength),
+        options(other.options),
+        deleted(other.deleted),
+        units(other.units),
+        index(other.index) { }
+    ~PcbCamAttrDefineData() { }
+
+    //数据类型
+    PcbCamAttrDefine::DataType dataType {PcbCamAttrDefine::Text};
+
+    //属性名称
+    QString name;
+
+    //属性标题
+    QString prompt;
+
+    //属性适用范围
+    PcbCamAttrDefine::Entity entity {PcbCamAttrDefine::Feature};
+
+    //默认值
+    QVariant defaultValue;
+
+    //最小长度
+    uint minLength {0};
+
+    //最大长度
+    uint maxLength {100};
+
+    //选项列表
+    QStringList options;
+
+    //暂时不知道干什么用的，规范文档里描述如下:
+    //A semi colon (;) separated list of the values YES and NO.This
+    //corresponds to the list of options, possibly causing an option to be
+    //deleted (YES value)
+    QStringList deleted;
+
+    //属性单位
+    PcbCamAttrDefine::Units units {PcbCamAttrDefine::NoUnits};
+
+    //排序
+    int index {0};
+
+};
+
+PcbCamAttrDefine::PcbCamAttrDefine() : d(new PcbCamAttrDefineData)
+{
+
+}
+
+PcbCamAttrDefine::PcbCamAttrDefine(const PcbCamAttrDefine &rhs) : d(rhs.d)
+{
+
+}
+
+PcbCamAttrDefine &PcbCamAttrDefine::operator=(const PcbCamAttrDefine &rhs)
+{
+    if (this != &rhs)
+        d.operator=(rhs.d);
+    return *this;
+}
+
+PcbCamAttrDefine::~PcbCamAttrDefine()
+{
+}
+
+PcbCamAttrDefine::DataType PcbCamAttrDefine::dataType() const
+{
+    return d->dataType;
+}
+
+void PcbCamAttrDefine::setDataType(PcbCamAttrDefine::DataType iDataType)
+{
+    d->dataType = iDataType;
+}
+
+QString PcbCamAttrDefine::name() const
+{
+    return d->name;
+}
+
+void PcbCamAttrDefine::setName(const QString &iName)
+{
+    d->name = iName;
+}
+
+QString PcbCamAttrDefine::prompt() const
+{
+    return d->prompt;
+}
+
+void PcbCamAttrDefine::setPrompt(const QString &iPrompt)
+{
+    d->prompt = iPrompt;
+}
+
+PcbCamAttrDefine::Entity PcbCamAttrDefine::entity() const
+{
+    return d->entity;
+}
+
+void PcbCamAttrDefine::setEntity(PcbCamAttrDefine::Entity iEntity)
+{
+    d->entity = iEntity;
+}
+
+QVariant PcbCamAttrDefine::defaultValue() const
+{
+    return d->defaultValue;
+}
+
+void PcbCamAttrDefine::setDefaultValue(const QVariant &iValue)
+{
+    d->defaultValue = iValue;
+}
+
+uint PcbCamAttrDefine::minLength() const
+{
+    return d->minLength;
+}
+
+void PcbCamAttrDefine::setMinLength(uint iLen)
+{
+    d->minLength = iLen;
+}
+
+uint PcbCamAttrDefine::maxLength() const
+{
+    return d->maxLength;
+}
+
+void PcbCamAttrDefine::setMaxLength(uint iLen)
+{
+    d->maxLength = iLen;
+}
+
+QStringList PcbCamAttrDefine::options() const
+{
+    return d->options;
+}
+
+void PcbCamAttrDefine::setOptions(const QStringList &iOptions)
+{
+    d->options = iOptions;
+}
+
+QStringList PcbCamAttrDefine::deleted() const
+{
+    return d->deleted;
+}
+
+void PcbCamAttrDefine::setDeleted(const QStringList &iList)
+{
+    d->deleted = iList;
+}
+
+PcbCamAttrDefine::Units PcbCamAttrDefine::units() const
+{
+    return d->units;
+}
+
+void PcbCamAttrDefine::setUnits(PcbCamAttrDefine::Units iUnits)
+{
+    d->units = iUnits;
+}
+
+int PcbCamAttrDefine::index() const
+{
+    return d->index;
+}
+
+void PcbCamAttrDefine::setIndex(int iIndex)
+{
+    d->index = iIndex;
+}
+
+PcbCamAttrDefine::DataType PcbCamAttrDefine::dataTypeFromString(const QString &iStr)
+{
+    QString str = iStr.toUpper();
+    if (str == "BOOLEAN") {
+        return PcbCamAttrDefine::Boolean;
+    }
+    else if (str == "OPTION") {
+        return PcbCamAttrDefine::Option;
+    }
+    else if (str == "INTEGER") {
+        return PcbCamAttrDefine::Integer;
+    }
+    else if (str == "FLOAT") {
+        return PcbCamAttrDefine::Float;
+    }
+    return PcbCamAttrDefine::Text;
+}
+
+PcbCamAttrDefine::Entity PcbCamAttrDefine::entityFromString(const QString &iStr)
+{
+    QStringList list = iStr.trimmed().toUpper().split(";", Qt::SkipEmptyParts);
+
+    PcbCamAttrDefine::Entity entity;
+    for (const QString &item : list) {
+        if (item == "JOB"){
+            entity |= PcbCamAttrDefine::Job;
+        }
+        else if (item == "STEP"){
+            entity |= PcbCamAttrDefine::Step;
+        }
+        else if (item == "SYMBOL"){
+            entity |= PcbCamAttrDefine::Symbol;
+        }
+        else if (item == "LAYER"){
+            entity |= PcbCamAttrDefine::Layer;
+        }
+        else if (item == "STACKUP"){
+            entity |= PcbCamAttrDefine::Stackup;
+        }
+        else if (item == "WHEEL"){
+            entity |= PcbCamAttrDefine::Wheel;
+        }
+        else if (item == "FEATURE"){
+            entity |= PcbCamAttrDefine::Feature;
+        }
+        else if (item == "COMPONENT"){
+            entity |= PcbCamAttrDefine::Component;
+        }
+        else if (item == "ALL") {
+            entity = PcbCamAttrDefine::All;
+        }
+    }
+
+    return entity;
+}
+
+TITAN_END_NAMESPACE

lib/core/attrdefine.h

+#ifndef TITAN_PCBCAM_ATTRDEFINE_H
+#define TITAN_PCBCAM_ATTRDEFINE_H
+#include "../titanpcbcamglobal.h"
+#include <QSharedDataPointer>
+#include <QStringList>
+#include <QVariant>
+
+TITAN_BEGIN_NAMESPACE
+
+class PcbCamAttrDefineData;
+class TITAN_PCBCAM_EXPORT PcbCamAttrDefine
+{
+public:
+    enum DataType {
+        Boolean,
+        Text,
+        Option,
+        Integer,
+        Float
+    };
+
+    enum EntityFlag {
+        Job = 0x0001,
+        Step = 0x0002,
+        Symbol = 0x0004,
+        Layer = 0x0008,
+        Stackup = 0x0010,
+        Wheel = 0x0020,
+        Feature = 0x0040,
+        Component = 0x0080,
+        All = Job | Step | Symbol | Layer | Stackup | Wheel | Feature | Component
+    };
+    Q_DECLARE_FLAGS(Entity, EntityFlag)
+
+    enum Units {
+        NoUnits,
+        InchMm,
+        MilMicrons
+    };
+
+
+    PcbCamAttrDefine();
+    PcbCamAttrDefine(const PcbCamAttrDefine &);
+    PcbCamAttrDefine &operator=(const PcbCamAttrDefine &);
+    ~PcbCamAttrDefine();
+
+    PcbCamAttrDefine::DataType dataType() const;
+    void setDataType(DataType iDataType);
+
+    QString name() const;
+    void setName(const QString &iName);
+
+    QString prompt() const;
+    void setPrompt(const QString &iPrompt);
+
+    PcbCamAttrDefine::Entity entity() const;
+    void setEntity(Entity iEntity);
+
+    QVariant defaultValue() const;
+    void setDefaultValue(const QVariant &iValue);
+
+    uint minLength() const;
+    void setMinLength(uint iLen);
+
+    uint maxLength() const;
+    void setMaxLength(uint iLen);
+
+    QStringList options() const;
+    void setOptions(const QStringList &iOptions);
+
+    QStringList deleted() const;
+    void setDeleted(const QStringList &iList);
+
+    Units units() const;
+    void setUnits(Units iUnits);
+
+    int index() const;
+    void setIndex(int iIndex);
+
+    static PcbCamAttrDefine::DataType dataTypeFromString(const QString &iStr);
+    static PcbCamAttrDefine::Entity entityFromString(const QString &iStr);
+
+private:
+    QSharedDataPointer<PcbCamAttrDefineData> d;
+};
+
+TITAN_END_NAMESPACE
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(titan::PcbCamAttrDefine::Entity)
+
+#endif // TITAN_PCBCAM_ATTRDEFINE_H
+

lib/core/common.h

+#ifndef TITAN_PCBCAM_COMMON_H
+#define TITAN_PCBCAM_COMMON_H
+#include "../titanpcbcamglobal.h"
+#include <Qt>
+#include <QString>
+#include <QRegularExpression>
+
+TITAN_BEGIN_NAMESPACE
+
+class TITAN_PCBCAM_EXPORT PcbCam : public QObject
+{
+    Q_OBJECT
+public:
+    enum LayerContext {
+        BoardContext = 0x01,
+        MiscContext = 0x02,
+        AllContext = BoardContext|MiscContext,
+    };
+    Q_ENUM(LayerContext)
+    Q_DECLARE_FLAGS(LayerContexts, LayerContext)
+    Q_FLAGS(LayerContexts)
+
+    enum FeatureType {
+        LineFeature = 0x0001,
+        PadFeature = 0x0002,
+        ArcFeature = 0x0004,
+        TextFeature = 0x0008,
+        BarcodeFeature = 0x0010,
+        SurfaceFeature = 0x0200,
+        PathFeature = 0x0400, // profile and package
+        ComponentFeature = 0x0800, // component
+        AllFeatures = LineFeature|PadFeature|ArcFeature|TextFeature|BarcodeFeature|SurfaceFeature|PathFeature|ComponentFeature,
+    };
+
+    Q_ENUM(FeatureType)
+    Q_DECLARE_FLAGS(FeatureTypes, FeatureType)
+    Q_FLAGS(FeatureTypes)
+
+    enum Polarity {
+        Positive = 0x01,
+        Negative = 0x02,
+        BothPolarity = Positive|Negative,
+    };
+    Q_ENUM(Polarity)
+    Q_DECLARE_FLAGS(Polarities, Polarity)
+    Q_FLAGS(Polarities)
+
+    enum ProfileRegion {
+        InProfile = 0x01,
+        OutProfile = 0x02,
+        AllProfile = InProfile|OutProfile,
+    };
+    Q_ENUM(ProfileRegion)
+    Q_DECLARE_FLAGS(ProfileRegions, ProfileRegion)
+    Q_FLAGS(Polarities)
+
+    enum Orient {
+        Orient_N_0 = 0,
+        Orient_N_90 = 1,
+        Orient_N_180 = 2,
+        Orient_N_270 = 3,
+        Orient_Y_0 = 4,
+        Orient_Y_90 = 5,
+        Orient_Y_180 = 6,
+        Orient_Y_270 = 7
+    };
+
+    enum SymbolType {
+        Sym_R,
+        Sym_S,
+        Sym_Rect,
+        Sym_RectR,
+        Sym_RectC,
+        Sym_Oval,
+        Sym_Di,
+        Sym_Oct,
+        Sym_DonutR,
+        Sym_DonutS,
+        Sym_HexL,
+        Sym_HexS,
+        Sym_Bfr,
+        Sym_Bfs,
+        Sym_Tri,
+        Sym_OvalH,
+        Sym_Thr,
+        Sym_Ths,
+        Sym_SThs,
+        Sym_STho,
+        Sym_SrThs,
+        Sym_RcThs,
+        Sym_RcTho,
+        Sym_El,
+        Sym_Moire,
+        Sym_Hole,
+        Sym_User = 1000,
+    };
+
+    enum BarcodeTextPos {
+        BarcodeTextPos_Top,
+        BarcodeTextPos_Bot,
+    };
+
+    enum FeatureSelectionOperation {
+        NoFeatureSelection,
+        ReplaceFeatureSelection,
+        AppendFeatureSelection,
+        RemoveFeatureSelection,
+    };
+
+    enum FeatureSelectionMode {
+        ContainsFeatureShape,
+        IntersectsFeatureShape,
+    };
+
+    enum UnitsType {
+        Units_Unknow,
+        Units_Inch,
+        Units_Mm
+    };
+
+    enum ZerosOmit
+    {
+        ZerosOmit_Unknow,
+        ZerosOmit_None,
+        ZerosOmit_Leading,
+        ZerosOmit_Training,
+        ZerosOmit_Decimal,
+    };
+
+    enum CoordNotation
+    {
+        CoordUnknow,
+        CoordAbsoulte,
+        CoordIncremental,
+    };
+
+    enum LogicOperator {
+        Logic_And,
+        Logic_Or,
+    };
+
+    enum SnapMode {
+        SnapOff = 0x0000,
+        SnapCenter = 0x0001,
+        SnapSkeleton = 0x0002,
+        SnapEdge = 0x0004,
+        SnapIntersect = 0x0008,
+        SnapMidPoint = 0x0010,
+        SnapProfile = 0x0020,
+        SnapBetween = 0x0040,
+        AllSnapMode = SnapCenter|SnapSkeleton|SnapEdge|SnapIntersect|SnapMidPoint|SnapProfile|SnapBetween,
+    };
+    Q_ENUM(SnapMode)
+    Q_DECLARE_FLAGS(SnapModes, SnapMode)
+    Q_FLAGS(SnapModes)
+
+    enum DisplayOption {
+        DisplayFill = 0x0001,
+        DisplayOutline = 0x0002,
+        DisplaySketeon = 0x0004,
+        DisplayNegative = 0x0008,
+        DisplayMultiLayer = 0x0010,
+        DisplayStepRepeat = 0x0020,
+        DisplayTextValue = 0x0040,
+        DisplayProfile = 0x0080,
+        DisplayDatumn = 0x0100,
+        DisplayFullCursor = 0x0200,
+    };
+    Q_ENUM(DisplayOption)
+    Q_DECLARE_FLAGS(DisplayOptions, DisplayOption)
+    Q_FLAGS(DisplayOptions)
+
+    enum MessageType {
+        Message_Error,
+        Message_Warn,
+        Message_Info,
+        Message_Ok,
+    };
+
+    struct FeatureSelectionFilter {
+        FeatureTypes type {FeatureType::AllFeatures};
+        Polarities polarity {Polarity::BothPolarity};
+        ProfileRegions profile {ProfileRegion::AllProfile};
+        QStringList includeSymbols;
+        QStringList excludeSymbols;
+        QStringList includeAttributes;
+        QStringList excludeAttributes;
+        LogicOperator includeAttributesLogic {LogicOperator::Logic_And};
+        LogicOperator excludeAttributesLogic {LogicOperator::Logic_And};
+        bool isEmpty() const {
+            return ((type == FeatureType::AllFeatures)
+                    && (polarity == Polarity::BothPolarity)
+                    && (profile == ProfileRegion::AllProfile)
+                    && (includeSymbols.isEmpty())
+                    && (excludeSymbols.isEmpty())
+                    && (includeAttributes.isEmpty())
+                    && (excludeAttributes.isEmpty()));
+        }
+    };
+
+    struct AttrCompareInfo {
+        ushort type {0}; //比较类型(0:是否有此属性; 1:属性值是否相等; 2:数值是否在范围)
+        QString name;
+        QString strValue;
+        double minValue = INTMAX_MIN;
+        double maxValue = INTMAX_MAX;
+        AttrCompareInfo() {}
+        AttrCompareInfo(const QString &iAttrStr) {
+            auto idx = iAttrStr.indexOf("=");
+            if (idx != -1) {
+                this->type = 1;
+                this->name = iAttrStr.left(idx).trimmed();
+                this->strValue = iAttrStr.mid(idx+1).trimmed();
+                auto vidx = this->strValue.indexOf('~');
+                if (vidx != -1) {
+                    this->type = 2;
+                    auto minstr = this->strValue.left(vidx).trimmed();
+                    auto maxstr = this->strValue.mid(vidx+1).trimmed();
+                    if (!minstr.isEmpty()) {
+                        this->minValue = minstr.toDouble();
+                    }
+                    if (!maxstr.isEmpty()) {
+                        this->maxValue = maxstr.toDouble();
+                    }
+                }
+            }
+            else {
+                this->name = iAttrStr.trimmed();
+            }
+        }
+    };
+};
+
+TITAN_END_NAMESPACE
+
+#endif //TITAN_PCBCAM_COMMON_H
+

lib/core/config.cpp

+#include "config.h"
+
+
+TITAN_BEGIN_NAMESPACE
+
+class PcbCamConfigData : public QSharedData
+{
+public:
+    PcbCamConfigData() { }
+    PcbCamConfigData(const PcbCamConfigData &other): QSharedData(other),
+        gzipCmd(other.gzipCmd),
+        tarCmd(other.tarCmd){ }
+
+    ~PcbCamConfigData() { }
+
+    QString gzipCmd {"gzip"};
+    QString tarCmd {"tar"};
+
+};
+
+PcbCamConfig::PcbCamConfig() : d(new PcbCamConfigData)
+{
+
+}
+
+PcbCamConfig::PcbCamConfig(const PcbCamConfig &rhs) : d(rhs.d)
+{
+
+}
+
+PcbCamConfig &PcbCamConfig::operator=(const PcbCamConfig &rhs)
+{
+    if (this != &rhs)
+        d.operator=(rhs.d);
+    return *this;
+}
+
+PcbCamConfig::~PcbCamConfig()
+{
+
+}
+
+QString PcbCamConfig::gzipCmd() const
+{
+    return d->gzipCmd;
+}
+
+void PcbCamConfig::setGzipCmd(const QString &iCmd)
+{
+    d->gzipCmd = iCmd;
+}
+
+QString PcbCamConfig::tarCmd() const
+{
+    return d->tarCmd;
+}
+
+void PcbCamConfig::setTarCmd(const QString &iCmd)
+{
+    d->tarCmd = iCmd;
+}
+
+TITAN_END_NAMESPACE

lib/core/config.h

+#ifndef TITAN_PCBCAM_CONFIG_H
+#define TITAN_PCBCAM_CONFIG_H
+#include "../titanpcbcamglobal.h"
+#include <QSharedDataPointer>
+
+TITAN_BEGIN_NAMESPACE
+
+class PcbCamConfigData;
+class TITAN_PCBCAM_EXPORT PcbCamConfig
+{
+public:
+    PcbCamConfig();
+    PcbCamConfig(const PcbCamConfig &);
+    PcbCamConfig &operator=(const PcbCamConfig &);
+    ~PcbCamConfig();
+
+    QString gzipCmd() const;
+    void setGzipCmd(const QString &iCmd);
+
+    QString tarCmd() const;
+    void setTarCmd(const QString &iCmd);
+
+
+private:
+    QSharedDataPointer<PcbCamConfigData> d;
+};
+
+TITAN_END_NAMESPACE
+
+#endif // TITAN_PCBCAM_CONFIG_H

lib/core/core.cpp

+#include "core.h"
+#include <QFile>
+#include <QDir>
+
+TITAN_BEGIN_NAMESPACE
+
+
+class PcbCamCorePrivate
+{
+    Q_DECLARE_PUBLIC(PcbCamCore)
+public:
+    explicit PcbCamCorePrivate(PcbCamCore *qptr):q_ptr(qptr){}
+    ~PcbCamCorePrivate(){}
+
+    PcbCamConfig config;
+    PcbCamAbstractDataIo *dataIo {nullptr};
+
+protected:
+    PcbCamCore * const q_ptr;
+};
+
+
+PcbCamCore *PcbCamCore::instance()
+{
+    static PcbCamCore gInstance;
+    return &gInstance;
+}
+
+void PcbCamCore::setConfig(const PcbCamConfig &iConf)
+{
+    Q_D(PcbCamCore);
+    d->config = iConf;
+}
+
+PcbCamConfig &PcbCamCore::config()
+{
+    Q_D(PcbCamCore);
+    return d->config;
+}
+
+void PcbCamCore::setDataIo(PcbCamAbstractDataIo *iDataIo)
+{
+    Q_D(PcbCamCore);
+    d->dataIo = iDataIo;
+}
+
+PcbCamAbstractDataIo *PcbCamCore::dataIo()
+{
+    Q_D(PcbCamCore);
+    return d->dataIo;
+}
+
+void PcbCamCore::notifyMessage(const QString &iMessage, const QString &iType, const QString &iCategory, const QVariant &iUserData)
+{
+    emit messageNotified(iMessage, iType, iCategory, iUserData);
+}
+
+PcbCamCore::PcbCamCore() : QObject(nullptr),
+    d_ptr(new PcbCamCorePrivate(this))
+{
+
+}
+
+PcbCamCore::~PcbCamCore()
+{
+
+}
+
+TITAN_END_NAMESPACE

lib/core/core.h

+#ifndef TITAN_PCBCAM_CORE_H
+#define TITAN_PCBCAM_CORE_H
+#include "../titanpcbcamglobal.h"
+#include <QObject>
+#include <QVariant>
+#include <QString>
+#include "./abstractdataio.h"
+#include "./config.h"
+
+TITAN_BEGIN_NAMESPACE
+
+class PcbCamCorePrivate;
+class TITAN_PCBCAM_EXPORT PcbCamCore : public QObject
+{
+    Q_OBJECT
+public:
+    static PcbCamCore *instance();
+    void setConfig(const PcbCamConfig &iConf);
+    PcbCamConfig &config();
+
+    void setDataIo(PcbCamAbstractDataIo *iDataIo);
+    PcbCamAbstractDataIo *dataIo();
+
+
+signals:
+    void messageNotified(const QString &iMessage, const QString &iType, const QString &iCategory, const QVariant &iUserData) const;
+
+public slots:
+    void notifyMessage(const QString &iMessage, const QString &iType = "INFO", const QString &iCategory = "", const QVariant &iUserData = QVariant());
+
+private:
+    PcbCamCore();
+    ~PcbCamCore();
+
+protected:
+    const QScopedPointer<PcbCamCorePrivate> d_ptr;
+
+private:
+    Q_DECLARE_PRIVATE(PcbCamCore)
+    Q_DISABLE_COPY(PcbCamCore)
+
+};
+
+
+TITAN_END_NAMESPACE
+
+#endif // TITAN_PCBCAM_CORE_H

lib/core/feature.h

+#ifndef TITAN_PCBCAM_FEATURE_H
+#define TITAN_PCBCAM_FEATURE_H
+#include "../titanpcbcamglobal.h"
+#include <QPointF>
+#include <QVariantMap>
+#include <QSizeF>
+#include <QPainterPath>
+#include <QLineF>
+#include "./common.h"
+#include "./font.h"
+
+TITAN_BEGIN_NAMESPACE
+
+class PcbCamSymbol;
+
+class PcbCamFeaturePrivate;
+class TITAN_PCBCAM_EXPORT PcbCamFeature
+{
+public:
+    PcbCamFeature();
+    virtual ~PcbCamFeature();
+
+    PcbCam::FeatureType type() const;
+
+    PcbCam::Polarity polarity() const;
+    void setPolarity(PcbCam::Polarity iPolarity);
+
+    int index() const;
+    void setIndex(int iIndex);
+
+    int dcode() const;
+    void setDcode(int iDcode);
+
+    void setSymbol(PcbCamSymbol *iSymbol);
+    PcbCamSymbol *symbol() const;
+
+    QVariantMap attr() const;
+    QVariant attr(const QString &iName) const;
+    bool hasAttr(const QString &iName) const;
+    void setAttr(const QString &iName, const QVariant &iValue);
+    void setAttr(const QVariantMap &iAttrMap);
+    void removeAttr(const QString &iName);
+    void clearAttr();
+
+    void setSelected(bool iSel = true);
+    bool isSelected() const;
+
+    virtual QPainterPath shape() const = 0;
+    virtual QRectF boundingRect() const = 0;
+
+protected:
+    PcbCamFeature(PcbCamFeaturePrivate &dd);
+    const QScopedPointer<PcbCamFeaturePrivate> d_ptr;
+
+private:
+    Q_DECLARE_PRIVATE(PcbCamFeature)
+    Q_DISABLE_COPY(PcbCamFeature)
+};
+
+class PcbCamFeatureLinePrivate;
+class TITAN_PCBCAM_EXPORT PcbCamFeatureLine : public PcbCamFeature
+{
+public:
+    PcbCamFeatureLine();
+    ~PcbCamFeatureLine();
+
+    void setLine(const QLineF &iLine);
+    QLineF line() const;
+
+    QPainterPath shape() const;
+    QRectF boundingRect() const;
+
+private:
+    Q_DECLARE_PRIVATE(PcbCamFeatureLine)
+    Q_DISABLE_COPY(PcbCamFeatureLine)
+};
+
+class PcbCamFeaturePadPrivate;
+class TITAN_PCBCAM_EXPORT PcbCamFeaturePad : public PcbCamFeature
+{
+public:
+    PcbCamFeaturePad();
+    ~PcbCamFeaturePad();
+
+    QPointF pos() const;
+    void setPos(const QPointF &iPos);
+
+    PcbCam::Orient orient() const;
+    void setOrient(PcbCam::Orient iOrient);
+
+    QPainterPath shape() const;
+    QRectF boundingRect() const;
+
+private:
+    Q_DECLARE_PRIVATE(PcbCamFeaturePad)
+    Q_DISABLE_COPY(PcbCamFeaturePad)
+};
+
+class PcbCamFeatureArcPrivate;
+class TITAN_PCBCAM_EXPORT PcbCamFeatureArc : public PcbCamFeature
+{
+public:
+    PcbCamFeatureArc();
+    ~PcbCamFeatureArc();
+
+    void setData(const QPointF &iPs, const QPointF &iPe, const QPointF &iPc, bool iCw);
+    QPointF ps() const;
+    QPointF pe() const;
+    QPointF pc() const;
+    bool cw() const;
+
+    QPainterPath shape() const;
+    QRectF boundingRect() const;
+
+private:
+    Q_DECLARE_PRIVATE(PcbCamFeatureArc)
+    Q_DISABLE_COPY(PcbCamFeatureArc)
+};
+
+class PcbCamFeatureTextPrivate;
+class TITAN_PCBCAM_EXPORT PcbCamFeatureText : public PcbCamFeature
+{
+public:
+    PcbCamFeatureText();
+    ~PcbCamFeatureText();
+
+    void setData(const QPointF &iPos,
+                 PcbCamFont *iFont,
+                 PcbCam::Orient iOrient,
+                 const QSizeF &iSize,
+                 qreal iWithFactor,
+                 const QString &iText,
+                 int iVersion = 1);
+
+    QPointF pos() const;
+    PcbCamFont *font() const;
+    PcbCam::Orient orient() const;
+    QSizeF size() const;
+    qreal widthFactor() const;
+    QString text() const;
+    int version() const;
+    QString dynamicText() const;
+    void setDynamicText(const QString &iText);
+
+    QList<PcbCamFeature *> features() const;
+
+    QPainterPath shape() const;
+    QRectF boundingRect() const;
+
+
+private:
+    Q_DECLARE_PRIVATE(PcbCamFeatureText)
+    Q_DISABLE_COPY(PcbCamFeatureText)
+};
+
+class PcbCamFeatureBarcodePrivate;
+class TITAN_PCBCAM_EXPORT PcbCamFeatureBarcode : public PcbCamFeature
+{
+public:
+    PcbCamFeatureBarcode();
+    ~PcbCamFeatureBarcode();
+
+    QPointF pos() const;
+    void setPos(const QPointF &iPos);
+
+    QString barcode() const;
+    void setBarcode(const QString &iBarcode);
+
+    QString font() const;
+    void setFont(const QString &iFont);
+
+    PcbCam::Orient orient() const;
+    void setOrient(PcbCam::Orient iOrient);
+
+    QSizeF size() const;
+    void setSize(const QSizeF &iSize);
+
+    bool fullAscii() const;
+    void setFullAscii(bool iBol);
+
+    bool checkSum() const;
+    void setCheckSum(bool iBol);
+
+    bool background() const;
+    void setBackground(bool iBol);
+
+    bool additionStr() const;
+    void setAdditionStr(bool iBol);
+
+    PcbCam::BarcodeTextPos additiontStrPos() const;
+    void setAdditionStrPos(PcbCam::BarcodeTextPos iTorB);
+
+    QString text() const;
+    void setText(const QString &iText);
+
+    QPainterPath shape() const;
+    QRectF boundingRect() const;
+
+private:
+    Q_DECLARE_PRIVATE(PcbCamFeatureBarcode)
+    Q_DISABLE_COPY(PcbCamFeatureBarcode)
+};
+
+class PcbCamFeatureSurfacePrivate;
+class TITAN_PCBCAM_EXPORT PcbCamFeatureSurface : public PcbCamFeature
+{
+public:
+    PcbCamFeatureSurface();
+    ~PcbCamFeatureSurface();
+
+    QPainterPath path() const;
+    void setPath(const QPainterPath &iPath);
+
+    QPainterPath shape() const;
+    QRectF boundingRect() const;
+
+private:
+    Q_DECLARE_PRIVATE(PcbCamFeatureSurface)
+    Q_DISABLE_COPY(PcbCamFeatureSurface)
+};
+
+class PcbCamFeaturePathPrivate;
+class TITAN_PCBCAM_EXPORT PcbCamFeaturePath : public PcbCamFeature
+{
+public:
+    PcbCamFeaturePath();
+    ~PcbCamFeaturePath();
+
+    QPainterPath path() const;
+    void setPath(const QPainterPath &iPath);
+
+    int width() const;
+    void setWidth(int iWidth);
+
+    QPainterPath shape() const;
+    QRectF boundingRect() const;
+
+private:
+    Q_DECLARE_PRIVATE(PcbCamFeaturePath)
+    Q_DISABLE_COPY(PcbCamFeaturePath)
+};
+
+
+class PcbCamFeatureComponentPrivate;
+class TITAN_PCBCAM_EXPORT PcbCamFeatureComponent : public PcbCamFeature
+{
+public:
+    PcbCamFeatureComponent();
+    ~PcbCamFeatureComponent();
+
+    void setData(const QPointF &iPos,
+                 double iRotation,
+                 bool iMirror,
+                 const QString &iCompName,
+                 const QString &iPartName);
+
+    QPointF pos() const;
+    double rotation() const;
+    bool mirror() const;
+    QString compName() const;
+    QString partName() const;
+
+    QPainterPath shape() const;
+    QRectF boundingRect() const;
+
+
+private:
+    Q_DECLARE_PRIVATE(PcbCamFeatureComponent)
+    Q_DISABLE_COPY(PcbCamFeatureComponent)
+};
+
+TITAN_END_NAMESPACE
+
+#endif // TITAN_PCBCAM_FEATURE_H

lib/core/font.cpp

+#include "font.h"
+
+TITAN_BEGIN_NAMESPACE
+
+class PcbCamFontData : public QSharedData
+{
+public:
+    PcbCamFontData() { }
+    PcbCamFontData(const PcbCamFontData &other): QSharedData(other),
+        name(other.name),
+        sizeX(other.sizeX),
+        sizeY(other.sizeY),
+        offset(other.offset),
+        charLinesMap(other.charLinesMap){ }
+    ~PcbCamFontData() { }
+
+    QString name {"standard"};
+    double sizeX {0.0};
+    double sizeY {0.0};
+    double offset {0.0};
+    QMap<QChar, QList<PcbCamFontCharLine> > charLinesMap;
+
+};
+
+PcbCamFont::PcbCamFont() : d(new PcbCamFontData)
+{
+
+}
+
+PcbCamFont::PcbCamFont(const PcbCamFont &rhs) : d (rhs.d)
+{
+
+}
+
+PcbCamFont &PcbCamFont::operator=(const PcbCamFont &rhs)
+{
+    if (this != &rhs)
+        d.operator=(rhs.d);
+    return *this;
+}
+
+PcbCamFont::~PcbCamFont()
+{
+
+}
+
+void PcbCamFont::setName(const QString &iName)
+{
+    d->name = iName;
+}
+
+QString PcbCamFont::name() const
+{
+    return d->name;
+}
+
+void PcbCamFont::setSizeX(double iSizeX)
+{
+    d->sizeX = iSizeX;
+}
+
+void PcbCamFont::setSizeY(double iSizeY)
+{
+    d->sizeY = iSizeY;
+}
+
+double PcbCamFont::sizeX() const
+{
+    return d->sizeX;
+}
+
+double PcbCamFont::sizeY()
+{
+    return d->sizeY;
+}
+
+
+void PcbCamFont::setOffset(double iOffset)
+{
+    d->offset = iOffset;
+}
+
+double PcbCamFont::offset() const
+{
+    return d->offset;
+}
+
+QList<PcbCamFontCharLine> PcbCamFont::charLines(QChar iChar) const
+{
+    return d->charLinesMap.value(iChar);
+}
+
+void PcbCamFont::setCharLines(QChar iChar, const QList<PcbCamFontCharLine> &iLines)
+{
+    d->charLinesMap.insert(iChar, iLines);
+}
+
+TITAN_END_NAMESPACE

lib/core/font.h

+#ifndef TITAN_PCBCAM_FONT_H
+#define TITAN_PCBCAM_FONT_H
+#include "../titanpcbcamglobal.h"
+#include <QSharedDataPointer>
+#include "./common.h"
+#include "./fontcharline.h"
+
+TITAN_BEGIN_NAMESPACE
+
+class PcbCamFontData;
+class TITAN_PCBCAM_EXPORT PcbCamFont
+{
+public:
+    PcbCamFont();
+    PcbCamFont(const PcbCamFont &);
+    PcbCamFont &operator=(const PcbCamFont &);
+    ~PcbCamFont();
+
+
+    void setName(const QString &iName);
+    QString name() const;
+
+    void setSizeX(double iSizeX);
+    void setSizeY(double iSizeY);
+    double sizeX() const;
+    double sizeY();
+
+    void setOffset(double iOffset);
+    double offset() const;
+
+    QList<PcbCamFontCharLine> charLines(QChar iChar) const;
+    void setCharLines(QChar iChar, const QList<PcbCamFontCharLine> &iLines);
+
+
+private:
+    QSharedDataPointer<PcbCamFontData> d;
+};
+
+TITAN_END_NAMESPACE
+
+#endif // TITAN_PCBCAM_FONT_H

lib/core/fontcharline.cpp

+#include "fontcharline.h"
+
+TITAN_BEGIN_NAMESPACE
+
+class PcbCamFontCharLineData : public QSharedData
+{
+public:
+    PcbCamFontCharLineData() { }
+    PcbCamFontCharLineData(const PcbCamFontCharLineData &other): QSharedData(other),
+        line(other.line),
+        polarity(other.polarity),
+        shape(other.shape),
+        width(other.width) { }
+    ~PcbCamFontCharLineData() { }
+
+    QLineF line;
+    PcbCam::Polarity polarity {PcbCam::Positive};
+    PcbCamFontCharLine::LineShape shape {PcbCamFontCharLine::LineShape_R};
+    double width {0.0};
+
+};
+
+
+PcbCamFontCharLine::PcbCamFontCharLine() : d(new PcbCamFontCharLineData)
+{
+
+}
+
+PcbCamFontCharLine::PcbCamFontCharLine(const PcbCamFontCharLine &rhs) : d(rhs.d)
+{
+
+}
+
+PcbCamFontCharLine &PcbCamFontCharLine::operator=(const PcbCamFontCharLine &rhs)
+{
+    if (this != &rhs)
+        d.operator=(rhs.d);
+    return *this;
+}
+
+PcbCamFontCharLine::~PcbCamFontCharLine()
+{
+
+}
+
+QLineF PcbCamFontCharLine::line() const
+{
+    return d->line;
+}
+
+void PcbCamFontCharLine::setLine(const QLineF &iLine)
+{
+    d->line = iLine;
+}
+
+PcbCam::Polarity PcbCamFontCharLine::polarity() const
+{
+    return d->polarity;
+}
+
+void PcbCamFontCharLine::setPolarity(PcbCam::Polarity iPolarity)
+{
+    d->polarity = iPolarity;
+}
+
+PcbCamFontCharLine::LineShape PcbCamFontCharLine::shape() const
+{
+    return d->shape;
+}
+
+void PcbCamFontCharLine::setShape(LineShape iShape)
+{
+    d->shape = iShape;
+}
+
+double PcbCamFontCharLine::width() const
+{
+    return d->width;
+}
+
+void PcbCamFontCharLine::setWidth(double iWidth)
+{
+    d->width = iWidth;
+}
+
+TITAN_END_NAMESPACE

lib/core/fontcharline.h

+#ifndef TITAN_PCBCAM_FONTCHARLINE_H
+#define TITAN_PCBCAM_FONTCHARLINE_H
+#include "../titanpcbcamglobal.h"
+#include <QSharedDataPointer>
+#include <QLineF>
+#include "./common.h"
+
+TITAN_BEGIN_NAMESPACE
+
+class PcbCamFontCharLineData;
+class TITAN_PCBCAM_EXPORT PcbCamFontCharLine {
+public:
+    enum LineShape {
+        LineShape_R,
+        LineShape_S
+    };
+
+    PcbCamFontCharLine();
+    PcbCamFontCharLine(const PcbCamFontCharLine &);
+    PcbCamFontCharLine &operator=(const PcbCamFontCharLine &);
+    ~PcbCamFontCharLine();
+
+    QLineF line() const;
+    void setLine(const QLineF &iLine);
+
+    PcbCam::Polarity polarity() const;
+    void setPolarity(PcbCam::Polarity iPolarity);
+
+    LineShape shape() const;
+    void setShape(LineShape iShape);
+
+    double width() const;
+    void setWidth(double iWidth);
+
+private:
+    QSharedDataPointer<PcbCamFontCharLineData> d;
+};
+
+TITAN_END_NAMESPACE
+
+#endif // TITAN_PCBCAM_FONTCHARLINE_H

lib/core/job.h

+#ifndef TITAN_PCBCAM_JOB_H
+#define TITAN_PCBCAM_JOB_H
+#include "../titanpcbcamglobal.h"
+#include <QObject>
+#include <QDateTime>
+#include <QVariant>
+#include <QVariantMap>
+#include "./attrdefine.h"
+#include "./step.h"
+#include "./layer.h"
+#include "./matrixlayer.h"
+#include "./symbol.h"
+#include "../parser/odbfeatureparser.h"
+
+TITAN_BEGIN_NAMESPACE
+
+class PcbCamJobPrivate;
+class TITAN_PCBCAM_EXPORT PcbCamJob : public QObject
+{
+    Q_OBJECT
+public:
+    explicit PcbCamJob(QObject *parent = 0);
+    ~PcbCamJob();
+
+signals:
+    void messageNotified(const QString &iMessage, const QString &iType, const QVariant &iUserData) const;
+    void actionNotified(const QString &iActionName, const QVariantMap &iUserData) const;
+
+public slots:
+    QString jobname() const;
+    void setJobname(const QString &iJobname);
+
+    uint odbVersionMajor() const;
+    void setOdbVersionMajor(uint iVersion);
+
+    uint odbVersionMinor() const;
+    void setOdbVersionMinor(uint iVersion);
+
+    QDateTime creationDate() const;
+    void setCreationDate(QDateTime iDt);
+
+    QDateTime saveDate() const;
+    void setSaveDate(QDateTime iDt);
+
+    QString saveApp() const;
+    void setSaveApp(const QString &iApp);
+
+    QString saveUser() const;
+    void setSaveUser(const QString &iUser);
+
+    QVariant jobAttr(const QString &iName) const;
+    bool hasJobAttr(const QString &iName) const;
+    void setJobAttr(const QString &iName, const QVariant &iValue);
+
+    PcbCamAttrDefine userAttrDefine(const QString &iName) const;
+    QHash<QString, PcbCamAttrDefine> userAttrDefine() const;
+    void addUserAttrDefine(const PcbCamAttrDefine &iAttrDefine);
+
+    PcbCamStep *step(const QString &iStepName) const;
+    bool isStepExists(const QString &iStepName) const;
+    QHash<QString, PcbCamStep*> allSteps() const;
+//    void addStep(PcbCamStep *iStep);
+//    void addStep(const QVector<PcbCamStep*> &iStep);
+    bool createStep(const QString &iStepName);
+    bool deleteStep(const QString &iStepName);
+    bool renameStep(const QString &iOldStepName, const QString &iNewStepName);
+
+    bool createLayer(const QString &iLayerName, PcbCam::LayerContext iLayerContext = PcbCam::MiscContext, const QString &iLayerType="document");
+
+    PcbCamLayer *layer(const QString &iStepName, const QString &iLayerName);
+    bool isStepLayerExists(const QString &iStepName, const QString &iLayerName) const;
+    bool renameLayer(const QString &iOldLayerName, const QString &iNewLayerName);
+    void setLayerType(const QString &iLayerName, const QString &iLayerType);
+    void setLayerContext(const QString &iLayerName, PcbCam::LayerContext iLayerContext);
+    void setLayerPolarity(const QString &iLayerName, PcbCam::Polarity iLayerPolarity);
+    void setLayerSpan(const QString &iLayerName, const QString &iStartLayer, const QString &iEndLayer);
+    void setLayerRow(const QString &iLayerName, int iRow);
+
+
+    void setStepWorkLayer(const QString &iStepName, const QString &iLayerName);
+    void setStepLayerAffected(const QString &iStepName, const QString &iLayerName, bool iAffected = true);
+    void setStepLayerDisplayColor(const QString &iStepName, const QString &iLayerName, const QString iColor);
+    void clearStepAffectedLayer(const QString &iStepName);
+    void resetStepAttectedLayer(const QString &iStepName, const QStringList &iAffectedLayers);
+    void clearStepWorkLayer(const QString &iStepName);
+    void clearStepDisplayLayer(const QString &iStepName);
+    PcbCamLayer *stepWorkLayer(const QString &iStepName) const;
+    QList<PcbCamLayer *> stepAffectedLayer(const QString &iStepName) const;
+    QList<PcbCamLayer *> stepDispalyLayer(const QString &iStepName) const;
+
+
+    QString jobPath() const;
+    void setJobPath(const QString &iPath);
+    void setLogJobPath(const QString &iPath);
+
+    QList<PcbCamMatrixLayer> matrixLayers() const;
+    QHash<QString, int> matrixSteps() const;
+    bool isLayerExists(const QString &iLayerName) const;
+    PcbCamMatrixLayer matrixLayer(const QString &iLayerName) const;
+
+    bool isSymbolExists(const QString &iSymbolName) const;
+    PcbCamSymbol *symbol(const QString &iSymbolName) const;
+    QHash<QString, PcbCamSymbol*> symbols() const;
+
+    bool isFontExists(const QString &iFontName) const;
+    PcbCamFont *font(const QString &iFontName) const;
+
+    void openJob();
+    void loadStepLayer(const QString &iStep, const QString &iLayer);
+    void loadSymbol(const QString &iSymbolName);
+    void loadFont(const QString &iFontName);
+
+    void notifyMessage(const QString &iText, const QString &iType, const QVariant &iUserData = QVariant()) const;
+
+    QByteArray readJobFile(const QString &iRelPath, QString *oErrStr = nullptr) const;
+    bool importGerber274X(const QString &iGerberFile, const QString &iStep, const QString &iLayer);
+    bool importDrill(const QString &iDrlFile, const QString &iStep, const QString &iLayer, const QVariantMap &iStatement);
+
+
+private:
+    bool readMiscInfo();
+    bool readMiscAttrlist();
+    bool readMiscUserattr();
+    bool readMatrix();
+    bool readSteps();
+    QList<PcbCamOdbFeatureInfo> readLayerFeature(const QString &iStep, const QString &iLayer);
+    QList<PcbCamOdbFeatureInfo> readSymbolFeature(const QString &iSymbol);
+    QList<QList<PcbCamOdbFeatureInfo>> readEdaPackagesFeature(const QString &iStep);
+    QList<PcbCamOdbFeatureInfo> readLayerComponent(const QString &iStep, const QString &iLayer);
+
+
+    PcbCamFeature *createFeature(const PcbCamOdbFeatureInfo &iFeat);
+
+protected:
+    const QScopedPointer<PcbCamJobPrivate> d_ptr;
+
+private:
+    Q_DECLARE_PRIVATE(PcbCamJob)
+    Q_DISABLE_COPY(PcbCamJob)
+
+};
+
+TITAN_END_NAMESPACE
+
+#endif // TITAN_PCBCAM_JOB_H

lib/core/layer.h

+#ifndef TITAN_PCBCAM_LAYER_H
+#define TITAN_PCBCAM_LAYER_H
+#include "../titanpcbcamglobal.h"
+#include <QString>
+#include <QVariantMap>
+#include <QPainterPath>
+#include "./common.h"
+
+TITAN_BEGIN_NAMESPACE
+
+class PcbCamJob;
+class PcbCamFeature;
+
+class PcbCamLayerPrivate;
+class TITAN_PCBCAM_EXPORT PcbCamLayer
+{
+public:
+    PcbCamLayer(PcbCamJob *iJob);
+    ~PcbCamLayer();
+
+    PcbCamJob *job() const;
+
+    QString name() const;
+    void setName(const QString &iName);
+
+    QString step() const;
+    void setStep(const QString &iStep);
+
+    QVariant attr(const QString &iName) const;
+    bool hasAttr(const QString &iName) const;
+    void initAttr(const QVariantMap &iAttrMap);
+    void setAttr(const QString &iName, const QVariant &iValue);
+
+    void setAffectedLayer(bool iAffected = true);
+    bool isAffectedLayer() const;
+    void setWorkLayer(bool iBol = true);
+    bool isWorkLayer() const;
+    void setDisplayColor(const QString &iColor);
+    QString displayColor() const;
+
+    QList<PcbCamFeature*> features() const;
+    void clearFeatures();
+    void addFeature(PcbCamFeature *iFeature);
+    void addFeatures(const QList<PcbCamFeature *> &iFeatures);
+    PcbCamFeature *addLine(const QLineF &iLine,
+                           const QString &iSymbol,
+                           PcbCam::Polarity iPolarity = PcbCam::Positive,
+                           const QVariantMap &iAttr = QVariantMap());
+    PcbCamFeature *addPad(const QPointF &iPos,
+                          const QString &iSymbol,
+                          PcbCam::Orient iOrient = PcbCam::Orient_N_0,
+                          PcbCam::Polarity iPolarity = PcbCam::Positive,
+                          const QVariantMap &iAttr = QVariantMap());
+    PcbCamFeature *addArc(const QPointF &iPs,
+                          const QPointF &iPe,
+                          const QPointF &iPc,
+                          bool iCw,
+                          const QString &iSymbol,
+                          PcbCam::Polarity iPolarity = PcbCam::Positive,
+                          const QVariantMap &iAttr = QVariantMap());
+    PcbCamFeature *addText(const QPointF &iPos,
+                           const QString &iText,
+                           const QSizeF &iSize,
+                           PcbCam::Orient iOrient = PcbCam::Orient_N_0,
+                           PcbCam::Polarity iPolarity = PcbCam::Positive,
+                           const QVariantMap &iAttr = QVariantMap(),
+                           qreal iWidthFactor = 1.0,
+                           const QString &iFont = "standard"
+                           );
+    PcbCamFeature *addSurface(const QPainterPath &iPath,
+                              PcbCam::Polarity iPolarity = PcbCam::Positive,
+                              const QVariantMap &iAttr = QVariantMap());
+
+    PcbCamFeature *addPath(const QPainterPath &iPath,
+                           int iWidth = 1,
+                           PcbCam::Polarity iPolarity = PcbCam::Positive,
+                           const QVariantMap &iAttr = QVariantMap());
+
+
+    void deleteFeature(int iIndex);
+    QList<PcbCamFeature *> selectFeature(const QPainterPath &iRegionPath,
+                                         const PcbCam::FeatureSelectionFilter &iFilter,
+                                         PcbCam::FeatureSelectionOperation iSelOp,
+                                         PcbCam::FeatureSelectionMode iSelMode);
+
+    QList<PcbCamFeature *> selectedFeatures() const;
+    void clearSelection();
+    bool hasFeatureSelected() const;
+
+
+    QRectF boundingRect() const;
+
+protected:
+    const QScopedPointer<PcbCamLayerPrivate> d_ptr;
+
+private:
+    Q_DECLARE_PRIVATE(PcbCamLayer)
+    Q_DISABLE_COPY(PcbCamLayer)
+
+};
+
+TITAN_END_NAMESPACE
+
+#endif // TITAN_PCBCAM_LAYER_H

lib/core/math.cpp

+#include "math.h"
+

lib/core/math.h

+#ifndef TITAN_PCBCAM_MATH_H
+#define TITAN_PCBCAM_MATH_H
+#include "../titanpcbcamglobal.h"
+#include <QPointF>
+#include <QLineF>
+#include <QPolygonF>
+#include <cmath>
+
+TITAN_BEGIN_NAMESPACE
+
+class TITAN_PCBCAM_EXPORT PcbCamMath
+{
+public:
+
+    /* 计算两点之间距离 */
+    static inline double point2pointDist(const QPointF &p1, const QPointF &p2)
+    {
+        return sqrt( (p1.x()-p2.x())*(p1.x()-p2.x())+(p1.y()-p2.y())*(p1.y()-p2.y()));
+    }
+
+    /* 计算矢量(sp->op)和(ep->op)的叉积,其结果r的几何意义如下
+     * r>0: ep在矢量(os->sp)的逆时针方向
+     * r=0: op,sp,ep三点共线
+     * r<0: ep在矢量(os->sp)的顺时针方向
+     */
+    static inline double crossMultiply(const QPointF &sp, const QPointF &ep, const QPointF &op)
+    {
+        return((sp.x()-op.x())*(ep.y()-op.y())-(ep.x()-op.x())*(sp.y()-op.y()));
+    }
+
+    /* 计算矢量(p1->p0)和(p2->p0)的点积，其结果r的几何含意如下
+     * r<0: 两矢量的夹角为锐角
+     * r=0: 两矢量的夹角为直角
+     * r>0: 两矢量的夹角为钝角
+     */
+    static inline double dotMultiply(const QPointF &p1, const QPointF &p2, const QPointF &p0)
+    {
+        return ((p1.x()-p0.x())*(p2.x()-p0.x())+(p1.y()-p0.y())*(p2.y()-p0.y()));
+    }
+
+    /* 判断点是否在直线上*/
+    static inline bool isPointOnLine(const QPointF &p, const QLineF &l)
+    {
+        //判断条件: (点在线段所在的直线上） 并且 (点在线段对角线的矩形范围内)
+        return (crossMultiply(l.p2(), p, l.p1())==0) && ( ( (p.x()-l.p1().x())*(p.x()-l.p2().x())<=0 )&&( (p.y()-l.p1().y())*(p.y()-l.p2().y())<=0 ) );
+    }
+
+    /* 计算点到线段的垂足系数
+     *
+     *        AC dot AB
+     *  r = ---------------
+     *        ||AB||^2
+     *
+     *  结果r的几何含意如下:
+     *  r=0:    垂足=A
+     *  r=1:    垂足=B
+     *  r<0:    垂足在线段AB的反向延长线上
+     *  r>1:    垂足在线段AB的正向延长线上
+     *  0<r<1:  垂足在线段AB中
+     */
+    static inline double pedalFactor(const QPointF &p, const QLineF &l)
+    {
+        QLineF tl(l.p1(), p);
+        return dotMultiply(tl.p2(),l.p2(),l.p1())/(point2pointDist(l.p1(),l.p2())*point2pointDist(l.p1(),l.p2()));
+    }
+
+    /* 计算点到线段的垂足 */
+    static inline QPointF pedalPoint(const QPointF &p, const QLineF &l)
+    {
+        double r = pedalFactor(p, l);
+        return QPointF(l.p1().x()+r*(l.p2().x()-l.p1().x()), l.p1().y()+r*(l.p2().y()-l.p1().y()));
+    }
+
+    /* 计算点到线段的最近距离和点 */
+    static inline double point2lineDist(const QPointF &p, const QLineF &l, QPointF &np)
+    {
+        double r=pedalFactor(p, l);
+        if(r<0) np = l.p1();
+        else if(r>1) np = l.p2();
+        else np = pedalPoint(p, l);
+        return point2pointDist(p, np);
+    }
+
+    /* 计算点到多段线的最近距离和点 */
+    static inline double point2polylineDist(const QPointF &p, const QPolygonF &polyline, QPointF &np)
+    {
+        double dist = 9999999;
+        double tmpdist;
+        QLineF line;
+        QPointF tnp;
+        for (int i = 0; i < polyline.count() -1; ++i) {
+            line.setP1(polyline.at(i));
+            line.setP2(polyline.at(i+1));
+            tmpdist = point2lineDist(p, line, tnp);
+            if (tmpdist < dist) {
+                dist = tmpdist;
+                np = tnp;
+            }
+        }
+        return dist;
+    }
+
+};
+
+TITAN_END_NAMESPACE
+
+#endif // TITAN_PCBCAM_MATH_H

lib/core/matrixlayer.h

+#ifndef TITAN_PCBCAM_MATRIXLAYER_H
+#define TITAN_PCBCAM_MATRIXLAYER_H
+#include "../titanpcbcamglobal.h"
+#include <QSharedDataPointer>
+#include "./common.h"
+
+TITAN_BEGIN_NAMESPACE
+
+class PcbCamMatrixLayerData;
+class TITAN_PCBCAM_EXPORT PcbCamMatrixLayer
+{
+public:
+    PcbCamMatrixLayer();
+    PcbCamMatrixLayer(const PcbCamMatrixLayer &);
+    PcbCamMatrixLayer &operator=(const PcbCamMatrixLayer &);
+    ~PcbCamMatrixLayer();
+
+    int id() const;
+    void setId(int iId);
+
+    int row() const;
+    void setRow(int iRow);
+
+    PcbCam::LayerContext context() const;
+    void setContext(PcbCam::LayerContext iContext);
+
+    QString type() const;
+    void setType(const QString &iType);
+
+    QString name() const;
+    void setName(const QString &iName);
+
+    QString oldName() const;
+    void setOldName(const QString &iOldName);
+
+    PcbCam::Polarity polarity() const;
+    void setPolarity(PcbCam::Polarity iPolarity);
+
+    QString startName() const;
+    void setStartName(const QString iName);
+
+    QString endName() const;
+    void setEndName(const QString &iName);
+
+private:
+    QSharedDataPointer<PcbCamMatrixLayerData> d;
+};
+
+TITAN_END_NAMESPACE
+
+#endif // TITAN_PCBCAM_MATRIXLAYER_H