HG_REPOSITORIES/LPP/INSTRUMENTATION/kicadtools Commit - r14:72560b13551a

Added Polygon drawing but huge perf issue, to be solved.

jeandet -

r14:72560b13551a default

parent child

Context file:

r14:72560b13551a

test/PCBView/pcbzone.cpp created 644 +62 0

@@ -0,0 +1,62
	1	/*------------------------------------------------------------------------------
	2	-- This file is a part of the Kicad Tools Software
	3	-- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
	4	--
	5	-- This program is free software; you can redistribute it and/or modify
	6	-- it under the terms of the GNU General Public License as published by
	7	-- the Free Software Foundation; either version 2 of the License, or
	8	-- (at your option) any later version.
	9	--
	10	-- This program is distributed in the hope that it will be useful,
	11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	-- GNU General Public License for more details.
	14	--
	15	-- You should have received a copy of the GNU General Public License
	16	-- along with this program; if not, write to the Free Software
	17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	-------------------------------------------------------------------------------*/
	19	/*-- Author : Alexis Jeandet
	20	-- Mail : alexis.jeandet@member.fsf.org
	21	----------------------------------------------------------------------------*/
	22	#include "pcbzone.h"
	23	#include <QPen>
	24	#include <QPixmapCache>
	25
	26	PCBZone::PCBZone(QIlib::QIcadPcbZone zoneNode, PCBContext context)
	27	:QGraphicsItemGroup(),zoneNode(zoneNode),context(context)
	28	{
	29	this->init();
	30	}
	31
	32	void PCBZone::init()
	33	{
	34	this->setFlags(ItemIsMovable\|ItemIsSelectable\|ItemIsFocusable);
	35	QPolygonF poly;
	36	for(int i=0;i<this->zoneNode->filledPolygon.points.points.count();i++)
	37	{
	38	poly.append(this->zoneNode->filledPolygon.points.points.at(i)->pos());
	39	}
	40	QGraphicsPixmapItem* test=new QGraphicsPixmapItem();
	41	QPixmap pix;
	42	QPainter painter;
	43	QGraphicsPolygonItem* polygonItem = new QGraphicsPolygonItem();
	44	QPen pen = polygonItem->pen();
	45	pen.setWidthF(0.01);
	46
	47	polygonItem->setPen(pen);
	48	QBrush brush = polygonItem->brush();
	49	brush.setStyle(Qt::SolidPattern);
	50	brush.setColor(context->layerColor(this->zoneNode->layer.value()));
	51	polygonItem->setBrush(brush);
	52	polygonItem->setZValue(-context->layer(this->zoneNode->layer.value()));
	53	polygonItem->setPolygon(poly);
	54	polygonItem->setCacheMode(QGraphicsItem::DeviceCoordinateCache);
	55	// test->setPixmap(polygonItem->);
	56	//voir doc/qt/...
	57	// polygonItem->paint();
	58	this->addToGroup(polygonItem);
	59
	60	this->setCacheMode(QGraphicsItem::DeviceCoordinateCache);
	61	setOpacity(0.6);
	62	}

test/PCBView/pcbzone.h created 644 +43 0

@@ -0,0 +1,43
	1	/*------------------------------------------------------------------------------
	2	-- This file is a part of the Kicad Tools Software
	3	-- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
	4	--
	5	-- This program is free software; you can redistribute it and/or modify
	6	-- it under the terms of the GNU General Public License as published by
	7	-- the Free Software Foundation; either version 2 of the License, or
	8	-- (at your option) any later version.
	9	--
	10	-- This program is distributed in the hope that it will be useful,
	11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	-- GNU General Public License for more details.
	14	--
	15	-- You should have received a copy of the GNU General Public License
	16	-- along with this program; if not, write to the Free Software
	17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	-------------------------------------------------------------------------------*/
	19	/*-- Author : Alexis Jeandet
	20	-- Mail : alexis.jeandet@member.fsf.org
	21	----------------------------------------------------------------------------*/
	22	#ifndef PCBZONE_H
	23	#define PCBZONE_H
	24	#include <QObject>
	25	#include <QWidget>
	26	#include <QGraphicsRectItem>
	27	#include <QGraphicsItemGroup>
	28	#include <pcbcontext.h>
	29	#include <qicadpcb.h>
	30	#include <QPainterPath>
	31
	32	class PCBZone: public QGraphicsItemGroup
	33	{
	34	public:
	35	PCBZone(QIlib::QIcadPcbZone* zoneNode,PCBContext* context);
	36	private:
	37	void init();
	38	QIlib::QIcadPcbZone* zoneNode;
	39	int layer;
	40	PCBContext* context;
	41	};
	42
	43	#endif // PCBZONE_H

