Code cleaning

CHANGELOG.txt

@@ -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.
 
 
 

eeschema/block.cpp

@@ -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( unsigned ii = 0; ii < DrawPoly->GetCornerCount(); ii++ )
-        for( ii = 0; ii < DrawPoly->m_NumOfPoints; 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( unsigned ii = 0; ii < DrawPoly->GetCornerCount(); ii++ )
-        for( ii = 0; ii < DrawPoly->m_NumOfPoints; ii++ )
         {
-            Points[ii * 2]     += move_vector.x;
+            DrawPoly->m_PolyPoints[ii] += move_vector;
-            Points[ii * 2 + 1] += move_vector.y;
         }
 
         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;
         }

eeschema/bus-wire-junction.cpp

@@ -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] ) <
+        if( ABS( endpos.x - NewPoly->m_PolyPoints[idx].x ) <
-           ABS( endpos.y - NewPoly->m_Points[NewPoly->m_NumOfPoints * 2 - 1] ) )
+           ABS( endpos.y - NewPoly->m_PolyPoints[idx].y ) )
-            endpos.x = NewPoly->m_Points[NewPoly->m_NumOfPoints * 2 - 2];
+            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_PolyPoints[idx] = endpos;
-    NewPoly->m_Points[NewPoly->m_NumOfPoints * 2 - 1] = endpos.y;
     RedrawOneStruct( panel, DC, NewPoly, g_XorMode, color );
-    NewPoly->m_NumOfPoints--;
 }
 
 

eeschema/class_libentry_fields.h

@@ -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

eeschema/class_pin.cpp

@@ -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

eeschema/class_schematic_items.cpp

@@ -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 );
-
+    newitem->m_PolyPoints = m_PolyPoints;   // std::vector copy
-    memsize = sizeof(int) * 2 * m_NumOfPoints;
-    newitem->m_NumOfPoints = m_NumOfPoints;
-    newitem->m_Points = (int*) MyZMalloc( memsize );
-    memcpy( newitem->m_Points, m_Points, memsize );
-
     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_PolyPoints[ii ].x, m_PolyPoints[ii].y ) == EOF )
-                m_Points[ii * 2 + 1] ) == EOF )
         {
             success = false;
             break;

eeschema/class_schematic_items.h

@@ -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 */

eeschema/classes_body_items.cpp

@@ -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;
@@ -278,7 +279,7 @@ void LibDrawPolyline::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
                Buf_Poly_Drawings, 1, linewidth, color,
                ReturnLayerColor( LAYER_DEVICE_BACKGROUND ) );
     else if( fill == FILLED_SHAPE  )
-        GRPoly( &aPanel->m_ClipBox, aDC,m_PolyPoints.size(),
+        GRPoly( &aPanel->m_ClipBox, aDC, m_PolyPoints.size(),
                 Buf_Poly_Drawings, 1, linewidth, color, color );
     else
         GRPoly( &aPanel->m_ClipBox, aDC, m_PolyPoints.size(),
@@ -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
@@ -348,11 +349,11 @@ bool LibDrawField::HitTest( const wxPoint& refPos )
 
     bbox.SetOrigin( m_Pos );
     int      dx;                                // X size for the full text
-    if ( m_FieldId == REFERENCE )
+    if( m_FieldId == REFERENCE )
-        dx = m_Size.x * (m_Text.Len( ) + 1);   // The displayed text has one char more (U is displayed U?)
+        dx = m_Size.x * (m_Text.Len() + 1);     // The displayed text has one char more (U is displayed U?)
     else
-        dx = m_Size.x * m_Text.Len( );
+        dx = m_Size.x * m_Text.Len();
-    dx = (int) ((double) dx * 10.0/9);      // spacing between char is 0.1 the char size
+    dx = (int) ( (double) dx * 10.0 / 9 );      // spacing between char is 0.1 the char size
     int dy = m_Size.y;
 
     if( m_Orient )
@@ -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,31 +553,33 @@ 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);
+    for( unsigned ii = 0; ii < m_PolyPoints.size() - 1; ii++ )
-    /* Move origin coordinate to segment start point */
-    wxPoint end;
-    for ( unsigned ii = 0; ii < m_PolyPoints.size() -1; ii++ )
     {
-    aPosRef -= m_PolyPoints[0];
+        start = TransformCoordinate( aTransMat, m_PolyPoints[0] );
-    end = m_PolyPoints[1] - 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
  */
-EDA_Rect LibDrawPolyline::GetBoundaryBox( )
+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 );
 

eeschema/classes_body_items.h

@@ -3,7 +3,7 @@
 /****************************************************************/
 
 /* Definitions of graphic items used to create shapes of component in libraries (libentry)
-*/
+ */
 #ifndef CLASSES_BODY_ITEMS_H
 #define CLASSES_BODY_ITEMS_H
 
@@ -56,7 +56,7 @@ enum ElectricPinType {      /* Type des Pins. si modif: modifier tableau des mgs
 /* Messages d'affichage du type electrique */
 eda_global const wxChar* MsgPinElectricType[]
 #ifdef MAIN
-= {
+    = {
     wxT( "input" ),
     wxT( "output" ),
     wxT( "BiDi" ),
@@ -68,7 +68,7 @@ eda_global const wxChar* MsgPinElectricType[]
     wxT( "openCol" ),
     wxT( "openEm" ),
     wxT( "?????" )
-}
+    }
 
 
 #endif
@@ -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,
+    void         PlotPinTexts( wxPoint& pin_pos,
-                                  int TextInside, bool DrawPinNum, bool DrawPinNameint, int aWidth, bool aItalic );
+                               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
+class LibDrawText  : public LibEDA_BaseStruct,
-			, public EDA_TextStruct
+    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,15 +458,15 @@ 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
      */
-    EDA_Rect GetBoundaryBox( );
+    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

eeschema/eelibs_draw_components.cpp

@@ -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;

eeschema/eeredraw.cpp

@@ -127,7 +127,7 @@ void WinEDA_SchematicFrame::RedrawActiveWindow( wxDC* DC, bool EraseBg )
     else
     {
         title = wxT( "[" );
-        title << GetScreen()->m_FileName << wxT( "]  " ) << _("Sheet") ;
+        title << GetScreen()->m_FileName << wxT( "]  " ) << _( "Sheet" );
         title << wxT( " " ) << m_CurrentSheet->PathHumanReadable();
         SetTitle( title );
     }
@@ -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
@@ -290,7 +294,8 @@ void DrawNoConnectStruct::Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint
 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) );
+    EDA_Rect  box( wxPoint( m_Pos.x - DELTA, m_Pos.y - DELTA ), wxSize( 2 * DELTA, 2 * DELTA ) );
+
     box.Normalize();
     return box;
 }
@@ -326,18 +331,20 @@ 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) );
+    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++ )
+        for( unsigned i = 1; i < GetCornerCount(); i++ )
-            GRDashedLineTo( &panel->m_ClipBox, DC, m_Points[i * 2] + offset.x,
+            GRDashedLineTo( &panel->m_ClipBox, DC, m_PolyPoints[i].x + offset.x,
-                m_Points[i * 2 + 1] + offset.y, width, color );
+                            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_PolyPoints[i].x + offset.x,
-                m_Points[i * 2 + 1] + offset.y,
+                      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;
+        DrawPolylineStruct* Struct = (DrawPolylineStruct*) DrawStruct;
-        Struct = (DrawPolylineStruct*) DrawStruct;
+        GRMoveTo( Struct->m_PolyPoints[0].x + dx, Struct->m_PolyPoints[0].y + dy );
-        GRMoveTo( Struct->m_Points[0] + dx, Struct->m_Points[1] + dy );
+        for( unsigned ii = 1; ii < Struct->GetCornerCount(); ii++ )
-        for( ii = 1; ii < Struct->m_NumOfPoints; ii++ )
+            GRLineTo( &panel->m_ClipBox, DC, Struct->m_PolyPoints[ii].x + dx,
-            GRLineTo( &panel->m_ClipBox, DC, Struct->m_Points[ii * 2] + dx,
+                      Struct->m_PolyPoints[ii].y + dy, width, g_GhostColor );
-                Struct->m_Points[ii * 2 + 1] + dy, width, g_GhostColor );
 
         break;
     }

