GBR_LAYOUT Class Reference

Class GBR_LAYOUT holds list of GERBER_DRAW_ITEM currently loaded. More...

#include <class_gbr_layout.h>

Public Member Functions
	GBR_LAYOUT ()
	~GBR_LAYOUT ()
GERBER_FILE_IMAGE_LIST *	GetImagesList ()
const wxPoint &	GetAuxOrigin () const
void	SetAuxOrigin (const wxPoint &aPosition)
TITLE_BLOCK &	GetTitleBlock ()
void	SetTitleBlock (const TITLE_BLOCK &aTitleBlock)
EDA_RECT	ComputeBoundingBox ()
	Function ComputeBoundingBox calculates the bounding box containing all Gerber items. More...
EDA_RECT	GetBoundingBox () const
	Function GetBoundingBox may be called soon after ComputeBoundingBox() to return the same EDA_RECT, as long as the CLASS_GBR_LAYOUT has not changed. More...
void	SetBoundingBox (const EDA_RECT &aBox)
void	Draw (EDA_DRAW_PANEL *aPanel, wxDC *aDC, GR_DRAWMODE aDrawMode, const wxPoint &aOffset, GBR_DISPLAY_OPTIONS *aDisplayOptions)
	Function Draw. More...
void	DrawItemsDCodeID (EDA_DRAW_PANEL *aPanel, wxDC *aDC, GR_DRAWMODE aDrawMode, COLOR4D aDrawColor)
	Function DrawItemsDCodeID Draw the DCode value (if exists) corresponding to gerber item (polygons do not have a DCode) More...
void	SetPrintableLayers (const std::vector< int > &aLayerList)
	Function SetPrintableLayers Set the list of printable graphic layers. More...
std::vector< int >	GetPrintableLayers ()
	Function GetPrintableLayers. More...
void	ClearPrintableLayers ()
	Function ClearPrintableLayers Clear the list of graphic layers to print. More...
void	AddLayerToPrintableList (int aLayer)
	Function AddLayerToPrintableList Add a layer to the list of graphic layers to print. More...
bool	IsLayerPrintable (int aLayer) const
	Function IsLayerPrintable tests whether a given layer is visible. More...

Private Attributes
EDA_RECT	m_BoundingBox
TITLE_BLOCK	m_titles
wxPoint	m_originAxisPosition
std::vector< int >	m_printLayersList

Detailed Description

Class GBR_LAYOUT holds list of GERBER_DRAW_ITEM currently loaded.

Definition at line 53 of file class_gbr_layout.h.

Constructor & Destructor Documentation

GBR_LAYOUT::GBR_LAYOUT

(

)

Definition at line 39 of file class_gbr_layout.cpp.

{
}

GBR_LAYOUT::~GBR_LAYOUT

(

)

Definition at line 44 of file class_gbr_layout.cpp.

{
}

Member Function Documentation

void GBR_LAYOUT::AddLayerToPrintableList ( int  aLayer )

inline

Function AddLayerToPrintableList Add a layer to the list of graphic layers to print.

Parameters

aLayer

= the id of the graphic layer.

Definition at line 165 of file class_gbr_layout.h.

Referenced by GERBVIEW_FRAME::PrintPage().

    {
        m_printLayersList.push_back( aLayer );
    }

void GBR_LAYOUT::ClearPrintableLayers ( )

inline

Function ClearPrintableLayers Clear the list of graphic layers to print.

Definition at line 155 of file class_gbr_layout.h.

Referenced by GERBVIEW_FRAME::PrintPage().

    {
        m_printLayersList.clear();
    }

EDA_RECT GBR_LAYOUT::ComputeBoundingBox

(

)

Function ComputeBoundingBox calculates the bounding box containing all Gerber items.

Returns

EDA_RECT - the full item list bounding box

Definition at line 67 of file class_gbr_layout.cpp.

References GERBER_FILE_IMAGE_LIST::GetGbrImage(), GetImagesList(), GERBER_FILE_IMAGE::GetItemsList(), GERBER_FILE_IMAGE_LIST::ImagesMaxCount(), EDA_RECT::Merge(), GERBER_DRAW_ITEM::Next(), and SetBoundingBox().

Referenced by GERBVIEW_FRAME::BestZoom(), and GERBVIEW_FRAME::GetGerberLayoutBoundingBox().