qilib/qicadlisplikelexique.cpp +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
             ----------------------------------------------------------------------------*/
             const char*    add_net_c  =  "(add_net";
             const char*    angle_c  =  "(angle";
             const char*    area_c  =  "(area";
             const char*    arrow1a_c  =  "(arrow1a";
             const char*    arrow1b_c  =  "(arrow1b";
             const char*    arrow2a_c  =  "(arrow2a";
             const char*    arrow2b_c  =  "(arrow2b";
             const char*    at_c  =  "(at";
             const char*    attr_c  =  "(attr";
             const char*    center_c  =  "(center";
             const char*    clearance_c  =  "(clearance";
             const char*    code_c  =  "(code";
             const char*    component_c  =  "(component";
             const char*    components_c  =  "(components";
             const char*    crossbar_c  =  "(crossbar";
             const char*    date_c  =  "(date";
             const char*    design_c  =  "(design";
             const char*    dimension_c  =  "(dimension";
             const char*    drawings_c  =  "(drawings";
             const char*    drill_c  =  "(drill";
             const char*    drillshape_c  =  "(drillshape";
             const char*    edge_width_c  =  "(edge_width";
             const char*    effects_c  =  "(effects";
             const char*    end_c  =  "(end";
             const char*    excludeedgelayer_c  =  "(excludeedgelayer";
             const char*    export_c  =  "(export";
             const char*    feature1_c  =  "(feature1";
             const char*    feature2_c  =  "(feature2";
             const char*    field_c  =  "(field";
             const char*    fields_c  =  "(fields";
+            const char*    filled_polygon_c  =  "(filled_polygon";
             const char*    font_c  =  "(font";
             const char*    fp_circle_c  =  "(fp_circle";
             const char*    fp_line_c  =  "(fp_line";
             const char*    fp_text_c  =  "(fp_text";
             const char*    general_c  =  "(general";
             const char*    gr_arc_c  =  "(gr_arc";
             const char*    gr_circle_c  =  "(gr_circle";
             const char*    gr_line_c  =  "(gr_line";
             const char*    gr_text_c  =  "(gr_text";
             const char*    host_c  =  "(host";
             const char*    hpglpendiameter_c  =  "(hpglpendiameter";
             const char*    hpglpennumber_c  =  "(hpglpennumber";
             const char*    hpglpenoverlay_c  =  "(hpglpenoverlay";
             const char*    hpglpenspeed_c  =  "(hpglpenspeed";
             const char*    kicad_pcb_c  =  "(kicad_pcb";
             const char*    last_trace_width_c  =  "(last_trace_width";
             const char*    layers_c  =  "(layers";
             const char*    layer_c  =  "(layer";
             const char*    layerselection_c  =  "(layerselection";
             const char*    lib_c  =  "(lib";
             const char*    libpart_c  =  "(libpart";
             const char*    libparts_c  =  "(libparts";
             const char*    libraries_c  =  "(libraries";
             const char*    library_c  =  "(library";
             const char*    libsource_c  =  "(libsource";
             const char*    linewidth_c  =  "(linewidth";
             const char*    links_c  =  "(links";
             const char*    logical_c  =  "(logical";
             const char*    mirror_c  =  "(mirror";
             const char*    mod_edge_width_c  =  "(mod_edge_width";
             const char*    mod_text_size_c  =  "(mod_text_size";
             const char*    mode_c  =  "(mode";
             const char*    model_c  =  "(model";
             const char*    module_c  =  "(module";
             const char*    modules_c  =  "(modules";
             const char*    name_c  =  "(name";
             const char*    names_c  =  "(names";
             const char*    net_c  =  "(net";
             const char*    net_class_c  =  "(net_class";
             const char*    nets_c  =  "(nets";
             const char*    no_connect_c  =  "(no_connect";
             const char*    node_c  =  "(node";
             const char*    num_c  =  "(num";
             const char*    outputdirectory_c  =  "(outputdirectory";
             const char*    outputformat_c  =  "(outputformat";
             const char*    pad_c  =  "(pad";
             const char*    pad_drill_c  =  "(pad_drill";
             const char*    pad_size_c  =  "(pad_size";
             const char*    pad_to_mask_clearance_c  =  "(pad_to_mask_clearance";
             const char*    padsonsilk_c  =  "(padsonsilk";
             const char*    page_c  =  "(page";
             const char*    part_c  =  "(part";
             const char*    path_c  =  "(path";
             const char*    pcb_text_size_c  =  "(pcb_text_size";
             const char*    pcb_text_width_c  =  "(pcb_text_width";
             const char*    pcbplotparams_c  =  "(pcbplotparams";
             const char*    pin_c  =  "(pin";
             const char*    pins_c  =  "(pins";
             const char*    plotframeref_c  =  "(plotframeref";
             const char*    plotinvisibletext_c  =  "(plotinvisibletext";
             const char*    plotothertext_c  =  "(plotothertext";
             const char*    plotreference_c  =  "(plotreference";
             const char*    plotvalue_c  =  "(plotvalue";
