haskal
/
kicad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

GerbView header housekeeping.

This commit is contained in:
Wayne Stambaugh 2021-06-03 14:32:24 -04:00
parent 937f502158
commit 5395a7fe67
15 changed files with 738 additions and 786 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
gerbview/X2_gerber_attributes.h
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application.
*
* Copyright (C) 2010-2018 Jean-Pierre Charras jp.charras at wanadoo.fr
* Copyright (C) 1992-2018 KiCad Developers, see AUTHORS.txt for contributors.
* Copyright (C) 1992-2021 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
@ -47,17 +47,11 @@
#include <wx/arrstr.h>
/**
* X2_ATTRIBUTE
* The attribute value consists of a number of substrings separated by a comma
*/
class X2_ATTRIBUTE
{
protected:
wxArrayString m_Prms; ///< the list of parameters (after TF) in gbr file
///< the first one is the attribute name,
///< if starting by '.'
public:
X2_ATTRIBUTE();
~X2_ATTRIBUTE();
@ -88,8 +82,8 @@ public:
int GetPrmCount() { return int( m_Prms.GetCount() ); }
/**
* parse a TF command terminated with a % and fill m_Prms
* by the parameters found.
* Parse a TF command terminated with a % and fill m_Prms by the parameters found.
*
* @param aFile = a FILE* ptr to the current Gerber file.
* @param aBuffer = the buffer containing current Gerber data (can be null)
* @param aBuffSize = the size of the buffer
@ -102,12 +96,12 @@ public:
bool ParseAttribCmd( FILE* aFile, char *aBuffer, int aBuffSize, char* &aText, int& aLineNum );
/**
* Debug function: pring using wxLogMessage le list of parameters
* Debug function: print using wxLogMessage le list of parameters
*/
void DbgListPrms();
/**
* return true if the attribute is .FileFunction
* Return true if the attribute is .FileFunction
*/
bool IsFileFunction()
{
@ -115,7 +109,7 @@ public:
}
/**
* return true if the attribute is .MD5
* Return true if the attribute is .MD5
*/
bool IsFileMD5()
{
@ -123,12 +117,17 @@ public:
}
/**
* return true if the attribute is .Part
* Return true if the attribute is .Part
*/
bool IsFilePart()
{
return GetAttribute().IsSameAs( wxT(".Part"), false );
}
protected:
wxArrayString m_Prms; ///< the list of parameters (after TF) in gbr file
///< the first one is the attribute name,
///< if starting by '.'
};
/**
@ -149,9 +148,6 @@ public:
class X2_ATTRIBUTE_FILEFUNCTION : public X2_ATTRIBUTE
{
int m_z_order; // the z order of the layer for a board
int m_z_sub_order; // the z sub_order of the copper layer for a board
public:
X2_ATTRIBUTE_FILEFUNCTION( X2_ATTRIBUTE& aAttributeBase );
@ -199,6 +195,9 @@ private:
* Initialize the z order priority of the current file, from its attributes
*/
void set_Z_Order();
int m_z_order; // the z order of the layer for a board
int m_z_sub_order; // the z sub_order of the copper layer for a board
};
#endif // X2_GERBER_ATTRIBUTE_H

92
gerbview/am_param.h
View File

@ -7,7 +7,7 @@
*
* Copyright (C) 1992-2017 Jean-Pierre Charras <jp.charras at wanadoo.fr>
* Copyright (C) 2010 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
* Copyright (C) 1992-2017 KiCad Developers, see change_log.txt for contributors.
* Copyright (C) 1992-2021 KiCad Developers, see change_log.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
@ -36,8 +36,8 @@
* Inside a given aperture primitive, a fixed list of parameters defines info
* about the shape: size, thickness, number of vertex ...
*
* Each parameter can be an immediate value or a defered value.
* When value is defered, it is defined when the aperture macro is instancied by
* Each parameter can be an immediate value or a deferred value.
* When value is deferred, it is defined when the aperture macro is instanced by
* an ADD macro command
*
* Actual values of a parameter can also be the result of an arithmetic operation.
@ -45,12 +45,12 @@
* Here is some examples:
* An immediate value:
* 3.5
* A deferend value:
* A deferred value:
* $2 means: replace me by the second value given in the ADD command
* Actual value as arithmetic calculation:
* $2/2+1
*
* Note also a defered parameter can be defined in aperture macro,
* Note also a defer ed parameter can be defined in aperture macro,
* but outside aperture primitives. Example
* %AMRECTHERM*
* $4=$3/2* parameter $4 is half value of parameter $3
@ -77,7 +77,7 @@
* Example of instanciation:
* %ADD12VECTOR,0.05X0X0*%
*
* A more complicated aperture macro definition, with parameters and arihmetic operations:
* A more complicated aperture macro definition, with parameters and arithmetic operations:
* %AMRNDREC*
* 0 this is a comment*
* 21,1,$1+$1,$2+$2-$3-$3,0,0,0*
@ -105,14 +105,14 @@
#include <dcode.h>
/*
Values of a parameter can be the result of an arithmetic operation,
between immediate values and defered value.
between immediate values and deferred value.
From an idea found in Gerbv, here is the way to evaluate a parameter.
a AM_PARAM_ITEM holds info about operands and operators in a parameter definition
( a AM_PARAM ) like $2+$2-$3-$3/2
Precedence was recently actually defined in gerber RS274X
(Previously, there was no actual info about this precedence)
This is the usual arithmetic precendence between + - x / ( ), the only ones used in Gerber
This is the usual arithmetic precedence between + - x / ( ), the only ones used in Gerber
Before 2015 apr 10, actual value was calculated step to step:
no precedence, and '(' ')' are ignored.
@ -131,7 +131,7 @@ NOP : The no operation. This is the default instruction and are
added as a security measure.
PUSHVALUE : Pushes an arithmetical value on the stack. This machine only works with floats
on the stack.
PUSHPARM: Pushes a defered parameter onto the stack. Gerber aperture macros accepts
PUSHPARM: Pushes a deferred parameter onto the stack. Gerber aperture macros accepts
parameters to be set when later declared, so the same macro can
be used at several instances. Which parameter to be set is an integer
and starts with 1. definition is like $1 or $3
@ -210,20 +210,14 @@ private:
typedef std::vector<AM_PARAM_EVAL> AM_PARAM_EVAL_STACK;
/**
* AM_PARAM
* holds an operand for an AM_PARAM as defined within
* standard RS274X. The \a value field can be a constant, i.e. "immediate"
* parameter or it may not be used if this param is going to defer to the
* referencing aperture macro. In that case, the \a index field is an index
* into the aperture macro's parameters.
* Hold an operand for an AM_PARAM as defined within standard RS274X.
*
* The \a value field can be a constant, i.e. "immediate" parameter or it may not be used if
* this param is going to defer to the referencing aperture macro. In that case, the \a index
* field is an index into the aperture macro's parameters.
*/
class AM_PARAM_ITEM
{
private:
parm_item_type m_type; // the type of item
double m_dvalue; // the value, for PUSHVALUE type item
int m_ivalue; // the integer value, for PUSHPARM type item
public:
AM_PARAM_ITEM( parm_item_type aType, double aValue )
{
@ -272,33 +266,31 @@ public:
{
return m_type == PUSHPARM;
}
private:
parm_item_type m_type; // the type of item
double m_dvalue; // the value, for PUSHVALUE type item
int m_ivalue; // the integer value, for PUSHPARM type item
};
/**
* AM_PARAM
* holds a parameter value for an "aperture macro" as defined within
* standard RS274X. The parameter can be a constant, i.e. "immediate" parameter,
* or depend on some defered values, defined in a D_CODE, by the ADD command.
* Note the actual value could need an evaluation from an arithmetical expression
* items in the expression are stored in .
* A simple definition is just a value stored in one item in m_paramStack
* Hold a parameter value for an "aperture macro" as defined within standard RS274X.
*
* The parameter can be a constant, i.e. "immediate" parameter, or depend on some deferred
* values, defined in a D_CODE, by the ADD command. Note the actual value could need an
* evaluation from an arithmetical expression items in the expression are stored in. A
* simple definition is just a value stored in one item in m_paramStack.
*/
class AM_PARAM
{
private:
int m_index; // has meaning to define parameter local to an aperture macro
std::vector<AM_PARAM_ITEM> m_paramStack; // list of operands/operators to evalutate the actual value
// if a par def is $3/2, there are 3 items in stack:
// 3 (type PUSHPARM) , / (type DIV), 2 (type PUSHVALUE)
public:
AM_PARAM();
/**
* function PushOperator
* add an operator/operand to the current stack
* @param aType = the type of item (NOP, PUSHVALUE, PUSHPARM, ADD, SUB, MUL, DIV, EQUATE)
* @param aValue = the item value, double for PUSHVALUE or int for PUSHPARM type.
* Add an operator/operand to the current stack.
*
* @param aType is the type of item (NOP, PUSHVALUE, PUSHPARM, ADD, SUB, MUL, DIV, EQUATE)
* @param aValue is the item value, double for PUSHVALUE or int for PUSHPARM type.
*/
void PushOperator( parm_item_type aType, double aValue );
void PushOperator( parm_item_type aType, int aValue = 0);
@ -306,10 +298,11 @@ public:
double GetValue( const D_CODE* aDcode ) const;
/**
* Function IsImmediate
* tests if this AM_PARAM holds an immediate parameter or is a pointer
* into a parameter held by an owning D_CODE.
* @return true if the value is immediate, i.e. no defered value in operands used in its definition
* Test if this AM_PARAM holds an immediate parameter or is a pointer into a parameter held
* by an owning D_CODE.
*
* @return true if the value is immediate, i.e. no deferred value in operands used in its
* definition.
*/
bool IsImmediate() const;
@ -324,18 +317,27 @@ public:
}
/**
* Function ReadParam
* Read one aperture macro parameter
* Read one aperture macro parameter.
*
* a parameter can be:
* a number
* a reference to an aperture definition parameter value: $1 ot $3 ...
* a parameter definition can be complex and have operators between numbers and/or other parameter
* a reference to an aperture definition parameter value: $1 to $3 ...
* a parameter definition can be complex and have operators between numbers and/or other
* parameter
* like $1+3 or $2x2..
* Parameters are separated by a comma ( of finish by *)
* @param aText = pointer to the parameter to read. Will be modified to point to the next field
* @return true if a param is read, or false
*/
bool ReadParam( char*& aText );
private:
int m_index; ///< has meaning to define parameter local to an aperture macro
std::vector<AM_PARAM_ITEM> m_paramStack; ///< List of operands/operators to evaluate the
///< actual value if a par def is $3/2, there are
///< 3 items in stack: 3 (type PUSHPARM) , / (type
///< DIV), 2 (type PUSHVALUE).
};
typedef std::vector<AM_PARAM> AM_PARAMS;

186
gerbview/am_primitive.h
View File