{
    EDA_RECT bbox;
    bool first_item = true;

    for( unsigned layer = 0; layer < GetImagesList()->ImagesMaxCount(); ++layer )
    {
        GERBER_FILE_IMAGE* gerber = GetImagesList()->GetGbrImage( layer );

        if( gerber == NULL )    // Graphic layer not yet used
            continue;

        for( GERBER_DRAW_ITEM* item = gerber->GetItemsList(); item; item = item->Next() )
        {
            if( first_item )
            {
                bbox = item->GetBoundingBox();
                first_item = false;
            }
            else
                bbox.Merge( item->GetBoundingBox() );
        }
    }

    SetBoundingBox( bbox );
    return bbox;
}

void GBR_LAYOUT::Draw	(	EDA_DRAW_PANEL *	aPanel,
		wxDC *	aDC,
		GR_DRAWMODE	aDrawMode,
		const wxPoint &	aOffset,
		GBR_DISPLAY_OPTIONS *	aDisplayOptions
	)

Function Draw.

Redraw the CLASS_GBR_LAYOUT items but not cursors, axis or grid.

Parameters

aPanel	= the draw canvas
aDC	= the current device context
aDrawMode	= GR_COPY, GR_OR ... (not always used)
aOffset	= an draw offset value
aDisplayOptions	= a GBR_DISPLAY_OPTIONS for draw/print display opts

Definition at line 97 of file class_gbr_layout.cpp.

References BLACK, EDA_DRAW_PANEL::DoPrepareDC(), DrawModeAddHighlight(), GERBER_DRAWLAYERS_COUNT, GERBVIEW_FRAME::getActiveLayer(), EDA_RECT::GetBottom(), EDA_DRAW_PANEL::GetClipBox(), GERBER_FILE_IMAGE_LIST::GetGbrImage(), GetImagesList(), GERBER_FILE_IMAGE::GetItemsList(), GERBVIEW_FRAME::GetLayerColor(), EDA_DRAW_PANEL::GetParent(), GERBER_FILE_IMAGE::GetPositiveDrawColor(), EDA_RECT::GetRight(), EDA_RECT::GetX(), EDA_RECT::GetY(), GR_COPY, GR_OR, GRFilledRect(), GRSetDrawMode(), GERBER_FILE_IMAGE::HasNegativeItems(), IsLayerPrintable(), GERBVIEW_FRAME::IsLayerVisible(), GBR_DISPLAY_OPTIONS::m_BgDrawColor, GBR_DISPLAY_OPTIONS::m_ForceBlackAndWhite, GERBER_FILE_IMAGE::m_ImageNegative, GBR_DISPLAY_OPTIONS::m_IsPrinting, GERBER_FILE_IMAGE::m_IsVisible, GERBER_FILE_IMAGE::m_PositiveDrawColor, GERBVIEW_FRAME::m_SelAperAttributesBox, GERBVIEW_FRAME::m_SelComponentBox, GERBER_FILE_IMAGE::m_Selected_Tool, GERBVIEW_FRAME::m_SelNetnameBox, GERBER_DRAW_ITEM::Next(), scale, EDA_DRAW_PANEL::SetClipBox(), WHITE, wxPoint::x, and wxPoint::y.

Referenced by GERBVIEW_FRAME::PrintPage(), and GERBVIEW_FRAME::RedrawActiveWindow().

