HG_REPOSITORIES/LPP/INSTRUMENTATION/kicadtools Commit - r12:93ef9e74723d

Non working pad rendering.. Rotation issue.

jeandet -

r12:93ef9e74723d default

parent child

Context file:

r12:93ef9e74723d

qilib/qicadpcb.cpp +2 -1

             #include "qicadpcb.h"
             QIlib::QIcadPcb::QIcadPcb()
                 :pcbRoot(NULL)
             {
             }
             bool QIlib::QIcadPcb::parsePcb(const QString &pcb)
             {
                 parse(pcb.toStdString().c_str());
                 updateConcreteTree();
                 return false;
             }
             QString QIlib::QIcadPcb::toString()
             {
             }
             QString QIlib::QIcadPcb::print()
             {
                 return rootNode.print();
             }
             void QIlib::QIcadPcb::updateConcreteTree()
             {
                 if(this->rootNode.nodes.count())
                 {
                     if(this->rootNode.nodes.at(0)->name==QIlib::Lexique::kicad_pcb_c)
                     {
                         if(this->pcbRoot==NULL)
                         {
                             this->pcbRoot = new QIcadPcbRoot(this->rootNode.nodes.at(0));
                         }
                     }
                 }
             }
             QIlib::QIcadPcbRoot::QIcadPcbRoot(QIlib::AbstractNode *node)
                 :QIcadAbstractNodeWrapper(node)
             {
                 this->setNode(node);
             }
             void QIlib::QIcadPcbRoot::setNode(QIlib::AbstractNode *node)
             {
                 this->clrNets();
                 this->clrModules();
                 this->clrDimensions();
                 this->clrLines();
                 this->clrSegments();
                 this->clrVias();
                 this->clrArcs();
                 this->clrCircles();
                 this->clrTexts();
                 this->clrZones();
                 if(node->name==QIlib::Lexique::kicad_pcb_c)
                 {
                     this->p_node = node;
                     for(int i=0;i<node->nodes.count();i++)
                     {
                         if(node->nodes.at(i)->name==QIlib::Lexique::version_c)
                         {
                             this->version.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::host_c)
                         {
                             this->host.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::page_c)
                         {
                             this->page.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::general_c)
                         {
                             this->general.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::layers_c)
                         {
                             this->layers.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::setup_c)
                         {
                             this->setup.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::net_c)
                         {
                             this->apendNet(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::module_c)
                         {
                             this->apendModule(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::gr_line_c)
                         {
                             this->apendLine(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::dimension_c)
                         {
                             this->apendDimension(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::via_c)
                         {
                             this->apendVia(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::segment_c)
                         {
                             this->apendSegment(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::gr_text_c)
                         {
                             this->apendText(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::gr_arc_c)
                         {
                             this->apendArc(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::gr_circle_c)
                         {
                             this->apendCircle(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::zone_c)
                         {
                             this->apendZone(node->nodes.at(i));
                         }
                     }
                 }
             }
             void QIlib::QIcadPcbRoot::clrNets()
             {
                 while(nets.count())
                 {
                     QIcadAbstractNodeWrapper* net;
                     net = nets.last();
                     nets.removeLast();
                     delete net;
                 }
             }
             void QIlib::QIcadPcbRoot::apendNet(QIlib::AbstractNode *node)
             {
                 if(node->name==QIlib::Lexique::net_c)
                 {
                     this->nets.append(new QIcadAbstractNodeWrapper(node));
                 }
             }
             void QIlib::QIcadPcbRoot::clrModules()
             {
                 while(modules.count())
                 {
                     QIcadPcbModule* module;
                     module = modules.last();
                     modules.removeLast();
                     delete module;
                 }
             }
             void QIlib::QIcadPcbRoot::apendModule(QIlib::AbstractNode *node)
             {
                 if(node->name==QIlib::Lexique::module_c)
                 {
                     this->modules.append(new QIcadPcbModule(node));
                 }
             }
             void QIlib::QIcadPcbRoot::clrDimensions()
             {
                 while(dimensions.count())
                 {
                     QIcadPcbDimension* dimension;
                     dimension = dimensions.last();
                     dimensions.removeLast();
                     delete dimension;
                 }
             }
             void QIlib::QIcadPcbRoot::apendDimension(QIlib::AbstractNode *node)
             {
                 if(node->name==QIlib::Lexique::dimension_c)
                 {
                     this->dimensions.append(new QIcadPcbDimension(node));
                 }
             }
             void QIlib::QIcadPcbRoot::apendLine(QIlib::AbstractNode *node)
             {
                 if(node->name==QIlib::Lexique::gr_line_c)
                 {
                     this->lines.append(new QIcadPcbLine(node));
                 }
             }
             void QIlib::QIcadPcbRoot::clrLines()
             {
                 while(lines.count())
                 {
                     QIcadPcbLine* line;
                     line = lines.last();
                     lines.removeLast();
                     delete line;
                 }
             }
             void QIlib::QIcadPcbRoot::clrSegments()
             {
                 while(segments.count())
                 {
                     QIcadPcbSegment* segment;
                     segment = segments.last();
                     segments.removeLast();
                     delete segment;
                 }
             }
             void QIlib::QIcadPcbRoot::apendSegment(QIlib::AbstractNode *node)
             {
                 if(node->name==QIlib::Lexique::segment_c)
                 {
                     this->segments.append(new QIcadPcbSegment(node));
                 }
             }
             void QIlib::QIcadPcbRoot::clrVias()
             {
                 while(vias.count())
                 {
                     QIcadPcbVia* via;
                     via = vias.last();
                     vias.removeLast();
                     delete via;
                 }
             }
             void QIlib::QIcadPcbRoot::apendVia(QIlib::AbstractNode *node)
             {
                 if(node->name==QIlib::Lexique::via_c)
                 {
                     this->vias.append(new QIcadPcbVia(node,this->setup.defaultViaDrillSize()));
                 }
             }
             void QIlib::QIcadPcbRoot::clrArcs()
             {
                 while(arcs.count())
                 {
                     QIcadPcbArc* arc;
                     arc = arcs.last();
                     arcs.removeLast();
                     delete arc;
                 }
             }
             void QIlib::QIcadPcbRoot::apendArc(QIlib::AbstractNode *node)
             {
                 if(node->name==QIlib::Lexique::gr_arc_c)
                 {
                     this->arcs.append(new QIcadPcbArc(node));
                 }
             }
             void QIlib::QIcadPcbRoot::clrCircles()
             {
                 while(circles.count())
                 {
                     QIcadPcbCircle* circle;
                     circle = circles.last();
                     circles.removeLast();
                     delete circle;
                 }
             }
             void QIlib::QIcadPcbRoot::apendCircle(QIlib::AbstractNode *node)
             {
                 if(node->name==QIlib::Lexique::gr_circle_c)
                 {
                     this->circles.append(new QIcadPcbCircle(node));
                 }
             }
             void QIlib::QIcadPcbRoot::clrTexts()
             {
                 while(texts.count())
                 {
                     QIcadPcbText* text;
                     text = texts.last();
                     texts.removeLast();
                     delete text;
                 }
             }
             void QIlib::QIcadPcbRoot::apendText(QIlib::AbstractNode *node)
             {
                 if(node->name==QIlib::Lexique::gr_text_c)
                 {
                     this->texts.append(new QIcadPcbText(node));
                 }
             }
             void QIlib::QIcadPcbRoot::clrZones()
             {
                 while(zones.count())
                 {
                     QIcadPcbZone* zone;
                     zone = zones.last();
                     zones.removeLast();
                     delete zone;
                 }
             }
             void QIlib::QIcadPcbRoot::apendZone(QIlib::AbstractNode *node)
             {
                 if(node->name==QIlib::Lexique::zone_c)
                 {
                     this->zones.append(new QIcadPcbZone(node));
                 }
             }
             QIlib::QIcadPcbGeneralInfo::QIcadPcbGeneralInfo(QIlib::AbstractNode *node)
                 :QIcadAbstractNodeWrapper(node)
             {
                 this->setNode(node);
             }
             void QIlib::QIcadPcbGeneralInfo::setNode(QIlib::AbstractNode *node)
             {
                 if(node->name==QIlib::Lexique::general_c)
                 {
                     this->p_node = node;
                     for(int i=0;i<node->nodes.count();i++)
                     {
                         if(node->nodes.at(i)->name==QIlib::Lexique::links_c)
                         {
                             this->links.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::no_connect_c)
                         {
                             this->no_connections.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::area_c)
                         {
                             this->area.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::thickness_c)
                         {
                             this->thickness.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::drawings_c)
                         {
                             this->drawings.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::tracks_c)
                         {
                             this->tracks.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::zones_c)
                         {
                             this->zones.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::modules_c)
                         {
                             this->modules.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::nets_c)
                         {
                             this->nets.setNode(node->nodes.at(i));
                         }
                     }
                 }
             }
             QIlib::QIcadPcbLayers::QIcadPcbLayers(QIlib::AbstractNode *node)
                 :QIcadAbstractNodeWrapper(node)
             {
                 this->setNode(node);
             }
             void QIlib::QIcadPcbLayers::setNode(QIlib::AbstractNode *node)
             {
                 this->p_node = node;
                 if(node->name==QIlib::Lexique::layers_c)
                 {
                     this->clrLayers();
                     for(int i=0;i<node->nodes.count();i++)
                     {
                         this->apendLayer(node->nodes.at(i));
                     }
                 }
             }
             void QIlib::QIcadPcbLayers::clrLayers()
             {
                 while(layers.count())
                 {
                     QIcadPcbLayer* layer;
                     layer = layers.last();
                     layers.removeLast();
                     delete layer;
                 }
             }
             void QIlib::QIcadPcbLayers::apendLayer(QIlib::AbstractNode *node)
             {
                     this->layers.append(new QIcadPcbLayer(node));
             }
             QIlib::QIcadPcbLine::QIcadPcbLine(QIlib::AbstractNode *node)
                 :QIcadAbstractPcbLine(node)
             {
                 this->setNode(node);
             }
             void QIlib::QIcadPcbLine::setNode(QIlib::AbstractNode *node)
             {
                 if(node->name==QIlib::Lexique::gr_line_c)
                 {
                     this->p_node = node;
                     for(int i=0;i<node->nodes.count();i++)
                     {
                         if(node->nodes.at(i)->name==QIlib::Lexique::start_c)
                         {
                             this->p_startpos = nodeTo2DCoords(node->nodes.at(i));
                             this->start.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::end_c)
                         {
                             this->p_stoppos = nodeTo2DCoords(node->nodes.at(i));
                             this->end.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::angle_c)
                         {
                             this->angle.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::layer_c)
                         {
                             this->p_layers = node->nodes.at(i)->Values;
                             this->layer.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::width_c)
                         {
                             this->p_width = nodeValueToDouble(node->nodes.at(i));
                             this->width.setNode(node->nodes.at(i));
                         }
                     }
                 }
             }
             QIlib::QIcadPcbModule::QIcadPcbModule(QIlib::AbstractNode *node)
                 :QIcadAbstractNodeWrapper(node)
             {
                 this->setNode(node);
             }
             const QPointF &QIlib::QIcadPcbModule::pos()
             {
                 return p_pos;
             }
             double QIlib::QIcadPcbModule::angle()
             {
                 return p_angle;
             }
             void QIlib::QIcadPcbModule::setNode(QIlib::AbstractNode *node)
             {
                 this->clrPads();
                 if(node->name==QIlib::Lexique::module_c)
                 {
                     this->p_node = node;
                     for(int i=0;i<node->nodes.count();i++)
                     {
                         if(node->nodes.at(i)->name==QIlib::Lexique::layer_c)
                         {
                             this->layer.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::tedit_c)
                         {
                             this->tedit.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::tstamp_c)
                         {
                             this->tstamp.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::at_c)
                         {
                             this->at.setNode(node->nodes.at(i));
                             QStringList coords=node->nodes.at(i)->Values;
                             p_pos = nodeTo2DCoords(node->nodes.at(i));
                             if(coords.count()==3)
                             {
                                 p_angle = coords.at(2).toDouble();
                             }
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::tags_c)
                         {
                             this->tags.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::path_c)
                         {
                             this->path.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::attr_c)
                         {
                             this->attr.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::pad_c)
                         {
                             this->apendPad(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::fp_line_c)
                         {
                             this->apendLine(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::fp_text_c)
                         {
                             this->apendText(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::fp_circle_c)
                         {
                             this->apendCircle(node->nodes.at(i));
                         }
                     }
                 }
             }
             void QIlib::QIcadPcbModule::clrPads()
             {
                 while(pads.count())
                 {
                     QIcadPcbPad* pad;
                     pad = pads.last();
                     pads.removeLast();
                     delete pad;
                 }
             }
             void QIlib::QIcadPcbModule::apendPad(QIlib::AbstractNode *node)
             {
                 if(node->name==QIlib::Lexique::pad_c)
                 {
                     this->pads.append(new QIcadPcbPad(node));
                 }
             }
             void QIlib::QIcadPcbModule::clrTexts()
             {
                 while(fp_texts.count())
                 {
                     QIcadPcbFPText* text;
                     text = fp_texts.last();
                     fp_texts.removeLast();
                     delete text;
                 }
             }
             void QIlib::QIcadPcbModule::apendText(QIlib::AbstractNode *node)
             {
                 if(node->name==QIlib::Lexique::fp_text_c)
                 {
                     this->fp_texts.append(new QIcadPcbFPText(node));
                 }
             }
             void QIlib::QIcadPcbModule::clrLines()
             {
                 while(fp_lines.count())
                 {
                     QIcadPcbFPLine* line;
                     line = fp_lines.last();
                     fp_lines.removeLast();
                     delete line;
                 }
             }
             void QIlib::QIcadPcbModule::apendLine(QIlib::AbstractNode *node)
             {
                 if(node->name==QIlib::Lexique::fp_line_c)
                 {
                     this->fp_lines.append(new QIcadPcbFPLine(node));
                 }
             }
             void QIlib::QIcadPcbModule::clrCircles()
             {
                 while(fp_circles.count())
                 {
                     QIcadPcbFPCircle* circle;
                     circle = fp_circles.last();
                     fp_circles.removeLast();
                     delete circle;
                 }
             }
             void QIlib::QIcadPcbModule::apendCircle(QIlib::AbstractNode *node)
             {
                 if(node->name==QIlib::Lexique::fp_circle_c)
                 {
                     this->fp_circles.append(new QIcadPcbFPCircle(node));
                 }
             }
             QIlib::QIcadPcbDimension::QIcadPcbDimension(QIlib::AbstractNode *node)
                 :QIcadAbstractNodeWrapper(node)
             {
                 this->setNode(node);
             }
             void QIlib::QIcadPcbDimension::setNode(QIlib::AbstractNode *node)
             {
                 if(node->name==QIlib::Lexique::dimension_c)
                 {
                     this->p_node = node;
                     for(int i=0;i<node->nodes.count();i++)
                     {
                         if(node->nodes.at(i)->name==QIlib::Lexique::width_c)
                         {
                             this->width.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::layer_c)
                         {
                             this->layer.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::gr_text_c)
                         {
                             this->gr_text.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::feature1_c)
                         {
                             this->feature1.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::crossbar_c)
                         {
                             this->crossbar.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::arrow1a_c)
                         {
                             this->arrow1a.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::arrow1b_c)
                         {
                             this->arrow1b.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::arrow2a_c)
                         {
                             this->arrow2a.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::arrow2b_c)
                         {
                             this->arrow2b.setNode(node->nodes.at(i));
                         }
                     }
                 }
             }
             QIlib::QIcadPcbModuleModel::QIcadPcbModuleModel(QIlib::AbstractNode *node)
                 :QIcadAbstractNodeWrapper(node)
             {
                 this->setNode(node);
             }
             void QIlib::QIcadPcbModuleModel::setNode(QIlib::AbstractNode *node)
             {
                 this->p_node = node;
             }
             QIlib::QIcadPcbFPText::QIcadPcbFPText(QIlib::AbstractNode *node)
                 :QIcadAbstractNodeWrapper(node)
             {
                 this->setNode(node);
             }
             void QIlib::QIcadPcbFPText::setNode(QIlib::AbstractNode *node)
             {
                 if(node->name==QIlib::Lexique::pad_c)
                 {
                     this->p_node = node;
                     for(int i=0;i<node->nodes.count();i++)
                     {
                         if(node->nodes.at(i)->name==QIlib::Lexique::at_c)
                         {
                             this->at.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::layer_c)
                         {
                             this->layer.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::effects_c)
                         {
                             this->effects.setNode(node->nodes.at(i));
                         }
                     }
                 }
             }
             QIlib::QIcadPcbFpTextEffects::QIcadPcbFpTextEffects(QIlib::AbstractNode *node)
                 :QIcadAbstractNodeWrapper(node)
             {
                 this->setNode(node);
             }
             void QIlib::QIcadPcbFpTextEffects::setNode(QIlib::AbstractNode *node)
             {
                 this->p_node = node;
             }
             QIlib::QIcadPcbFpTextEffectsFont::QIcadPcbFpTextEffectsFont(QIlib::AbstractNode *node)
                 :QIcadAbstractNodeWrapper(node)
             {
                 this->setNode(node);
             }
             void QIlib::QIcadPcbFpTextEffectsFont::setNode(QIlib::AbstractNode *node)
             {
                 this->p_node = node;
             }
             QIlib::QIcadPcbNetClass::QIcadPcbNetClass(QIlib::AbstractNode *node)
                 :QIcadAbstractNodeWrapper(node)
             {
                 this->setNode(node);
             }
             void QIlib::QIcadPcbNetClass::setNode(QIlib::AbstractNode *node)
             {
                 this->p_node = node;
             }
             QIlib::QIcadPcbSetup::QIcadPcbSetup(QIlib::AbstractNode *node)
                 :QIcadAbstractNodeWrapper(node)
             {
                 this->setNode(node);
             }
             void QIlib::QIcadPcbSetup::setNode(QIlib::AbstractNode *node)
             {
                 if(node->name==QIlib::Lexique::setup_c)
                 {
                     this->p_node = node;
                     for(int i=0;i<node->nodes.count();i++)
                     {
                         if(node->nodes.at(i)->name==QIlib::Lexique::via_drill_c)
                         {
                             this->via_dril.setNode(node->nodes.at(i));
                             this->p_defaultViaDrillSize = nodeValueToDouble(node->nodes.at(i));
                         }
                     }
                 }
             }
             QIlib::QIcadPcbPlotParams::QIcadPcbPlotParams(QIlib::AbstractNode *node)
                 :QIcadAbstractNodeWrapper(node)
             {
                 this->setNode(node);
             }
             void QIlib::QIcadPcbPlotParams::setNode(QIlib::AbstractNode *node)
             {
                 this->p_node = node;
             }
             QIlib::QIcadPcbSegment::QIcadPcbSegment(QIlib::AbstractNode *node)
                 :QIcadAbstractPcbLine(node)
             {
                 this->setNode(node);
             }
             void QIlib::QIcadPcbSegment::setNode(QIlib::AbstractNode *node)
             {
                 if(node->name==QIlib::Lexique::segment_c)
                 {
                     this->p_node = node;
                     for(int i=0;i<node->nodes.count();i++)
                     {
                         if(node->nodes.at(i)->name==QIlib::Lexique::start_c)
                         {
                             this->p_startpos = nodeTo2DCoords(node->nodes.at(i));
                             this->start.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::end_c)
                         {
                             this->p_stoppos = nodeTo2DCoords(node->nodes.at(i));
                             this->end.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::width_c)
                         {
                             this->p_width = nodeValueToDouble(node->nodes.at(i));
                             this->width.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::layer_c)
                         {
                             this->p_layers = node->nodes.at(i)->Values;
                             this->layer.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::net_c)
                         {
                             this->net.setNode(node->nodes.at(i));
                         }
                     }
                 }
             }
             QIlib::QIcadPcbVia::QIcadPcbVia(QIlib::AbstractNode *node, double defaultDrill)
                 :QIcadAbstractNodeWrapper(node),p_drill(defaultDrill)
             {
                 this->setNode(node);
             }
             void QIlib::QIcadPcbVia::setNode(QIlib::AbstractNode *node)
             {
                 if(node->name==QIlib::Lexique::via_c)
                 {
                     this->p_node = node;
                     for(int i=0;i<node->nodes.count();i++)
                     {
                         if(node->nodes.at(i)->name==QIlib::Lexique::at_c)
                         {
                             this->at.setNode(node->nodes.at(i));
                             p_pos = nodeTo2DCoords(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::size_c)
                         {
                             this->sizeNode.setNode(node->nodes.at(i));
                             p_size = QSizeF(nodeValueToDouble(node->nodes.at(i)),nodeValueToDouble(node->nodes.at(i)));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::drill_c)
                         {
                             this->drillNode.setNode(node->nodes.at(i));
                             p_drill = nodeValueToDouble(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::layers_c)
                         {
                             this->layersNode.setNode(node->nodes.at(i));
                             p_layers = node->nodes.at(i)->Values;
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::net_c)
                         {
                             this->net.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::tstamp_c)
                         {
                             this->tstamp.setNode(node->nodes.at(i));
                         }
                     }
                 }
             }
             QIlib::QIcadPcbPad::QIcadPcbPad(QIlib::AbstractNode *node)
                 :QIcadAbstractNodeWrapper(node)
             {
                 this->setNode(node);
             }
             void QIlib::QIcadPcbPad::setNode(QIlib::AbstractNode *node)
             {
                 if(node->name==QIlib::Lexique::pad_c)
                 {
                     this->p_node = node;
                     if(p_node->Values.count()>=3)
                     {
                         if(!this->p_node->Values.at((2)).compare("rect"))
                         {
                             this->p_shape = rectangle;
                         }
                         else
                             if(!this->p_node->Values.at((2)).compare("circle"))
                             {
                                 this->p_shape = circle;
                             }
+                        this->p_padNumber = nodeValueToInt(node,0);
                     }
                     for(int i=0;i<node->nodes.count();i++)
                     {
                         if(node->nodes.at(i)->name==QIlib::Lexique::at_c)
                         {
                             this->at.setNode(node->nodes.at(i));
                             this->p_pos = nodeTo2DCoords(node->nodes.at(i));
+                            this->p_angle = nodeValueToDouble(node->nodes.at(i),2);
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::size_c)
                         {
                             this->sizeNode.setNode(node->nodes.at(i));
                             this->p_size = nodeTo2DSize(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::layers_c)
                         {
                             this->layer.setNode(node->nodes.at(i));
                             this->p_layers = node->nodes.at(i)->Values;
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::net_c)
                         {
                             this->netNode.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::drill_c)
                         {
                             this->drillNode.setNode(node->nodes.at(i));
                             this->p_drill = nodeValueToDouble(node->nodes.at(i));
                         }
                     }
                 }
             }
             QIlib::QIcadPcbFPLine::QIcadPcbFPLine(QIlib::AbstractNode *node)
                 :QIcadAbstractPcbLine(node)
             {
                 this->setNode(node);
             }
             void QIlib::QIcadPcbFPLine::setNode(QIlib::AbstractNode *node)
             {
                 if(node->name==QIlib::Lexique::fp_line_c)
                 {
                     this->p_node = node;
                     for(int i=0;i<node->nodes.count();i++)
                     {
                         if(node->nodes.at(i)->name==QIlib::Lexique::start_c)
                         {
                             this->p_startpos = nodeTo2DCoords(node->nodes.at(i));
                             this->start.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::end_c)
                         {
                             this->p_stoppos = nodeTo2DCoords(node->nodes.at(i));
                             this->end.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::layer_c)
                         {
                             this->p_layers = node->nodes.at(i)->Values;
                             this->layer.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::width_c)
                         {
                             this->p_width = nodeValueToDouble(node->nodes.at(i));
                             this->width.setNode(node->nodes.at(i));
                         }
                     }
                 }
             }
             QIlib::QIcadPcbFPCircle::QIcadPcbFPCircle(QIlib::AbstractNode *node)
                 :QIcadAbstractNodeWrapper(node)
             {
                 this->setNode(node);
             }
             void QIlib::QIcadPcbFPCircle::setNode(QIlib::AbstractNode *node)
             {
                 if(node->name==QIlib::Lexique::fp_circle_c)
                 {
                     this->p_node = node;
                     for(int i=0;i<node->nodes.count();i++)
                     {
                         if(node->nodes.at(i)->name==QIlib::Lexique::center_c)
                         {
                             this->center.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::end_c)
                         {
                             this->end.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::layer_c)
                         {
                             this->layer.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::width_c)
                         {
                             this->width.setNode(node->nodes.at(i));
                         }
                     }
                 }
             }
             QIlib::QIcadPcbText::QIcadPcbText(QIlib::AbstractNode *node)
                 :QIcadAbstractNodeWrapper(node)
             {
                 this->setNode(node);
             }
             void QIlib::QIcadPcbText::setNode(QIlib::AbstractNode *node)
             {
                 if(node->name==QIlib::Lexique::gr_text_c)
                 {
                     this->p_node = node;
                     for(int i=0;i<node->nodes.count();i++)
                     {
                         if(node->nodes.at(i)->name==QIlib::Lexique::at_c)
                         {
                             this->at.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::layer_c)
                         {
                             this->layer.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::width_c)
                         {
                             this->width.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::effects_c)
                         {
                             this->effects.setNode(node->nodes.at(i));
                         }
                     }
                 }
             }
             QIlib::QIcadPcbCircle::QIcadPcbCircle(QIlib::AbstractNode *node)
                 :QIcadAbstractNodeWrapper(node)
             {
                 this->setNode(node);
             }
             void QIlib::QIcadPcbCircle::setNode(QIlib::AbstractNode *node)
             {
                 if(node->name==QIlib::Lexique::gr_circle_c)
                 {
                     this->p_node = node;
                     for(int i=0;i<node->nodes.count();i++)
                     {
                         if(node->nodes.at(i)->name==QIlib::Lexique::center_c)
                         {
                             this->center.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::end_c)
                         {
                             this->end.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::layer_c)
                         {
                             this->layer.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::width_c)
                         {
                             this->width.setNode(node->nodes.at(i));
                         }
                     }
                 }
             }
             QIlib::QIcadPcbArc::QIcadPcbArc(QIlib::AbstractNode *node)
                 :QIcadAbstractNodeWrapper(node)
             {
                 this->setNode(node);
             }
             void QIlib::QIcadPcbArc::setNode(QIlib::AbstractNode *node)
             {
                 if(node->name==QIlib::Lexique::gr_arc_c)
                 {
                     this->p_node = node;
                     for(int i=0;i<node->nodes.count();i++)
                     {
                         if(node->nodes.at(i)->name==QIlib::Lexique::start_c)
                         {
                             this->start.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::end_c)
                         {
                             this->end.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::angle_c)
                         {
                             this->angle.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::layer_c)
                         {
                             this->layer.setNode(node->nodes.at(i));
                         }
                         if(node->nodes.at(i)->name==QIlib::Lexique::width_c)
                         {
                             this->width.setNode(node->nodes.at(i));
                         }
                     }
                 }
             }
             QIlib::QIcadPcbZone::QIcadPcbZone(QIlib::AbstractNode *node)
                 :QIcadAbstractNodeWrapper(node)
             {
                 this->setNode(node);
             }
             void QIlib::QIcadPcbZone::setNode(QIlib::AbstractNode *node)
             {
                 if(node->name==QIlib::Lexique::zone_c)
                 {
                     this->p_node = node;
                 }
             }
             const QPointF QIlib::nodeTo2DCoords(QIlib::AbstractNode *node)
             {
                 QPointF point;
                 QStringList coords=node->Values;
                 if(coords.count()>=2)
                 {
                     point.setX(coords.at(0).toDouble());
                     point.setY(coords.at(1).toDouble());
                 }
                 return point;
             }
             double QIlib::nodeValueToDouble(QIlib::AbstractNode *node, int index)
             {
                 if(node->Values.count()>index)
                 {
                     return node->Values.at(index).toDouble();
                 }
                 return 0.0;
             }
             int QIlib::nodeValueToInt(QIlib::AbstractNode *node, int index)
             {
                 if(node->Values.count()>index)
                 {
                     return node->Values.at(index).toInt();
                 }
                 return 0;
             }
             QIlib::QIcadPcbLayer::QIcadPcbLayer(QIlib::AbstractNode *node)
                 :QIcadAbstractNodeWrapper(node)
             {
                 this->p_index = QString(this->p_node->name).remove('(').toInt();
                 if(this->p_node->Values.count()>=1)
                 {
                     this->p_name = this->p_node->Values.at(0);
                 }
                 if(this->p_node->Values.count()>=2)
                 {
                     QString typestr=this->p_node->Values.at(1);
                     this->p_type = none;
                     if(!typestr.compare("signal"))
                     {
                         this->p_type = signal;
                     }
                     else
                         if(!typestr.compare("user"))
                         {
                             this->p_type = user;
                         }
                 }
             }
             const QSizeF QIlib::nodeTo2DSize(QIlib::AbstractNode *node)
             {
                 QSizeF size;
                 QStringList sz=node->Values;
                 if(sz.count()>=2)
                 {
                     size.setWidth(sz.at(0).toDouble());
                     size.setHeight(sz.at(1).toDouble());
                 }
                 return size;
             }

qilib/qicadpcb.h +4 0

             /*------------------------------------------------------------------------------
             --  This file is a part of the Kicad Tools Software
             --  Copyright (C) 2014, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #ifndef QICADPCB_H
             #define QICADPCB_H
             #include <QString>
             #include <QStringList>
             #include <QList>
             #include <QFile>
             #include <parsers/lispLike_driver.h>
             #include <qicadlisplikelexique.h>
             #include <QPointF>
             #include <QRectF>
             namespace QIlib{
             const QPointF nodeTo2DCoords(QIlib::AbstractNode* node);
             const QSizeF nodeTo2DSize(QIlib::AbstractNode* node);
             double nodeValueToDouble(QIlib::AbstractNode* node,int index=0);
             int nodeValueToInt(QIlib::AbstractNode* node,int index=0);
             class QIcadAbstractPcbLine : public QIcadAbstractNodeWrapper
             {
             public:
                 QIcadAbstractPcbLine(QIlib::AbstractNode* node)
                     :QIcadAbstractNodeWrapper(node)
                 {}
                 QIcadAbstractPcbLine(){}
                 virtual const QPointF& startPos(){return p_startpos;}
                 virtual const QPointF& stopPos(){return p_stoppos;}
                 virtual double width(){return p_width;}
                 virtual const QStringList& layers(){return p_layers;}
             protected:
                 double p_width;
                 QPointF p_startpos;
                 QPointF p_stoppos;
                 QStringList p_layers;
             };
             class QIcadPcbLayer : public QIcadAbstractNodeWrapper
             {
             public:
                 typedef enum
                 {
                     signal,
                     user,
                     none
                 }layetType_t;
                 QIcadPcbLayer(QIlib::AbstractNode* node);
                 QIcadPcbLayer(){}
                 int index(){return p_index;}
                 const QString& name(){return p_name;}
                 layetType_t type(){return p_type;}
             protected:
                 int p_index;
                 QString p_name;
                 layetType_t p_type;
             };
             class QIcadPcbPlotParams : public QIcadAbstractNodeWrapper
             {
             public:
                 QIcadPcbPlotParams(QIlib::AbstractNode* node);
                 QIcadPcbPlotParams(){}
                 QIcadAbstractNodeWrapper layerselection;
                 QIcadAbstractNodeWrapper usegerberextensions;
                 QIcadAbstractNodeWrapper excludeedgelayer;
                 QIcadAbstractNodeWrapper linewidth;
                 QIcadAbstractNodeWrapper plotframeref;
                 QIcadAbstractNodeWrapper viasonmask;
                 QIcadAbstractNodeWrapper mode;
                 QIcadAbstractNodeWrapper useauxorigin;
                 QIcadAbstractNodeWrapper hpglpennumber;
                 QIcadAbstractNodeWrapper hpglpenspeed;
                 QIcadAbstractNodeWrapper hpglpendiameter;
                 QIcadAbstractNodeWrapper hpglpenoverlay;
                 QIcadAbstractNodeWrapper psnegative;
                 QIcadAbstractNodeWrapper psa4output;
                 QIcadAbstractNodeWrapper plotreference;
                 QIcadAbstractNodeWrapper plotvalue;
                 QIcadAbstractNodeWrapper plotothertext;
                 QIcadAbstractNodeWrapper plotinvisibletext;
                 QIcadAbstractNodeWrapper padsonsilk;
                 QIcadAbstractNodeWrapper subtractmaskfromsilk;
                 QIcadAbstractNodeWrapper outputformat;
                 QIcadAbstractNodeWrapper mirror;
                 QIcadAbstractNodeWrapper drillshape;
                 QIcadAbstractNodeWrapper scaleselection;
                 QIcadAbstractNodeWrapper outputdirectory;
                 void setNode(QIlib::AbstractNode* node);
             };
             class QIcadPcbSetup : public QIcadAbstractNodeWrapper
             {
             public:
                 QIcadPcbSetup(QIlib::AbstractNode* node);
                 QIcadPcbSetup(){}
                 QIcadAbstractNodeWrapper last_trace_width;
                 QIcadAbstractNodeWrapper trace_clearance;
                 QIcadAbstractNodeWrapper zone_clearance;
                 QIcadAbstractNodeWrapper zone_45_only;
                 QIcadAbstractNodeWrapper trace_min;
                 QIcadAbstractNodeWrapper segment_width;
                 QIcadAbstractNodeWrapper edge_width;
                 QIcadAbstractNodeWrapper via_size;
                 QIcadAbstractNodeWrapper via_dril;
                 QIcadAbstractNodeWrapper via_min_size;
                 QIcadAbstractNodeWrapper via_min_drill;
                 QIcadAbstractNodeWrapper uvia_size;
                 QIcadAbstractNodeWrapper uvia_drill;
                 QIcadAbstractNodeWrapper uvias_allowed;
                 QIcadAbstractNodeWrapper uvia_min_size;
                 QIcadAbstractNodeWrapper uvia_min_drill;
                 QIcadAbstractNodeWrapper pcb_text_width;
                 QIcadAbstractNodeWrapper pcb_text_size;
                 QIcadAbstractNodeWrapper mod_edge_width;
                 QIcadAbstractNodeWrapper mod_text_size;
                 QIcadAbstractNodeWrapper mod_text_width;
                 QIcadAbstractNodeWrapper pad_size;
                 QIcadAbstractNodeWrapper pad_drill;
                 QIcadAbstractNodeWrapper pad_to_mask_clearance;
                 QIcadAbstractNodeWrapper aux_axis_origin;
                 QIcadAbstractNodeWrapper visible_elements;
                 QIcadPcbPlotParams plotParams;
                 void setNode(QIlib::AbstractNode* node);
                 double defaultViaDrillSize(){return p_defaultViaDrillSize;}
             private:
                 double p_defaultViaDrillSize;
             };
             class QIcadPcbNetClass : public QIcadAbstractNodeWrapper
             {
             public:
                 QIcadPcbNetClass(QIlib::AbstractNode* node);
                 QIcadPcbNetClass(){}
                 QIcadAbstractNodeWrapper clearance;
                 QIcadAbstractNodeWrapper trace_width;
                 QIcadAbstractNodeWrapper via_dia;
                 QIcadAbstractNodeWrapper via_drill;
                 QIcadAbstractNodeWrapper uvia_dia;
                 QIcadAbstractNodeWrapper uvia_drill;
                 QList<QIcadAbstractNodeWrapper*> nets;
                 void setNode(QIlib::AbstractNode* node);
             };
             class QIcadPcbFpTextEffectsFont : public QIcadAbstractNodeWrapper
             {
             public:
                 QIcadPcbFpTextEffectsFont(QIlib::AbstractNode* node);
                 QIcadAbstractNodeWrapper size;
                 void setNode(QIlib::AbstractNode* node);
             };
             class QIcadPcbFpTextEffects : public QIcadAbstractNodeWrapper
             {
             public:
                 QIcadPcbFpTextEffects(QIlib::AbstractNode* node);
                 QIcadPcbFpTextEffects(){}
                 QIcadAbstractNodeWrapper font;
                 QIcadAbstractNodeWrapper thickness;
                 void setNode(QIlib::AbstractNode* node);
             };
             class QIcadPcbFPText : public QIcadAbstractNodeWrapper
             {
             public:
                 QIcadPcbFPText(QIlib::AbstractNode* node);
                 QIcadPcbFPText(){}
                 QIcadAbstractNodeWrapper at;
                 QIcadAbstractNodeWrapper layer;
                 QIcadPcbFpTextEffects effects;
                 void setNode(QIlib::AbstractNode* node);
             };
             class QIcadPcbModuleModel : public QIcadAbstractNodeWrapper
             {
             public:
                 QIcadPcbModuleModel(QIlib::AbstractNode* node);
                 QIcadPcbModuleModel(){}
                 QIcadAbstractNodeWrapper at;
                 QIcadAbstractNodeWrapper scale;
                 QIcadAbstractNodeWrapper rotate;
                 void setNode(QIlib::AbstractNode* node);
             };
             class QIcadPcbDimension : public QIcadAbstractNodeWrapper
             {
             public:
                 QIcadPcbDimension(QIlib::AbstractNode* node);
                 QIcadPcbDimension(){}
                 QIcadAbstractNodeWrapper width;
                 QIcadAbstractNodeWrapper layer;
                 QIcadAbstractNodeWrapper gr_text;
                 QIcadAbstractNodeWrapper feature1;
                 QIcadAbstractNodeWrapper feature2;
                 QIcadAbstractNodeWrapper crossbar;
                 QIcadAbstractNodeWrapper arrow1a;
                 QIcadAbstractNodeWrapper arrow1b;
                 QIcadAbstractNodeWrapper arrow2a;
                 QIcadAbstractNodeWrapper arrow2b;
                 void setNode(QIlib::AbstractNode* node);
             };
             class QIcadPcbPad : public QIcadAbstractNodeWrapper
             {
             public:
                 typedef enum
                 {
                     rectangle,
                     circle
                 }padShape;
                 QIcadPcbPad(QIlib::AbstractNode* node);
                 QIcadPcbPad(){}
                 QIcadAbstractNodeWrapper at;
                 QIcadAbstractNodeWrapper sizeNode;
                 QIcadAbstractNodeWrapper layer;
                 QIcadAbstractNodeWrapper netNode;
                 QIcadAbstractNodeWrapper drillNode;
                 const QStringList& layers(){return p_layers;}
                 const QSizeF& size(){return p_size;}
                 const QPointF& pos(){return p_pos;}
                 double drill(){return p_drill;}
+                double angle(){return p_angle;}
                 padShape shape(){return p_shape;}
+                int padNumber(){return p_padNumber;}
                 void setNode(QIlib::AbstractNode* node);
             private:
+                int p_padNumber;
                 padShape p_shape;
                 double p_drill;
+                double p_angle;
                 QSizeF p_size;
                 QPointF p_pos;
                 QStringList p_layers;
             };
             class QIcadPcbFPLine : public QIcadAbstractPcbLine
             {
             public:
                 QIcadPcbFPLine(QIlib::AbstractNode* node);
                 QIcadPcbFPLine(){}
                 QIcadAbstractNodeWrapper start;
                 QIcadAbstractNodeWrapper end;
                 QIcadAbstractNodeWrapper layer;
                 QIcadAbstractNodeWrapper width;
                 void setNode(QIlib::AbstractNode* node);
             };
             class QIcadPcbFPCircle : public QIcadAbstractNodeWrapper
             {
             public:
                 QIcadPcbFPCircle(QIlib::AbstractNode* node);
                 QIcadPcbFPCircle(){}
                 QIcadAbstractNodeWrapper center;
                 QIcadAbstractNodeWrapper end;
                 QIcadAbstractNodeWrapper layer;
                 QIcadAbstractNodeWrapper width;
                 void setNode(QIlib::AbstractNode* node);
             };
             class QIcadPcbModule : public QIcadAbstractNodeWrapper
             {
             public:
                 QIcadPcbModule(QIlib::AbstractNode* node);
                 QIcadPcbModule(){}
                 const QPointF& pos();
                 double angle();
                 QIcadAbstractNodeWrapper layer;
                 QIcadAbstractNodeWrapper tedit;
                 QIcadAbstractNodeWrapper tstamp;
                 QIcadAbstractNodeWrapper at;
                 QIcadAbstractNodeWrapper descr;
                 QIcadAbstractNodeWrapper tags;
                 QIcadAbstractNodeWrapper path;
                 QIcadAbstractNodeWrapper attr;
                 QList<QIcadPcbFPText*> fp_texts;
                 QList<QIcadPcbFPLine*> fp_lines;
                 QList<QIcadPcbFPCircle*> fp_circles;
                 QList<QIcadPcbPad*> pads;
                 QIcadPcbModuleModel model;
                 void setNode(QIlib::AbstractNode* node);
                 void clrPads();
                 void apendPad(QIlib::AbstractNode* node);
                 void clrTexts();
                 void apendText(QIlib::AbstractNode* node);
                 void clrLines();
                 void apendLine(QIlib::AbstractNode* node);
                 void clrCircles();
                 void apendCircle(QIlib::AbstractNode* node);
             private:
                 QPointF p_pos;
                 double p_angle;
             };
             class QIcadPcbSegment : public QIcadAbstractPcbLine
             {
             public:
                 QIcadPcbSegment(QIlib::AbstractNode* node);
                 QIcadPcbSegment(){}
                 QIcadAbstractNodeWrapper start;
                 QIcadAbstractNodeWrapper end;
                 QIcadAbstractNodeWrapper width;
                 QIcadAbstractNodeWrapper layer;
                 QIcadAbstractNodeWrapper net;
                 void setNode(QIlib::AbstractNode* node);
             };
             class QIcadPcbVia : public QIcadAbstractNodeWrapper
             {
             public:
                 QIcadPcbVia(QIlib::AbstractNode* node, double defaultDrill=0);
                 QIcadPcbVia(){}
                 QIcadAbstractNodeWrapper at;
                 QIcadAbstractNodeWrapper sizeNode;
                 QIcadAbstractNodeWrapper drillNode;
                 QIcadAbstractNodeWrapper layersNode;
                 QIcadAbstractNodeWrapper net;
                 QIcadAbstractNodeWrapper tstamp;
                 void setNode(QIlib::AbstractNode* node);
                 const QStringList& layers(){return p_layers;}
                 const QSizeF& size(){return p_size;}
                 const QPointF& pos(){return p_pos;}
                 double drill(){return p_drill;}
             private:
                 double p_drill;
                 QSizeF p_size;
                 QPointF p_pos;
                 QStringList p_layers;
             };
             class QIcadPcbLine : public QIcadAbstractPcbLine
             {
             public:
                 QIcadPcbLine(QIlib::AbstractNode* node);
                 QIcadPcbLine(){}
                 QIcadAbstractNodeWrapper start;
                 QIcadAbstractNodeWrapper end;
                 QIcadAbstractNodeWrapper angle;
                 QIcadAbstractNodeWrapper layer;
                 QIcadAbstractNodeWrapper width;
                 void setNode(QIlib::AbstractNode* node);
             };
             class QIcadPcbZone : public QIcadAbstractNodeWrapper
             {
             public:
                 QIcadPcbZone(QIlib::AbstractNode* node);
                 QIcadPcbZone(){}
                 void setNode(QIlib::AbstractNode* node);
             };
             class QIcadPcbArc : public QIcadAbstractNodeWrapper
             {
             public:
                 QIcadPcbArc(QIlib::AbstractNode* node);
                 QIcadPcbArc(){}
                 QIcadAbstractNodeWrapper start;
                 QIcadAbstractNodeWrapper end;
                 QIcadAbstractNodeWrapper angle;
                 QIcadAbstractNodeWrapper layer;
                 QIcadAbstractNodeWrapper width;
                 void setNode(QIlib::AbstractNode* node);
             };
             class QIcadPcbCircle : public QIcadAbstractNodeWrapper
             {
             public:
                 QIcadPcbCircle(QIlib::AbstractNode* node);
                 QIcadPcbCircle(){}
                 QIcadAbstractNodeWrapper center;
                 QIcadAbstractNodeWrapper end;
                 QIcadAbstractNodeWrapper layer;
                 QIcadAbstractNodeWrapper width;
                 void setNode(QIlib::AbstractNode* node);
             };
             class QIcadPcbText : public QIcadAbstractNodeWrapper
             {
             public:
                 QIcadPcbText(QIlib::AbstractNode* node);
                 QIcadPcbText(){}
                 QIcadAbstractNodeWrapper at;
                 QIcadAbstractNodeWrapper layer;
                 QIcadAbstractNodeWrapper width;
                 QIcadPcbFpTextEffects effects;
                 void setNode(QIlib::AbstractNode* node);
             };
             class QIcadPcbLayers : public QIcadAbstractNodeWrapper
             {
             public:
                 QIcadPcbLayers(QIlib::AbstractNode* node);
                 QIcadPcbLayers(){}
                 QList<QIcadPcbLayer*> layers;
                 void setNode(QIlib::AbstractNode* node);
                 void clrLayers();
                 void apendLayer(QIlib::AbstractNode* node);
             };
             class QIcadPcbGeneralInfo : public QIcadAbstractNodeWrapper
             {
             public:
                 QIcadPcbGeneralInfo(QIlib::AbstractNode* node);
                 QIcadPcbGeneralInfo(){}
                 QIcadAbstractNodeWrapper links;
                 QIcadAbstractNodeWrapper no_connections;
                 QIcadAbstractNodeWrapper area;
                 QIcadAbstractNodeWrapper thickness;
                 QIcadAbstractNodeWrapper drawings;
                 QIcadAbstractNodeWrapper tracks;
                 QIcadAbstractNodeWrapper zones;
                 QIcadAbstractNodeWrapper modules;
                 QIcadAbstractNodeWrapper nets;
                 void setNode(QIlib::AbstractNode* node);
             };
             class QIcadPcbRoot : public QIcadAbstractNodeWrapper
             {
             public:
                 QIcadPcbRoot(QIlib::AbstractNode* node);
                 QIcadAbstractNodeWrapper version;
                 QIcadAbstractNodeWrapper host;
                 QIcadAbstractNodeWrapper page;
                 QIcadPcbGeneralInfo general;
                 QIcadPcbLayers layers;
                 QIcadPcbSetup setup;
                 QList<QIcadAbstractNodeWrapper*> nets;
                 QList<QIcadPcbModule*> modules;
                 QList<QIcadPcbDimension*> dimensions;
                 QList<QIcadPcbLine*> lines;
                 QList<QIcadPcbSegment*> segments;
                 QList<QIcadPcbVia*> vias;
                 QList<QIcadPcbArc*> arcs;
                 QList<QIcadPcbCircle*> circles;
                 QList<QIcadPcbText*> texts;
                 QList<QIcadPcbZone*> zones;
                 void setNode(QIlib::AbstractNode* node);
                 void clrNets();
                 void apendNet(QIlib::AbstractNode* node);
                 void clrModules();
                 void apendModule(QIlib::AbstractNode* node);
                 void clrDimensions();
                 void apendDimension(QIlib::AbstractNode* node);
                 void apendLine(QIlib::AbstractNode* node);
                 void clrLines();
                 void clrSegments();
                 void apendSegment(QIlib::AbstractNode* node);
                 void clrVias();
                 void apendVia(QIlib::AbstractNode* node);
                 void clrArcs();
                 void apendArc(QIlib::AbstractNode* node);
                 void clrCircles();
                 void apendCircle(QIlib::AbstractNode* node);
                 void clrTexts();
                 void apendText(QIlib::AbstractNode* node);
                 void clrZones();
                 void apendZone(QIlib::AbstractNode* node);
             };
             class QIcadPcb : private lispLike_Driver
             {
             public:
                 QIcadPcb();
                 bool parsePcb(const QString& pcb);
                 QString toString();
                 QString fileName;
                 QString print();
                 QIcadPcbRoot* pcbRoot;
             private:
                 void updateConcreteTree();
             };
             }
             #endif // QICADPCB_H

test/PCBView/mainwindow.cpp +45 -27

             /*------------------------------------------------------------------------------
             --  This file is a part of the Kicad Tools Software
             --  Copyright (C) 2015, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include "mainwindow.h"
             #include "ui_mainwindow.h"
             #include "pcbmodule.h"
             #include "pcbline.h"
             #include "pcbvia.h"
+            #include <QFileDialog>
             MainWindow::MainWindow(QWidget *parent) :
                 QMainWindow(parent),
                 ui(new Ui::MainWindow)
             {
                 ui->setupUi(this);
                 this->p_scene = new QGraphicsScene();
-                this->p_scene->setSceneRect(0, 0, 500, 200);
                 this->context = new PCBContext();
                 this->ui->graphicsView->setScene(this->p_scene);
-                QIlib::QIcadPcb pcbDriver;
+                this->pcbDriver =NULL;
-            //    pcbDriver.parsePcb("/opt/kicadTools/test/testFiles/pcb2.kicad_pcb");
-            //    pcbDriver.parsePcb("/home/jeandet/Documents/PCB/ADC_STAMP/ADC_STAMP.kicad_pcb");
-                pcbDriver.parsePcb("/usr/share/kicad/demos/video/video.kicad_pcb");
-            //    pcbDriver.parsePcb("/usr/share/kicad/demos/kit-dev-coldfire-xilinx_5213/kit-dev-coldfire-xilinx_5213.kicad_pcb");
-                for(int i=0;i<pcbDriver.pcbRoot->layers.layers.count();i++)
-                    this->context->addlayer(pcbDriver.pcbRoot->layers.layers.at(i)->name(),pcbDriver.pcbRoot->layers.layers.at(i)->index());
-                for(int i=0;i<pcbDriver.pcbRoot->modules.count();i++)
-                    this->p_scene->addItem(new PCBModule(pcbDriver.pcbRoot->modules.at(i),this->context));
-                for(int i=0;i<pcbDriver.pcbRoot->lines.count();i++)
-                    this->p_scene->addItem(new PCBLine((QIlib::QIcadAbstractPcbLine*)pcbDriver.pcbRoot->lines.at(i),this->context));
-                for(int i=0;i<pcbDriver.pcbRoot->segments.count();i++)
-                    this->p_scene->addItem(new PCBLine((QIlib::QIcadAbstractPcbLine*)pcbDriver.pcbRoot->segments.at(i),this->context));
-                for(int i=0;i<pcbDriver.pcbRoot->vias.count();i++)
-                    this->p_scene->addItem(new PCBVia(pcbDriver.pcbRoot->vias.at(i),this->context));
                 connect(this->ui->actionRedraw,SIGNAL(triggered(bool)),this,SLOT(redraw()));
+                connect(this->ui->actionOpen,SIGNAL(triggered(bool)),this,SLOT(openFile()));
             }
             MainWindow::~MainWindow()
             {
                 delete ui;
             }
             void MainWindow::redraw()
             {
                 this->p_scene->update();
             }
+            void MainWindow::openFile()
+            {
+                QString file = QFileDialog::getOpenFileName(this,tr("Open kicad PCB file"),
+                                                            "",
+                                                            tr("PCB file (*.kicad_pcb)"));
+                if(QFile::exists(file))
+                    loadFile(file);
+            }
             void MainWindow::changeEvent(QEvent *e)
             {
                 QMainWindow::changeEvent(e);
                 switch (e->type()) {
                 case QEvent::LanguageChange:
                     ui->retranslateUi(this);
                     break;
                 default:
                     break;
                 }
             }
+            void MainWindow::loadFile(const QString &file)
+            {
+                this->p_scene->setSceneRect(0, 0, 500, 200);
+                if(pcbDriver!=NULL)delete pcbDriver;
+                pcbDriver = new QIlib::QIcadPcb();
+                this->context->clear();
+                this->p_scene->clear();
+            //    pcbDriver.parsePcb("/opt/kicadTools/test/testFiles/pcb2.kicad_pcb");
+            //    pcbDriver.parsePcb("/home/jeandet/Documents/PCB/ADC_STAMP/ADC_STAMP.kicad_pcb");
+                pcbDriver->parsePcb(file);
+            //    pcbDriver.parsePcb("/usr/share/kicad/demos/kit-dev-coldfire-xilinx_5213/kit-dev-coldfire-xilinx_5213.kicad_pcb");
+                for(int i=0;i<pcbDriver->pcbRoot->layers.layers.count();i++)
+                {
+                    this->context->addlayer(pcbDriver->pcbRoot->layers.layers.at(i)->name(),pcbDriver->pcbRoot->layers.layers.at(i)->index());
+                }
+                for(int i=0;i<pcbDriver->pcbRoot->modules.count();i++)
+                {
+                    this->p_scene->addItem(new PCBModule(pcbDriver->pcbRoot->modules.at(i),this->context));
+                }
+                for(int i=0;i<pcbDriver->pcbRoot->lines.count();i++)
+                {
+                    this->p_scene->addItem(new PCBLine((QIlib::QIcadAbstractPcbLine*)pcbDriver->pcbRoot->lines.at(i),this->context));
+                }
+                for(int i=0;i<pcbDriver->pcbRoot->segments.count();i++)
+                {
+                    this->p_scene->addItem(new PCBLine((QIlib::QIcadAbstractPcbLine*)pcbDriver->pcbRoot->segments.at(i),this->context));
+                }
+                for(int i=0;i<pcbDriver->pcbRoot->vias.count();i++)
+                {
+                    this->p_scene->addItem(new PCBVia(pcbDriver->pcbRoot->vias.at(i),this->context));
+                }
+            }

test/PCBView/mainwindow.h +3 0

             /*------------------------------------------------------------------------------
             --  This file is a part of the Kicad Tools Software
             --  Copyright (C) 2015, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #ifndef MAINWINDOW_H
             #define MAINWINDOW_H
             #include <QMainWindow>
             #include <QGraphicsScene>
             #include <qicadnetlist.h>
             #include <qicadpcb.h>
             #include <QMap>
             #include <pcbcontext.h>
             namespace Ui {
             class MainWindow;
             }
             class MainWindow : public QMainWindow
             {
                 Q_OBJECT
             public:
                 explicit MainWindow(QWidget *parent = 0);
                 ~MainWindow();
             public slots:
                 void redraw();
+                void openFile();
             protected:
                 void changeEvent(QEvent *e);
             private:
+                void loadFile(const QString& file);
                 Ui::MainWindow *ui;
                 QGraphicsScene* p_scene;
                 PCBContext* context;
+                QIlib::QIcadPcb* pcbDriver;
             };
             #endif // MAINWINDOW_H

test/PCBView/pcbcontext.cpp +6 0

             /*------------------------------------------------------------------------------
             --  This file is a part of the Kicad Tools Software
             --  Copyright (C) 2015, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include "pcbcontext.h"
             Qt::GlobalColor Colours[]= {
                 Qt::red,
                 Qt::blue,
                 Qt::black,
                 Qt::green,
                 Qt::darkGreen,
                 Qt::cyan,
                 Qt::darkRed,
                 Qt::gray,
                 Qt::yellow,
                 Qt::darkBlue,
                 Qt::darkCyan,
                 Qt::magenta,
                 Qt::darkMagenta,
                 Qt::darkYellow,
                 Qt::darkGray,
                 Qt::lightGray
             };
             PCBContext::PCBContext(QObject *parent) : QObject(parent)
             {
             }
             void PCBContext::addlayer(const QString &name, int number)
             {
                 this->layers_map[name]=number;
                 layers_colors[number] = Colours[number%15];
             }
             int PCBContext::layer(const QString &name)
             {
                 return layers_map[name];
             }
             const QColor &PCBContext::layerColor(const QString &name)
             {
                 return layers_colors[layers_map[name]];
             }
             const QColor &PCBContext::layerColor(int number)
             {
                 return layers_colors[number];
             }
             const QString PCBContext::layer(int number)
             {
                 return layers_map.key(number);
             }
+            void PCBContext::clear()
+            {
+                this->layers_colors.clear();
+                this->layers_map.clear();
+            }

test/PCBView/pcbcontext.h +1 0

             /*------------------------------------------------------------------------------
             --  This file is a part of the Kicad Tools Software
             --  Copyright (C) 2015, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #ifndef PCBCONTEXT_H
             #define PCBCONTEXT_H
             #include <QObject>
             #include <QWidget>
             #include <QMap>
             class PCBContext : public QObject
             {
                 Q_OBJECT
             public:
                 explicit PCBContext(QObject *parent = 0);
                 void addlayer(const QString& name,int number);
                 int layer(const QString& name);
                 const QColor& layerColor(const QString& name);
                 const QColor& layerColor(int number);
                 const QString layer(int number);
+                void clear();
             signals:
             public slots:
             private:
                 QMap<int,QColor> layers_colors;
                 QMap<QString,int> layers_map;
             };
             #endif // PCBCONTEXT_H

test/PCBView/pcbrectpad.cpp +9 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the Kicad Tools Software
             --  Copyright (C) 2015, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include "pcbrectpad.h"
             #include <QPen>
             PCBRectPad::PCBRectPad(QIlib::QIcadPcbPad *padNode, PCBContext *context)
                 :QGraphicsItemGroup(),padNode(padNode),context(context)
             {
                 this->init(QPointF(0.0,0.0));
             }
             PCBRectPad::PCBRectPad(QIlib::QIcadPcbPad *padNode, QPointF offset, PCBContext *context)
                 :QGraphicsItemGroup(),padNode(padNode),context(context)
             {
                 this->init(offset);
             }
             void PCBRectPad::init( QPointF offset)
             {
                 this->setCacheMode(QGraphicsItem::DeviceCoordinateCache);
                 offset-=QPointF(this->padNode->size().width()/2,this->padNode->size().height()/2);
                 if(this->padNode->shape()==QIlib::QIcadPcbPad::rectangle)
                 {
+                    QRectF rec(this->padNode->pos()+offset,this->padNode->size());
                     for(int i=0;i<this->padNode->layers().count();i++)
                     {
                         QGraphicsRectItem* rect = new QGraphicsRectItem();
+                        rect->setTransformOriginPoint(rec.center());
                         QPen pen = rect->pen();
                         pen.setWidthF(0.01);
                         rect->setPen(pen);
                         QBrush brush = rect->brush();
                         brush.setStyle(Qt::SolidPattern);
                         brush.setColor(context->layerColor(this->padNode->layers().at(i)));
                         rect->setBrush(brush);
-                        QRectF rec(this->padNode->pos()+offset,this->padNode->size());
                         rect->setRect(rec);
                         rect->setZValue(-context->layer(padNode->layers().at(i)));
+                        rect->setRotation(padNode->angle());
                         this->addToGroup(rect);
                     }
+                    QGraphicsTextItem* text=new QGraphicsTextItem(QString::number(padNode->padNumber()));
+                    text->setPos(rec.center());
+                    text->setScale(0.01);
+                    text->setZValue(1);
+                    this->addToGroup(text);
                 }
                 if(this->padNode->shape()==QIlib::QIcadPcbPad::circle)
                 {
                     for(int i=0;i<this->padNode->layers().count();i++)
                     {
                         QGraphicsEllipseItem* ellipse = new QGraphicsEllipseItem();
                         QPen pen = ellipse->pen();
                         pen.setWidthF(0.01);
                         ellipse->setPen(pen);
                         QBrush brush = ellipse->brush();
                         brush.setStyle(Qt::SolidPattern);
                         brush.setColor(context->layerColor(this->padNode->layers().at(i)));
                         ellipse->setBrush(brush);
                         QRectF rec(this->padNode->pos()+offset,this->padNode->size());
                         ellipse->setRect(rec);
                         ellipse->setZValue(-context->layer(padNode->layers().at(i)));
                         this->addToGroup(ellipse);
                     }
                 }
                 setOpacity(0.6);
             }

test/PCBView/pcbvia.cpp +16 -13

             /*------------------------------------------------------------------------------
             --  This file is a part of the Kicad Tools Software
             --  Copyright (C) 2015, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include "pcbvia.h"
             #include <QPen>
             PCBVia::PCBVia(QIlib::QIcadPcbVia *viaNode, PCBContext *context)
                 :QGraphicsItemGroup(),viaNode(viaNode),context(context)
             {
                 this->init(QPointF(0.0,0.0));
             }
             PCBVia::PCBVia(QIlib::QIcadPcbVia *viaNode, QPointF offset, PCBContext *context)
                 :QGraphicsItemGroup(),viaNode(viaNode),context(context)
             {
                 this->init(offset);
             }
             void PCBVia::init(QPointF offset)
             {
+                this->path.addEllipse(this->viaNode->pos(),this->viaNode->size().width()/2,this->viaNode->size().height()/2);
+                double thickness = (this->viaNode->size().width()-this->viaNode->drill())/2;
+                this->path.addEllipse(this->viaNode->pos(),(this->viaNode->size().width()/2)-thickness,(this->viaNode->size().height()/2)-thickness);
                 this->setCacheMode(QGraphicsItem::DeviceCoordinateCache);
                 this->setFlags(ItemIsMovable|ItemIsSelectable|ItemIsFocusable);
                 offset-=QPointF(this->viaNode->size().width()/2,this->viaNode->size().height()/2);
                 for(int i=0;i<this->viaNode->layers().count();i++)
                 {
-                    QGraphicsEllipseItem* ellipse = new QGraphicsEllipseItem();
+                    QGraphicsPathItem* pathitem = new QGraphicsPathItem();
-                    QPen pen = ellipse->pen();
+                    QPen pen = pathitem->pen();
-                    double thickness = (this->viaNode->size().width()-this->viaNode->drill())/2;
+                    pen.setWidthF(0.01);
-                    pen.setWidthF(thickness);
-                    ellipse->setPen(pen);
+                    pathitem->setPen(pen);
-            //        QBrush brush = ellipse->brush();
+                    QBrush brush = pathitem->brush();
-            //        brush.setStyle(Qt::SolidPattern);
+                    brush.setStyle(Qt::SolidPattern);
-            //        brush.setColor(context->layerColor(this->viaNode->layers().at(i)));
+                    brush.setColor(context->layerColor(this->viaNode->layers().at(i)));
-            //        ellipse->setBrush(brush);
+                    pathitem->setBrush(brush);
-                    QRectF rec(this->viaNode->pos()+offset,QSizeF(this->viaNode->size().width()-thickness,this->viaNode->size().width()-thickness));
+            //        QRectF rec(this->viaNode->pos()+offset,QSizeF(this->viaNode->size().width()-thickness,this->viaNode->size().width()-thickness));
-                    ellipse->setRect(rec);
+            //        pathitem->setRect(rec);
-                    ellipse->setZValue(-context->layer(viaNode->layers().at(i)));
+                    pathitem->setZValue(-context->layer(viaNode->layers().at(i)));
-                    this->addToGroup(ellipse);
+                    pathitem->setPath(path);
+                    this->addToGroup(pathitem);
                 }
                 setOpacity(0.6);
             }

test/PCBView/pcbvia.h +2 0

             /*------------------------------------------------------------------------------
             --  This file is a part of the Kicad Tools Software
             --  Copyright (C) 2015, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #ifndef PCBVIA_H
             #define PCBVIA_H
             #include <QObject>
             #include <QWidget>
             #include <QGraphicsRectItem>
             #include <QGraphicsItemGroup>
             #include <pcbcontext.h>
             #include <qicadpcb.h>
+            #include <QPainterPath>
             class PCBVia: public QGraphicsItemGroup
             {
             public:
                 PCBVia(QIlib::QIcadPcbVia* viaNode,PCBContext* context);
                 PCBVia(QIlib::QIcadPcbVia* viaNode,QPointF offset,PCBContext* context);
             private:
                 void init(QPointF offset);
                 QIlib::QIcadPcbVia* viaNode;
                 QString name;
                 QPointF pos;
                 QRectF size;
                 QList<int> layers;
                 PCBContext* context;
+                QPainterPath path;
             };
             #endif // PCBVIA_H

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages