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

Code cleaning

This commit is contained in:
charras 2009-01-02 17:07:50 +00:00
parent ada6b6b8ba
commit 598cc337d2
15 changed files with 609 additions and 590 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGELOG.txt
View File

@ -10,6 +10,7 @@ email address.
++Eeschema:
Code cleaning.
LibDrawPolyline uses now std::vector<wxPoint> to handle corners.
DrawPolylineStruct uses now std::vector<wxPoint> to handle corners.

20
eeschema/block.cpp
View File

@ -626,7 +626,7 @@ void MirrorOneStruct( SCH_ITEM* DrawStruct, wxPoint& Center )
/* Given a structure rotate it to 90 degrees refer to the Center point.
*/
{
int dx, ii, * Points;
int dx;
DrawPolylineStruct* DrawPoly;
DrawJunctionStruct* DrawConnect;
EDA_DrawLineStruct* DrawSegment;
@ -652,13 +652,12 @@ void MirrorOneStruct( SCH_ITEM* DrawStruct, wxPoint& Center )
case DRAW_POLYLINE_STRUCT_TYPE:
DrawPoly = (DrawPolylineStruct*) DrawStruct;
Points = DrawPoly->m_Points;
for( ii = 0; ii < DrawPoly->m_NumOfPoints; ii++ )
for( unsigned ii = 0; ii < DrawPoly->GetCornerCount(); ii++ )
{
wxPoint point;
point.x = Points[ii * 2]; point.y = Points[ii * 2 + 1];
point = DrawPoly->m_PolyPoints[ii];
MirrorYPoint( point, Center );
Points[ii * 2] = point.x; Points[ii * 2 + 1] = point.y;
DrawPoly->m_PolyPoints[ii] = point;
}
break;
@ -740,7 +739,7 @@ void MirrorOneStruct( SCH_ITEM* DrawStruct, wxPoint& Center )
MirrorYPoint( DrawLibItem->m_Pos, Center );
dx -= DrawLibItem->m_Pos.x;
for( ii = 0; ii < DrawLibItem->GetFieldCount(); ii++ )
for( int ii = 0; ii < DrawLibItem->GetFieldCount(); ii++ )
{
/* move the fields to the new position because the component itself has moved */
DrawLibItem->GetField( ii )->m_Pos.x -= dx;
@ -1194,7 +1193,6 @@ void MoveOneStruct( SCH_ITEM* DrawStruct, const wxPoint& move_vector )
/* Given a structure move it by Dx, Dy.
*/
{
int ii, * Points;
DrawPolylineStruct* DrawPoly;
DrawJunctionStruct* DrawConnect;
EDA_DrawLineStruct* DrawSegment;
@ -1215,11 +1213,9 @@ void MoveOneStruct( SCH_ITEM* DrawStruct, const wxPoint& move_vector )
case DRAW_POLYLINE_STRUCT_TYPE:
DrawPoly = (DrawPolylineStruct*) DrawStruct;
Points = DrawPoly->m_Points;
for( ii = 0; ii < DrawPoly->m_NumOfPoints; ii++ )
for( unsigned ii = 0; ii < DrawPoly->GetCornerCount(); ii++ )
{
Points[ii * 2] += move_vector.x;
Points[ii * 2 + 1] += move_vector.y;
DrawPoly->m_PolyPoints[ii] += move_vector;
}
break;
@ -1275,7 +1271,7 @@ void MoveOneStruct( SCH_ITEM* DrawStruct, const wxPoint& move_vector )
case TYPE_SCH_COMPONENT:
DrawLibItem = (SCH_COMPONENT*) DrawStruct;
DrawLibItem->m_Pos += move_vector;
for( ii = 0; ii < DrawLibItem->GetFieldCount(); ii++ )
for( int ii = 0; ii < DrawLibItem->GetFieldCount(); ii++ )
{
DrawLibItem->GetField( ii )->m_Pos += move_vector;
}

14
eeschema/bus-wire-junction.cpp
View File

@ -474,24 +474,22 @@ static void Show_Polyline_in_Ghost( WinEDA_DrawPanel* panel, wxDC* DC, bool eras
GRSetDrawMode( DC, g_XorMode );
int idx = NewPoly->GetCornerCount() - 1;
if( g_HVLines )
{
/* Coerce the line to vertical or horizontal one: */
if( ABS( endpos.x - NewPoly->m_Points[NewPoly->m_NumOfPoints * 2 - 2] ) <
ABS( endpos.y - NewPoly->m_Points[NewPoly->m_NumOfPoints * 2 - 1] ) )
endpos.x = NewPoly->m_Points[NewPoly->m_NumOfPoints * 2 - 2];
if( ABS( endpos.x - NewPoly->m_PolyPoints[idx].x ) <
ABS( endpos.y - NewPoly->m_PolyPoints[idx].y ) )
endpos.x = NewPoly->m_PolyPoints[idx].x;
else
endpos.y = NewPoly->m_Points[NewPoly->m_NumOfPoints * 2 - 1];
endpos.y = NewPoly->m_PolyPoints[idx].y;
}
NewPoly->m_NumOfPoints++;
if( erase )
RedrawOneStruct( panel, DC, NewPoly, g_XorMode, color );
NewPoly->m_Points[NewPoly->m_NumOfPoints * 2 - 2] = endpos.x;
NewPoly->m_Points[NewPoly->m_NumOfPoints * 2 - 1] = endpos.y;
NewPoly->m_PolyPoints[idx] = endpos;
RedrawOneStruct( panel, DC, NewPoly, g_XorMode, color );
NewPoly->m_NumOfPoints--;
}

2
eeschema/class_libentry_fields.h
View File

@ -59,7 +59,7 @@ public:
void SetFields( const std::vector <LibDrawField> aFields );
void Draw( WinEDA_DrawPanel * aPanel, wxDC * aDC, const wxPoint &aOffset, int aColor,
int aDrawMode, void* aData, int aTransformMatrix[2][2] );
int aDrawMode, void* aData, const int aTransformMatrix[2][2] );
/**
* Function HitTest

4
eeschema/class_pin.cpp
View File

@ -19,7 +19,7 @@ void LibDrawPin::Draw( WinEDA_DrawPanel* aPanel,
int aColor,
int aDrawMode,
void* aData,
int aTransformMatrix[2][2] )
const int aTransformMatrix[2][2] )
/**********************************************************************************************/
{
// Invisibles pins are only drawn on request.
@ -866,7 +866,7 @@ wxPoint LibDrawPin::ReturnPinEndPoint()
/********************************************************/
int LibDrawPin::ReturnPinDrawOrient( int TransMat[2][2] )
int LibDrawPin::ReturnPinDrawOrient( const int TransMat[2][2] )
/********************************************************/
/** Function ReturnPinDrawOrient

20
eeschema/class_schematic_items.cpp
View File

@ -427,8 +427,6 @@ DrawPolylineStruct::DrawPolylineStruct( int layer ) :
SCH_ITEM( NULL, DRAW_POLYLINE_STRUCT_TYPE )
/***********************************************************/
{
m_NumOfPoints = 0; /* Number of XY pairs in Points array. */
m_Points = NULL; /* XY pairs that forms the polyline. */
m_Width = GR_NORM_WIDTH;
switch( layer )
@ -454,8 +452,6 @@ DrawPolylineStruct::DrawPolylineStruct( int layer ) :
DrawPolylineStruct::~DrawPolylineStruct()
/*********************************************/
{
if( m_Points )
free( m_Points );
}
@ -463,16 +459,9 @@ DrawPolylineStruct::~DrawPolylineStruct()
DrawPolylineStruct* DrawPolylineStruct::GenCopy()
/*****************************************************/
{
int memsize;
DrawPolylineStruct* newitem =
new DrawPolylineStruct( m_Layer );
memsize = sizeof(int) * 2 * m_NumOfPoints;
newitem->m_NumOfPoints = m_NumOfPoints;
newitem->m_Points = (int*) MyZMalloc( memsize );
memcpy( newitem->m_Points, m_Points, memsize );
newitem->m_PolyPoints = m_PolyPoints; // std::vector copy
return newitem;
}
@ -497,16 +486,15 @@ bool DrawPolylineStruct::Save( FILE* aFile ) const
if( m_Width != GR_NORM_WIDTH )
width = "Bus";
if( fprintf( aFile, "Poly %s %s %d\n",
width, layer, m_NumOfPoints ) == EOF )
width, layer, GetCornerCount() ) == EOF )
{
success = false;
return success;
}
for( int ii = 0; ii < m_NumOfPoints; ii++ )
for( unsigned ii = 0; ii < GetCornerCount(); ii++ )
{
if( fprintf( aFile, "\t%-4d %-4d\n",
m_Points[ii * 2],
m_Points[ii * 2 + 1] ) == EOF )
m_PolyPoints[ii ].x, m_PolyPoints[ii].y ) == EOF )
{
success = false;
break;

285
eeschema/class_schematic_items.h Normal file
View File

@ -0,0 +1,285 @@
/************************************************************************/
/* classes to handle items used in schematic: wires, bus, junctions ... */
/************************************************************************/
#ifndef CLASS_SCHEMATIC_ITEMS_H
#define CLASS_SCHEMATIC_ITEMS_H
#ifndef eda_global
#define eda_global extern
#endif
#define DRAWJUNCTION_SIZE 16 /* Rayon du symbole connexion */
#define DRAWMARKER_SIZE 16 /* Rayon du symbole marqueur */
#define DRAWNOCONNECT_SIZE 48 /* Rayon du symbole No Connexion */
/* flags pour BUS ENTRY (bus to bus ou wire to bus */
#define WIRE_TO_BUS 0
#define BUS_TO_BUS 1
enum TypeMarker { /* Type des Marqueurs */
MARQ_UNSPEC,
MARQ_ERC,
MARQ_PCB,
MARQ_SIMUL,
MARQ_NMAX /* Derniere valeur: fin de tableau */
};
/* Messages correspondants aux types des marqueurs */
#ifdef MAIN
const wxChar* NameMarqueurType[] =
{
wxT( "" ),
wxT( "ERC" ),
wxT( "PCB" ),
wxT( "SIMUL" ),
wxT( "?????" )
};
#else
extern const wxChar* NameMarqueurType[];
#endif
/**
* Class EDA_DrawLineStruct
* is a segment decription base class to describe items which have 2 end
* points (track, wire, draw line ...)
*/
class EDA_DrawLineStruct : public SCH_ITEM
{
public:
int m_Width; // 0 = line, > 0 = tracks, bus ...
wxPoint m_Start; // Line start point
wxPoint m_End; // Line end point
bool m_StartIsDangling;
bool m_EndIsDangling; // TRUE si Start ou End not connected (wires, tracks...)
public:
EDA_DrawLineStruct( const wxPoint& pos, int layer );
~EDA_DrawLineStruct() { }
EDA_DrawLineStruct* Next() const { return (EDA_DrawLineStruct*) Pnext; }
EDA_DrawLineStruct* Back() const { return (EDA_DrawLineStruct*) Pback; }
virtual wxString GetClass() const
{
return wxT( "EDA_DrawLine" );
}
bool IsOneEndPointAt( const wxPoint& pos );
EDA_DrawLineStruct* GenCopy();
bool IsNull()
{
return m_Start == m_End;
}
EDA_Rect GetBoundingBox();
virtual void Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset, int draw_mode,
int Color = -1 );
/**
* Function Save
* writes the data structures for this object out to a FILE in "*.brd" format.
* @param aFile The FILE to write to.
* @return bool - true if success writing else false.
*/
bool Save( FILE* aFile ) const;
#if defined(DEBUG)
void Show( int nestLevel, std::ostream& os );
#endif
};
class DrawMarkerStruct : public SCH_ITEM /* marqueurs */
{
public:
wxPoint m_Pos; /* XY coordinates of marker. */
TypeMarker m_Type;
int m_MarkFlags; // complements d'information
wxString m_Comment; /* Texte (commentaireassocie eventuel */
public:
DrawMarkerStruct( const wxPoint& pos, const wxString& text );
~DrawMarkerStruct();
virtual wxString GetClass() const
{
return wxT( "DrawMarker" );
}
DrawMarkerStruct* GenCopy();
wxString GetComment();
virtual void Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset,
int draw_mode, int Color = -1 );
/**
* Function Save
* writes the data structures for this object out to a FILE in "*.brd" format.
* @param aFile The FILE to write to.
* @return bool - true if success writing else false.
*/
bool Save( FILE* aFile ) const;
#if defined(DEBUG)
void Show( int nestLevel, std::ostream& os );
#endif
};
class DrawNoConnectStruct : public SCH_ITEM /* Symboles de non connexion */
{
public:
wxPoint m_Pos; /* XY coordinates of NoConnect. */
public:
DrawNoConnectStruct( const wxPoint& pos );
~DrawNoConnectStruct() { }
virtual wxString GetClass() const
{
return wxT( "DrawNoConnect" );
}
DrawNoConnectStruct* GenCopy();
virtual void Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset,
int draw_mode, int Color = -1 );
/**
* Function Save
* writes the data structures for this object out to a FILE in "*.brd" format.
* @param aFile The FILE to write to.
* @return bool - true if success writing else false.
*/
bool Save( FILE* aFile ) const;
EDA_Rect GetBoundingBox();
};
/**
* Class DrawBusEntryStruct
* Struct de descr 1 raccord a 45 degres de BUS ou WIRE
*/
class DrawBusEntryStruct : public SCH_ITEM
{
public:
int m_Width;
wxPoint m_Pos;
wxSize m_Size;
public:
DrawBusEntryStruct( const wxPoint& pos, int shape, int id );
~DrawBusEntryStruct() { }
virtual wxString GetClass() const
{
return wxT( "DrawBusEntry" );
}
DrawBusEntryStruct* GenCopy();
wxPoint m_End() const; // retourne la coord de fin du raccord
virtual void Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset,
int draw_mode, int Color = -1 );
/**
* Function Save
* writes the data structures for this object out to a FILE in "*.brd" format.
* @param aFile The FILE to write to.
* @return bool - true if success writing else false.
*/
bool Save( FILE* aFile ) const;
EDA_Rect GetBoundingBox();
};
class DrawPolylineStruct : public SCH_ITEM /* Polyligne (serie de segments) */
{
public:
int m_Width; /* Tickness */
std::vector<wxPoint> m_PolyPoints; // list of points (>= 2)
public:
DrawPolylineStruct( int layer );
~DrawPolylineStruct();
virtual wxString GetClass() const
{
return wxT( "DrawPolyline" );
}
DrawPolylineStruct* GenCopy();
virtual void Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset,
int draw_mode, int Color = -1 );
/**
* Function Save
* writes the data structures for this object out to a FILE in "*.brd" format.
* @param aFile The FILE to write to.
* @return bool - true if success writing else false.
*/
bool Save( FILE* aFile ) const;
/** Function AddPoint
* add a corner to m_PolyPoints
*/
void AddPoint( const wxPoint& point )
{
m_PolyPoints.push_back( point );
}
/** Function GetCornerCount
* @return the number of corners
*/
unsigned GetCornerCount() const { return m_PolyPoints.size(); }
};
class DrawJunctionStruct : public SCH_ITEM
{
public:
wxPoint m_Pos; /* XY coordinates of connection. */
public:
DrawJunctionStruct( const wxPoint& pos );
~DrawJunctionStruct() { }
virtual wxString GetClass() const
{
return wxT( "DrawJunction" );
}
EDA_Rect GetBoundingBox();
DrawJunctionStruct* GenCopy();
virtual void Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset,
int draw_mode, int Color = -1 );
/**
* Function Save
* writes the data structures for this object out to a FILE in "*.brd" format.
* @param aFile The FILE to write to.
* @return bool - true if success writing else false.
*/
bool Save( FILE* aFile ) const;
#if defined(DEBUG)
void Show( int nestLevel, std::ostream& os );
#endif
};
#endif /* CLASS_SCHEMATIC_ITEMS_H */