{
    GERBVIEW_FRAME* gerbFrame = (GERBVIEW_FRAME*) aPanel->GetParent();

    // Collect the highlight selections
    wxString cmpHighlight;

    if( gerbFrame->m_SelComponentBox->GetSelection() > 0 )
        cmpHighlight = gerbFrame->m_SelComponentBox->GetStringSelection();

    wxString netHighlight;

    if( gerbFrame->m_SelNetnameBox->GetSelection() > 0 )
        netHighlight = gerbFrame->m_SelNetnameBox->GetStringSelection();

    wxString aperAttrHighlight = gerbFrame->m_SelAperAttributesBox->GetStringSelection();

    if( gerbFrame->m_SelAperAttributesBox->GetSelection() > 0 )
        aperAttrHighlight = gerbFrame->m_SelAperAttributesBox->GetStringSelection();


    // Because Images can be negative (i.e with background filled in color) items are drawn
    // graphic layer per graphic layer, after the background is filled
    // to a temporary bitmap
    // at least when aDrawMode = GR_COPY or aDrawMode = GR_OR
    // If aDrawMode = UNSPECIFIED_DRAWMODE, items are drawn to the main screen, and therefore
    // artifacts can happen with negative items or negative images

    int      bitmapWidth, bitmapHeight;
    wxDC*    plotDC = aDC;

    aPanel->GetClientSize( &bitmapWidth, &bitmapHeight );

    wxBitmap*  layerBitmap  = NULL;
    wxBitmap*  screenBitmap = NULL;
    wxMemoryDC layerDC;         // used sequentially for each gerber layer
    wxMemoryDC screenDC;

    // When each image must be drawn using GR_OR (transparency mode)
    // or GR_COPY (stacked mode) we must use a temporary bitmap
    // to draw gerber images.
    // this is due to negative objects (drawn using background color) that create artifacts
    // on other images when drawn on screen
    bool useBufferBitmap = false;

#ifndef __WXMAC__
    // Can't work with MAC
    // Don't try this with retina display
    if( (aDrawMode == GR_COPY) || ( aDrawMode == GR_OR ) )
        useBufferBitmap = true;
#endif

    // these parameters are saved here, because they are modified
    // and restored later
    EDA_RECT drawBox = *aPanel->GetClipBox();
    double scale;
    aDC->GetUserScale(&scale, &scale);
    wxPoint dev_org = aDC->GetDeviceOrigin();
    wxPoint logical_org = aDC->GetLogicalOrigin( );

    COLOR4D bgColor = aDisplayOptions->m_BgDrawColor;
    wxBrush  bgBrush( bgColor.ToColour(), wxBRUSHSTYLE_SOLID );

    if( useBufferBitmap )
    {
        layerBitmap  = new wxBitmap( bitmapWidth, bitmapHeight );
        screenBitmap = new wxBitmap( bitmapWidth, bitmapHeight );
        layerDC.SelectObject( *layerBitmap );
        aPanel->DoPrepareDC( layerDC );
        aPanel->SetClipBox( drawBox );
        layerDC.SetBackground( bgBrush );
        layerDC.SetBackgroundMode( wxSOLID );
        layerDC.Clear();

        screenDC.SelectObject( *screenBitmap );
        screenDC.SetBackground( bgBrush );
        screenDC.SetBackgroundMode( wxSOLID );
        screenDC.Clear();

        plotDC = &layerDC;
    }

    bool doBlit = false; // this flag requests an image transfer to actual screen when true.

    bool end = false;

    // Draw graphic layers from bottom to top, and the active layer is on the top of others.
    // In non transparent modes, the last layer drawn masks others layers
    for( int layer = GERBER_DRAWLAYERS_COUNT-1; !end; --layer )
    {
        int active_layer = gerbFrame->getActiveLayer();

        if( layer == active_layer ) // active layer will be drawn after other layers
            continue;

        if( layer < 0 )   // last loop: draw active layer
        {
            end   = true;
            layer = active_layer;
        }

        GERBER_FILE_IMAGE* gerber = GetImagesList()->GetGbrImage( layer );

        if( gerber == NULL )    // Graphic layer not yet used
            continue;

        if( aDisplayOptions->m_IsPrinting )
            gerber->m_IsVisible = IsLayerPrintable( layer );
        else
            gerber->m_IsVisible = gerbFrame->IsLayerVisible( layer );

        if( !gerber->m_IsVisible )
            continue;

        gerber->m_PositiveDrawColor = gerbFrame->GetLayerColor( layer );

       // Force black and white draw mode on request:
        if( aDisplayOptions->m_ForceBlackAndWhite )
            gerber->m_PositiveDrawColor = ( aDisplayOptions->m_BgDrawColor == BLACK ) ? WHITE : BLACK;

        if( useBufferBitmap )
        {
            // Draw each layer into a bitmap first. Negative Gerber
            // layers are drawn in background color.
            if( gerber->HasNegativeItems() &&  doBlit )
            {
                // Set Device origin, logical origin and scale to default values
                // This is needed by Blit function when using a mask.
                // Beside, for Blit call, both layerDC and screenDc must have the same settings
                layerDC.SetDeviceOrigin(0,0);
                layerDC.SetLogicalOrigin( 0, 0 );
                layerDC.SetUserScale( 1, 1 );

                if( aDrawMode == GR_COPY )
                {
                    // Use the layer bitmap itself as a mask when blitting.  The bitmap
                    // cannot be referenced by a device context when setting the mask.
                    layerDC.SelectObject( wxNullBitmap );
                    layerBitmap->SetMask( new wxMask( *layerBitmap, bgColor.ToColour() ) );
                    layerDC.SelectObject( *layerBitmap );
                    screenDC.Blit( 0, 0, bitmapWidth, bitmapHeight, &layerDC, 0, 0, wxCOPY, true );
                }
                else if( aDrawMode == GR_OR )
                {
                    // On Linux with a large screen, this version is much faster and without
                    // flicker, but gives a Pcbnew look where layer colors blend together.
                    // Plus it works only because the background color is black.  But it may
                    // be more usable for some.  The difference is due in part because of
                    // the cpu cycles needed to create the monochromatic bitmap above, and
                    // the extra time needed to do bit indexing into the monochromatic bitmap
                    // on the blit above.
                    screenDC.Blit( 0, 0, bitmapWidth, bitmapHeight, &layerDC, 0, 0, wxOR );
                }
                // Restore actual values and clear bitmap for next drawing
                layerDC.SetDeviceOrigin( dev_org.x, dev_org.y );
                layerDC.SetLogicalOrigin( logical_org.x, logical_org.y );
                layerDC.SetUserScale( scale, scale );
                layerDC.SetBackground( bgBrush );
                layerDC.SetBackgroundMode( wxSOLID );
                layerDC.Clear();

                doBlit = false;
            }

        }

        if( gerber->m_ImageNegative )
        {
            // Draw background negative (i.e. in graphic layer color) for negative images.
            COLOR4D neg_color = gerber->GetPositiveDrawColor();

            GRSetDrawMode( &layerDC, GR_COPY );
            GRFilledRect( &drawBox, plotDC, drawBox.GetX(), drawBox.GetY(),
                          drawBox.GetRight(), drawBox.GetBottom(),
                          0, neg_color, neg_color );

            GRSetDrawMode( plotDC, GR_COPY );
            doBlit = true;
        }

        int dcode_highlight = 0;

        if( layer == gerbFrame->getActiveLayer() )
            dcode_highlight = gerber->m_Selected_Tool;

        GR_DRAWMODE layerdrawMode = GR_COPY;

        if( aDrawMode == GR_OR && !gerber->HasNegativeItems() )
            layerdrawMode = GR_OR;

        // Now we can draw the current layer to the bitmap buffer
        // When needed, the previous bitmap is already copied to the screen buffer.
        for( GERBER_DRAW_ITEM* item = gerber->GetItemsList(); item; item = item->Next() )
        {
            if( item->GetLayer() != layer )
                continue;

            GR_DRAWMODE drawMode = layerdrawMode;

            if( dcode_highlight && dcode_highlight == item->m_DCode )
                DrawModeAddHighlight( &drawMode);

            if( !aperAttrHighlight.IsEmpty() && item->GetDcodeDescr() &&
                item->GetDcodeDescr()->m_AperFunction == aperAttrHighlight )
                DrawModeAddHighlight( &drawMode);

            if( !cmpHighlight.IsEmpty() &&
                cmpHighlight == item->GetNetAttributes().m_Cmpref )
                DrawModeAddHighlight( &drawMode);

            if( !netHighlight.IsEmpty() &&
                netHighlight == item->GetNetAttributes().m_Netname )
                DrawModeAddHighlight( &drawMode);

            item->Draw( aPanel, plotDC, drawMode, wxPoint(0,0), aDisplayOptions );
            doBlit = true;
        }
    }

    if( doBlit && useBufferBitmap )     // Blit is used only if aDrawMode >= 0
    {
        // For this Blit call, layerDC and screenDC must have the same settings
        // So we set device origin, logical origin and scale to default values
        // in layerDC
        layerDC.SetDeviceOrigin(0,0);
        layerDC.SetLogicalOrigin( 0, 0 );
        layerDC.SetUserScale( 1, 1 );

        // this is the last transfer to screenDC.  If there are no negative items, this is
        // the only one
        if( aDrawMode == GR_COPY )
        {
            layerDC.SelectObject( wxNullBitmap );
            layerBitmap->SetMask( new wxMask( *layerBitmap, bgColor.ToColour() ) );
            layerDC.SelectObject( *layerBitmap );
            screenDC.Blit( 0, 0, bitmapWidth, bitmapHeight, &layerDC, 0, 0, wxCOPY, true );

        }
        else if( aDrawMode == GR_OR )
        {
            screenDC.Blit( 0, 0, bitmapWidth, bitmapHeight, &layerDC, 0, 0, wxOR );
        }
    }

    if( useBufferBitmap )
    {
        // For this Blit call, aDC and screenDC must have the same settings
        // So we set device origin, logical origin and scale to default values
        // in aDC
        aDC->SetDeviceOrigin( 0, 0);
        aDC->SetLogicalOrigin( 0, 0 );
        aDC->SetUserScale( 1, 1 );

        aDC->Blit( 0, 0, bitmapWidth, bitmapHeight, &screenDC, 0, 0, wxCOPY );

        // Restore aDC values
        aDC->SetDeviceOrigin(dev_org.x, dev_org.y);
        aDC->SetLogicalOrigin( logical_org.x, logical_org.y );
        aDC->SetUserScale( scale, scale );

        layerDC.SelectObject( wxNullBitmap );
        screenDC.SelectObject( wxNullBitmap );
        delete layerBitmap;
        delete screenBitmap;
    }
}