+            const char*    polygon_c  =  "(polygon";
             const char*    psa4output_c  =  "(psa4output";
             const char*    psnegative_c  =  "(psnegative";
+            const char*    pts_c  =  "(pts";
             const char*    ref_c  =  "(ref";
             const char*    rotate  =  "(rota";
             const char*    scale_c  =  "(scale";
             const char*    scaleselection_c  =  "(scaleselection";
             const char*    segment_c  =  "(segment";
             const char*    segment_width_c  =  "(segment_width";
             const char*    setup_c  =  "(setup";
             const char*    sheetpath_c  =  "(sheetpath";
             const char*    size_c  =  "(size";
             const char*    source_c  =  "(source";
             const char*    start_c  =  "(start";
             const char*    subtractmaskfromsilk_c  =  "(subtractmaskfromsilk";
             const char*    tags_c  =  "(tags";
             const char*    tedit_c  =  "(tedit";
             const char*    thickness_c  =  "(thickness";
             const char*    tool_c  =  "(tool";
             const char*    trace_clearance_c  =  "(trace_clearance";
             const char*    trace_min_c  =  "(trace_min";
             const char*    trace_width_c  =  "(trace_width";
             const char*    tracks_c  =  "(tracks";
             const char*    tstamp_c  =  "(tstamp";
             const char*    tstamps_c  =  "(tstamps";
             const char*    type_c  =  "(type";
             const char*    uri_c  =  "(uri";
             const char*    useauxorigin_c  =  "(useauxorigin";
             const char*    usegerberextensions_c  =  "(usegerberextensions";
             const char*    uvia_dia_c  =  "(uvia_dia";
             const char*    uvia_drill_c  =  "(uvia_drill";
             const char*    uvia_min_drill_c  =  "(uvia_min_drill";
             const char*    uvia_min_size_c  =  "(uvia_min_size";
             const char*    uvia_size_c  =  "(uvia_size";
             const char*    uvias_allowed_c  =  "(uvias_allowed";
             const char*    value_c  =  "(value";
             const char*    version_c  =  "(version";
             const char*    via_c  =  "(via";
             const char*    via_dia_c  =  "(via_dia";
             const char*    via_drill_c  =  "(via_drill";
             const char*    via_min_drill_c  =  "(via_min_drill";
             const char*    via_min_size_c  =  "(via_min_size";
             const char*    via_size_c  =  "(via_size";
             const char*    viasonmask_c  =  "(viasonmask";
             const char*    visible_elements_c  =  "(visible_elements";
             const char*    width_c  =  "(width";
             const char*    xyz  =  "(x";
+            const char*    xy_c  =  "(xy";
             const char*    zone_45_only_c  =  "(zone_45_only";
             const char*    zone_clearance_c  =  "(zone_clearance";
             const char*    zone_c  =  "(zone";
             const char*    zones_c  =  "(zones";