@ -10,7 +10,7 @@
*
* Copyright (C) 1992-2010 Jean-Pierre Charras <jp.charras at wanadoo.fr>
* Copyright (C) 2010 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
* Copyright (C) 1992-2010 KiCad Developers, see AUTHORS.txt for contributors.
* Copyright (C) 1992-2021 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
@ -44,10 +44,10 @@ class SHAPE_POLY_SET;
* Inside a given aperture primitive, a fixed list of parameters defines info
* about the shape: size, thickness, number of vertex ...
*
* Each parameter can be an immediate value or a defered value.
* When value is defered, it is defined when the aperture macro is instancied by
* Each parameter can be an immediate value or a deferred value.
* When value is deferred, it is defined when the aperture macro is instanced by
* an ADD macro command
* Note also a defered parameter can be defined in aperture macro,
* Note also a deferred parameter can be defined in aperture macro,
* but outside aperture primitives. Example
* %AMRECTHERM*
* $4=$3/2* parameter $4 is half value of parameter $3
@ -61,31 +61,33 @@ class SHAPE_POLY_SET;
*/
/**
* Enum AM_PRIMITIVE_ID
* is the set of all "aperture macro primitives" (primitive numbers). See
* Table 3 in http://gerbv.sourceforge.net/docs/rs274xrevd_e.pdf
* aperture macro primitives are basic shapes which can be combined to create a complex shape
* This complex shape is flashed.
* The set of all "aperture macro primitives" (primitive numbers).
*
* See Table 3 in http://gerbv.sourceforge.net/docs/rs274xrevd_e.pdf aperture macro primitives
* are basic shapes which can be combined to create a complex shape. This complex shape is
* flashed.
*/
enum AM_PRIMITIVE_ID {
AMP_UNKNOWN = -1, // A value for uninitialized AM_PRIMITIVE.
AMP_COMMENT = 0, // A primitive description is not really a primitive, this is a comment
AMP_COMMENT = 0, // A primitive description is not really a primitive, this is a
// comment
AMP_CIRCLE = 1, // Circle. (diameter and position)
AMP_LINE2 = 2, // Line with rectangle ends. (Width, start and end pos + rotation)
AMP_LINE20 = 20, // Same as AMP_LINE2
AMP_LINE_CENTER = 21, // Rectangle. (height, width and center pos + rotation)
AMP_LINE_LOWER_LEFT = 22, // Rectangle. (height, width and left bottom corner pos + rotation)
AMP_EOF = 3, // End Of File marquer: not really a shape
AMP_EOF = 3, // End Of File marker: not really a shape
AMP_OUTLINE = 4, // Free polyline (n corners + rotation)
AMP_POLYGON = 5, // Closed regular polygon(diameter, number of vertices (3 to 10), rotation)
AMP_POLYGON = 5, // Closed regular polygon(diameter, number of vertices (3 to 10),
// rotation)
AMP_MOIRE = 6, // A cross hair with n concentric circles + rotation
AMP_THERMAL = 7 // Thermal shape (pos, outer and inner diameter, cross hair thickness + rotation)
AMP_THERMAL = 7 // Thermal shape (pos, outer and inner diameter, cross hair
// thickness + rotation)
};
/**
* Struct AM_PRIMITIVE
* holds an aperture macro primitive as given in Table 3 of
* An aperture macro primitive as given in Table 3 of
* http://gerbv.sourceforge.net/docs/rs274xrevd_e.pdf
*/
class AM_PRIMITIVE
@ -96,7 +98,8 @@ public:
// the primitive
bool m_GerbMetric; // units for this primitive:
// false = Inches, true = metric
public: AM_PRIMITIVE( bool aGerbMetric, AM_PRIMITIVE_ID aId = AMP_UNKNOWN )
AM_PRIMITIVE( bool aGerbMetric, AM_PRIMITIVE_ID aId = AMP_UNKNOWN )
{
primitive_id = aId;
m_GerbMetric = aGerbMetric;
@ -106,7 +109,6 @@ public: AM_PRIMITIVE( bool aGerbMetric, AM_PRIMITIVE_ID aId = AMP_UNKNOWN )
~AM_PRIMITIVE() {}
/**
* Function IsAMPrimitiveExposureOn
* @return true if the first parameter is not 0 (it can be only 0 or 1).
* Some but not all primitives use the first parameter as an exposure control.
* Others are always ON.
@ -117,127 +119,129 @@ public: AM_PRIMITIVE( bool aGerbMetric, AM_PRIMITIVE_ID aId = AMP_UNKNOWN )
/* Draw functions: */
/** GetShapeDim
* Calculate a value that can be used to evaluate the size of text
* when displaying the D-Code of an item
* due to the complexity of the shape of some primitives
* one cannot calculate the "size" of a shape (only a bounding box)
* but here, the "dimension" of the shape is the diameter of the primitive
* or for lines the width of the line
* @param aParent = the parent GERBER_DRAW_ITEM which is actually drawn
/**
* Calculate a value that can be used to evaluate the size of text when displaying the
* D-Code of an item.
*
* Due to the complexity of the shape of some primitives one cannot calculate the "size"
* of a shape (only a bounding box) but here, the "dimension" of the shape is the diameter
* of the primitive or for lines the width of the line.
*
* @param aParent is the parent GERBER_DRAW_ITEM which is actually drawn
* @return a dimension, or -1 if no dim to calculate
*/
int GetShapeDim( const GERBER_DRAW_ITEM* aParent );
/**
* Function drawBasicShape
* Draw (in fact generate the actual polygonal shape of) the primitive shape of an aperture macro instance.
* @param aParent = the parent GERBER_DRAW_ITEM which is actually drawn
* @param aShapeBuffer = a SHAPE_POLY_SET to put the shape converted to a polygon
* @param aShapePos = the actual shape position
* Draw (in fact generate the actual polygonal shape of) the primitive shape of an aperture
* macro instance.
*
* @param aParent is the parent GERBER_DRAW_ITEM which is actually drawn.
* @param aShapeBuffer is a SHAPE_POLY_SET to put the shape converted to a polygon.
* @param aShapePos is the actual shape position.
*/
void DrawBasicShape( const GERBER_DRAW_ITEM* aParent,
SHAPE_POLY_SET& aShapeBuffer,
wxPoint aShapePos );
private:
private:
/**
* Function ConvertShapeToPolygon
* convert a shape to an equivalent polygon.
* Arcs and circles are approximated by segments
* Useful when a shape is not a graphic primitive (shape with hole,
* rotated shape ... ) and cannot be easily drawn.
* Convert a shape to an equivalent polygon.
*
* Arcs and circles are approximated by segments. Useful when a shape is not a graphic
* primitive (shape with hole, rotated shape ... ) and cannot be easily drawn.
*/
void ConvertShapeToPolygon( const GERBER_DRAW_ITEM* aParent,
std::vector<wxPoint>& aBuffer );
void ConvertShapeToPolygon( const GERBER_DRAW_ITEM* aParent, std::vector<wxPoint>& aBuffer );
};
typedef std::vector<AM_PRIMITIVE> AM_PRIMITIVES;
/**
* Struct APERTURE_MACRO
* helps support the "aperture macro" defined within standard RS274X.
* Support the "aperture macro" defined within standard RS274X.
*/
struct APERTURE_MACRO
{
wxString name; ///< The name of the aperture macro
AM_PRIMITIVES primitives; ///< A sequence of AM_PRIMITIVEs
/* A defered parameter can be defined in aperture macro,
* but outside aperture primitives. Example
* %AMRECTHERM*
* $4=$3/2* parameter $4 is half value of parameter $3
* m_localparamStack handle a list of local defered parameters
*/
AM_PARAMS m_localparamStack;
SHAPE_POLY_SET m_shape; ///< The shape of the item, calculated by GetApertureMacroShape
EDA_RECT m_boundingBox; ///< The bounding box of the item, calculated by GetApertureMacroShape
/**
* function GetLocalParam
* Usually, parameters are defined inside the aperture primitive
* using immediate mode or defered mode.
* in defered mode the value is defined in a DCODE that want to use the aperture macro.
* But some parameters are defined outside the aperture primitive
* and are local to the aperture macro
* @return the value of a defered parameter defined inside the aperture macro
* @param aDcode = the D_CODE that uses this apertur macro and define defered parameters
* @param aParamId = the param id (defined by $3 or $5 ..) to evaluate
* Usually, parameters are defined inside the aperture primitive using immediate mode or
* deferred mode.
*
* In deferred mode the value is defined in a DCODE that want to use the aperture macro.
* Some parameters are defined outside the aperture primitive and are local to the aperture
* macro.
*
* @return the value of a deferred parameter defined inside the aperture macro.
* @param aDcode is the D_CODE that uses this aperture macro and define deferred parameters.
* @param aParamId is the param id (defined by $3 or $5 ..) to evaluate.
*/
double GetLocalParam( const D_CODE* aDcode, unsigned aParamId ) const;
/**
* Function GetApertureMacroShape
* Calculate the primitive shape for flashed items.
* When an item is flashed, this is the shape of the item
* @param aParent = the parent GERBER_DRAW_ITEM which is actually drawn
* @return The shape of the item
*
* When an item is flashed, this is the shape of the item.
*
* @param aParent is the parent #GERBER_DRAW_ITEM which is actually drawn.
* @return the shape of the item.
*/
SHAPE_POLY_SET* GetApertureMacroShape( const GERBER_DRAW_ITEM* aParent, wxPoint aShapePos );
/**
* Function DrawApertureMacroShape
* Draw the primitive shape for flashed items.
* When an item is flashed, this is the shape of the item
* @param aParent = the parent GERBER_DRAW_ITEM which is actually drawn
* @param aClipBox = DC clip box (NULL is no clip)
* @param aDC = device context
* @param aColor = the color of shape
* @param aShapePos = the actual shape position
* @param aFilledShape = true to draw in filled mode, false to draw in skecth mode
*
* When an item is flashed, this is the shape of the item.
*
* @param aParent is the parent GERBER_DRAW_ITEM which is actually drawn.
* @param aClipBox is DC clip box (NULL is no clip).
* @param aDC is the device context.
* @param aColor is the color of shape.
* @param aShapePos is the actual shape position.
* @param aFilledShape set to true to draw in filled mode, false to draw in sketch mode.
*/
void DrawApertureMacroShape( GERBER_DRAW_ITEM* aParent, EDA_RECT* aClipBox, wxDC* aDC,
COLOR4D aColor, wxPoint aShapePos, bool aFilledShape );
/**
* Function GetShapeDim
* Calculate a value that can be used to evaluate the size of text
* when displaying the D-Code of an item
* due to the complexity of a shape using many primitives
* one cannot calculate the "size" of a shape (only abounding box)
* but most of aperture macro are using one or few primitives
* and the "dimension" of the shape is the diameter of the primitive
* (or the max diameter of primitives)
* @param aParent = the parent GERBER_DRAW_ITEM which is actually drawn
* @return a dimension, or -1 if no dim to calculate
* Calculate a value that can be used to evaluate the size of text when displaying the
* D-Code of an item.
*
* Due to the complexity of a shape using many primitives one cannot calculate the "size" of
* a shape (only abounding box) but most of aperture macro are using one or few primitives
* and the "dimension" of the shape is the diameter of the primitive (or the max diameter of
* primitives).
*
* @param aParent is the parent #GERBER_DRAW_ITEM which is actually drawn.
* @return a dimension, or -1 if no dim to calculate.
*/
int GetShapeDim( GERBER_DRAW_ITEM* aParent );
/// Returns the bounding box of the shape
/// Return the bounding box of the shape.
EDA_RECT GetBoundingBox() const
{
return m_boundingBox;
}
wxString name; ///< The name of the aperture macro
AM_PRIMITIVES primitives; ///< A sequence of AM_PRIMITIVEs
/* A deferred parameter can be defined in aperture macro,
* but outside aperture primitives. Example
* %AMRECTHERM*
* $4=$3/2* parameter $4 is half value of parameter $3
* m_localparamStack handle a list of local deferred parameters
*/
AM_PARAMS m_localparamStack;
SHAPE_POLY_SET m_shape; ///< The shape of the item, calculated by GetApertureMacroShape
EDA_RECT m_boundingBox; ///< The bounding box of the item, calculated by
///< GetApertureMacroShape.
};
/**
* Struct APERTURE_MACRO_less_than
* is used by std:set<APERTURE_MACRO> instantiation which uses
* APERTURE_MACRO.name as its key.
* Used by std:set<APERTURE_MACRO> instantiation which uses APERTURE_MACRO.name as its key.
*/
struct APERTURE_MACRO_less_than
{
@ -250,9 +254,7 @@ struct APERTURE_MACRO_less_than
/**
* Type APERTURE_MACRO_SET
* is a sorted collection of APERTURE_MACROS whose key is the name field in
* the APERTURE_MACRO.
* A sorted collection of APERTURE_MACROS whose key is the name field in the APERTURE_MACRO.
*/
typedef std::set<APERTURE_MACRO, APERTURE_MACRO_less_than> APERTURE_MACRO_SET;
typedef std::pair<APERTURE_MACRO_SET::iterator, bool> APERTURE_MACRO_SET_PAIR;

31
gerbview/dcode.cpp
View File

@ -2,8 +2,8 @@
* This program source code file is part of KiCad, a free EDA CAD application.
*
* Copyright (C) 2016 Jean-Pierre Charras, jp.charras at wanadoo.fr
* Copyright (C) 2011 Wayne Stambaugh <stambaughw@verizon.net>
* Copyright (C) 1992-2016 KiCad Developers, see AUTHORS.txt for contributors.
* Copyright (C) 2011 Wayne Stambaugh <stambaughw@gmail.com>
* Copyright (C) 1992-2021 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
@ -56,11 +56,6 @@
*/
/***************/
/* Class DCODE */
/***************/
D_CODE::D_CODE( int num_dcode )
{
m_Num_Dcode = num_dcode;
@ -117,9 +112,11 @@ const wxChar* D_CODE::ShowApertureType( APERTURE_T aType )
return ret;
}
int D_CODE::GetShapeDim( GERBER_DRAW_ITEM* aParent )
{
int dim = -1;
switch( m_Shape )
{
case APT_CIRCLE:
@ -148,9 +145,8 @@ int D_CODE::GetShapeDim( GERBER_DRAW_ITEM* aParent )
}
void D_CODE::DrawFlashedShape( GERBER_DRAW_ITEM* aParent,
EDA_RECT* aClipBox, wxDC* aDC, COLOR4D aColor,
wxPoint aShapePos, bool aFilledShape )
void D_CODE::DrawFlashedShape( GERBER_DRAW_ITEM* aParent, EDA_RECT* aClipBox, wxDC* aDC,
COLOR4D aColor, const wxPoint& aShapePos, bool aFilledShape )
{
int radius;
@ -264,10 +260,8 @@ void D_CODE::DrawFlashedShape( GERBER_DRAW_ITEM* aParent,
}
void D_CODE::DrawFlashedPolygon( GERBER_DRAW_ITEM* aParent,
EDA_RECT* aClipBox, wxDC* aDC,
COLOR4D aColor, bool aFilled,
const wxPoint& aPosition )
void D_CODE::DrawFlashedPolygon( GERBER_DRAW_ITEM* aParent, EDA_RECT* aClipBox, wxDC* aDC,
COLOR4D aColor, bool aFilled, const wxPoint& aPosition )
{
if( m_Polygon.OutlineCount() == 0 )
return;
@ -286,6 +280,7 @@ void D_CODE::DrawFlashedPolygon( GERBER_DRAW_ITEM* aParent,
GRClosedPoly( aClipBox, aDC, pointCount, &points[0], aFilled, aColor, aColor );
}
// TODO(snh): Remove the hard-coded count
#define SEGS_CNT 64 // number of segments to approximate a circle
@ -293,8 +288,8 @@ void D_CODE::DrawFlashedPolygon( GERBER_DRAW_ITEM* aParent,
// A helper function for D_CODE::ConvertShapeToPolygon(). Add a hole to a polygon
static void addHoleToPolygon( SHAPE_POLY_SET* aPolygon,
APERTURE_DEF_HOLETYPE aHoleShape,
wxSize aSize,
wxPoint aAnchorPos );
const wxSize& aSize,
const wxPoint& aAnchorPos );
void D_CODE::ConvertShapeToPolygon()
@ -422,8 +417,8 @@ void D_CODE::ConvertShapeToPolygon()
// Add a hole to a polygon
static void addHoleToPolygon( SHAPE_POLY_SET* aPolygon,
APERTURE_DEF_HOLETYPE aHoleShape,
wxSize aSize,
wxPoint aAnchorPos )
const wxSize& aSize,
const wxPoint& aAnchorPos )
{
wxPoint currpos;
SHAPE_POLY_SET holeBuffer;

165
gerbview/dcode.h
View File

@ -3,7 +3,7 @@
*
* Copyright (C) 1992-2010 Jean-Pierre Charras <jean-pierre.charras@gipsa-lab.inpg.fr>
* Copyright (C) 2010 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
* Copyright (C) 1992-2010 KiCad Developers, see change_log.txt for contributors.
* Copyright (C) 1992-2021 KiCad Developers, see change_log.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
@ -43,8 +43,7 @@ class EDA_RECT;
/**
* Enum APERTURE_T
* is the set of all gerber aperture types allowed, according to page 16 of
* The set of all gerber aperture types allowed, according to page 16 of
* http://gerbv.sourceforge.net/docs/rs274xrevd_e.pdf
*/
enum APERTURE_T {
@ -76,48 +75,19 @@ struct APERTURE_MACRO;
/**
* D_CODE
* holds a gerber DCODE (also called Aperture) definition.
* A gerber DCODE (also called Aperture) definition.
*/
class D_CODE
{
private:
APERTURE_MACRO* m_Macro; ///< no ownership, points to
// GERBER.m_aperture_macros element
/**
* parameters used only when this D_CODE holds a reference to an aperture
* macro, and these parameters would customize the macro.
*/
std::vector<double> m_am_params;
public:
wxSize m_Size; ///< Horizontal and vertical dimensions.
APERTURE_T m_Shape; ///< shape ( Line, rectangle, circle , oval .. )
int m_Num_Dcode; ///< D code value ( >= 10 )
wxSize m_Drill; ///< dimension of the hole (if any) (draill file)
APERTURE_DEF_HOLETYPE m_DrillShape; ///< shape of the hole (0 = no hole, round = 1, rect = 2) */
double m_Rotation; ///< shape rotation in degrees
int m_EdgesCount; ///< in aperture definition Polygon only:
///< number of edges for the polygon
bool m_InUse; ///< false if the aperure (previously defined)
///< is not used to draw something
bool m_Defined; ///< false if the aperture is not defined in the header
wxString m_AperFunction; ///< the aperture attribute (created by a %TA.AperFunction command)
///< attached to the D_CODE
SHAPE_POLY_SET m_Polygon; /* Polygon used to draw APT_POLYGON shape and some other
* complex shapes which are converted to polygon
* (shapes with hole )
*/
public:
D_CODE( int num_dcode );
~D_CODE();
void Clear_D_CODE_Data();
/**
* AppendParam()
* Add a parameter to the D_CODE parameter list.
* used to customize the corresponding aperture macro
*
* Used to customize the corresponding aperture macro.
*/
void AppendParam( double aValue )
{
@ -125,8 +95,7 @@ public:
}
/**
* GetParamCount()
* Returns the number of parameters stored in parameter list.
* Return the number of parameters stored in parameter list.
*/
unsigned GetParamCount() const
{
@ -134,88 +103,116 @@ public:
}
/**
* GetParam()
* Returns a parameter stored in parameter list.
* @param aIdx = index of parameter
* Return a parameter stored in parameter list.
*
* @param aIdx is the index of parameter.
*/
double GetParam( unsigned aIdx ) const
{
wxASSERT( aIdx <= m_am_params.size() );
if( aIdx <= m_am_params.size() )
return m_am_params[aIdx - 1];
else
return 0;
}
void SetMacro( APERTURE_MACRO* aMacro )
{
m_Macro = aMacro;
}
APERTURE_MACRO* GetMacro() const { return m_Macro; }
/**
* Function ShowApertureType
* returns a character string telling what type of aperture type \a aType is.
* @param aType The aperture type to show.
* Return a character string telling what type of aperture type \a aType is.
*
* @param aType is the aperture type to show.
*/
static const wxChar* ShowApertureType( APERTURE_T aType );
/**
* Function DrawFlashedShape
* Draw the dcode shape for flashed items.
* When an item is flashed, the DCode shape is the shape of the item
* @param aParent = the GERBER_DRAW_ITEM being drawn
* @param aClipBox = DC clip box (NULL is no clip)
* @param aDC = device context
* @param aColor = the normal color to use
* @param aShapePos = the actual shape position
* @param aFilledShape = true to draw in filled mode, false to draw in sketch mode
*
* When an item is flashed, the DCode shape is the shape of the item.
*
* @param aParent is the #GERBER_DRAW_ITEM being drawn.
* @param aClipBox is the device context clip box (NULL is no clip).
* @param aDC is the device context.
* @param aColor is the normal color to use.
* @param aShapePos is the actual shape position
* @param aFilledShape set to true to draw in filled mode, false to draw in sketch mode
*/
void DrawFlashedShape( GERBER_DRAW_ITEM* aParent, EDA_RECT* aClipBox,
wxDC* aDC, COLOR4D aColor,
wxPoint aShapePos, bool aFilledShape );
void DrawFlashedShape( GERBER_DRAW_ITEM* aParent, EDA_RECT* aClipBox, wxDC* aDC,
COLOR4D aColor, const wxPoint& aShapePos, bool aFilledShape );
/**
* Function DrawFlashedPolygon
* a helper function used to draw the polygon stored ion m_PolyCorners
* Draw some Apertures shapes when they are defined as filled polygons.
* APT_POLYGON is always a polygon, but some complex shapes are also converted to
* polygons (shapes with holes, some rotated shapes)
* @param aParent = the GERBER_DRAW_ITEM being drawn
* @param aClipBox = DC clip box (NULL is no clip)
* @param aDC = device context
* @param aColor = the normal color to use
* @param aFilled = true to draw in filled mode, false to draw in sketch mode
* @param aPosition = the actual shape position
* A helper function used to draw the polygon stored in m_PolyCorners.
*
* Draw some Apertures shapes when they are defined as filled polygons. APT_POLYGON is
* always a polygon, but some complex shapes are also converted to polygons (shapes with
* holes, some rotated shapes).
*
* @param aParent is the #GERBER_DRAW_ITEM being drawn.
* @param aClipBox is the device context clip box (NULL is no clip).
* @param aDC is the device context.
* @param aColor is the normal color to use.
* @param aFilled set to true to draw in filled mode, false to draw in sketch mode.
* @param aPosition is the actual shape position.
*/
void DrawFlashedPolygon( GERBER_DRAW_ITEM* aParent,
EDA_RECT* aClipBox, wxDC* aDC, COLOR4D aColor,
bool aFilled, const wxPoint& aPosition );
void DrawFlashedPolygon( GERBER_DRAW_ITEM* aParent, EDA_RECT* aClipBox, wxDC* aDC,
COLOR4D aColor, bool aFilled, const wxPoint& aPosition );
/**
* Function ConvertShapeToPolygon
* convert a shape to an equivalent polygon.
* Arcs and circles are approximated by segments
* Useful when a shape is not a graphic primitive (shape with hole,
* rotated shape ... ) and cannot be easily drawn.
* Convert a shape to an equivalent polygon.
*
* Arcs and circles are approximated by segments. Useful when a shape is not a graphic
* primitive (shape with hole, rotated shape ... ) and cannot be easily drawn.
*/
void ConvertShapeToPolygon();
/**
* Function GetShapeDim
* calculates a value that can be used to evaluate the size of text
* when displaying the D-Code of an item
* due to the complexity of some shapes,
* one cannot calculate the "size" of a shape (only a bounding box)
* but here, the "dimension" of the shape is the diameter of the primitive
* or for lines the width of the line if the shape is a line
* @param aParent = the parent GERBER_DRAW_ITEM which is actually drawn
* @return a dimension, or -1 if no dim to calculate
* Calculate a value that can be used to evaluate the size of text when displaying the
* D-Code of an item.
*
* Due to the complexity of some shapes, one cannot calculate the "size" of a shape (only
* a bounding box) but here, the "dimension" of the shape is the diameter of the primitive
* or for lines the width of the line if the shape is a line.
*
* @param aParent is the parent GERBER_DRAW_ITEM which is actually drawn.
* @return a dimension, or -1 if no dim to calculate.
*/
int GetShapeDim( GERBER_DRAW_ITEM* aParent );
public:
wxSize m_Size; ///< Horizontal and vertical dimensions.
APERTURE_T m_Shape; ///< shape ( Line, rectangle, circle , oval .. )
int m_Num_Dcode; ///< D code value ( >= 10 )
wxSize m_Drill; ///< dimension of the hole (if any) (drill file)
APERTURE_DEF_HOLETYPE m_DrillShape; ///< shape of the hole (0 = no hole, round = 1,
///< rect = 2).
double m_Rotation; ///< shape rotation in degrees
int m_EdgesCount; ///< in aperture definition Polygon only:
///< number of edges for the polygon
bool m_InUse; ///< false if the aperture (previously defined)
///< is not used to draw something
bool m_Defined; ///< false if the aperture is not defined in the header
wxString m_AperFunction; ///< the aperture attribute (created by a
///< %TA.AperFunction command).
///< attached to the D_CODE
SHAPE_POLY_SET m_Polygon; /* Polygon used to draw APT_POLYGON shape and some other
* complex shapes which are converted to polygon
* (shapes with hole )
*/
private:
APERTURE_MACRO* m_Macro; ///< no ownership, points to GERBER.m_aperture_macros element.
/**
* parameters used only when this D_CODE holds a reference to an aperture
* macro, and these parameters would customize the macro.
*/
std::vector<double> m_am_params;
};

39
gerbview/dialogs/dialog_layers_select_to_pcb.h
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application.
*
* Copyright (C) 2011-2018 Jean-Pierre Charras jp.charras at wanadoo.fr
* Copyright (C) 1992-2018 KiCad Developers, see AUTHORS.txt for contributors.
* Copyright (C) 1992-2021 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
@ -39,15 +39,6 @@ class GERBVIEW_FRAME;
*/
class LAYERS_MAP_DIALOG : public LAYERS_MAP_DIALOG_BASE
{
private:
GERBVIEW_FRAME* m_Parent;
int m_gerberActiveLayersCount; // Number of initialized gerber layers
static int m_exportBoardCopperLayersCount;
LAYER_NUM m_layersLookUpTable[GERBER_DRAWLAYERS_COUNT]; // Indexes Gerber layers to PCB file layers
// the last value in table is the number of copper layers
int m_buttonTable[int(GERBER_DRAWLAYERS_COUNT)+1]; // Indexes buttons to Gerber layers
wxStaticText* m_layersList[int(GERBER_DRAWLAYERS_COUNT)+1]; // Indexes text strings to buttons
public: LAYERS_MAP_DIALOG( GERBVIEW_FRAME* parent );
~LAYERS_MAP_DIALOG() {};
@ -74,9 +65,9 @@ private:
* number. Gerbers that can be identified or which don't map to an
* equivalent KiCad PCB layer will be set to UNSELECTED_LAYER.
*
* @param aGerber2KicadMapping passed to return KiCad PCB layer number for each Gerber
* @param aGerber2KicadMapping passed to return KiCad PCB layer number for each Gerber.
*
* @return int - The number of loaded Gerbers that have Altium extensions
* @return The number of loaded Gerbers that have Altium extensions.
*/
int findKnownGerbersLoaded( std::vector<int>& aGerber2KicadMapping );
@ -89,9 +80,9 @@ private:
* number. Gerbers that aren't using Altium extensions or which don't map to an
* equivalent KiCad PCB layer will be set to UNSELECTED_LAYER.
*
* @param aGerber2KicadMapping passed to return KiCad PCB layer number for each Gerber
* @param aGerber2KicadMapping passed to return KiCad PCB layer number for each Gerber.
*
* @return int - The number of loaded Gerbers that have Altium extensions
* @return The number of loaded Gerbers that have Altium extensions.
*/
int findNumAltiumGerbersLoaded( std::vector<int>& aGerber2KicadMapping );
@ -104,9 +95,9 @@ private:
* number. Gerbers that aren't using KiCad naming or which don't map to an
* equivalent KiCad PCB layer will be set to UNSELECTED_LAYER.
*
* @param aGerber2KicadMapping passed to return KiCad PCB layer number for each Gerber
* @param aGerber2KicadMapping passed to return KiCad PCB layer number for each Gerber.
*
* @return int - The number of loaded Gerbers using KiCad naming conventions
* @return The number of loaded Gerbers using KiCad naming conventions.
*/
int findNumKiCadGerbersLoaded( std::vector<int>& aGerber2KicadMapping );
@ -119,14 +110,24 @@ private:
* number. Gerbers that aren't using X2 File functions or which don't map to an
* equivalent KiCad PCB layer will be set to UNSELECTED_LAYER.
*
* @param aGerber2KicadMapping passed to return KiCad PCB layer number for each Gerber
* @param aGerber2KicadMapping passed to return KiCad PCB layer number for each Gerber.
*
* @return int - The number of loaded Gerbers with X2 File Functions
* @return The number of loaded Gerbers with X2 File Functions.
*/
int findNumX2GerbersLoaded( std::vector<int>& aGerber2KicadMapping );
DECLARE_EVENT_TABLE()
private:
GERBVIEW_FRAME* m_Parent;
int m_gerberActiveLayersCount; // Number of initialized gerber layers
static int m_exportBoardCopperLayersCount;
// Indexes Gerber layers to PCB file layers the last value in table is the number of
// copper layers.
LAYER_NUM m_layersLookUpTable[GERBER_DRAWLAYERS_COUNT];
int m_buttonTable[int(GERBER_DRAWLAYERS_COUNT)+1]; // Indexes buttons to Gerber layers
wxStaticText* m_layersList[int(GERBER_DRAWLAYERS_COUNT)+1]; // Indexes text strings to buttons
};
#endif // DIALOG_LAYERS_SELECT_TO_PCB_H_

9
gerbview/dialogs/panel_gerbview_display_options.h
View File

@ -1,7 +1,7 @@
/*
* This program source code file is part of KiCad, a free EDA CAD application.
*
* Copyright (C) 2018 KiCad Developers, see AUTHORS.txt for contributors.
* Copyright (C) 2018-2021 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
@ -33,10 +33,6 @@ class GAL_OPTIONS_PANEL;
class PANEL_GERBVIEW_DISPLAY_OPTIONS : public PANEL_GERBVIEW_DISPLAY_OPTIONS_BASE
{
private:
GERBVIEW_FRAME* m_Parent;
GAL_OPTIONS_PANEL* m_galOptsPanel;
public:
PANEL_GERBVIEW_DISPLAY_OPTIONS( GERBVIEW_FRAME* aFrame, wxWindow* aWindow );
~PANEL_GERBVIEW_DISPLAY_OPTIONS() {};
@ -44,6 +40,9 @@ public:
private:
bool TransferDataToWindow() override;
bool TransferDataFromWindow() override;
GERBVIEW_FRAME* m_Parent;
GAL_OPTIONS_PANEL* m_galOptsPanel;
};

7
gerbview/dialogs/panel_gerbview_settings.h
View File

@ -1,7 +1,7 @@
/*
* This program source code file is part of KiCad, a free EDA CAD application.
*
* Copyright (C) 2018 KiCad Developers, see AUTHORS.txt for contributors.
* Copyright (C) 2018-2021 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
@ -31,9 +31,6 @@ class GERBVIEW_FRAME;
class PANEL_GERBVIEW_SETTINGS : public PANEL_GERBVIEW_SETTINGS_BASE
{
private:
GERBVIEW_FRAME* m_Parent;
public:
PANEL_GERBVIEW_SETTINGS( GERBVIEW_FRAME* aFrame, wxWindow* aWindow );
~PANEL_GERBVIEW_SETTINGS() {};
@ -41,6 +38,8 @@ public:
private:
bool TransferDataToWindow() override;
bool TransferDataFromWindow() override;
GERBVIEW_FRAME* m_Parent;
};
#endif //KICAD_PANEL_GERBVIEW_SETTINGS_H

57
gerbview/excellon_image.h
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application.
*
* Copyright (C) 2011-2016 Jean-Pierre Charras jp.charras at wanadoo.fr
* Copyright (C) 1992-2016 KiCad Developers, see AUTHORS.txt for contributors.
* Copyright (C) 1992-2021 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
@ -73,7 +73,7 @@ enum drill_G_code_t {
DRILL_G_CCWMOVE
};
// Helper struct to analyse Excellon commands
// Helper struct to analyze Excellon commands
struct EXCELLON_CMD
{
std::string m_Name; // key string
@ -123,27 +123,14 @@ struct EXCELLON_ROUTE_COORD
wxPoint GetPos() { return wxPoint( m_x, m_y ); }
};
/* EXCELLON_IMAGE handle a drill image
* It is derived from GERBER_FILE_IMAGE because there is a lot of likeness
* between EXCELLON files and GERBER files
* DCode aperture are also similat to T Codes.
* So we can reuse GERBER_FILE_IMAGE to handle EXCELLON_IMAGE with very few new functions
/**
* Handle a drill image.
*
* It is derived from #GERBER_FILE_IMAGE because there is a lot of likeness between EXCELLON
* files and GERBER files. DCode aperture are also similar to T Codes.
*/
class EXCELLON_IMAGE : public GERBER_FILE_IMAGE
{
private:
enum excellon_state {
READ_HEADER_STATE, // When we are in this state, we are reading header
READ_PROGRAM_STATE // When we are in this state, we are reading drill data
};
excellon_state m_State; // state of excellon file analysis
bool m_SlotOn; // true during an oblong drill definition
// by G85 (canned slot) command
bool m_RouteModeOn; // true during a route mode (for instance a oval hole) or a cutout
std::vector<EXCELLON_ROUTE_COORD> m_RoutePositions; // The list of points in a route mode
public: EXCELLON_IMAGE( int layer ) :
GERBER_FILE_IMAGE( layer )
{
@ -164,10 +151,11 @@ public: EXCELLON_IMAGE( int layer ) :
/**
* Read and load a drill (EXCELLON format) file.
* @param aFullFileName = the full filename of the Gerber file
* when the file cannot be loaded
* Warning and info messages are stored in m_Messages
* @return bool if OK, false if the gerber file was not loaded
*
* When the file cannot be loaded, warning and info messages are stored in m_Messages.
*
* @param aFullFileName is the full filename of the Gerber file.
* @return true if OK, false if the gerber file was not loaded.
*/
bool LoadFile( const wxString& aFullFileName );
@ -177,8 +165,9 @@ private:
bool Execute_EXCELLON_G_Command( char*& text );
bool Execute_Drill_Command( char*& text );
/** Read a tool definition like T1C0.02 or T1F00S00C0.02 or T1C0.02F00S00
* and enter params in TCODE list
/**
* Read a tool definition like T1C0.02 or T1F00S00C0.02 or T1C0.02F00S00
* and enter params in TCODE list.
*/
bool readToolInformation( char*& aText );
@ -187,11 +176,25 @@ private:
return DCodeNumber( aText );
}
/** Ends a route command started by M15 ot G01, G02 or G03 command
/**
* End a route command started by M15 ot G01, G02 or G03 command.
*/
void FinishRouteCommand();
void SelectUnits( bool aMetric );
private:
enum excellon_state {
READ_HEADER_STATE, // When we are in this state, we are reading header
READ_PROGRAM_STATE // When we are in this state, we are reading drill data
};
excellon_state m_State; // state of excellon file analysis
bool m_SlotOn; // true during an oblong drill definition
// by G85 (canned slot) command
bool m_RouteModeOn; // true during a route mode (for instance a oval hole) or
// a cutout.
std::vector<EXCELLON_ROUTE_COORD> m_RoutePositions; // The list of points in a route mode
};

218
gerbview/export_to_pcbnew.h
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application.
*
* Copyright (C) 2007-2014 Jean-Pierre Charras jp.charras at wanadoo.fr
* Copyright (C) 1992-2020 KiCad Developers, see change_log.txt for contributors.
* Copyright (C) 1992-2021 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
@ -46,120 +46,122 @@ class GERBVIEW_FRAME;
/**
* A helper class to export a Gerber set of files to Pcbnew
* A helper class to export a Gerber set of files to Pcbnew.
*/
class GBR_TO_PCB_EXPORTER
{
public:
GBR_TO_PCB_EXPORTER( GERBVIEW_FRAME* aFrame, const wxString& aFileName );
~GBR_TO_PCB_EXPORTER();
/**
* Save a board from a set of Gerber images.
*/
bool ExportPcb( const LAYER_NUM* aLayerLookUpTable, int aCopperLayers );
private:
/**
* Collect holes from a drill layer.
*
* We'll use these later when writing pads & vias.
*/
void collect_hole( const GERBER_DRAW_ITEM* aGbrItem );
/**
* Write a via to the board file.
*
* Some of these will represent actual vias while others are used to represent
* holes in pads. (We can't generate actual pads because the Gerbers don't contain
* info on how to group them into footprints.)
*/
void export_via( const EXPORT_VIA& aVia );
/**
* Write a non copper line or arc to the board file.
*
* @param aGbrItem is the Gerber item (line, arc) to export.
* @param aLayer is the technical layer to use.
*/
void export_non_copper_item( const GERBER_DRAW_ITEM* aGbrItem, LAYER_NUM aLayer );
/**
* Write a non-copper polygon to the board file.
*
* @param aLayer is the technical layer to use.
*/
void writePcbPolygon( const SHAPE_POLY_SET& aPolys, LAYER_NUM aLayer,
const wxPoint& aOffset = { 0, 0 } );
/**
* Write a zone item to the board file.
*
* @warning This is experimental for tests only.
*
* @param aGbrItem is the Gerber item (line, arc) to export.
* @param aLayer is the technical layer to use.
*/
void writePcbZoneItem( const GERBER_DRAW_ITEM* aGbrItem, LAYER_NUM aLayer );
/**
* Write a track (or via) to the board file.
*
* @param aGbrItem is the Gerber item (line, arc, flashed) to export.
* @param aLayer is the copper layer to use.
*/
void export_copper_item( const GERBER_DRAW_ITEM* aGbrItem, LAYER_NUM aLayer );
/**
* Write a synthetic pad to the board file.
*
* We can't create real pads because the Gerbers don't store grouping/footprint info.
* So we synthesize a pad with a via for the hole (if present) and a copper polygon for
* the pad.
*
* @param aGbrItem is the flashed Gerber item to export.
*/
void export_flashed_copper_item( const GERBER_DRAW_ITEM* aGbrItem, LAYER_NUM aLayer );
/**
* Write a track (not via) to the board file.
*
* @param aGbrItem is the Gerber item (line only) to export.
* @param aLayer is the copper layer to use.
*/
void export_segline_copper_item( const GERBER_DRAW_ITEM* aGbrItem, LAYER_NUM aLayer );
/**
* Write a set of tracks (arcs are approximated by track segments) to the board file.
*
* @param aGbrItem is the Gerber item (arc only) to export.
* @param aLayer is the copper layer to use
*/
void export_segarc_copper_item( const GERBER_DRAW_ITEM* aGbrItem, LAYER_NUM aLayer );
/**
* Basic write function to write a a #TRACK item to the board file from a non flashed item.
*/
void writeCopperLineItem( const wxPoint& aStart, const wxPoint& aEnd,
int aWidth, LAYER_NUM aLayer );
/**
* Write a very basic header to the board file.
*/
void writePcbHeader( const LAYER_NUM* aLayerLookUpTable );
/**
* Map GerbView internal units to millimeters for Pcbnew board files.
*
* @param aValue is a coordinate value to convert in mm.
*/
double MapToPcbUnits( int aValue ) const
{
return aValue / IU_PER_MM;
}
private:
GERBVIEW_FRAME* m_gerbview_frame; // the main gerber frame
wxString m_pcb_file_name; // BOARD file to write to
FILE* m_fp; // the board file
int m_pcbCopperLayersCount;
std::vector<EXPORT_VIA> m_vias;
public:
GBR_TO_PCB_EXPORTER( GERBVIEW_FRAME* aFrame, const wxString& aFileName );
~GBR_TO_PCB_EXPORTER();
/**
* Function ExportPcb
* saves a board from a set of Gerber images.
*/
bool ExportPcb( const LAYER_NUM* aLayerLookUpTable, int aCopperLayers );
private:
/**
* collect holes from a drill layer.
* We'll use these later when writing pads & vias.
* @param aGbrItem
*/
void collect_hole( const GERBER_DRAW_ITEM* aGbrItem );
/**
* write a via to the board file.
* Some of these will represent actual vias while others are used to represent
* holes in pads. (We can't generate actual pads because the Gerbers don't contain
* info on how to group them into footprints.)
* @param aVia
*/
void export_via( const EXPORT_VIA& aVia );
/**
* write a non copper line or arc to the board file.
* @param aGbrItem = the Gerber item (line, arc) to export
* @param aLayer = the technical layer to use
*/
void export_non_copper_item( const GERBER_DRAW_ITEM* aGbrItem, LAYER_NUM aLayer );
/**
* write a non-copper polygon to the board file.
* @param aLayer = the technical layer to use
*/
void writePcbPolygon( const SHAPE_POLY_SET& aPolys, LAYER_NUM aLayer,
const wxPoint& aOffset = { 0, 0 } );
/**
* write a zone item to the board file.
* Currently: only experimental, for tests
* @param aGbrItem = the Gerber item (line, arc) to export
* @param aLayer = the technical layer to use
*/
void writePcbZoneItem( const GERBER_DRAW_ITEM* aGbrItem, LAYER_NUM aLayer );
/**
* write a track (or via) to the board file.
* @param aGbrItem = the Gerber item (line, arc, flashed) to export
* @param aLayer = the copper layer to use
*/
void export_copper_item( const GERBER_DRAW_ITEM* aGbrItem, LAYER_NUM aLayer );
/**
* Function export_flashed_copper_item
* write a synthetic pad to the board file.
* We can't create real pads because the Gerbers don't store grouping/footprint info.
* So we synthesize a pad with a via for the hole (if present) and a copper polygon for
* the pad.
* @param aGbrItem = the flashed Gerber item to export
*/
void export_flashed_copper_item( const GERBER_DRAW_ITEM* aGbrItem, LAYER_NUM aLayer );
/**
* Function export_segline_copper_item
* write a track (not via) to the board file.
* @param aGbrItem = the Gerber item (line only) to export
* @param aLayer = the copper layer to use
*/
void export_segline_copper_item( const GERBER_DRAW_ITEM* aGbrItem, LAYER_NUM aLayer );
/**
* Function export_segarc_copper_item
* write a set of tracks (arcs are approximated by track segments)
* to the board file.
* @param aGbrItem = the Gerber item (arc only) to export
* @param aLayer = the copper layer to use
*/
void export_segarc_copper_item( const GERBER_DRAW_ITEM* aGbrItem, LAYER_NUM aLayer );
/**
* function writeCopperLineItem
* basic write function to write a a TRACK item
* to the board file, from a non flashed item
*/
void writeCopperLineItem( const wxPoint& aStart,
const wxPoint& aEnd,
int aWidth, LAYER_NUM aLayer );
/**
* function writePcbHeader
* Write a very basic header to the board file
*/
void writePcbHeader( const LAYER_NUM* aLayerLookUpTable );
/** In Pcbnew files units are mm for coordinates.
* So MapToPcbUnits converts internal gerbview to mm any pcbnew value
* @param aValue is a coordinate value to convert in mm
*/
double MapToPcbUnits( int aValue ) const
{
return aValue / IU_PER_MM;
}
};

10
gerbview/gbr_layout.h
View File

@ -44,11 +44,6 @@ class GERBER_FILE_IMAGE_LIST;
*/
class GBR_LAYOUT : public EDA_ITEM
{
private:
mutable EDA_RECT m_BoundingBox;
TITLE_BLOCK m_titles;
wxPoint m_originAxisPosition;
public:
GBR_LAYOUT();
~GBR_LAYOUT();
@ -88,6 +83,11 @@ public:
#if defined(DEBUG)
void Show( int nestLevel, std::ostream& os ) const override { ShowDummy( os ); }
#endif
private:
mutable EDA_RECT m_BoundingBox;
TITLE_BLOCK m_titles;
wxPoint m_originAxisPosition;
};
#endif // #ifndef GBR_LAYOUT_H

86
gerbview/gerber_collectors.h
View File

@ -1,7 +1,7 @@
/*
* This program source code file is part of KiCad, a free EDA CAD application.
*
* Copyright (C) 2017 KiCad Developers, see AUTHORS.txt for contributors.
* Copyright (C) 2017-2021 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
@ -23,37 +23,11 @@
#include <collector.h>
/**
* GERBER_COLLECTOR
* is intended for use when the right click button is pressed, or when the
* plain "arrow" tool is in effect.
* Use when the right click button is pressed or when the select tool is in effect.
*/
class GERBER_COLLECTOR : public COLLECTOR
{
protected:
/**
* A place to hold collected objects which don't match precisely the search
* criteria, but would be acceptable if nothing else is found.
* "2nd" choice, which will be appended to the end of COLLECTOR's prime
* "list" at the end of the search.
*/
std::vector<EDA_ITEM*> m_List2nd;
/**
* Determines which items are to be collected by Inspect()
*/
//const COLLECTORS_GUIDE* m_Guide;
/**
* The number of items that were originally in the primary list before the
* m_List2nd was concatenated onto the end of it.
*/
int m_PrimaryLength;
public:
/**
* A scan list for all selectable gerber items
*/
@ -76,59 +50,73 @@ public:
m_List2nd.push_back( item );
}*/
/**
* Function SetGuide
* records which COLLECTORS_GUIDE to use.
* @param aGuide Which guide to use in the collection.
* Record which COLLECTORS_GUIDE to use.
*
* @param aGuide is the guide to use in the collection.
*/
//void SetGuide( const COLLECTORS_GUIDE* aGuide ) { m_Guide = aGuide; }
/**
* Function operator[int]
* overloads COLLECTOR::operator[](int) to return a EDA_ITEM* instead of
* an EDA_ITEM* type.
* Overload the [](int) operator to return a EDA_ITEM* instead of an EDA_ITEM* type.
*
* @param ndx The index into the list.
* @return EDA_ITEM* - or something derived from it, or NULL.
* @return the item collected or NULL.
*/
EDA_ITEM* operator[]( int ndx ) const override
{
if( (unsigned)ndx < (unsigned)GetCount() )
return (EDA_ITEM*) m_list[ ndx ];
return NULL;
}
/**
* Function GetPrimaryCount
* @return int - The number if items which met the primary search criteria
* @return The number if items which met the primary search criteria.
*/
int GetPrimaryCount() { return m_PrimaryLength; }
/**
* Function Inspect
* is the examining function within the INSPECTOR which is passed to the
* Iterate function.
* The examining function within the INSPECTOR which is passed to the Iterate function.
*
* @param testItem An EDA_ITEM to examine.
* @param testData is not used in this class.
* @return SEARCH_RESULT - SEARCH_QUIT if the Iterator is to stop the scan,
* else SCAN_CONTINUE;
* @return SEARCH_QUIT if the Iterator is to stop the scan else SCAN_CONTINUE.
*/
SEARCH_RESULT Inspect( EDA_ITEM* testItem, void* testData ) override;
/**
* Function Collect
* scans an EDA_ITEM using this class's Inspector method, which does the collection.
* Scan an EDA_ITEM using this class's Inspector method, which does the collection.
*
* @param aItem An EDA_ITEM to scan
* @param aScanList A list of KICAD_Ts with a terminating EOT, that specs
* what is to be collected and the priority order of the resultant
* collection in "m_list".
* what is to be collected and the priority order of the resultant
* collection in "m_list".
* @param aRefPos A wxPoint to use in hit-testing.
* @param aGuide The COLLECTORS_GUIDE to use in collecting items.
*/
void Collect( EDA_ITEM* aItem, const KICAD_T aScanList[],
const wxPoint& aRefPos/*, const COLLECTORS_GUIDE& aGuide */);
const wxPoint& aRefPos /*, const COLLECTORS_GUIDE& aGuide */ );
protected:
/**
* A place to hold collected objects which don't match precisely the search
* criteria, but would be acceptable if nothing else is found.
* "2nd" choice, which will be appended to the end of COLLECTOR's prime
* "list" at the end of the search.
*/
std::vector<EDA_ITEM*> m_List2nd;
/**
* Determines which items are to be collected by Inspect()
*/
//const COLLECTORS_GUIDE* m_Guide;
/**
* The number of items that were originally in the primary list before the
* m_List2nd was concatenated onto the end of it.
*/
int m_PrimaryLength;
};
#endif

39
gerbview/gerber_file_image_list.h
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application.
*
* Copyright (C) 2010-2016 Jean-Pierre Charras jp.charras at wanadoo.fr
* Copyright (C) 1992-2016 KiCad Developers, see AUTHORS.txt for contributors.
* Copyright (C) 1992-2021 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
@ -40,7 +40,7 @@
* have specific parameters
* if a Image parameter is set more than once, only the last value is used
* Some parameters can change along a file and are not layer specific: they are stored
* in GERBER_ITEM items, when instancied.
* in GERBER_ITEM items, when instanced.
*
* In GerbView, to handle these parameters, there are 2 classes:
* GERBER_FILE_IMAGE : the main class containing most of parameters and data to plot a graphic layer
@ -48,7 +48,7 @@
* There is one GERBER_FILE_IMAGE per file and one graphic layer per file or GERBER_FILE_IMAGE
* GerbView does not read and merge 2 gerber file in one graphic layer:
* I believe this is not possible due to the constraints in Image parameters.
* GERBER_LAYER : containing the subset of parameters that is layer speficic
* GERBER_LAYER : containing the subset of parameters that is layer specific
* A GERBER_FILE_IMAGE must include one GERBER_LAYER to define all parameters to plot a file.
* But a GERBER_FILE_IMAGE can use more than one GERBER_LAYER.
*/
@ -62,14 +62,10 @@ class GERBER_FILE_IMAGE;
*/
class GERBER_FILE_IMAGE_LIST
{
// the list of loaded images (1 image = 1 gerber file)
std::vector<GERBER_FILE_IMAGE*> m_GERBER_List;
public:
GERBER_FILE_IMAGE_LIST();
~GERBER_FILE_IMAGE_LIST();
//Accessor
static GERBER_FILE_IMAGE_LIST& GetImagesList();
GERBER_FILE_IMAGE* GetGbrImage( int aIdx );
@ -78,8 +74,8 @@ public:
/**
* Add a GERBER_FILE_IMAGE* at index aIdx or at the first free location if aIdx < 0
*
* @param aGbrImage = the image to add
* @param aIdx = the location to use ( 0 ... GERBER_DRAWLAYERS_COUNT-1 )
* @param aGbrImage is the image to add.
* @param aIdx is the location to use ( 0 ... GERBER_DRAWLAYERS_COUNT-1 ).
* @return true if the index used, or -1 if no room to add image
*/
int AddGbrImage( GERBER_FILE_IMAGE* aGbrImage, int aIdx );
@ -91,28 +87,29 @@ public:
void DeleteAllImages();
/**
* Delete the loaded data of image aIdx, freeing the memory.
* Delete the loaded data of image \a aIdx, freeing the memory.
*
* @param aIdx = the index ( 0 ... GERBER_DRAWLAYERS_COUNT-1 )
* @param aIdx is the index ( 0 ... GERBER_DRAWLAYERS_COUNT-1 ).
*/
void DeleteImage( int aIdx );
/**
* Get the display name for the layer at aIdx.
* Get the display name for the layer at \a aIdx.
*
* @param aIdx = the index ( 0 ... GERBER_DRAWLAYERS_COUNT-1 )
* @param aNameOnly = false (default) to add the layer number (for layers manager)
* or true to return only the name without layer name (status bar)
* @param aFullName = false (default) to ellipsize the name, true to return the full name.
*
* @return a name for image aIdx which can be used in layers manager
* and layer selector or in the status bar
* if a file is loaded, the name is:
* "<aIdx+1> <short filename> <X2 FileFunction info> if a X2 FileFunction info is found"
* or (if no FileFunction info)
* "<aIdx+1> <short filename> *"
* if no file loaded, the name is:
* "Layer n" with n = aIdx+1
*
* @param aIdx is the index ( 0 ... GERBER_DRAWLAYERS_COUNT-1 ).
* @param aNameOnly set to false (default) to add the layer number (for layers manager)
* or true to return only the name without layer name (status bar)/
* @param aFullName set to false (default) to ellipsize the name, true to return the full name.
*
* @return a name for image aIdx which can be used in layers manager and layer selector or
* in the status bar
*/
const wxString GetDisplayName( int aIdx, bool aNameOnly = false, bool aFullName = false );
@ -123,6 +120,10 @@ public:
* @return a mapping of old to new layer index
*/
std::unordered_map<int, int> SortImagesByZOrder();
private:
// the list of loaded images (1 image = 1 gerber file)
std::vector<GERBER_FILE_IMAGE*> m_GERBER_List;
};
#endif // ifndef GERBER_FILE_IMAGE_LIST_H

92
gerbview/widgets/gerbview_layer_widget.h
View File

@ -3,7 +3,7 @@
*
* Copyright (C) 2004-2010 Jean-Pierre Charras, jp.charras at wanadoo.fr
* Copyright (C) 2010 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
* Copyright (C) 2010 KiCad Developers, see change_log.txt for contributors.
* Copyright (C) 2010-2021 KiCad Developers, see change_log.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
@ -34,53 +34,22 @@
#include "layer_widget.h"
/**
* GERBER_LAYER_WIDGET
* is here to implement the abtract functions of LAYER_WIDGET so they
* may be tied into the GERBVIEW_FRAME's data and so we can add a popup
* menu which is specific to Pcbnew's needs.
* Abstract functions of LAYER_WIDGET so they may be tied into the GERBVIEW_FRAME's data and
* we can add a popup menu which is specific to Pcbnew's needs.
*/
class GERBER_LAYER_WIDGET : public LAYER_WIDGET
{
GERBVIEW_FRAME* myframe;
bool m_alwaysShowActiveLayer; // If true: Only shows the current active layer
// even if it is changed
/**
* Function OnRightDownLayers
* puts up a popup menu for the layer panel.
*/
void onRightDownLayers( wxMouseEvent& event );
void onPopupSelection( wxCommandEvent& event );
/// this is for the popup menu, the right click handler has to be installed
/// on every child control within the layer panel.
void installRightLayerClickHandler();
/**
* Virtual Function useAlternateBitmap
* @return true if bitmaps shown in Render layer list
* are alternate bitmaps, or false if they are "normal" bitmaps
*/
virtual bool useAlternateBitmap(int aRow) override;
GERBER_FILE_IMAGE_LIST* GetImagesList();
public:
/**
* Constructor
* @param aParent : the parent frame
* @param aFocusOwner : the window that has the keyboard focus.
* @param aParent is the parent frame.
* @param aFocusOwner is the window that has the keyboard focus.
*/
GERBER_LAYER_WIDGET( GERBVIEW_FRAME* aParent, wxWindow* aFocusOwner );
void ReFill();
/**
* Function ReFillRender
* Rebuild Render for instance after the config is read
* Rebuild Render for instance after the config is read.
*/
void ReFillRender();
@ -93,30 +62,28 @@ public:
void OnRenderEnable( int aId, bool isEnabled ) override;
/**
* Function SetLayersManagerTabsText
* Update the layer manager tabs labels
* Useful when changing Language or to set labels to a non default value
* Update the layer manager tabs labels.
*
* Useful when changing Language or to set labels to a non default value.
*/
void SetLayersManagerTabsText( );
//-----</implement LAYER_WIDGET abstract callback functions>----------
/**
* Function OnLayerSelected
* ensure the active layer is visible, and other layers not visible
* when m_alwaysShowActiveLayer is true
* Otherwise do nothing.
* @return true m_alwaysShowActiveLayer is true and the canvas is refreshed,
* and false if do nothing
* Ensure the active layer is visible, and other layers not visible when
* m_alwaysShowActiveLayer is true.
*
* @return true m_alwaysShowActiveLayer is true and the canvas is refreshed else false
* if do nothing.
*/
bool OnLayerSelected(); // postprocess after an active layer selection
// ensure active layer visible if
// m_alwaysShowActiveCopperLayer is true;
/**
* Function addRightClickMenuItems
* add menu items to a menu that should be shown when right-clicking
* the Gerber layer widget.
* @param aMenu is the menu to modify: menuitems will be added to aMenu
* Add menu items to a menu that should be shown when right-clicking the Gerber layer widget.
*
* @param aMenu is the menu to modify: menuitems will be added to aMenu.
*/
void AddRightClickMenuItems( wxMenu* aMenu );
@ -132,6 +99,31 @@ protected:
ID_SORT_GBR_LAYERS,
ID_LAYER_MANAGER_END = ID_SORT_GBR_LAYERS,
};
private:
/**
* Put up a popup menu for the layer panel.
*/
void onRightDownLayers( wxMouseEvent& event );
void onPopupSelection( wxCommandEvent& event );
/// this is for the popup menu, the right click handler has to be installed
/// on every child control within the layer panel.
void installRightLayerClickHandler();
/**
* @return true if bitmaps shown in Render layer list are alternate bitmaps else false if
* they are "normal" bitmaps.
*/
virtual bool useAlternateBitmap( int aRow ) override;
GERBER_FILE_IMAGE_LIST* GetImagesList();
GERBVIEW_FRAME* myframe;
bool m_alwaysShowActiveLayer; // If true: Only shows the current active layer
// even if it is changed
};
#endif // GERBER_LAYER_WIDGET_H

462
gerbview/widgets/layer_widget.h
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application.
*
* Copyright (C) 2010 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
* Copyright (C) 2010 KiCad Developers, see change_log.txt for contributors.
* Copyright (C) 2010-2021 KiCad Developers, see change_log.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
@ -58,41 +58,39 @@
using KIGFX::COLOR4D;
/**
* LAYER_WIDGET
* is abstract and is used to manage a list of layers, with the notion of
* a "current" layer, and layer specific visibility control. You must derive from
* it to use it so you can implement the abstract functions which recieve the
* events. Each layer is given its own color, and that color can be changed
* within the UI provided here. This widget knows nothing of the client code, meaning
* it has no knowledge of a BOARD or anything. To use it you must derive from
* this class and implement the abstract functions:
* Manage a list of layers with the notion of a "current" layer, and layer specific visibility
* control.
*
* You must derive from it to use it so you can implement the abstract functions which receive
* the events. Each layer is given its own color, and that color can be changed within the UI
* provided here. This widget knows nothing of the client code, meaning it has no knowledge of
* a BOARD or anything. To use it you must derive from this class and implement the abstract
* functions:
* <p> void OnLayerColorChange( int aLayer, int aColor );
* <p> bool OnLayerSelect( int aLayer );
* <p> void OnLayerVisible( int aLayer, bool isVisible );
* <p> void OnRenderColorChange( int id, int aColor );
* <p> void OnRenderEnable( int id, bool isEnabled );
*
* Please note that even if designed toward layers, it is used to
* contain other stuff, too (the second page in pcbnew contains render
* items, for example)
* @note Even if designed toward layers, it is used to contain other stuff, too (the second page
* in pcbnew contains render items, for example).
*/
class LAYER_WIDGET : public wxPanel
{
public:
/**
* Struct ROW
* provides all the data needed to add a row to a LAYER_WIDGET. This is
* Provide all the data needed to add a row to a LAYER_WIDGET. This is
* part of the public API for a LAYER_WIDGET.
*/
struct ROW
{
wxString rowName; ///< the prompt or layername
int id; ///< either a layer or "visible element" id
COLOR4D color; ///< COLOR4D::UNSPECIFIED if none.
bool state; ///< initial wxCheckBox state
wxString tooltip; ///< if not empty, use this tooltip on row
bool changeable; ///< if true, the state can be changed
bool spacer; ///< if true, this row is a spacer
wxString rowName; ///< the prompt or layername
int id; ///< either a layer or "visible element" id
COLOR4D color; ///< COLOR4D::UNSPECIFIED if none.
bool state; ///< initial wxCheckBox state
wxString tooltip; ///< if not empty, use this tooltip on row
bool changeable; ///< if true, the state can be changed
bool spacer; ///< if true, this row is a spacer
COLOR4D defaultColor; ///< The default color for the row
ROW( const wxString& aRowName, int aId, COLOR4D aColor = COLOR4D::UNSPECIFIED,
@ -122,150 +120,15 @@ public:
static const wxEventType EVT_LAYER_COLOR_CHANGE;
protected:
wxAuiNotebook* m_notebook;
wxPanel* m_LayerPanel;
wxScrolledWindow* m_LayerScrolledWindow;
wxFlexGridSizer* m_LayersFlexGridSizer;
wxPanel* m_RenderingPanel;
wxScrolledWindow* m_RenderScrolledWindow;
wxFlexGridSizer* m_RenderFlexGridSizer;
wxWindow* m_FocusOwner;
int m_CurrentRow; ///< selected row of layer list
int m_PointSize;
ROW_ICON_PROVIDER* m_IconProvider;
wxString m_smallestLayerString;
/**
* Virtual Function useAlternateBitmap
* @return true if bitmaps shown in Render layer list
* are alternate bitmaps, or false if they are "normal" bitmaps
* This is a virtual function because Pcbnew uses normal bitmaps
* but GerbView uses both bitmaps
* (alternate bitmaps to show layers in use, normal fo others)
*/
virtual bool useAlternateBitmap(int aRow) { return false; }
/**
* Subclasses can override this to provide accurate representation
* of transparent colour swatches.
*/
virtual COLOR4D getBackgroundLayerColor() { return COLOR4D::BLACK; }
/**
* Function encodeId
* is here to allow saving a layer index within a control as its wxControl id,
* but to do so in a way that all child wxControl ids within a wxWindow are unique,
* since this is required by Windows.
* @see getDecodedId()
*/
static int encodeId( int aColumn, int aId );
/**
* Function getDecodedId
* decodes \a aControlId to original un-encoded value. This of
* course holds iff encodedId was called with a LAYER_NUM (this box
* is used for other things than layers, too)
*/
static LAYER_NUM getDecodedId( int aControlId );
void OnLeftDownLayers( wxMouseEvent& event );
/**
* Function OnRightDownLayer
* Called when user right-clicks a layer
*/
void OnRightDownLayer( wxMouseEvent& event, COLOR_SWATCH* aColorSwatch, const wxString& aLayerName );
/**
* Function OnSwatchChanged()
* is called when a user changes a swatch color
*/
void OnLayerSwatchChanged( wxCommandEvent& aEvent );
/**
* Function OnLayerCheckBox
* handles the "is layer visible" checkbox and propogates the
* event to the client's notification function.
*/
void OnLayerCheckBox( wxCommandEvent& event );
/**
* Function OnRightDownRender
* Called when user right-clicks a render option
*/
void OnRightDownRender( wxMouseEvent& aEvent, COLOR_SWATCH* aColorSwatch, const wxString& aRenderName );
/**
* Function OnRenderSwatchChanged
* Called when user has changed the swatch color of a render entry
*/
void OnRenderSwatchChanged( wxCommandEvent& aEvent );
void OnRenderCheckBox( wxCommandEvent& event );
void OnTabChange( wxNotebookEvent& event );
/**
* Function getLayerComp
* returns the component within the m_LayersFlexGridSizer at @a aRow and @a aCol
* or NULL if these parameters are out of range.
*
* @param aRow is the row index
* @param aColumn is the column
* @return wxWindow - the component installed within the sizer at given grid coordinate.
*/
wxWindow* getLayerComp( int aRow, int aColumn ) const;
wxWindow* getRenderComp( int aRow, int aColumn ) const;
/**
* Function findLayerRow
* returns the row index that \a aLayer resides in, or -1 if not found.
*/
int findLayerRow( LAYER_NUM aLayer ) const;
int findRenderRow( int aId ) const;
/**
* Function insertLayerRow
* appends or inserts a new row in the layer portion of the widget.
*/
void insertLayerRow( int aRow, const ROW& aSpec );
void insertRenderRow( int aRow, const ROW& aSpec );
void setLayerCheckbox( LAYER_NUM aLayer, bool isVisible );
void updateLayerRow( int aRow, const wxString& aName );
/**
* Function passOnFocus
* gives away the keyboard focus up to the main parent window.
*/
void passOnFocus();
// popup menu ids.
enum POPUP_ID
{
ID_CHANGE_LAYER_COLOR = wxID_HIGHEST,
ID_CHANGE_RENDER_COLOR,
ID_LAST_VALUE
};
public:
/** Constructor
* @param aParent is the parent window
* @param aFocusOwner is the window that should be sent the focus after
* @param id is the wxWindow id ( default = wxID_ANY)
* @param pos is the window position
* @param size is the window size
* @param style is the window style
* every operation.
/**
* @param aParent is the parent window.
* @param aFocusOwner is the window that should be sent the focus after.
* @param id is the wxWindow id ( default = wxID_ANY).
* @param pos is the window position.
* @param size is the window size.
* @param style is the window style.
*/
LAYER_WIDGET( wxWindow* aParent, wxWindow* aFocusOwner, wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
@ -282,36 +145,33 @@ public:
}
/**
* Function GetBestSize
* returns the preferred minimum size, taking into consideration the
* dynamic content. Nothing in wxWidgets was reliable enough so this
* overrides one of their functions.
* Return the preferred minimum size, taking into consideration the dynamic content.
*
* Nothing in wxWidgets was reliable enough so this overrides one of their functions.
*/
wxSize GetBestSize() const;
/**
* Function GetLayerRowCount
* returns the number of rows in the layer tab.
* Return the number of rows in the layer tab.
*/
int GetLayerRowCount() const;
/**
* Function GetRenderRowCount
* returns the number of rows in the render tab.
* Return the number of rows in the render tab.
*/
int GetRenderRowCount() const;
/**
* Function AppendLayerRow
* appends a new row in the layer portion of the widget. The user must
* ensure that ROW::id is unique for all existing rows on Windows.
* Append a new row in the layer portion of the widget.
*
* The user must ensure that ROW::id is unique for all existing rows on Windows.
*/
void AppendLayerRow( const ROW& aRow );
/**
* Function AppendLayerRows
* appends new rows in the layer portion of the widget. The user must
* ensure that ROW::id is unique for all existing rows on Windows.
* Append new rows in the layer portion of the widget.
*
* The user must ensure that ROW::id is unique for all existing rows on Windows.
*/
void AppendLayerRows( const ROW* aRowsArray, int aRowCount )
{
@ -322,22 +182,21 @@ public:
}
/**
* Function ClearLayerRows
* empties out the layer rows.
* Empty out the layer rows.
*/
void ClearLayerRows();
/**
* Function AppendRenderRow
* appends a new row in the render portion of the widget. The user must
* ensure that ROW::id is unique for all existing rows on Windows.
* Append a new row in the render portion of the widget.
*
* The user must ensure that ROW::id is unique for all existing rows on Windows.
*/
void AppendRenderRow( const ROW& aRow );
/**
* Function AppendRenderRows
* appends new rows in the render portion of the widget. The user must
* ensure that ROW::id is unique for all existing rows on Windows.
* Append new rows in the render portion of the widget.
*
* The user must ensure that ROW::id is unique for all existing rows on Windows.
*/
void AppendRenderRows( const ROW* aRowsArray, int aRowCount )
{
@ -348,76 +207,68 @@ public:
}
/**
* Function ClearRenderRows
* empties out the render rows.
* Empty out the render rows.
*/
void ClearRenderRows();
/**
* Function SelectLayerRow
* changes the row selection in the layer list to the given row.
* Change the row selection in the layer list to the given row.
*/
void SelectLayerRow( int aRow );
/**
* Function SelectLayer
* changes the row selection in the layer list to \a aLayer provided.
* Change the row selection in the layer list to \a aLayer provided.
*/
void SelectLayer( LAYER_NUM aLayer );
/**
* Function GetSelectedLayer
* returns the selected layer or -1 if none.
* Return the selected layer or -1 if none.
*/
LAYER_NUM GetSelectedLayer();
/**
* Function SetLayerVisible
* sets \a aLayer visible or not. This does not invoke OnLayerVisible().
* Set \a aLayer visible or not. This does not invoke OnLayerVisible().
*/
void SetLayerVisible( LAYER_NUM aLayer, bool isVisible );
/**
* Function IsLayerVisible
* returns the visible state of the layer ROW associated with \a aLayer id.
* Return the visible state of the layer ROW associated with \a aLayer id.
*/
bool IsLayerVisible( LAYER_NUM aLayer );
/**
* Function SetLayerColor
* changes the color of \a aLayer
* Change the color of \a aLayer
*/
void SetLayerColor( LAYER_NUM aLayer, COLOR4D aColor );
/**
* Function GetLayerColor
* returns the color of the layer ROW associated with \a aLayer id.
* Return the color of the layer ROW associated with \a aLayer id.
*/
COLOR4D GetLayerColor( LAYER_NUM aLayer ) const;
/**
* Function SetRenderState
* sets the state of the checkbox associated with \a aId within the
* Render tab group of the widget. Does not fire an event, i.e. does
* not invoke OnRenderEnable().
* @param aId is the same unique id used when adding a ROW to the
* Render tab.
* @param isSet = the new checkbox state
* Set the state of the checkbox associated with \a aId within the Render tab group of the
* widget.
*
* This does not fire an event, i.e. does not invoke OnRenderEnable().
*
* @param aId is the same unique id used when adding a ROW to the Render tab.
* @param isSet is the new checkbox state.
*/
void SetRenderState( int aId, bool isSet );
/**
* Function GetRenderState
* returns the state of the checkbox associated with \a aId.
* @return bool - true if checked, else false.
* Return the state of the checkbox associated with \a aId.
*
* @return true if checked, else false.
*/
bool GetRenderState( int aId );
void UpdateLayouts();
/**
* Function UpdateLayerIcons
* Update all layer manager icons (layers only)
* Update all layer manager icons (layers only).
*
* Useful when loading a file or clearing a layer because they change,
* and the indicator arrow icon needs to be updated
*/
@ -442,65 +293,186 @@ public:
//-----<abstract functions>-------------------------------------------
/**
* Function OnLayerColorChange
* is called to notify client code about a layer color change. Derived
*es will handle this accordingly.
* @param aLayer is the board layer to change
* @param aColor is the new color
* Notify client code about a layer color change.
*
* Derived objects will handle this accordingly.
*
* @param aLayer is the board layer to change.
* @param aColor is the new color.
*/
virtual void OnLayerColorChange( int aLayer, COLOR4D aColor ) = 0;
/**
* Function OnLayerSelect
* is called to notify client code whenever the user selects a different
* layer. Derived classes will handle this accordingly, and can deny
* the change by returning false.
* @param aLayer is the board layer to select
* Notify client code whenever the user selects a different layer.
*
* Derived classes will handle this accordingly, and can deny the change by returning false.
*
* @param aLayer is the board layer to select.
*/
virtual bool OnLayerSelect( int aLayer ) = 0;
/**
* Function OnLayerVisible
* is called to notify client code about a layer visibility change.
* Notify client code about a layer visibility change.
*
* @param aLayer is the board layer to select
* @param isVisible is the new visible state
* @param isFinal is true when this is the last of potentially several
* such calls, and can be used to decide when to update the screen only
* one time instead of several times in the midst of a multiple layer change.
* @param aLayer is the board layer to select.
* @param isVisible is the new visible state.
* @param isFinal is true when this is the last of potentially several such calls, and can
* be used to decide when to update the screen only one time instead of
* several times in the midst of a multiple layer change.
*/
virtual void OnLayerVisible( LAYER_NUM aLayer, bool isVisible, bool isFinal = true ) = 0;
/**
* Function OnLayerRightClick
* is called to notify client code about a layer being right-clicked.
* Notify client code about a layer being right-clicked.
*
* @param aMenu is the right-click menu containing layer-scoped options.
* It can be used to add extra, wider scoped menu items.
*/
virtual void OnLayerRightClick( wxMenu& aMenu ) = 0;
/**
* Function OnRenderColorChange
* is called to notify client code whenever the user changes a rendering
* color.
* @param aId is the same id that was established in a Rendering row
* via the AddRenderRow() function.
* @param aColor is the new color
* Notify client code whenever the user changes a rendering color.
*
* @param aId is the same id that was established in a Rendering row via the AddRenderRow()
* function.
* @param aColor is the new color.
*/
virtual void OnRenderColorChange( int aId, COLOR4D aColor ) = 0;
/**
* Function OnRenderEnable
* is called to notify client code whenever the user changes an rendering
* enable in one of the rendering checkboxes.
* @param aId is the same id that was established in a Rendering row
* via the AddRenderRow() function.
* Notify client code whenever the user changes an rendering enable in one of the rendering
* checkboxes.
*
* @param aId is the same id that was established in a Rendering row via the AddRenderRow()
* function.
* @param isEnabled is the state of the checkbox, true if checked.
*/
virtual void OnRenderEnable( int aId, bool isEnabled ) = 0;
//-----</abstract functions>------------------------------------------
protected:
/**
* @return true if bitmaps shown in Render layer list
* are alternate bitmaps, or false if they are "normal" bitmaps
* This is a virtual function because Pcbnew uses normal bitmaps
* but GerbView uses both bitmaps
* (alternate bitmaps to show layers in use, normal for others)
*/
virtual bool useAlternateBitmap(int aRow) { return false; }
/**
* Subclasses can override this to provide accurate representation
* of transparent color swatches.
*/
virtual COLOR4D getBackgroundLayerColor() { return COLOR4D::BLACK; }
/**
* Allow saving a layer index within a control as its wxControl id.
*
* To do so in a way that all child wxControl ids within a wxWindow are unique, since this
* is required by Windows.
*
* @see getDecodedId()
*/
static int encodeId( int aColumn, int aId );
/**
* Decode \a aControlId to original un-encoded value.
*
* This holds if encodedId was called with a LAYER_NUM (this box is used for other things
* than layers, too).
*/
static LAYER_NUM getDecodedId( int aControlId );
void OnLeftDownLayers( wxMouseEvent& event );
/**
* Called when user right-clicks a layer.
*/
void OnRightDownLayer( wxMouseEvent& event, COLOR_SWATCH* aColorSwatch,
const wxString& aLayerName );
/**
* Called when a user changes a swatch color.
*/
void OnLayerSwatchChanged( wxCommandEvent& aEvent );
/**
* Handle the "is layer visible" checkbox and propagates the event to the client's
* notification function.
*/
void OnLayerCheckBox( wxCommandEvent& event );
/**
* Notify when user right-clicks a render option.
*/
void OnRightDownRender( wxMouseEvent& aEvent, COLOR_SWATCH* aColorSwatch,
const wxString& aRenderName );
/**
* Called when user has changed the swatch color of a render entry.
*/
void OnRenderSwatchChanged( wxCommandEvent& aEvent );
void OnRenderCheckBox( wxCommandEvent& event );
void OnTabChange( wxNotebookEvent& event );
/**
* Return the component within the m_LayersFlexGridSizer at @a aRow and @a aCol
* or NULL if these parameters are out of range.
*
* @param aRow is the row index
* @param aColumn is the column
* @return the component installed within the sizer at given grid coordinate.
*/
wxWindow* getLayerComp( int aRow, int aColumn ) const;
wxWindow* getRenderComp( int aRow, int aColumn ) const;
/**
* Return the row index that \a aLayer resides in, or -1 if not found.
*/
int findLayerRow( LAYER_NUM aLayer ) const;
int findRenderRow( int aId ) const;
/**
* Append or insert a new row in the layer portion of the widget.
*/
void insertLayerRow( int aRow, const ROW& aSpec );
void insertRenderRow( int aRow, const ROW& aSpec );
void setLayerCheckbox( LAYER_NUM aLayer, bool isVisible );
void updateLayerRow( int aRow, const wxString& aName );
/**
* Give away the keyboard focus up to the main parent window.
*/
void passOnFocus();
// popup menu ids.
enum POPUP_ID
{
ID_CHANGE_LAYER_COLOR = wxID_HIGHEST,
ID_CHANGE_RENDER_COLOR,
ID_LAST_VALUE
};
wxAuiNotebook* m_notebook;
wxPanel* m_LayerPanel;
wxScrolledWindow* m_LayerScrolledWindow;
wxFlexGridSizer* m_LayersFlexGridSizer;
wxPanel* m_RenderingPanel;
wxScrolledWindow* m_RenderScrolledWindow;
wxFlexGridSizer* m_RenderFlexGridSizer;
wxWindow* m_FocusOwner;
int m_CurrentRow; ///< selected row of layer list
int m_PointSize;
ROW_ICON_PROVIDER* m_IconProvider;
wxString m_smallestLayerString;
};
#endif // LAYERWIDGET_H_