void GBR_LAYOUT::DrawItemsDCodeID	(	EDA_DRAW_PANEL *	aPanel,
		wxDC *	aDC,
		GR_DRAWMODE	aDrawMode,
		COLOR4D	aDrawColor
	)

Function DrawItemsDCodeID Draw the DCode value (if exists) corresponding to gerber item (polygons do not have a DCode)

Parameters

aPanel	= the draw canvas
aDC	= the current device context
aDrawMode	= GR_COPY, GR_OR ...
aDrawColor	= the color of dcode texts

Definition at line 366 of file class_gbr_layout.cpp.

References abs, delta, DrawGraphicText(), GBR_ARC, EDA_DRAW_PANEL::GetClipBox(), GERBER_FILE_IMAGE_LIST::GetGbrImage(), GetImagesList(), GERBER_FILE_IMAGE::GetItemsList(), GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER, GRSetDrawMode(), GERBER_FILE_IMAGE_LIST::ImagesMaxCount(), GERBER_FILE_IMAGE::m_IsVisible, min, GERBER_DRAW_ITEM::Next(), TEXT_ANGLE_HORIZ, TEXT_ANGLE_VERT, wxPoint::x, and wxPoint::y.

Referenced by GERBVIEW_FRAME::RedrawActiveWindow().