qilib/qicadlisplikelexique.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
             ----------------------------------------------------------------------------*/
             /*
              *          Have a look to LispLikeLexique.ods
             */
             #ifndef LEXIQUE_H
             #define LEXIQUE_H
             namespace QIlib{
             namespace Lexique
             {
             extern "C" const char*   add_net_c;
             extern "C" const char*   angle_c;
             extern "C" const char*   area_c;
             extern "C" const char*   arrow1a_c;
             extern "C" const char*   arrow1b_c;
             extern "C" const char*   arrow2a_c;
             extern "C" const char*   arrow2b_c;
             extern "C" const char*   at_c;
             extern "C" const char*   attr_c;
             extern "C" const char*   center_c;
             extern "C" const char*   clearance_c;
             extern "C" const char*   code_c;
             extern "C" const char*   component_c;
             extern "C" const char*   components_c;
             extern "C" const char*   crossbar_c;
             extern "C" const char*   date_c;
             extern "C" const char*   design_c;
             extern "C" const char*   dimension_c;
             extern "C" const char*   drawings_c;
             extern "C" const char*   drill_c;
             extern "C" const char*   drillshape_c;
             extern "C" const char*   edge_width_c;
             extern "C" const char*   effects_c;
             extern "C" const char*   end_c;
             extern "C" const char*   excludeedgelayer_c;
             extern "C" const char*   export_c;
             extern "C" const char*   feature1_c;
             extern "C" const char*   feature2_c;
             extern "C" const char*   field_c;
             extern "C" const char*   fields_c;
+            extern "C" const char*   filled_polygon_c;
             extern "C" const char*   font_c;
             extern "C" const char*   fp_circle_c;
             extern "C" const char*   fp_line_c;
             extern "C" const char*   fp_text_c;
             extern "C" const char*   general_c;
             extern "C" const char*   gr_arc_c;
             extern "C" const char*   gr_circle_c;
             extern "C" const char*   gr_line_c;
             extern "C" const char*   gr_text_c;
             extern "C" const char*   host_c;
             extern "C" const char*   hpglpendiameter_c;
             extern "C" const char*   hpglpennumber_c;
             extern "C" const char*   hpglpenoverlay_c;
             extern "C" const char*   hpglpenspeed_c;
             extern "C" const char*   kicad_pcb_c;
             extern "C" const char*   last_trace_width_c;
             extern "C" const char*   layers_c;
             extern "C" const char*   layer_c;
             extern "C" const char*   layerselection_c;
             extern "C" const char*   lib_c;
             extern "C" const char*   libpart_c;
             extern "C" const char*   libparts_c;
             extern "C" const char*   libraries_c;
             extern "C" const char*   library_c;
             extern "C" const char*   libsource_c;
             extern "C" const char*   linewidth_c;
             extern "C" const char*   links_c;
             extern "C" const char*   logical_c;
             extern "C" const char*   mirror_c;
             extern "C" const char*   mod_edge_width_c;
             extern "C" const char*   mod_text_size_c;
             extern "C" const char*   mode_c;
             extern "C" const char*   model_c;
             extern "C" const char*   module_c;
             extern "C" const char*   modules_c;
             extern "C" const char*   name_c;
             extern "C" const char*   names_c;
             extern "C" const char*   net_c;
             extern "C" const char*   net_class_c;
             extern "C" const char*   nets_c;
             extern "C" const char*   no_connect_c;
             extern "C" const char*   node_c;
             extern "C" const char*   num_c;
             extern "C" const char*   outputdirectory_c;
             extern "C" const char*   outputformat_c;
             extern "C" const char*   pad_c;
             extern "C" const char*   pad_drill_c;
             extern "C" const char*   pad_size_c;
             extern "C" const char*   pad_to_mask_clearance_c;
             extern "C" const char*   padsonsilk_c;
             extern "C" const char*   page_c;
             extern "C" const char*   part_c;
             extern "C" const char*   path_c;
             extern "C" const char*   pcb_text_size_c;
             extern "C" const char*   pcb_text_width_c;
             extern "C" const char*   pcbplotparams_c;
             extern "C" const char*   pin_c;
             extern "C" const char*   pins_c;
             extern "C" const char*   plotframeref_c;
             extern "C" const char*   plotinvisibletext_c;
             extern "C" const char*   plotothertext_c;
             extern "C" const char*   plotreference_c;
             extern "C" const char*   plotvalue_c;
+            extern "C" const char*   polygon_c;
             extern "C" const char*   psa4output_c;
             extern "C" const char*   psnegative_c;
+            extern "C" const char*   pts_c;
             extern "C" const char*   ref_c;
             extern "C" const char*   rotate;
             extern "C" const char*   scale_c;
             extern "C" const char*   scaleselection_c;
             extern "C" const char*   segment_c;
             extern "C" const char*   segment_width_c;
             extern "C" const char*   setup_c;
             extern "C" const char*   sheetpath_c;
             extern "C" const char*   size_c;
             extern "C" const char*   source_c;
             extern "C" const char*   start_c;
             extern "C" const char*   subtractmaskfromsilk_c;
             extern "C" const char*   tags_c;
             extern "C" const char*   tedit_c;
             extern "C" const char*   thickness_c;
             extern "C" const char*   tool_c;
             extern "C" const char*   trace_clearance_c;
             extern "C" const char*   trace_min_c;
             extern "C" const char*   trace_width_c;
             extern "C" const char*   tracks_c;
             extern "C" const char*   tstamp_c;
             extern "C" const char*   tstamps_c;
             extern "C" const char*   type_c;
             extern "C" const char*   uri_c;
             extern "C" const char*   useauxorigin_c;
             extern "C" const char*   usegerberextensions_c;
             extern "C" const char*   uvia_dia_c;
             extern "C" const char*   uvia_drill_c;
             extern "C" const char*   uvia_min_drill_c;
             extern "C" const char*   uvia_min_size_c;
             extern "C" const char*   uvia_size_c;
             extern "C" const char*   uvias_allowed_c;
             extern "C" const char*   value_c;
             extern "C" const char*   version_c;
             extern "C" const char*   via_c;
             extern "C" const char*   via_dia_c;
             extern "C" const char*   via_drill_c;
             extern "C" const char*   via_min_drill_c;
             extern "C" const char*   via_min_size_c;
             extern "C" const char*   via_size_c;
             extern "C" const char*   viasonmask_c;
             extern "C" const char*   visible_elements_c;
             extern "C" const char*   width_c;
             extern "C" const char*   xyz;
+            extern "C" const char*   xy_c;
             extern "C" const char*   zone_45_only_c;
             extern "C" const char*   zone_clearance_c;
             extern "C" const char*   zone_c;
             extern "C" const char*   zones_c;
             }
             }
             #endif // LEXIQUE_H