eeschema/load_one_schematic_file.cpp

@@ -249,16 +249,12 @@ bool WinEDA_SchematicFrame::LoadOneEEFile( SCH_SCREEN* screen, const wxString& F
                 layer = LAYER_BUS;
 
             PolylineStruct = new DrawPolylineStruct( layer );
-
+            for( unsigned jj = 0; jj < (unsigned)ii; jj++ )
-            PolylineStruct->m_NumOfPoints = ii;
-            PolylineStruct->m_Points = (int*) MyZMalloc( sizeof(int) * 2 *
-                PolylineStruct->m_NumOfPoints );
-            for( ii = 0; ii < PolylineStruct->m_NumOfPoints; ii++ )
             {
                 LineCount++;
+                wxPoint point;
                 if( fgets( Line, 256 - 1, f ) == NULL
-                    || sscanf( Line, "%d %d", &PolylineStruct->m_Points[ii * 2],
+                    || sscanf( Line, "%d %d", &point.x, &point.y ) != 2 )
-                        &PolylineStruct->m_Points[ii * 2 + 1] ) != 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 )

eeschema/locate.cpp

@@ -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,
+static bool IsPointOnSegment( wxPoint aPosRef, wxPoint aSegmStart, wxPoint aSegmEnd, int aDist = 0 );
-                              int SegmX1, int SegmY1, int SegmX2, int SegmY2, int seuil = 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;
-    int x1, y1, x2, y2, NumOfPoints2;
     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;
+            for( unsigned i = 0; i < STRUCT->GetCornerCount() - 1; i ++ )
-            NumOfPoints2 = STRUCT->m_NumOfPoints * 2;
-            for( i = 0; i < NumOfPoints2 - 2; i += 2 )
             {
-                x1 = Points[i]; y1 = Points[i + 1];
+                if( IsPointOnSegment( aPosRef, STRUCT->m_PolyPoints[i], STRUCT->m_PolyPoints[i+1] ) )
-                x2 = Points[i + 2]; y2 = Points[i + 3];
-                if( IsPointOnSegment( aPosRef, x1, y1, x2, y2 ) )
                 {
                     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,
+            if( IsPointOnSegment( aPosRef, STRUCT->m_Start, STRUCT->m_End ) )
-                   STRUCT->m_End.x, STRUCT->m_End.y ) )
             {
                 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,
+            if( IsPointOnSegment( aPosRef, STRUCT->m_Pos, STRUCT->m_End() ) )
-                   STRUCT->m_End().x, STRUCT->m_End().y ) )
             {
                 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,
+bool DrawStructInBox( int x1, int y1, int x2, int y2, SCH_ITEM* DrawStruct )
-                      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;
+        for( unsigned i = 0; i < STRUCT->GetCornerCount(); i ++ )
-        NumOfPoints2 = STRUCT->m_NumOfPoints * 2;
-        for( i = 0; i < NumOfPoints2; i += 2 )
         {
-            if( Points[i] >= x1 && Points[i] <= x2
+            if( STRUCT->m_PolyPoints[i].x >= x1 && STRUCT->m_PolyPoints[i].x <= x2
-                && Points[i + 1] >= y1 && Points[i + 1] <=y2 )
+                && 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,
+static bool IsPointOnSegment( wxPoint aPosRef, wxPoint aSegmStart, wxPoint aSegmEnd, int aDist )
-                              int SegmX1, int SegmY1, int SegmX2, int SegmY2, int seuil )
 /********************************************************************************/
 
 /* 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 */
+    /* Move coordinates origin to aSegmStart */
-    aPosRef.x     -= SegmX1; aPosRef.y -= SegmY1;
+    aPosRef     -= aSegmStart;
-    SegmX2 -= SegmX1; SegmY2 -= SegmY1;
+    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 )
+/* Locates a body item( not pins )
- *  Unit = Unite d'appartenance (si Unit = 0, recherche sur toutes unites)
+ *  Unit = part number (if Unit = 0, all parts are considered)
- *  Convert = Conversion d'appartenance (si Convert = 0, recherche sur
+ *  Convert = convert value for shape (si Convert = 0, all shapes are considered)
- *  toutes variantes)
+ *  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
+            wxPoint start, end;
-                   Square->m_Pos.x, -Square->m_Pos.y,
+            start.x = Square->m_Pos.x;
-                   Square->m_End.x, -Square->m_Pos.y, seuil ) )
+            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
+            // locate right segment
-                   Square->m_End.x, -Square->m_Pos.y,
+            start.x = Square->m_End.x;
-                   Square->m_End.x, -Square->m_End.y, seuil ) )
+            end.y = -Square->m_End.y;
+            if( IsPointOnSegment( aRefPoint, start,end , seuil ) )
                 return DrawItem;
-            if( IsPointOnSegment( aRefPoint,   // locate upper segment
+            // locate upper segment
-                   Square->m_End.x, -Square->m_End.y,
+            start.y = -Square->m_End.y;
-                   Square->m_Pos.x, -Square->m_End.y, seuil ) )
+            end.x = Square->m_Pos.x;
+            if( IsPointOnSegment( aRefPoint, start, end, seuil ) )
                 return DrawItem;
-            if( IsPointOnSegment( aRefPoint,   // locate left segment
+            // locate left segment
-                   Square->m_Pos.x, -Square->m_End.y,
+            start.x = Square->m_Pos.x;
-                   Square->m_Pos.x, -Square->m_Pos.y, seuil ) )
+            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;
-
+            if ( polyline->HitTest(aRefPoint, seuil, DefaultTransformMatrix) )
-            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 ) )
                     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,
+            wxPoint ref = aRefPoint;
-                   Segment->m_Pos.x, -Segment->m_Pos.y,
+            NEGATE ( ref.y);
-                   Segment->m_End.x, -Segment->m_End.y, seuil ) )
+            if( IsPointOnSegment( ref, Segment->m_Pos, Segment->m_End, seuil ) )
                 return DrawItem;
         }
             break;

eeschema/program.h

@@ -18,271 +18,24 @@
 #include "class_screen.h"
 #include "class_drawsheet.h"
 #include "class_text-label.h"
-
+#include "class_schematic_items.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 */
 
 #define HIGHLIGHT_COLOR WHITE
 
-
 #define TEXT_NO_VISIBLE 1
 
-/* flags pour BUS ENTRY (bus to bus ou wire to bus */
+/* Rotation, mirror of graphic items in components bodies are handled by a transform matrix
-#define WIRE_TO_BUS 0
+ *  The default matix is useful to draw lib entries with a defualt matix ( no rotation, no mirrot
-#define BUS_TO_BUS  1
+ *  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;
-enum TypeMarker {      /* Type des Marqueurs */
+ *      DefaultTransformMatrix[1][0] = DefaultTransformMatrix[0][1] = 0;
-    MARQ_UNSPEC,
+ */
-    MARQ_ERC,
+eda_global int DefaultTransformMatrix[2][2]
-    MARQ_PCB,
-    MARQ_SIMUL,
-    MARQ_NMAX        /* Derniere valeur: fin de tableau */
-};
-
-
-/* Messages correspondants aux types des marqueurs */
 #ifdef MAIN
-const wxChar*        NameMarqueurType[] =
+    = { {1, 0}, {0, -1} }
-{
-    wxT( "" ),
-    wxT( "ERC" ),
-    wxT( "PCB" ),
-    wxT( "SIMUL" ),
-    wxT( "?????" )
-};
-#else
-extern const wxChar* NameMarqueurType[];
 #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

eeschema/protos.h

@@ -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);