{
    wxPoint     pos;
    int         width;
    wxString    Line;

    GRSetDrawMode( aDC, aDrawMode );

    for( unsigned layer = 0; layer < GetImagesList()->ImagesMaxCount(); ++layer )
    {
        GERBER_FILE_IMAGE* gerber = GetImagesList()->GetGbrImage( layer );

        if( gerber == NULL )    // Graphic layer not yet used
            continue;

        if( ! gerber->m_IsVisible )
            continue;

        for( GERBER_DRAW_ITEM* item = gerber->GetItemsList(); item != NULL; item = item->Next() )
        {

            if( item->m_DCode <= 0 )
                continue;

            if( item->m_Flashed || item->m_Shape == GBR_ARC )
            {
                pos = item->m_Start;
            }
            else
            {
                pos.x = (item->m_Start.x + item->m_End.x) / 2;
                pos.y = (item->m_Start.y + item->m_End.y) / 2;
            }

            pos = item->GetABPosition( pos );

            Line.Printf( wxT( "D%d" ), item->m_DCode );

            if( item->GetDcodeDescr() )
                width = item->GetDcodeDescr()->GetShapeDim( item );
            else
                width = std::min( item->m_Size.x, item->m_Size.y );

            double orient = TEXT_ANGLE_HORIZ;

            if( item->m_Flashed )
            {
                // A reasonable size for text is width/3 because most of time this text has 3 chars.
                width /= 3;
            }
            else        // this item is a line
            {
                wxPoint delta = item->m_Start - item->m_End;

                if( abs( delta.x ) < abs( delta.y ) )
                    orient = TEXT_ANGLE_VERT;

                // A reasonable size for text is width/2 because text needs margin below and above it.
                // a margin = width/4 seems good
                width /= 2;
            }

            DrawGraphicText( aPanel->GetClipBox(), aDC, pos, aDrawColor, Line,
                             orient, wxSize( width, width ),
                             GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER,
                             0, false, false );
        }
    }
}

const wxPoint& GBR_LAYOUT::GetAuxOrigin ( ) const

inline

Definition at line 70 of file class_gbr_layout.h.

References m_originAxisPosition.

Referenced by GERBVIEW_FRAME::GetAuxOrigin().

    {
        return m_originAxisPosition;
    }

EDA_RECT GBR_LAYOUT::GetBoundingBox ( ) const

inline

Function GetBoundingBox may be called soon after ComputeBoundingBox() to return the same EDA_RECT, as long as the CLASS_GBR_LAYOUT has not changed.

Definition at line 102 of file class_gbr_layout.h.

References m_BoundingBox.