qilib/qicadpcb.cpp +113 0

             #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),p_angle(0.0)
             {
                 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();
                                 this->updatePadsAngle();
                             }
                         }
                         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, this->p_angle));
                 }
             }
             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));
                 }
             }
             void QIlib::QIcadPcbModule::updatePadsAngle()
             {
                 for(int i=0;i<this->pads.count();i++)
                 {
                     this->pads.at(i)->setModuleAngle(this->p_angle);
                 }
             }
             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, double modAngle)
                 :QIcadAbstractNodeWrapper(node),p_Mod_angle(modAngle),p_angle(0.0)
             {
                 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;
+                    for(int i=0;i<node->nodes.count();i++)
+                    {
+                        if(node->nodes.at(i)->name==QIlib::Lexique::polygon_c)
+                        {
+                            this->polygon.setNode(node->nodes.at(i));
+                        }
+                        if(node->nodes.at(i)->name==QIlib::Lexique::filled_polygon_c)
+                        {
+                            this->filledPolygon.setNode(node->nodes.at(i));
+                        }
+                        if(node->nodes.at(i)->name==QIlib::Lexique::layer_c)
+                        {
+                            this->layer.setNode(node->nodes.at(i));
+                        }
+                    }
+                }
+            }
+            QIlib::QIcadPcbPolygonPoint::QIcadPcbPolygonPoint(QIlib::AbstractNode *node)
+                :QIcadAbstractNodeWrapper(node)
+            {
+                this->p_pos.setX(0.0);
+                this->p_pos.setY(0.0);
+                this->setNode(node);
+            }
+            void QIlib::QIcadPcbPolygonPoint::setNode(QIlib::AbstractNode *node)
+            {
+                if(node->name==QIlib::Lexique::xy_c)
+                {
+                    this->p_node = node;
+                    this->p_pos = nodeTo2DCoords(node);
                 }
             }