35
eeschema/classes_body_items.cpp
View File

@ -39,7 +39,7 @@ LibEDA_BaseStruct::LibEDA_BaseStruct( KICAD_T struct_type ) :
/**********************************************************************************************/
void LibDrawArc::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC, const wxPoint& aOffset, int aColor,
int aDrawMode, void* aData, int aTransformMatrix[2][2] )
int aDrawMode, void* aData, const int aTransformMatrix[2][2] )
/**********************************************************************************************/
{
wxPoint pos1, pos2, posc;
@ -99,7 +99,7 @@ void LibDrawArc::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC, const wxPoint& aOffs
/*************************************************************************************************/
void LibDrawCircle::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC, const wxPoint& aOffset, int aColor,
int aDrawMode, void* aData, int aTransformMatrix[2][2] )
int aDrawMode, void* aData, const int aTransformMatrix[2][2] )
/*************************************************************************************************/
{
wxPoint pos1;
@ -137,7 +137,7 @@ void LibDrawCircle::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC, const wxPoint& aO
/*************************************************************************************************/
void LibDrawText::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC, const wxPoint& aOffset, int aColor,
int aDrawMode, void* aData, int aTransformMatrix[2][2] )
int aDrawMode, void* aData, const int aTransformMatrix[2][2] )
/*************************************************************************************************/
{
wxPoint pos1, pos2;
@ -168,7 +168,7 @@ void LibDrawText::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC, const wxPoint& aOff
/*************************************************************************************************/
void LibDrawSquare::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC, const wxPoint& aOffset, int aColor,
int aDrawMode, void* aData, int aTransformMatrix[2][2] )
int aDrawMode, void* aData, const int aTransformMatrix[2][2] )
/*************************************************************************************************/
{
wxPoint pos1, pos2;
@ -206,7 +206,7 @@ void LibDrawSquare::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC, const wxPoint& aO
/*************************************************************************************************/
void LibDrawSegment::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC, const wxPoint& aOffset, int aColor,
int aDrawMode, void* aData, int aTransformMatrix[2][2] )
int aDrawMode, void* aData, const int aTransformMatrix[2][2] )
/*************************************************************************************************/
{
wxPoint pos1, pos2;
@ -233,7 +233,7 @@ void LibDrawSegment::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC, const wxPoint& a
void LibDrawPolyline::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
const wxPoint& aOffset, int aColor,
int aDrawMode, void* aData,
int aTransformMatrix[2][2] )
const int aTransformMatrix[2][2] )
/*************************************************************************************************/
{
wxPoint pos1;
@ -266,7 +266,8 @@ void LibDrawPolyline::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
for( unsigned ii = 0; ii < m_PolyPoints.size(); ii++ )
{
Buf_Poly_Drawings[ii] = TransformCoordinate( aTransformMatrix, m_PolyPoints[ii] ) + aOffset;
Buf_Poly_Drawings[ii] =
TransformCoordinate( aTransformMatrix, m_PolyPoints[ii] ) + aOffset;
}
FILL_T fill = aData ? NO_FILL : m_Fill;
@ -288,7 +289,7 @@ void LibDrawPolyline::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
/*************************************************************************************************/
void LibDrawField::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC, const wxPoint& aOffset, int aColor,
int aDrawMode, void* aData, int aTransformMatrix[2][2] )
int aDrawMode, void* aData, const int aTransformMatrix[2][2] )
/*************************************************************************************************/
/* if aData not NULL, aData must point a wxString which is used instead of the m_Text
@ -524,6 +525,7 @@ LibDrawPolyline* LibDrawPolyline::GenCopy()
/************************************************/
{
LibDrawPolyline* newitem = new LibDrawPolyline();
newitem->m_PolyPoints = m_PolyPoints; // Vector copy
newitem->m_Width = m_Width;
newitem->m_Unit = m_Unit;
@ -551,24 +553,25 @@ void LibDrawPolyline::AddPoint( const wxPoint& point )
* @param aThreshold = max distance to a segment
* @param aTransMat = the transform matrix
*/
bool LibDrawPolyline::HitTest( wxPoint aPosRef, int aThreshold, int aTransMat[2][2] )
bool LibDrawPolyline::HitTest( wxPoint aPosRef, int aThreshold, const int aTransMat[2][2] )
{
wxPoint ref, start, end;
aPosRef = TransformCoordinate( aTransMat, aPosRef);
/* Move origin coordinate to segment start point */
wxPoint end;
for( unsigned ii = 0; ii < m_PolyPoints.size() - 1; ii++ )
{
aPosRef -= m_PolyPoints[0];
end = m_PolyPoints[1] - m_PolyPoints[0];
start = TransformCoordinate( aTransMat, m_PolyPoints[0] );
end = TransformCoordinate( aTransMat, m_PolyPoints[1] );
ref = aPosRef - start;
end -= start;
if( distance( end.x, end.y, aPosRef.x, aPosRef.y, aThreshold ) )
if( distance( end.x, end.y, ref.x, ref.y, aThreshold ) )
return true;
}
return false;
}
/** Function GetBoundaryBox
* @return the boundary box for this, in library coordinates
*/
@ -576,6 +579,7 @@ EDA_Rect LibDrawPolyline::GetBoundaryBox( )
{
EDA_Rect BoundaryBox;
int xmin, xmax, ymin, ymax;
xmin = xmax = m_PolyPoints[0].x;
ymin = ymax = m_PolyPoints[0].y;
for( unsigned ii = 1; ii < GetCornerCount(); ii++ )
@ -585,6 +589,7 @@ EDA_Rect LibDrawPolyline::GetBoundaryBox( )
ymin = MIN( ymin, m_PolyPoints[0].y );
ymax = MAX( ymax, m_PolyPoints[0].y );
}
BoundaryBox.SetX( xmin ); BoundaryBox.SetWidth( xmax - xmin );
BoundaryBox.SetY( ymin ); BoundaryBox.SetHeight( ymax - ymin );

34
eeschema/classes_body_items.h
View File

@ -158,7 +158,7 @@ public:
* @param aTransformMatrix = Transform Matrix (rotaion, mirror ..)
*/
virtual void Draw( WinEDA_DrawPanel * aPanel, wxDC * aDC, const wxPoint &aOffset, int aColor,
int aDrawMode, void* aData, int aTransformMatrix[2][2] ) = 0;
int aDrawMode, void* aData, const int aTransformMatrix[2][2] ) = 0;
/**
* Function Save
@ -218,12 +218,12 @@ public:
void Display_Infos( WinEDA_DrawFrame* frame );
wxPoint ReturnPinEndPoint();
int ReturnPinDrawOrient( int TransMat[2][2] );
int ReturnPinDrawOrient( const int TransMat[2][2] );
void ReturnPinStringNum( wxString& buffer ) const;
void SetPinNumFromString( wxString& buffer );
void Draw( WinEDA_DrawPanel * aPanel, wxDC * aDC, const wxPoint &aOffset, int aColor,
int aDrawMode, void* aData, int aTransformMatrix[2][2] );
int aDrawMode, void* aData, const int aTransformMatrix[2][2] );
void DrawPinSymbol( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& pin_pos,
int orient,
@ -233,8 +233,13 @@ public:
wxPoint& pin_pos, int orient,
int TextInside, bool DrawPinNum, bool DrawPinName,
int Color, int DrawMode );
void PlotPinTexts( wxPoint& pin_pos, int orient,
int TextInside, bool DrawPinNum, bool DrawPinNameint, int aWidth, bool aItalic );
void PlotPinTexts( wxPoint& pin_pos,
int orient,
int TextInside,
bool DrawPinNum,
bool DrawPinNameint,
int aWidth,
bool aItalic );
};
@ -272,7 +277,7 @@ public:
LibDrawArc* GenCopy();
void Draw( WinEDA_DrawPanel * aPanel, wxDC * aDC, const wxPoint &aOffset, int aColor,
int aDrawMode, void* aData, int aTransformMatrix[2][2] );
int aDrawMode, void* aData, const int aTransformMatrix[2][2] );
};
/*****************************/
@ -306,7 +311,7 @@ public:
LibDrawCircle* GenCopy();
void Draw( WinEDA_DrawPanel * aPanel, wxDC * aDC, const wxPoint &aOffset, int aColor,
int aDrawMode, void* aData, int aTransformMatrix[2][2] );
int aDrawMode, void* aData, const int aTransformMatrix[2][2] );
};
@ -316,10 +321,9 @@ public:
/* Fields like Ref , value... are not Text, */
/* they are a separate class */
/*********************************************/
class LibDrawText : public LibEDA_BaseStruct
, public EDA_TextStruct
class LibDrawText : public LibEDA_BaseStruct,
public EDA_TextStruct
{
public:
LibDrawText();
~LibDrawText() { }
@ -341,7 +345,7 @@ public:
LibDrawText* GenCopy();
void Draw( WinEDA_DrawPanel * aPanel, wxDC * aDC, const wxPoint &aOffset, int aColor,
int aDrawMode, void* aData, int aTransformMatrix[2][2] );
int aDrawMode, void* aData, const int aTransformMatrix[2][2] );
};
@ -376,7 +380,7 @@ public:
LibDrawSquare* GenCopy();
void Draw( WinEDA_DrawPanel * aPanel, wxDC * aDC, const wxPoint &aOffset, int aColor,
int aDrawMode, void* aData, int aTransformMatrix[2][2] );
int aDrawMode, void* aData, const int aTransformMatrix[2][2] );
};
/**********************************/
@ -410,7 +414,7 @@ public:
LibDrawSegment* GenCopy();
void Draw( WinEDA_DrawPanel * aPanel, wxDC * aDC, const wxPoint &aOffset, int aColor,
int aDrawMode, void* aData, int aTransformMatrix[2][2] );
int aDrawMode, void* aData, const int aTransformMatrix[2][2] );
};
/**********************************************************/
@ -454,7 +458,7 @@ public:
* @param aThreshold = max distance to a segment
* @param aTransMat = the transform matrix
*/
bool HitTest( wxPoint aPosRef, int aThreshold, int aTransMat[2][2] );
bool HitTest( wxPoint aPosRef, int aThreshold, const int aTransMat[2][2] );
/** Function GetBoundaryBox
* @return the boundary box for this, in library coordinates
@ -462,7 +466,7 @@ public:
EDA_Rect GetBoundaryBox();
void Draw( WinEDA_DrawPanel * aPanel, wxDC * aDC, const wxPoint &aOffset, int aColor,
int aDrawMode, void* aData, int aTransformMatrix[2][2] );
int aDrawMode, void* aData, const int aTransformMatrix[2][2] );
};
#endif // CLASSES_BODY_ITEMS_H

20
eeschema/eelibs_draw_components.cpp
View File

@ -34,7 +34,7 @@ static void DrawLibPartAux( WinEDA_DrawPanel * panel, wxDC * DC,
SCH_COMPONENT * Component,
EDA_LibComponentStruct * Entry,
const wxPoint &Pos,
int TransMat[2][2],
const int TransMat[2][2],
int Multi, int convert,
int DrawMode, int Color = -1, bool DrawPinText = TRUE );
@ -42,7 +42,7 @@ static void DrawLibPartAux( WinEDA_DrawPanel * panel, wxDC * DC,
static EDA_LibComponentStruct* DummyCmp;
/***************************************************************************/
wxPoint TransformCoordinate( int aTransformMatrix[2][2], wxPoint& aPosition )
wxPoint TransformCoordinate( const int aTransformMatrix[2][2], const wxPoint& aPosition )
/***************************************************************************/
/** Function TransformCoordinate
@ -102,17 +102,13 @@ void DrawLibEntry( WinEDA_DrawPanel* panel, wxDC* DC,
*/
{
int color;
int TransMat[2][2];
wxString Prefix;
LibDrawField* Field;
wxPoint text_pos;
/* Orientation normale */
TransMat[0][0] = 1; TransMat[1][1] = -1;
TransMat[1][0] = TransMat[0][1] = 0;
DrawLibPartAux( panel, DC, NULL, LibEntry, aOffset,
TransMat, Multi,
DefaultTransformMatrix, Multi,
convert, DrawMode, Color );
/* Trace des 2 champs ref et value (Attention aux coord: la matrice
@ -139,7 +135,7 @@ void DrawLibEntry( WinEDA_DrawPanel* panel, wxDC* DC,
Prefix = LibEntry->m_Prefix.m_Text + wxT( "?" );
if( (LibEntry->m_Prefix.m_Flags & IS_MOVED) == 0 )
LibEntry->m_Prefix.Draw( panel, DC, aOffset, color, DrawMode, &Prefix, TransMat );
LibEntry->m_Prefix.Draw( panel, DC, aOffset, color, DrawMode, &Prefix, DefaultTransformMatrix );
if( LibEntry->m_Name.m_Attributs & TEXT_NO_VISIBLE )
{
@ -151,7 +147,7 @@ void DrawLibEntry( WinEDA_DrawPanel* panel, wxDC* DC,
else color = Color;
if( (LibEntry->m_Name.m_Flags & IS_MOVED) == 0 )
LibEntry->m_Name.Draw( panel, DC, aOffset, color, DrawMode, NULL, TransMat );
LibEntry->m_Name.Draw( panel, DC, aOffset, color, DrawMode, NULL, DefaultTransformMatrix );
for( Field = LibEntry->m_Fields; Field != NULL; Field = Field->Next() )
{
@ -167,7 +163,7 @@ void DrawLibEntry( WinEDA_DrawPanel* panel, wxDC* DC,
color = g_InvisibleItemColor;
}
else color = Color;
Field->Draw( panel, DC, aOffset, color, DrawMode, NULL, TransMat );
Field->Draw( panel, DC, aOffset, color, DrawMode, NULL, DefaultTransformMatrix );
}
// Trace de l'ancre
@ -446,7 +442,7 @@ void DrawLibPartAux( WinEDA_DrawPanel* panel, wxDC* DC,
SCH_COMPONENT* Component,
EDA_LibComponentStruct* Entry,
const wxPoint& Pos,
int TransMat[2][2],
const int TransMat[2][2],
int Multi, int convert, int DrawMode,
int Color, bool DrawPinText )
{
@ -534,7 +530,7 @@ void DrawLibPartAux( WinEDA_DrawPanel* panel, wxDC* DC,
* transform (only mirror and rotate so it remains on the unit circle) to *
* a new point which is used to detect new angle. *
*****************************************************************************/
bool MapAngles( int* Angle1, int* Angle2, int TransMat[2][2] )
bool MapAngles( int* Angle1, int* Angle2, const int TransMat[2][2] )
{
int Angle, Delta;
double x, y, t;

38
eeschema/eeredraw.cpp
View File

@ -135,8 +135,12 @@ void WinEDA_SchematicFrame::RedrawActiveWindow( wxDC* DC, bool EraseBg )
/******************************************************************************************************/
void WinEDA_DrawPanel::PrintPage( wxDC* DC, bool Print_Sheet_Ref, int PrintMask, bool aPrintMirrorMode )
void WinEDA_DrawPanel::PrintPage( wxDC* DC,
bool Print_Sheet_Ref,
int PrintMask,
bool aPrintMirrorMode )
/******************************************************************************************************/
/** PrintPage
* used to print a page.
* Print the page pointed by ActiveScreen, set by the calling print function
@ -291,6 +295,7 @@ EDA_Rect DrawNoConnectStruct::GetBoundingBox()
{
const int DELTA = (DRAWNOCONNECT_SIZE / 2);
EDA_Rect box( wxPoint( m_Pos.x - DELTA, m_Pos.y - DELTA ), wxSize( 2 * DELTA, 2 * DELTA ) );
box.Normalize();
return box;
}
@ -327,17 +332,19 @@ EDA_Rect DrawBusEntryStruct::GetBoundingBox()
int dx = m_Pos.x - m_End().x;
int dy = m_Pos.y - m_End().y;
EDA_Rect box( wxPoint( m_Pos.x, m_Pos.y ), wxSize( dx, dy ) );
box.Normalize();
return box;
}
/*****************************************************************************
* Routine to redraw polyline struct. *
*****************************************************************************/
void DrawPolylineStruct::Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset,
int DrawMode, int Color )
{
int i, color;
int color;
int zoom = panel->GetZoom();
int width = MAX( m_Width, g_DrawMinimunLineWidth );
@ -353,20 +360,20 @@ void DrawPolylineStruct::Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint&
width *= 3;
}
GRMoveTo( m_Points[0], m_Points[1] );
GRMoveTo( m_PolyPoints[0].x, m_PolyPoints[0].y );
if( m_Layer == LAYER_NOTES )
{
for( i = 1; i < m_NumOfPoints; i++ )
GRDashedLineTo( &panel->m_ClipBox, DC, m_Points[i * 2] + offset.x,
m_Points[i * 2 + 1] + offset.y, width, color );
for( unsigned i = 1; i < GetCornerCount(); i++ )
GRDashedLineTo( &panel->m_ClipBox, DC, m_PolyPoints[i].x + offset.x,
m_PolyPoints[i].y + offset.y, width, color );
}
else
{
for( i = 1; i < m_NumOfPoints; i++ )
for( unsigned i = 1; i < GetCornerCount(); i++ )
GRLineTo( &panel->m_ClipBox,
DC,
m_Points[i * 2] + offset.x,
m_Points[i * 2 + 1] + offset.y,
m_PolyPoints[i].x + offset.x,
m_PolyPoints[i].y + offset.y,
width,
color );
}
@ -403,7 +410,7 @@ void DrawStructsInGhost( WinEDA_DrawPanel* panel, wxDC* DC,
* Utilisee dans les deplacements de blocs
*/
{
int Width, ii;
int Width;
int DrawMode = g_XorMode;
int width = g_DrawMinimunLineWidth;
@ -414,12 +421,11 @@ void DrawStructsInGhost( WinEDA_DrawPanel* panel, wxDC* DC,
{
case DRAW_POLYLINE_STRUCT_TYPE:
{
DrawPolylineStruct* Struct;
Struct = (DrawPolylineStruct*) DrawStruct;
GRMoveTo( Struct->m_Points[0] + dx, Struct->m_Points[1] + dy );
for( ii = 1; ii < Struct->m_NumOfPoints; ii++ )
GRLineTo( &panel->m_ClipBox, DC, Struct->m_Points[ii * 2] + dx,
Struct->m_Points[ii * 2 + 1] + dy, width, g_GhostColor );
DrawPolylineStruct* Struct = (DrawPolylineStruct*) DrawStruct;
GRMoveTo( Struct->m_PolyPoints[0].x + dx, Struct->m_PolyPoints[0].y + dy );
for( unsigned ii = 1; ii < Struct->GetCornerCount(); ii++ )
GRLineTo( &panel->m_ClipBox, DC, Struct->m_PolyPoints[ii].x + dx,
Struct->m_PolyPoints[ii].y + dy, width, g_GhostColor );
break;
}

12
eeschema/load_one_schematic_file.cpp
View File

@ -249,16 +249,12 @@ bool WinEDA_SchematicFrame::LoadOneEEFile( SCH_SCREEN* screen, const wxString& F
layer = LAYER_BUS;
PolylineStruct = new DrawPolylineStruct( layer );
PolylineStruct->m_NumOfPoints = ii;
PolylineStruct->m_Points = (int*) MyZMalloc( sizeof(int) * 2 *
PolylineStruct->m_NumOfPoints );
for( ii = 0; ii < PolylineStruct->m_NumOfPoints; ii++ )
for( unsigned jj = 0; jj < (unsigned)ii; jj++ )
{
LineCount++;
wxPoint point;
if( fgets( Line, 256 - 1, f ) == NULL
|| sscanf( Line, "%d %d", &PolylineStruct->m_Points[ii * 2],
&PolylineStruct->m_Points[ii * 2 + 1] ) != 2 )
|| sscanf( Line, "%d %d", &point.x, &point.y ) != 2 )
{
MsgDiag.Printf(
wxT( "EESchema file polyline struct error at line %d, aborted" ),
@ -268,6 +264,8 @@ bool WinEDA_SchematicFrame::LoadOneEEFile( SCH_SCREEN* screen, const wxString& F
SAFE_DELETE( PolylineStruct );
break;
}
PolylineStruct->AddPoint( point );
}
if( !Failed )

101
eeschema/locate.cpp
View File

@ -24,8 +24,7 @@ static bool IsBox1InBox2( int StartX1, int StartY1, int EndX1, int EndY1,
int StartX2, int StartY2, int EndX2, int EndY2 );
static bool IsPointInBox( wxPoint aPosRef,
int BoxX1, int BoxY1, int BoxX2, int BoxY2 );
static bool IsPointOnSegment( wxPoint aPosRef,
int SegmX1, int SegmY1, int SegmX2, int SegmY2, int seuil = 0 );
static bool IsPointOnSegment( wxPoint aPosRef, wxPoint aSegmStart, wxPoint aSegmEnd, int aDist = 0 );
static bool SnapPoint2( const wxPoint& aPosRef, int SearchMask,
SCH_ITEM* DrawList, DrawPickedStruct* DontSnapList, int zoom_value );
@ -198,8 +197,7 @@ SCH_ITEM* PickStruct( EDA_Rect& block, BASE_SCREEN* screen, int SearchMask )
bool SnapPoint2( const wxPoint& aPosRef, int SearchMask,
SCH_ITEM* DrawList, DrawPickedStruct* DontSnapList, int zoom_value )
{
int i, * Points;
int x1, y1, x2, y2, NumOfPoints2;
int x1, y1, x2, y2;
DrawPickedStruct* DontSnap;
int dx, dy;
@ -223,13 +221,9 @@ bool SnapPoint2( const wxPoint& aPosRef, int SearchMask,
if( !( SearchMask & (DRAWITEM | WIREITEM | BUSITEM) ) )
break;
Points = STRUCT->m_Points;
NumOfPoints2 = STRUCT->m_NumOfPoints * 2;
for( i = 0; i < NumOfPoints2 - 2; i += 2 )
for( unsigned i = 0; i < STRUCT->GetCornerCount() - 1; i ++ )
{
x1 = Points[i]; y1 = Points[i + 1];
x2 = Points[i + 2]; y2 = Points[i + 3];
if( IsPointOnSegment( aPosRef, x1, y1, x2, y2 ) )
if( IsPointOnSegment( aPosRef, STRUCT->m_PolyPoints[i], STRUCT->m_PolyPoints[i+1] ) )
{
LastSnappedStruct = DrawList;
return TRUE;
@ -244,8 +238,7 @@ bool SnapPoint2( const wxPoint& aPosRef, int SearchMask,
if( !( SearchMask & (DRAWITEM | WIREITEM | BUSITEM) ) )
break;
if( IsPointOnSegment( aPosRef, STRUCT->m_Start.x, STRUCT->m_Start.y,
STRUCT->m_End.x, STRUCT->m_End.y ) )
if( IsPointOnSegment( aPosRef, STRUCT->m_Start, STRUCT->m_End ) )
{
if( ( (SearchMask & DRAWITEM) && (STRUCT->GetLayer() == LAYER_NOTES) )
|| ( (SearchMask & WIREITEM) && (STRUCT->GetLayer() == LAYER_WIRE) )
@ -277,8 +270,7 @@ bool SnapPoint2( const wxPoint& aPosRef, int SearchMask,
if( !( SearchMask & (RACCORDITEM) ) )
break;
if( IsPointOnSegment( aPosRef, STRUCT->m_Pos.x, STRUCT->m_Pos.y,
STRUCT->m_End().x, STRUCT->m_End().y ) )
if( IsPointOnSegment( aPosRef, STRUCT->m_Pos, STRUCT->m_End() ) )
{
LastSnappedStruct = DrawList;
return TRUE;
@ -419,7 +411,7 @@ bool SnapPoint2( const wxPoint& aPosRef, int SearchMask,
if( SearchMask & FIELDCMPITEM )
{
SCH_COMPONENT* DrawLibItem = (SCH_COMPONENT*) DrawList;
for( i = REFERENCE; i < DrawLibItem->GetFieldCount(); i++ )
for( int i = REFERENCE; i < DrawLibItem->GetFieldCount(); i++ )
{
SCH_CMP_FIELD* field = DrawLibItem->GetField(i);
@ -491,10 +483,9 @@ bool SnapPoint2( const wxPoint& aPosRef, int SearchMask,
* defined by x1/y1 and x2/y2 (x1 < x2, y1 < y2), and return TRUE if so. This *
* routine is used to pick all points in a given box. *
*****************************************************************************/
bool DrawStructInBox( int x1, int y1, int x2, int y2,
SCH_ITEM* DrawStruct )
bool DrawStructInBox( int x1, int y1, int x2, int y2, SCH_ITEM* DrawStruct )
{
int i, * Points, xt1, yt1, xt2, yt2, NumOfPoints2;
int xt1, yt1, xt2, yt2;
int dx, dy;
wxString msg;
@ -503,12 +494,10 @@ bool DrawStructInBox( int x1, int y1, int x2, int y2,
case DRAW_POLYLINE_STRUCT_TYPE:
#undef STRUCT
#define STRUCT ( (DrawPolylineStruct*) DrawStruct )
Points = STRUCT->m_Points;
NumOfPoints2 = STRUCT->m_NumOfPoints * 2;
for( i = 0; i < NumOfPoints2; i += 2 )
for( unsigned i = 0; i < STRUCT->GetCornerCount(); i ++ )
{
if( Points[i] >= x1 && Points[i] <= x2
&& Points[i + 1] >= y1 && Points[i + 1] <=y2 )
if( STRUCT->m_PolyPoints[i].x >= x1 && STRUCT->m_PolyPoints[i].x <= x2
&& STRUCT->m_PolyPoints[i].y >= y1 && STRUCT->m_PolyPoints[i].y <=y2 )
return TRUE;
}
@ -759,19 +748,18 @@ static bool IsPointInBox( wxPoint aPosRef,
/********************************************************************************/
static bool IsPointOnSegment( wxPoint aPosRef,
int SegmX1, int SegmY1, int SegmX2, int SegmY2, int seuil )
static bool IsPointOnSegment( wxPoint aPosRef, wxPoint aSegmStart, wxPoint aSegmEnd, int aDist )
/********************************************************************************/
/* Routine detectant que le point pX,pY est sur le Segment X1,Y1 a X2,Y2
* Retourne TRUE ou FALSE.
*/
{
/* Recalcul des coord avec SegmX1, SegmX2 comme origine */
aPosRef.x -= SegmX1; aPosRef.y -= SegmY1;
SegmX2 -= SegmX1; SegmY2 -= SegmY1;
/* Move coordinates origin to aSegmStart */
aPosRef -= aSegmStart;
aSegmEnd -= aSegmStart;
if( distance( SegmX2, SegmY2, aPosRef.x, aPosRef.y, seuil ) )
if( distance( aSegmEnd.x, aSegmEnd.y, aPosRef.x, aPosRef.y, aDist ) )
return TRUE;
else
@ -788,10 +776,10 @@ LibEDA_BaseStruct* LocateDrawItem( SCH_SCREEN* Screen,
int masque )
/*********************************************************************************/
/* Routine de localisation d'un element de dessin de symbole( sauf pins )
* Unit = Unite d'appartenance (si Unit = 0, recherche sur toutes unites)
* Convert = Conversion d'appartenance (si Convert = 0, recherche sur
* toutes variantes)
/* Locates a body item( not pins )
* Unit = part number (if Unit = 0, all parts are considered)
* Convert = convert value for shape (si Convert = 0, all shapes are considered)
* remember the Y axis is from bottom to top in library entries for graphic items.
*/
{
int dx, dy;
@ -847,25 +835,32 @@ LibEDA_BaseStruct* LocateDrawItem( SCH_SCREEN* Screen,
break;
case COMPONENT_RECT_DRAW_TYPE:
{ // Locate a rect if the mouse cursor is on a segment
{ // Locate a rect if the mouse cursor is on a side of this rectangle
LibDrawSquare* Square = (LibDrawSquare*) DrawItem;
if( (masque & LOCATE_COMPONENT_RECT_DRAW_TYPE) == 0 )
break;
if( IsPointOnSegment( aRefPoint, // locate lower segment
Square->m_Pos.x, -Square->m_Pos.y,
Square->m_End.x, -Square->m_Pos.y, seuil ) )
wxPoint start, end;
start.x = Square->m_Pos.x;
start.y = -Square->m_Pos.y;
end.x = Square->m_End.x;
end.y = -Square->m_Pos.y;
// locate lower segment
if( IsPointOnSegment( aRefPoint, start, end , seuil ) )
return DrawItem;
if( IsPointOnSegment( aRefPoint, // locate right segment
Square->m_End.x, -Square->m_Pos.y,
Square->m_End.x, -Square->m_End.y, seuil ) )
// locate right segment
start.x = Square->m_End.x;
end.y = -Square->m_End.y;
if( IsPointOnSegment( aRefPoint, start,end , seuil ) )
return DrawItem;
if( IsPointOnSegment( aRefPoint, // locate upper segment
Square->m_End.x, -Square->m_End.y,
Square->m_Pos.x, -Square->m_End.y, seuil ) )
// locate upper segment
start.y = -Square->m_End.y;
end.x = Square->m_Pos.x;
if( IsPointOnSegment( aRefPoint, start, end, seuil ) )
return DrawItem;
if( IsPointOnSegment( aRefPoint, // locate left segment
Square->m_Pos.x, -Square->m_End.y,
Square->m_Pos.x, -Square->m_Pos.y, seuil ) )
// locate left segment
start.x = Square->m_Pos.x;
end.x = -Square->m_Pos.y;
if( IsPointOnSegment( aRefPoint,start, end, seuil ) )
return DrawItem;
}
break;
@ -875,15 +870,9 @@ LibEDA_BaseStruct* LocateDrawItem( SCH_SCREEN* Screen,
LibDrawPolyline* polyline = (LibDrawPolyline*) DrawItem;
if( (masque & LOCATE_COMPONENT_POLYLINE_DRAW_TYPE) == 0 )
break;
for( unsigned ii = 0; ii < polyline->m_PolyPoints.size()-1; ii++ )
{
if( IsPointOnSegment( aRefPoint,
polyline->m_PolyPoints[ii].x, -polyline->m_PolyPoints[ii].y,
polyline->m_PolyPoints[ii+1].x, -polyline->m_PolyPoints[ii+1].y, seuil ) )
if ( polyline->HitTest(aRefPoint, seuil, DefaultTransformMatrix) )
return DrawItem;
}
}
break;
case COMPONENT_LINE_DRAW_TYPE:
@ -891,9 +880,9 @@ LibEDA_BaseStruct* LocateDrawItem( SCH_SCREEN* Screen,
LibDrawSegment* Segment = (LibDrawSegment*) DrawItem;
if( (masque & LOCATE_COMPONENT_LINE_DRAW_TYPE) == 0 )
break;
if( IsPointOnSegment( aRefPoint,
Segment->m_Pos.x, -Segment->m_Pos.y,
Segment->m_End.x, -Segment->m_End.y, seuil ) )
wxPoint ref = aRefPoint;
NEGATE ( ref.y);
if( IsPointOnSegment( ref, Segment->m_Pos, Segment->m_End, seuil ) )
return DrawItem;
}
break;

269
eeschema/program.h
View File

@ -18,271 +18,24 @@
#include "class_screen.h"
#include "class_drawsheet.h"
#include "class_text-label.h"
#define DRAWJUNCTION_SIZE 16 /* Rayon du symbole connexion */
#define DRAWMARKER_SIZE 16 /* Rayon du symbole marqueur */
#define DRAWNOCONNECT_SIZE 48 /* Rayon du symbole No Connexion */
#include "class_schematic_items.h"
#define HIGHLIGHT_COLOR WHITE
#define TEXT_NO_VISIBLE 1
/* flags pour BUS ENTRY (bus to bus ou wire to bus */
#define WIRE_TO_BUS 0
#define BUS_TO_BUS 1
enum TypeMarker { /* Type des Marqueurs */
MARQ_UNSPEC,
MARQ_ERC,
MARQ_PCB,
MARQ_SIMUL,
MARQ_NMAX /* Derniere valeur: fin de tableau */
};
/* Messages correspondants aux types des marqueurs */
/* Rotation, mirror of graphic items in components bodies are handled by a transform matrix
* The default matix is useful to draw lib entries with a defualt matix ( no rotation, no mirrot
* but Y axis is bottom to top, and Y draw axis is to to bottom
* so we must have a default matix that reverses the Y coordinate and keeps the X coordiante
* DefaultTransformMatrix[0][0] = 1; DefaultTransformMatrix[1][1] = -1;
* DefaultTransformMatrix[1][0] = DefaultTransformMatrix[0][1] = 0;
*/
eda_global int DefaultTransformMatrix[2][2]
#ifdef MAIN
const wxChar* NameMarqueurType[] =
{
wxT( "" ),
wxT( "ERC" ),
wxT( "PCB" ),
wxT( "SIMUL" ),
wxT( "?????" )
};
#else
extern const wxChar* NameMarqueurType[];
= { {1, 0}, {0, -1} }
#endif
/* Forward declarations */
class DrawSheetStruct;
/**
* Class EDA_DrawLineStruct
* is a segment decription base class to describe items which have 2 end
* points (track, wire, draw line ...)
*/
class EDA_DrawLineStruct : public SCH_ITEM
{
public:
int m_Width; // 0 = line, > 0 = tracks, bus ...
wxPoint m_Start; // Line start point
wxPoint m_End; // Line end point
bool m_StartIsDangling;
bool m_EndIsDangling; // TRUE si Start ou End not connected (wires, tracks...)
public:
EDA_DrawLineStruct( const wxPoint& pos, int layer );
~EDA_DrawLineStruct() { }
EDA_DrawLineStruct* Next() const { return (EDA_DrawLineStruct*) Pnext; }
EDA_DrawLineStruct* Back() const { return (EDA_DrawLineStruct*) Pback; }
virtual wxString GetClass() const
{
return wxT( "EDA_DrawLine" );
}
bool IsOneEndPointAt( const wxPoint& pos );
EDA_DrawLineStruct* GenCopy();
bool IsNull()
{
return m_Start == m_End;
}
EDA_Rect GetBoundingBox();
virtual void Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset, int draw_mode,
int Color = -1 );
/**
* Function Save
* writes the data structures for this object out to a FILE in "*.brd" format.
* @param aFile The FILE to write to.
* @return bool - true if success writing else false.
*/
bool Save( FILE* aFile ) const;
#if defined(DEBUG)
void Show( int nestLevel, std::ostream& os );
#endif
};
class DrawMarkerStruct : public SCH_ITEM /* marqueurs */
{
public:
wxPoint m_Pos; /* XY coordinates of marker. */
TypeMarker m_Type;
int m_MarkFlags; // complements d'information
wxString m_Comment; /* Texte (commentaireassocie eventuel */
public:
DrawMarkerStruct( const wxPoint& pos, const wxString& text );
~DrawMarkerStruct();
virtual wxString GetClass() const
{
return wxT( "DrawMarker" );
}
DrawMarkerStruct* GenCopy();
wxString GetComment();
virtual void Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset,
int draw_mode, int Color = -1 );
/**
* Function Save
* writes the data structures for this object out to a FILE in "*.brd" format.
* @param aFile The FILE to write to.
* @return bool - true if success writing else false.
*/
bool Save( FILE* aFile ) const;
#if defined(DEBUG)
void Show( int nestLevel, std::ostream& os );
#endif
};
class DrawNoConnectStruct : public SCH_ITEM /* Symboles de non connexion */
{
public:
wxPoint m_Pos; /* XY coordinates of NoConnect. */
public:
DrawNoConnectStruct( const wxPoint& pos );
~DrawNoConnectStruct() { }
virtual wxString GetClass() const
{
return wxT( "DrawNoConnect" );
}
DrawNoConnectStruct* GenCopy();
virtual void Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset,
int draw_mode, int Color = -1 );
/**
* Function Save
* writes the data structures for this object out to a FILE in "*.brd" format.
* @param aFile The FILE to write to.
* @return bool - true if success writing else false.
*/
bool Save( FILE* aFile ) const;
EDA_Rect GetBoundingBox();
};
/**
* Class DrawBusEntryStruct
* Struct de descr 1 raccord a 45 degres de BUS ou WIRE
*/
class DrawBusEntryStruct : public SCH_ITEM
{
public:
int m_Width;
wxPoint m_Pos;
wxSize m_Size;
public:
DrawBusEntryStruct( const wxPoint& pos, int shape, int id );
~DrawBusEntryStruct() { }
virtual wxString GetClass() const
{
return wxT( "DrawBusEntry" );
}
DrawBusEntryStruct* GenCopy();
wxPoint m_End() const ; // retourne la coord de fin du raccord
virtual void Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset,
int draw_mode, int Color = -1 );
/**
* Function Save
* writes the data structures for this object out to a FILE in "*.brd" format.
* @param aFile The FILE to write to.
* @return bool - true if success writing else false.
*/
bool Save( FILE* aFile ) const;
EDA_Rect GetBoundingBox();
};
class DrawPolylineStruct : public SCH_ITEM /* Polyligne (serie de segments) */
{
public:
int m_Width;
int m_NumOfPoints; /* Number of XY pairs in Points array. */
int* m_Points; /* XY pairs that forms the polyline. */
public:
DrawPolylineStruct( int layer );
~DrawPolylineStruct();
virtual wxString GetClass() const
{
return wxT( "DrawPolyline" );
}
DrawPolylineStruct* GenCopy();
virtual void Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset,
int draw_mode, int Color = -1 );
/**
* Function Save
* writes the data structures for this object out to a FILE in "*.brd" format.
* @param aFile The FILE to write to.
* @return bool - true if success writing else false.
*/
bool Save( FILE* aFile ) const;
};
class DrawJunctionStruct : public SCH_ITEM
{
public:
wxPoint m_Pos; /* XY coordinates of connection. */
public:
DrawJunctionStruct( const wxPoint& pos );
~DrawJunctionStruct() { }
virtual wxString GetClass() const
{
return wxT( "DrawJunction" );
}
EDA_Rect GetBoundingBox();
DrawJunctionStruct* GenCopy();
virtual void Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset,
int draw_mode, int Color = -1 );
/**
* Function Save
* writes the data structures for this object out to a FILE in "*.brd" format.
* @param aFile The FILE to write to.
* @return bool - true if success writing else false.
*/
bool Save( FILE* aFile ) const;
#if defined(DEBUG)
void Show( int nestLevel, std::ostream& os );
#endif
};
;
#define MAX_LAYERS 44

4
eeschema/protos.h
View File

@ -57,7 +57,7 @@ void DrawLibraryDrawStruct(WinEDA_DrawPanel * aPanel, wxDC * aDC,
LibEDA_BaseStruct *aDrawItem,
int aDrawMode, int aColor = -1);
bool MapAngles(int *Angle1, int *Angle2, int TransMat[2][2]);
bool MapAngles(int *Angle1, int *Angle2, const int TransMat[2][2]);
EDA_LibComponentStruct * Read_Component_Definition(WinEDA_DrawFrame * frame, char * Line,
FILE *f, int *LineNum);
@ -69,7 +69,7 @@ EDA_LibComponentStruct * Read_Component_Definition(WinEDA_DrawFrame * frame, cha
* @param aPosition = the position to transform
* @return the new coordinate
*/
wxPoint TransformCoordinate( int aTransformMatrix[2][2], wxPoint & aPosition );
wxPoint TransformCoordinate( const int aTransformMatrix[2][2], const wxPoint & aPosition );
LibraryStruct *FindLibrary(const wxString & Name);
int LoadDocLib(WinEDA_DrawFrame * frame, const wxString & FullDocLibName, const wxString & Libname);