Referenced by GERBVIEW_FRAME::GetGerberLayoutBoundingBox().

{ return m_BoundingBox; }

GERBER_FILE_IMAGE_LIST * GBR_LAYOUT::GetImagesList

(

)

Definition at line 49 of file class_gbr_layout.cpp.

References GERBER_FILE_IMAGE_LIST::GetImagesList().

Referenced by GERBVIEW_FRAME::Block_Move(), ComputeBoundingBox(), Draw(), DrawItemsDCodeID(), GERBVIEW_FRAME::ExportDataInPcbnewFormat(), GBR_TO_PCB_EXPORTER::ExportPcb(), GERBVIEW_FRAME::GetGbrImage(), GERBVIEW_FRAME::GetImagesList(), GERBVIEW_FRAME::ImagesMaxCount(), LAYERS_MAP_DIALOG::initDialog(), DIALOG_PRINT_USING_PRINTER::InitValues(), and GERBVIEW_FRAME::Read_EXCELLON_File().

{
    return &GERBER_FILE_IMAGE_LIST::GetImagesList();
}

std::vector<int> GBR_LAYOUT::GetPrintableLayers ( )

inline

Function GetPrintableLayers.

Returns

the list of printable layers

Definition at line 146 of file class_gbr_layout.h.

References m_printLayersList.

Referenced by DIALOG_PRINT_USING_PRINTER::PreparePrintPrms(), and GERBVIEW_FRAME::PrintPage().

    {
        return m_printLayersList;
    }

TITLE_BLOCK& GBR_LAYOUT::GetTitleBlock ( )

inline

Definition at line 80 of file class_gbr_layout.h.

References m_titles.

Referenced by GERBVIEW_FRAME::GetTitleBlock().

    {
        return m_titles;
    }

bool GBR_LAYOUT::IsLayerPrintable

(

int

aLayer

)

const

Function IsLayerPrintable tests whether a given layer is visible.

Parameters

aLayer

= The layer to be tested

Returns

bool - true if the layer is in print list.

Definition at line 55 of file class_gbr_layout.cpp.

References m_printLayersList.

Referenced by Draw(), and GERBVIEW_FRAME::IsLayerVisible().

{
    for( unsigned ii = 0; ii < m_printLayersList.size(); ++ii )
    {
        if( m_printLayersList[ii] == aLayer )
            return true;
    }

    return false;
}

void GBR_LAYOUT::SetAuxOrigin ( const wxPoint &  aPosition )

inline

Definition at line 75 of file class_gbr_layout.h.

Referenced by GERBVIEW_FRAME::SetAuxOrigin().

    {
        m_originAxisPosition = aPosition;
    }

void GBR_LAYOUT::SetBoundingBox ( const EDA_RECT &  aBox )

inline

Definition at line 104 of file class_gbr_layout.h.

Referenced by GERBVIEW_FRAME::Clear_DrawLayers(), and ComputeBoundingBox().

{ m_BoundingBox = aBox; }

void GBR_LAYOUT::SetPrintableLayers ( const std::vector< int > &  aLayerList )

inline

Function SetPrintableLayers Set the list of printable graphic layers.

Parameters

aLayerList

= the new list (std::vector) of printable layer id

Definition at line 137 of file class_gbr_layout.h.

Referenced by GERBVIEW_FRAME::PrintPage().

    {
        m_printLayersList = aLayerList;
    }

void GBR_LAYOUT::SetTitleBlock ( const TITLE_BLOCK &  aTitleBlock )

inline

Definition at line 85 of file class_gbr_layout.h.

Referenced by GERBVIEW_FRAME::SetTitleBlock().

    {
        m_titles = aTitleBlock;
    }

Member Data Documentation

EDA_RECT GBR_LAYOUT::m_BoundingBox

private

Definition at line 56 of file class_gbr_layout.h.

Referenced by GetBoundingBox().

wxPoint GBR_LAYOUT::m_originAxisPosition

private

Definition at line 58 of file class_gbr_layout.h.

Referenced by GetAuxOrigin().

std::vector<int> GBR_LAYOUT::m_printLayersList

private

Definition at line 59 of file class_gbr_layout.h.

Referenced by GetPrintableLayers(), and IsLayerPrintable().

TITLE_BLOCK GBR_LAYOUT::m_titles

private

Definition at line 57 of file class_gbr_layout.h.

Referenced by GetTitleBlock().

---

The documentation for this class was generated from the following files:

• class_gbr_layout.h
• class_gbr_layout.cpp