+            QIlib::QIcadPcbPolygon::QIcadPcbPolygon(QIlib::AbstractNode *node)
+                :QIcadAbstractNodeWrapper(node)
+            {
+                this->setNode(node);
+            }
+            void QIlib::QIcadPcbPolygon::setNode(QIlib::AbstractNode *node)
+            {
+                if(node->name==QIlib::Lexique::polygon_c)
+                {
+                    this->p_node = node;
+                    this->p_filled = false;
+                    for(int i=0;i<node->nodes.count();i++)
+                    {
+                        if(node->nodes.at(i)->name==QIlib::Lexique::pts_c)
+                        {
+                            this->points.setNode(node->nodes.at(i));
+                        }
+                    }
+                }
+                if(node->name==QIlib::Lexique::filled_polygon_c)
+                {
+                    this->p_node = node;
+                    this->p_filled = true;
+                    for(int i=0;i<node->nodes.count();i++)
+                    {
+                        if(node->nodes.at(i)->name==QIlib::Lexique::pts_c)
+                        {
+                            this->points.setNode(node->nodes.at(i));
+                        }
+                    }
+                }
+            }
+            QIlib::QIcadPcbPolygonPoints::QIcadPcbPolygonPoints(QIlib::AbstractNode *node)
+                :QIcadAbstractNodeWrapper(node)
+            {
+                this->setNode(node);
+            }
+            void QIlib::QIcadPcbPolygonPoints::setNode(QIlib::AbstractNode *node)
+            {
+                this->clrPoints();
+                if(node->name==QIlib::Lexique::pts_c)
+                {
+                    this->p_node = node;
+                    for(int i=0;i<node->nodes.count();i++)
+                    {
+                        if(node->nodes.at(i)->name==QIlib::Lexique::xy_c)
+                        {
+                            this->apendPoint(node->nodes.at(i));
+                        }
+                    }
+                }
+            }
+            void QIlib::QIcadPcbPolygonPoints::clrPoints()
+            {
+                while(points.count())
+                {
+                    QIcadPcbPolygonPoint* point;
+                    point = points.last();
+                    points.removeLast();
+                    delete point;
+                }
+            }
+            void QIlib::QIcadPcbPolygonPoints::apendPoint(QIlib::AbstractNode *node)
+            {
+                if(node->name==QIlib::Lexique::xy_c)
+                {
+                    this->points.append(new QIcadPcbPolygonPoint(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 +41 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,double modAngle=0.0);
                 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;}
                 void setModuleAngle(double modAngle){p_Mod_angle= modAngle;}
                 double angle(){return  - (p_angle - p_Mod_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;
                 // Dirty fix to transform pad angle from
                 // PCB coordinates to Module coordinates
                 double p_Mod_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:
                 void updatePadsAngle();
                 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 QIcadPcbPolygonPoint : public QIcadAbstractNodeWrapper
+            {
+            public:
+                QIcadPcbPolygonPoint(QIlib::AbstractNode* node);
+                QIcadPcbPolygonPoint(){}
+                void setNode(QIlib::AbstractNode* node);
+                const QPointF& pos(){return p_pos;}
+            private:
+                QPointF p_pos;
+            };
+            class QIcadPcbPolygonPoints : public QIcadAbstractNodeWrapper
+            {
+            public:
+                QIcadPcbPolygonPoints(QIlib::AbstractNode* node);
+                QIcadPcbPolygonPoints(){}
+                void setNode(QIlib::AbstractNode* node);
+                QList<QIcadPcbPolygonPoint*> points;
+                void clrPoints();
+                void apendPoint(QIlib::AbstractNode* node);
+            private:
+                QPointF p_pos;
+            };
+            class QIcadPcbPolygon : public QIcadAbstractNodeWrapper
+            {
+            public:
+                QIcadPcbPolygon(QIlib::AbstractNode* node);
+                QIcadPcbPolygon(){}
+                QIcadPcbPolygonPoints points;
+                void setNode(QIlib::AbstractNode* node);
+                bool isFilled(){return p_filled;}
+            private:
+                bool p_filled;
+            };
             class QIcadPcbZone : public QIcadAbstractNodeWrapper
             {
             public:
                 QIcadPcbZone(QIlib::AbstractNode* node);
                 QIcadPcbZone(){}
+                QIcadPcbPolygon polygon;
+                QIcadPcbPolygon filledPolygon;
+                QIcadAbstractNodeWrapper layer;
                 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/PCBView.pro +6 -4

             #-------------------------------------------------
             #
             # Project created by QtCreator 2015-06-11T21:37:25
             #
             #-------------------------------------------------
             QT       += core gui opengl
             CONFIG += qilib
             greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
             TARGET = PCBView
             TEMPLATE = app
             MOC_DIR      = moc
             RCC_DIR      = resources
             OBJECTS_DIR  = obj
             DESTDIR      = ../../bin
             INCLUDEPATH += $$top_builddir/../../qilib \
                                 $$top_srcdir/../../qilib
             LIBS += -L../../bin -lQIlib
             SOURCES += main.cpp\
                     mainwindow.cpp \
                 pcbgraphicview.cpp \
-                pcbrectpad.cpp \
                 pcbmodule.cpp \
                 pcbline.cpp \
                 pcbcontext.cpp \
-                pcbvia.cpp
+                pcbvia.cpp \
+                pcbpad.cpp \
+                pcbzone.cpp
             HEADERS  += mainwindow.h \
                 pcbgraphicview.h \
-                pcbrectpad.h \
                 pcbmodule.h \
                 pcbline.h \
                 pcbcontext.h \
-                pcbvia.h
+                pcbvia.h \
+                pcbpad.h \
+                pcbzone.h
             FORMS    += mainwindow.ui

test/PCBView/mainwindow.cpp +6 -3

             /*------------------------------------------------------------------------------
             --  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 "pcbzone.h"
             #include <QFileDialog>
             MainWindow::MainWindow(QWidget *parent) :
                 QMainWindow(parent),
                 ui(new Ui::MainWindow)
             {
                 ui->setupUi(this);
                 this->p_scene = new QGraphicsScene();
+            //    this->p_scene->setItemIndexMethod(QGraphicsScene::NoIndex);
                 this->context = new PCBContext();
                 this->ui->graphicsView->setScene(this->p_scene);
                 this->pcbDriver =NULL;
                 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));
                 }
+                for(int i=0;i<pcbDriver->pcbRoot->zones.count();i++)
+                {
+                    this->p_scene->addItem(new PCBZone(pcbDriver->pcbRoot->zones.at(i),this->context));
                 }
+            }

test/PCBView/pcbgraphicview.cpp +6 -4

             /*------------------------------------------------------------------------------
             --  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 "pcbgraphicview.h"
             #include <math.h>
             #include <QGLWidget>
+            #include <QOpenGLWidget>
+            #include <QPixmapCache>
             PCBGraphicView::PCBGraphicView(QWidget *parent)
                 :QGraphicsView(parent)
             {
                 this->setRenderHint(QPainter::Antialiasing, true);
                 this->setDragMode(QGraphicsView::RubberBandDrag);
                 this->setOptimizationFlags(QGraphicsView::DontSavePainterState);
                 this->setViewportUpdateMode(QGraphicsView::SmartViewportUpdate);
                 this->setContextMenuPolicy(Qt::ActionsContextMenu);
                 this->setTransformationAnchor(AnchorUnderMouse);
                 this->scale(qreal(0.8), qreal(0.8));
                 this->setRubberBandSelectionMode(Qt::ContainsItemBoundingRect);
-                this->setDragMode(RubberBandDrag);
                 this->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
                 this->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+            //    this->setViewport(new QOpenGLWidget());
+                QPixmapCache::setCacheLimit(1024*1024*4);
                 this->ctrl_pressed = false;
                 this->shift_pressed = false;
             }
             void PCBGraphicView::keyPressEvent(QKeyEvent *event)
             {
                 switch (event->key()) {
                 case Qt::Key_Plus:
                     zoomIn();
                     break;
                 case Qt::Key_Minus:
                     zoomOut();
                     break;
                 case Qt::Key_Shift:
                     this->shift_pressed = true;
                     break;
                 case Qt::Key_Control:
                     this->ctrl_pressed = true;
                     break;
                 default:
                     QGraphicsView::keyPressEvent(event);
                 }
             }
             void PCBGraphicView::keyReleaseEvent(QKeyEvent *event)
             {
                 switch (event->key()) {
                 case Qt::Key_Shift:
                     this->shift_pressed = false;
                     break;
                 case Qt::Key_Control:
                     this->ctrl_pressed = false;
                     break;
                 default:
                     QGraphicsView::keyReleaseEvent(event);
                 }
             }
             void PCBGraphicView::wheelEvent(QWheelEvent *event)
             {
                     if (event->modifiers() & Qt::ControlModifier)
                     {
+                        event->accept();
                         if (event->orientation()== Qt::Vertical)
                             scaleView(pow((double)2, event->delta() / 240.0));
                     }
                     else
                     {
                         if (event->modifiers() & Qt::ShiftModifier)
                         {
+                            event->accept();
                             QWheelEvent* tempevent = new QWheelEvent(event->pos(),(event->delta()/10),event->buttons(),event->modifiers(),Qt::Horizontal);
                             QGraphicsView::wheelEvent(tempevent);
                         }
                         else
                             QGraphicsView::wheelEvent(event);
                     }
             }
             void PCBGraphicView::drawBackground(QPainter *painter, const QRectF &rect)
             {
                 Q_UNUSED(rect);
                 // Shadow
                 QRectF sceneRect = this->sceneRect();
                 QRectF rightShadow(sceneRect.right(), sceneRect.top() + 20, 20, sceneRect.height());
                 QRectF bottomShadow(sceneRect.left() + 20, sceneRect.bottom(), sceneRect.width(), 20);
                 if (rightShadow.intersects(rect) || rightShadow.contains(rect))
                     painter->fillRect(rightShadow, Qt::darkGray);
                 if (bottomShadow.intersects(rect) || bottomShadow.contains(rect))
                     painter->fillRect(bottomShadow, Qt::darkGray);
                 // Fill
                 QLinearGradient gradient(sceneRect.topLeft(), sceneRect.bottomRight());
                 gradient.setColorAt(0, Qt::white);
                 gradient.setColorAt(1, Qt::lightGray);
                 painter->fillRect(rect.intersected(sceneRect), gradient);
                 painter->setBrush(Qt::NoBrush);
                 painter->drawRect(sceneRect);
             }
             void PCBGraphicView::scaleView(qreal scaleFactor)
             {
                 qreal factor = transform().scale(scaleFactor, scaleFactor).mapRect(QRectF(0, 0, 1, 1)).width();
                 if (factor < 0.02 || factor > 1000)
                     return;
                 scale(scaleFactor, scaleFactor);
             }
             void PCBGraphicView::zoomIn()
             {
                 scaleView(qreal(1.2));
             }
             void PCBGraphicView::zoomOut()
             {
                 scaleView(1 / qreal(1.2));
             }

test/PCBView/pcbgraphicview.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 PCBGRAPHICVIEW_H
             #define PCBGRAPHICVIEW_H
             #include <QGraphicsView>
             #include <QObject>
             #include <QWidget>
             #include <QKeyEvent>
             #include <QPainter>
             #include <QMap>
+            #include <QElapsedTimer>
             class PCBGraphicView : public QGraphicsView
             {
             public:
                 PCBGraphicView(QWidget *parent = 0);
                 void itemMoved();
             public slots:
                 void zoomIn();
                 void zoomOut();
             protected:
                 void keyPressEvent(QKeyEvent *event);
                 void keyReleaseEvent(QKeyEvent *event);
                 void wheelEvent(QWheelEvent *event);
                 void drawBackground(QPainter *painter, const QRectF &rect);
                 void scaleView(qreal scaleFactor);
             private:
                 bool ctrl_pressed;
                 bool shift_pressed;
             };
             #endif // PCBGRAPHICVIEW_H

test/PCBView/pcbmodule.cpp +2 -4

             /*------------------------------------------------------------------------------
             --  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 "pcbmodule.h"
             #include "pcbline.h"
-            #include "pcbrectpad.h"
+            #include "pcbpad.h"
             PCBModule::PCBModule(QIlib::QIcadPcbModule *moduleNode, PCBContext *context)
                 :QGraphicsItemGroup(),context(context)
             {
                 this->setCacheMode(QGraphicsItem::DeviceCoordinateCache);
                 this->setFlags(ItemIsMovable|ItemIsSelectable|ItemIsFocusable);
-            //    this->setFlag(QGraphicsItem::ItemSendsGeometryChanges, true);
-            //    this->addToGroup(new QGraphicsRectItem(0,0,2,2));
                 this->setPos(moduleNode->pos());
                 for(int i=0;i<moduleNode->fp_lines.count();i++)
                 {
                     this->addToGroup(new PCBLine((QIlib::QIcadAbstractPcbLine*)moduleNode->fp_lines.at(i),moduleNode->pos(),context));
                 }
                 for(int i=0;i<moduleNode->pads.count();i++)
                 {
-                    this->addToGroup(new PCBRectPad((QIlib::QIcadPcbPad*)moduleNode->pads.at(i),moduleNode->pos(),context));
+                    this->addToGroup(new PCBPad((QIlib::QIcadPcbPad*)moduleNode->pads.at(i),moduleNode->pos(),context));
                 }
                 this->setRotation(moduleNode->angle());
             }

test/PCBView/pcbpad.cpp ~~test/PCBView/pcbrectpad.cpp~~ renamed +4 -4

             /*------------------------------------------------------------------------------
             --  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 "pcbpad.h"
             #include <QPen>
-            PCBRectPad::PCBRectPad(QIlib::QIcadPcbPad *padNode, PCBContext *context)
+            PCBPad::PCBPad(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)
+            PCBPad::PCBPad(QIlib::QIcadPcbPad *padNode, QPointF offset, PCBContext *context)
                 :QGraphicsItemGroup(),padNode(padNode),context(context)
             {
                 this->init(offset);
             }
-            void PCBRectPad::init( QPointF offset)
+            void PCBPad::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);
                         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/pcbpad.h ~~test/PCBView/pcbrectpad.h~~ renamed +6 -6

             /*------------------------------------------------------------------------------
             --  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 PCBRECTPAD_H
+            #ifndef PCBPAD_H
-            #define PCBRECTPAD_H
+            #define PCBPAD_H
             #include <QObject>
             #include <QWidget>
             #include <QGraphicsRectItem>
             #include <QGraphicsItemGroup>
             #include <pcbcontext.h>
             #include <qicadpcb.h>
-            class PCBRectPad : public QGraphicsItemGroup
+            class PCBPad : public QGraphicsItemGroup
             {
             public:
-                PCBRectPad(QIlib::QIcadPcbPad* padNode,PCBContext* context);
+                PCBPad(QIlib::QIcadPcbPad* padNode,PCBContext* context);
-                PCBRectPad(QIlib::QIcadPcbPad* padNode,QPointF offset,PCBContext* context);
+                PCBPad(QIlib::QIcadPcbPad* padNode,QPointF offset,PCBContext* context);
             private:
                 void init(QPointF offset);
                 QIlib::QIcadPcbPad* padNode;
                 QString name;
                 QPointF pos;
                 QRectF size;
                 QList<int> layers;
                 PCBContext* context;
             };
-            #endif // PCBRECTPAD_H
+            #endif // PCBPAD_H

test/PCBView/pcbvia.cpp +2 -2

             /*------------------------------------------------------------------------------
             --  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->setCacheMode(QGraphicsItem::DeviceCoordinateCache);
+                this->setFlags(ItemIsMovable|ItemIsSelectable|ItemIsFocusable);
                 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++)
                 {
                     QGraphicsPathItem* pathitem = new QGraphicsPathItem();
                     QPen pen = pathitem->pen();
                     pen.setWidthF(0.01);
                     pathitem->setPen(pen);
                     QBrush brush = pathitem->brush();
                     brush.setStyle(Qt::SolidPattern);
                     brush.setColor(context->layerColor(this->viaNode->layers().at(i)));
                     pathitem->setBrush(brush);
             //        QRectF rec(this->viaNode->pos()+offset,QSizeF(this->viaNode->size().width()-thickness,this->viaNode->size().width()-thickness));
             //        pathitem->setRect(rec);
                     pathitem->setZValue(-context->layer(viaNode->layers().at(i)));
                     pathitem->setPath(path);
                     this->addToGroup(pathitem);
                 }
                 setOpacity(0.6);
             }

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