Added main execs

1 files changed, 688 insertions, 0 deletions

diff --git a/pcbnew/plot_brditems_plotter.cpp b/pcbnew/plot_brditems_plotter.cpp
new file mode 100644
index 0000000..248eda7
--- /dev/null
+++ b/pcbnew/plot_brditems_plotter.cpp
@@ -0,0 +1,688 @@
+/**
+ * @file plot_brditems_plotter.cpp
+ * @brief basic plot functions to plot board items, or a group of board items.
+ */
+
+
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 1992-2012 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#include <fctsys.h>
+#include <common.h>
+#include <plot_common.h>
+#include <base_struct.h>
+#include <drawtxt.h>
+#include <trigo.h>
+#include <macros.h>
+#include <wxBasePcbFrame.h>
+
+#include <class_board.h>
+#include <class_module.h>
+#include <class_track.h>
+#include <class_edge_mod.h>
+#include <class_pcb_text.h>
+#include <class_zone.h>
+#include <class_drawsegment.h>
+#include <class_mire.h>
+#include <class_dimension.h>
+
+#include <pcbnew.h>
+#include <pcbplot.h>
+
+/* class BRDITEMS_PLOTTER is a helper class to plot board items
+ * and a group of board items
+ */
+
+
+EDA_COLOR_T BRDITEMS_PLOTTER::getColor( LAYER_NUM aLayer )
+{
+    EDA_COLOR_T color = m_board->GetLayerColor( ToLAYER_ID( aLayer ) );
+    if (color == WHITE)
+        color = LIGHTGRAY;
+    return color;
+}
+
+
+void BRDITEMS_PLOTTER::PlotPad( D_PAD* aPad, EDA_COLOR_T aColor, EDA_DRAW_MODE_T aPlotMode )
+{
+    wxPoint shape_pos = aPad->ShapePos();
+
+    // Set plot color (change WHITE to LIGHTGRAY because
+    // the white items are not seen on a white paper or screen
+    m_plotter->SetColor( aColor != WHITE ? aColor : LIGHTGRAY);
+
+    switch( aPad->GetShape() )
+    {
+    case PAD_SHAPE_CIRCLE:
+        m_plotter->FlashPadCircle( shape_pos, aPad->GetSize().x, aPlotMode );
+        break;
+
+    case PAD_SHAPE_OVAL:
+        m_plotter->FlashPadOval( shape_pos, aPad->GetSize(),
+                                 aPad->GetOrientation(), aPlotMode );
+        break;
+
+    case PAD_SHAPE_TRAPEZOID:
+        {
+            wxPoint coord[4];
+            aPad->BuildPadPolygon( coord, wxSize(0,0), 0 );
+            m_plotter->FlashPadTrapez( shape_pos, coord,
+                                       aPad->GetOrientation(), aPlotMode );
+        }
+        break;
+
+    case PAD_SHAPE_RECT:
+    default:
+        m_plotter->FlashPadRect( shape_pos, aPad->GetSize(),
+                                 aPad->GetOrientation(), aPlotMode );
+        break;
+    }
+}
+
+
+bool BRDITEMS_PLOTTER::PlotAllTextsModule( MODULE* aModule )
+{
+    // see if we want to plot VALUE and REF fields
+    bool trace_val = GetPlotValue();
+    bool trace_ref = GetPlotReference();
+
+    TEXTE_MODULE* textModule = &aModule->Reference();
+    LAYER_NUM     textLayer = textModule->GetLayer();
+
+    if( textLayer >= LAYER_ID_COUNT )       // how will this ever be true?
+        return false;
+
+    if( !m_layerMask[textLayer] )
+        trace_ref = false;
+
+    if( !textModule->IsVisible() && !GetPlotInvisibleText() )
+        trace_ref = false;
+
+    textModule = &aModule->Value();
+    textLayer = textModule->GetLayer();
+
+    if( textLayer > LAYER_ID_COUNT )        // how will this ever be true?
+        return false;
+
+    if( !m_layerMask[textLayer] )
+        trace_val = false;
+
+    if( !textModule->IsVisible() && !GetPlotInvisibleText() )
+        trace_val = false;
+
+    // Plot text fields, if allowed
+    if( trace_ref )
+    {
+        PlotTextModule( &aModule->Reference(), getColor( textLayer ) );
+    }
+
+    if( trace_val )
+    {
+        PlotTextModule( &aModule->Value(), getColor( textLayer ) );
+    }
+
+    for( BOARD_ITEM *item = aModule->GraphicalItems().GetFirst(); item; item = item->Next() )
+    {
+        textModule = dyn_cast<TEXTE_MODULE*>( item );
+
+        if( !textModule )
+            continue;
+
+        if( !textModule->IsVisible() )
+            continue;
+
+        textLayer = textModule->GetLayer();
+
+        if( textLayer >= LAYER_ID_COUNT )
+            return false;
+
+        if( !m_layerMask[textLayer] )
+            continue;
+
+        PlotTextModule( textModule, getColor( textLayer ) );
+    }
+
+    return true;
+}
+
+
+// plot items like text and graphics, but not tracks and module
+void BRDITEMS_PLOTTER::PlotBoardGraphicItems()
+{
+    for( BOARD_ITEM* item = m_board->m_Drawings; item; item = item->Next() )
+    {
+        switch( item->Type() )
+        {
+        case PCB_LINE_T:
+            PlotDrawSegment( (DRAWSEGMENT*) item);
+            break;
+
+        case PCB_TEXT_T:
+            PlotTextePcb( (TEXTE_PCB*) item );
+            break;
+
+        case PCB_DIMENSION_T:
+            PlotDimension( (DIMENSION*) item );
+            break;
+
+        case PCB_TARGET_T:
+            PlotPcbTarget( (PCB_TARGET*) item );
+            break;
+
+        case PCB_MARKER_T:
+        default:
+            break;
+        }
+    }
+}
+
+void BRDITEMS_PLOTTER::PlotTextModule( TEXTE_MODULE* pt_texte, EDA_COLOR_T aColor )
+{
+    wxSize  size;
+    wxPoint pos;
+    double  orient;
+    int     thickness;
+
+    if( aColor == WHITE )
+        aColor = LIGHTGRAY;
+
+    m_plotter->SetColor( aColor );
+
+    // calculate some text parameters :
+    size = pt_texte->GetSize();
+    pos = pt_texte->GetTextPosition();
+
+    orient = pt_texte->GetDrawRotation();
+
+    thickness = pt_texte->GetThickness();
+
+    if( pt_texte->IsMirrored() )
+        size.x = -size.x;  // Text is mirrored
+
+    // Non bold texts thickness is clamped at 1/6 char size by the low level draw function.
+    // but in Pcbnew we do not manage bold texts and thickness up to 1/4 char size
+    // (like bold text) and we manage the thickness.
+    // So we set bold flag to true
+    bool allow_bold = pt_texte->IsBold() || thickness;
+
+    m_plotter->Text( pos, aColor,
+                     pt_texte->GetShownText(),
+                     orient, size,
+                     pt_texte->GetHorizJustify(), pt_texte->GetVertJustify(),
+                     thickness, pt_texte->IsItalic(), allow_bold );
+}
+
+
+void BRDITEMS_PLOTTER::PlotDimension( DIMENSION* aDim )
+{
+    if( !m_layerMask[aDim->GetLayer()] )
+        return;
+
+    DRAWSEGMENT draw;
+
+    draw.SetWidth( aDim->GetWidth() );
+    draw.SetLayer( aDim->GetLayer() );
+
+    EDA_COLOR_T color = getColor( aDim->GetLayer() );
+
+    // Set plot color (change WHITE to LIGHTGRAY because
+    // the white items are not seen on a white paper or screen
+    m_plotter->SetColor( color );
+
+    PlotTextePcb( &aDim->Text() );
+
+    draw.SetStart( aDim->m_crossBarO );
+    draw.SetEnd( aDim->m_crossBarF );
+    PlotDrawSegment( &draw );
+
+    draw.SetStart( aDim->m_featureLineGO);
+    draw.SetEnd( aDim->m_featureLineGF );
+    PlotDrawSegment( &draw );
+
+    draw.SetStart( aDim->m_featureLineDO );
+    draw.SetEnd( aDim->m_featureLineDF );
+    PlotDrawSegment( &draw );
+
+    draw.SetStart( aDim->m_crossBarF );
+    draw.SetEnd( aDim->m_arrowD1F );
+    PlotDrawSegment( &draw );
+
+    draw.SetStart( aDim->m_crossBarF );
+    draw.SetEnd( aDim->m_arrowD2F );
+    PlotDrawSegment( &draw );
+
+    draw.SetStart( aDim->m_crossBarO );
+    draw.SetEnd( aDim->m_arrowG1F );
+    PlotDrawSegment( &draw );
+
+    draw.SetStart( aDim->m_crossBarO );
+    draw.SetEnd( aDim->m_arrowG2F );
+    PlotDrawSegment( &draw );
+}
+
+
+void BRDITEMS_PLOTTER::PlotPcbTarget( PCB_TARGET* aMire )
+{
+    int     dx1, dx2, dy1, dy2, radius;
+
+    if( !m_layerMask[aMire->GetLayer()] )
+        return;
+
+    m_plotter->SetColor( getColor( aMire->GetLayer() ) );
+
+    DRAWSEGMENT  draw;
+
+    draw.SetShape( S_CIRCLE );
+    draw.SetWidth( aMire->GetWidth() );
+    draw.SetLayer( aMire->GetLayer() );
+    draw.SetStart( aMire->GetPosition() );
+    radius = aMire->GetSize() / 3;
+
+    if( aMire->GetShape() )   // shape X
+        radius = aMire->GetSize() / 2;
+
+    // Draw the circle
+    draw.SetEnd( wxPoint( draw.GetStart().x + radius, draw.GetStart().y ));
+
+    PlotDrawSegment( &draw );
+
+    draw.SetShape( S_SEGMENT );
+
+    radius = aMire->GetSize() / 2;
+    dx1    = radius;
+    dy1    = 0;
+    dx2    = 0;
+    dy2    = radius;
+
+    if( aMire->GetShape() )    // Shape X
+    {
+        dx1 = dy1 = radius;
+        dx2 = dx1;
+        dy2 = -dy1;
+    }
+
+    wxPoint mirePos( aMire->GetPosition() );
+
+    // Draw the X or + shape:
+    draw.SetStart( wxPoint( mirePos.x - dx1, mirePos.y - dy1 ));
+    draw.SetEnd(   wxPoint( mirePos.x + dx1, mirePos.y + dy1 ));
+    PlotDrawSegment( &draw );
+
+    draw.SetStart( wxPoint( mirePos.x - dx2, mirePos.y - dy2 ));
+    draw.SetEnd(   wxPoint( mirePos.x + dx2, mirePos.y + dy2 ));
+    PlotDrawSegment( &draw );
+}
+
+
+// Plot footprints graphic items (outlines)
+void BRDITEMS_PLOTTER::Plot_Edges_Modules()
+{
+    for( MODULE* module = m_board->m_Modules;  module;  module = module->Next() )
+    {
+        for( BOARD_ITEM* item = module->GraphicalItems().GetFirst(); item; item = item->Next() )
+        {
+            EDGE_MODULE* edge = dyn_cast<EDGE_MODULE*>( item );
+
+            if( !edge || !m_layerMask[edge->GetLayer()] )
+                continue;
+
+            Plot_1_EdgeModule( edge );
+        }
+    }
+}
+
+
+//* Plot a graphic item (outline) relative to a footprint
+void BRDITEMS_PLOTTER::Plot_1_EdgeModule( EDGE_MODULE* aEdge )
+{
+    int     type_trace;         // Type of item to plot.
+    int     thickness;          // Segment thickness.
+    int     radius;             // Circle radius.
+
+    if( aEdge->Type() != PCB_MODULE_EDGE_T )
+        return;
+
+    m_plotter->SetColor( getColor( aEdge->GetLayer() ) );
+
+    type_trace = aEdge->GetShape();
+    thickness  = aEdge->GetWidth();
+
+    wxPoint pos( aEdge->GetStart() );
+    wxPoint end( aEdge->GetEnd() );
+
+    switch( type_trace )
+    {
+    case S_SEGMENT:
+        m_plotter->ThickSegment( pos, end, thickness, GetPlotMode() );
+        break;
+
+    case S_CIRCLE:
+        radius = KiROUND( GetLineLength( end, pos ) );
+        m_plotter->ThickCircle( pos, radius * 2, thickness, GetPlotMode() );
+        break;
+
+    case S_ARC:
+    {
+        radius = KiROUND( GetLineLength( end, pos ) );
+        double startAngle  = ArcTangente( end.y - pos.y, end.x - pos.x );
+        double endAngle = startAngle + aEdge->GetAngle();
+
+        m_plotter->ThickArc( pos, -endAngle, -startAngle, radius, thickness, GetPlotMode() );
+    }
+    break;
+
+    case S_POLYGON:
+    {
+        const std::vector<wxPoint>& polyPoints = aEdge->GetPolyPoints();
+
+        if( polyPoints.size() <= 1 )  // Malformed polygon
+            break;
+
+        // We must compute true coordinates from m_PolyList
+        // which are relative to module position, orientation 0
+        MODULE* module = aEdge->GetParentModule();
+
+        std::vector< wxPoint > cornerList;
+
+        cornerList.reserve( polyPoints.size() );
+
+        for( unsigned ii = 0; ii < polyPoints.size(); ii++ )
+        {
+            wxPoint corner = polyPoints[ii];
+
+            if( module )
+            {
+                RotatePoint( &corner, module->GetOrientation() );
+                corner += module->GetPosition();
+            }
+
+            cornerList.push_back( corner );
+        }
+
+        m_plotter->PlotPoly( cornerList, FILLED_SHAPE, thickness );
+    }
+    break;
+    }
+}
+
+
+// Plot a PCB Text, i;e. a text found on a copper or technical layer
+void BRDITEMS_PLOTTER::PlotTextePcb( TEXTE_PCB* pt_texte )
+{
+    double  orient;
+    int     thickness;
+    wxPoint pos;
+    wxSize  size;
+    wxString shownText( pt_texte->GetShownText() );
+
+    if( shownText.IsEmpty() )
+        return;
+
+    if( !m_layerMask[pt_texte->GetLayer()] )
+        return;
+
+    EDA_COLOR_T color = getColor( pt_texte->GetLayer() );
+    m_plotter->SetColor( color );
+
+    size      = pt_texte->GetSize();
+    pos       = pt_texte->GetTextPosition();
+    orient    = pt_texte->GetOrientation();
+    thickness = pt_texte->GetThickness();
+
+    if( pt_texte->IsMirrored() )
+        size.x = -size.x;
+
+    // Non bold texts thickness is clamped at 1/6 char size by the low level draw function.
+    // but in Pcbnew we do not manage bold texts and thickness up to 1/4 char size
+    // (like bold text) and we manage the thickness.
+    // So we set bold flag to true
+    bool allow_bold = pt_texte->IsBold() || thickness;
+
+    if( pt_texte->IsMultilineAllowed() )
+    {
+        std::vector<wxPoint> positions;
+        wxArrayString strings_list;
+        wxStringSplit( shownText, strings_list, '\n' );
+        positions.reserve(  strings_list.Count() );
+
+        pt_texte->GetPositionsOfLinesOfMultilineText( positions, strings_list.Count() );
+
+        for( unsigned ii = 0; ii <  strings_list.Count(); ii++ )
+        {
+            wxString& txt =  strings_list.Item( ii );
+            m_plotter->Text( positions[ii], color, txt, orient, size,
+                             pt_texte->GetHorizJustify(), pt_texte->GetVertJustify(),
+                             thickness, pt_texte->IsItalic(), allow_bold );
+        }
+    }
+    else
+    {
+        m_plotter->Text( pos, color, shownText, orient, size,
+                         pt_texte->GetHorizJustify(), pt_texte->GetVertJustify(),
+                         thickness, pt_texte->IsItalic(), allow_bold );
+    }
+}
+
+
+/* Plot areas (given by .m_FilledPolysList member) in a zone
+ */
+void BRDITEMS_PLOTTER::PlotFilledAreas( ZONE_CONTAINER* aZone )
+{
+    const SHAPE_POLY_SET& polysList = aZone->GetFilledPolysList();
+
+    if( polysList.IsEmpty() )
+        return;
+
+    // We need a buffer to store corners coordinates:
+    static std::vector< wxPoint > cornerList;
+    cornerList.clear();
+
+    m_plotter->SetColor( getColor( aZone->GetLayer() ) );
+
+    /* Plot all filled areas: filled areas have a filled area and a thick
+     * outline we must plot the filled area itself ( as a filled polygon
+     * OR a set of segments ) and plot the thick outline itself
+     *
+     * in non filled mode the outline is plotted, but not the filling items
+     */
+    for( SHAPE_POLY_SET::CONST_ITERATOR ic =  polysList.CIterate(); ic; ++ic )
+    {
+        wxPoint pos( ic->x, ic->y );
+        cornerList.push_back( pos );
+
+        if( ic.IsEndContour() )   // Plot the current filled area outline
+        {
+            // First, close the outline
+            if( cornerList[0] != cornerList[cornerList.size() - 1] )
+            {
+                cornerList.push_back( cornerList[0] );
+            }
+
+            // Plot the current filled area and its outline
+            if( GetPlotMode() == FILLED )
+            {
+                // Plot the filled area polygon.
+                // The area can be filled by segments or uses solid polygons
+                if( aZone->GetFillMode() == 0 ) // We are using solid polygons
+                {
+                    m_plotter->PlotPoly( cornerList, FILLED_SHAPE, aZone->GetMinThickness() );
+                }
+                else    // We are using areas filled by segments: plot segments and outline
+                {
+                    for( unsigned iseg = 0; iseg < aZone->FillSegments().size(); iseg++ )
+                    {
+                        wxPoint start = aZone->FillSegments()[iseg].m_Start;
+                        wxPoint end   = aZone->FillSegments()[iseg].m_End;
+                        m_plotter->ThickSegment( start, end,
+                                                 aZone->GetMinThickness(),
+                                                 GetPlotMode() );
+                    }
+
+                // Plot the area outline only
+                if( aZone->GetMinThickness() > 0 )
+                    m_plotter->PlotPoly( cornerList, NO_FILL, aZone->GetMinThickness() );
+                }
+            }
+            else
+            {
+                if( aZone->GetMinThickness() > 0 )
+                {
+                    for( unsigned jj = 1; jj<cornerList.size(); jj++ )
+                        m_plotter->ThickSegment( cornerList[jj -1], cornerList[jj],
+                                                 aZone->GetMinThickness(),
+                                                 GetPlotMode() );
+                }
+
+                m_plotter->SetCurrentLineWidth( -1 );
+            }
+
+            cornerList.clear();
+        }
+    }
+}
+
+
+/* Plot items type DRAWSEGMENT on layers allowed by aLayerMask
+ */
+void BRDITEMS_PLOTTER::PlotDrawSegment( DRAWSEGMENT* aSeg )
+{
+    if( !m_layerMask[aSeg->GetLayer()] )
+        return;
+
+    int     radius = 0;
+    double  StAngle = 0, EndAngle = 0;
+    int thickness = aSeg->GetWidth();
+
+    m_plotter->SetColor( getColor( aSeg->GetLayer() ) );
+
+    wxPoint start( aSeg->GetStart() );
+    wxPoint end(   aSeg->GetEnd() );
+
+    m_plotter->SetCurrentLineWidth( thickness );
+
+    switch( aSeg->GetShape() )
+    {
+    case S_CIRCLE:
+        radius = KiROUND( GetLineLength( end, start ) );
+        m_plotter->ThickCircle( start, radius * 2, thickness, GetPlotMode() );
+        break;
+
+    case S_ARC:
+        radius = KiROUND( GetLineLength( end, start ) );
+        StAngle  = ArcTangente( end.y - start.y, end.x - start.x );
+        EndAngle = StAngle + aSeg->GetAngle();
+        m_plotter->ThickArc( start, -EndAngle, -StAngle, radius, thickness, GetPlotMode() );
+        break;
+
+    case S_CURVE:
+        {
+            const std::vector<wxPoint>& bezierPoints = aSeg->GetBezierPoints();
+
+            for( unsigned i = 1; i < bezierPoints.size(); i++ )
+                m_plotter->ThickSegment( bezierPoints[i - 1],
+                                         bezierPoints[i],
+                                         thickness, GetPlotMode() );
+        }
+        break;
+
+    default:
+        m_plotter->ThickSegment( start, end, thickness, GetPlotMode() );
+    }
+}
+
+
+/** Helper function to plot a single drill mark. It compensate and clamp
+ *   the drill mark size depending on the current plot options
+ */
+void BRDITEMS_PLOTTER::plotOneDrillMark( PAD_DRILL_SHAPE_T aDrillShape,
+                           const wxPoint &aDrillPos, wxSize aDrillSize,
+                           const wxSize &aPadSize,
+                           double aOrientation, int aSmallDrill )
+{
+    // Small drill marks have no significance when applied to slots
+    if( aSmallDrill && aDrillShape == PAD_DRILL_SHAPE_CIRCLE )
+        aDrillSize.x = std::min( aSmallDrill, aDrillSize.x );
+
+    // Round holes only have x diameter, slots have both
+    aDrillSize.x -= getFineWidthAdj();
+    aDrillSize.x = Clamp( 1, aDrillSize.x, aPadSize.x - 1 );
+
+    if( aDrillShape == PAD_DRILL_SHAPE_OBLONG )
+    {
+        aDrillSize.y -= getFineWidthAdj();
+        aDrillSize.y = Clamp( 1, aDrillSize.y, aPadSize.y - 1 );
+        m_plotter->FlashPadOval( aDrillPos, aDrillSize, aOrientation, GetPlotMode() );
+    }
+    else
+        m_plotter->FlashPadCircle( aDrillPos, aDrillSize.x, GetPlotMode() );
+}
+
+
+void BRDITEMS_PLOTTER::PlotDrillMarks()
+{
+    /* If small drills marks were requested prepare a clamp value to pass
+       to the helper function */
+    int small_drill = (GetDrillMarksType() == PCB_PLOT_PARAMS::SMALL_DRILL_SHAPE) ?
+                        SMALL_DRILL : 0;
+
+    /* In the filled trace mode drill marks are drawn white-on-black to scrape
+       the underlying pad. This works only for drivers supporting color change,
+       obviously... it means that:
+       - PS, SVG and PDF output is correct (i.e. you have a 'donut' pad)
+       - In HPGL you can't see them
+       - In gerbers you can't see them, too. This is arguably the right thing to
+         do since having drill marks and high speed drill stations is a sure
+         recipe for broken tools and angry manufacturers. If you *really* want them
+         you could start a layer with negative polarity to scrape the film.
+       - In DXF they go into the 'WHITE' layer. This could be useful.
+     */
+    if( GetPlotMode() == FILLED )
+         m_plotter->SetColor( WHITE );
+
+    for( TRACK *pts = m_board->m_Track; pts != NULL; pts = pts->Next() )
+    {
+        const VIA* via = dyn_cast<const VIA*>( pts );
+
+        if( via )
+            plotOneDrillMark( PAD_DRILL_SHAPE_CIRCLE, via->GetStart(),
+                    wxSize( via->GetDrillValue(), 0 ),
+                    wxSize( via->GetWidth(), 0 ), 0, small_drill );
+    }
+
+    for( MODULE *Module = m_board->m_Modules; Module != NULL; Module = Module->Next() )
+    {
+        for( D_PAD *pad = Module->Pads(); pad != NULL; pad = pad->Next() )
+        {
+            if( pad->GetDrillSize().x == 0 )
+                continue;
+
+            plotOneDrillMark( pad->GetDrillShape(),
+                              pad->GetPosition(), pad->GetDrillSize(),
+                              pad->GetSize(), pad->GetOrientation(),
+                              small_drill );
+        }
+    }
+
+    if( GetPlotMode() == FILLED )
+        m_plotter->SetColor( GetColor() );
+}