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

Block commands now works with zones.

This commit is contained in:
CHARRAS 2008-01-06 12:43:57 +00:00
parent cfd09d02bd
commit 339a90e7ac
25 changed files with 618 additions and 1104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
change_log.txt
View File

@ -4,6 +4,13 @@ Started 2007-June-11
Please add newer entries at the top, list the date and your name with Please add newer entries at the top, list the date and your name with
email address. email address.
2008-jan-06 UPDATE Jean-Pierre Charras <jean-pierre.charras@inpg.fr>
================================================================================
+pcbnew:
Block commands now works with zones.
Some code cleanning.
2008-Jan-5 UPDATE Dick Hollenbeck <dick@softplc.com> 2008-Jan-5 UPDATE Dick Hollenbeck <dick@softplc.com>
================================================================================ ================================================================================
+pcbnew: +pcbnew:

14
common/base_struct.cpp
View File

@ -294,6 +294,20 @@ bool EDA_TextStruct::HitTest( const wxPoint& posref )
return false; return false;
} }
/**
* Function HitTest (overlayed)
* tests if the given EDA_Rect intersect this object.
* @param refArea the given EDA_Rect to test
* @return bool - true if a hit, else false
*/
/*********************************************************/
bool EDA_TextStruct::HitTest( EDA_Rect& refArea )
/*********************************************************/
{
if( refArea.Inside( m_Pos ) )
return true;
return false;
}
/*******************************/ /*******************************/
int EDA_TextStruct::Pitch() int EDA_TextStruct::Pitch()

22
include/base_struct.h
View File

@ -89,6 +89,7 @@ enum SEARCH_RESULT {
class EDA_BaseStruct; class EDA_BaseStruct;
class WinEDA_DrawFrame; class WinEDA_DrawFrame;
class BOARD; class BOARD;
class EDA_Rect;
/** /**
* Class INSPECTOR * Class INSPECTOR
@ -254,6 +255,18 @@ public:
return false; // derived classes should override this function return false; // derived classes should override this function
} }
/**
* Function HitTest (overlayed)
* tests if the given EDA_Rect intersect this object.
* For now, an ending point must be inside this rect.
* @param refArea : the given EDA_Rect
* @return bool - true if a hit, else false
*/
virtual bool HitTest( EDA_Rect& refArea )
{
return false; // derived classes should override this function
}
/** /**
* Function IterateForward * Function IterateForward
@ -419,6 +432,15 @@ public:
bool HitTest( const wxPoint& ref_pos ); bool HitTest( const wxPoint& ref_pos );
/** /**
* Function HitTest (overlayed)
* tests if the given EDA_Rect intersect this object.
* For now, the anchor must be inside this rect.
* @param refArea : the given EDA_Rect
* @return bool - true if a hit, else false
*/
bool HitTest( EDA_Rect& refArea );
/**
* Function Len_Size * Function Len_Size
* Return the text lenght in internal units * Return the text lenght in internal units
*/ */

9
include/pcbstruct.h
View File

@ -301,6 +301,15 @@ public:
*/ */
bool HitTest( const wxPoint& ref_pos ); bool HitTest( const wxPoint& ref_pos );
/**
* Function HitTest (overlayed)
* tests if the given EDA_Rect intersect this object.
* For now, an ending point must be inside this rect.
* @param refPos the given EDA_Rect to test
* @return bool - true if a hit, else false
*/
bool HitTest( EDA_Rect& refArea );
/** /**
* Function GetClass * Function GetClass
* returns the class name. * returns the class name.

534
pcbnew/block.cpp
View File

File diff suppressed because it is too large Load Diff

6
pcbnew/class_board.h
View File

@ -18,11 +18,11 @@ class BOARD : public BOARD_ITEM
friend class WinEDA_PcbFrame; friend class WinEDA_PcbFrame;
private: private:
std::vector<MARKER*> m_markers; ///< MARKERs for clearance problems, owned by pointer std::vector<MARKER*> m_markers; ///< MARKERs for clearance problems, owned by pointer
std::vector<ZONE_CONTAINER*> m_ZoneDescriptorList; ///< edge zone descriptors, owned by pointer
public:
std::vector<ZONE_CONTAINER*> m_ZoneDescriptorList; ///< edge zone descriptors, owned by pointer
public: public:
WinEDA_BasePcbFrame* m_PcbFrame; // Window de visualisation WinEDA_BasePcbFrame* m_PcbFrame; // Window de visualisation
EDA_Rect m_BoundaryBox; // Board size and position EDA_Rect m_BoundaryBox; // Board size and position

169
pcbnew/class_cotation.cpp
View File

@ -226,70 +226,109 @@ bool COTATION::ReadCotationDescr( FILE* File, int* LineNum )
return FALSE; return FALSE;
} }
/****************************************/
#if 0 void COTATION::Move(const wxPoint& offset)
/**************************************************/ /****************************************/
bool COTATION::WriteCotationDescr( FILE* File ) /**
/**************************************************/ * Function Move
* @param offset : moving vector
*/
{ {
if( GetState( DELETED ) ) m_Pos += offset;
return FALSE; m_Text->m_Pos += offset;
Barre_ox += offset.x; Barre_oy += offset.y;
fprintf( File, "$COTATION\n" ); Barre_fx += offset.x; Barre_fy += offset.y;
TraitG_ox += offset.x; TraitG_oy += offset.y;
fprintf( File, "Ge %d %d %lX\n", m_Shape, TraitG_fx += offset.x; TraitG_fy += offset.y;
m_Layer, m_TimeStamp ); TraitD_ox += offset.x; TraitD_oy += offset.y;
TraitD_fx += offset.x; TraitD_fy += offset.y;
fprintf( File, "Va %d\n", m_Value ); FlecheG1_ox += offset.x; FlecheG1_oy += offset.y;
FlecheG1_fx += offset.x; FlecheG1_fy += offset.y;
if( !m_Text->m_Text.IsEmpty() ) FlecheG2_ox += offset.x; FlecheG2_oy += offset.y;
fprintf( File, "Te \"%s\"\n", CONV_TO_UTF8( m_Text->m_Text ) ); FlecheG2_fx += offset.x; FlecheG2_fy += offset.y;
else FlecheD1_ox += offset.x; FlecheD1_oy += offset.y;
fprintf( File, "Te \"?\"\n" ); FlecheD1_fx += offset.x; FlecheD1_fy += offset.y;
FlecheD2_ox += offset.x; FlecheD2_oy += offset.y;
fprintf( File, "Po %d %d %d %d %d %d %d\n", FlecheD2_fx += offset.x; FlecheD2_fy += offset.y;
m_Text->m_Pos.x, m_Text->m_Pos.y,
m_Text->m_Size.x, m_Text->m_Size.y,
m_Text->m_Width, m_Text->m_Orient,
m_Text->m_Miroir );
fprintf( File, "Sb %d %d %d %d %d %d\n", S_SEGMENT,
Barre_ox, Barre_oy,
Barre_fx, Barre_fy, m_Width );
fprintf( File, "Sd %d %d %d %d %d %d\n", S_SEGMENT,
TraitD_ox, TraitD_oy,
TraitD_fx, TraitD_fy, m_Width );
fprintf( File, "Sg %d %d %d %d %d %d\n", S_SEGMENT,
TraitG_ox, TraitG_oy,
TraitG_fx, TraitG_fy, m_Width );
fprintf( File, "S1 %d %d %d %d %d %d\n", S_SEGMENT,
FlecheD1_ox, FlecheD1_oy,
FlecheD1_fx, FlecheD1_fy, m_Width );
fprintf( File, "S2 %d %d %d %d %d %d\n", S_SEGMENT,
FlecheD2_ox, FlecheD2_oy,
FlecheD2_fx, FlecheD2_fy, m_Width );
fprintf( File, "S3 %d %d %d %d %d %d\n", S_SEGMENT,
FlecheG1_ox, FlecheG1_oy,
FlecheG1_fx, FlecheG1_fy, m_Width );
fprintf( File, "S4 %d %d %d %d %d %d\n", S_SEGMENT,
FlecheG2_ox, FlecheG2_oy,
FlecheG2_fx, FlecheG2_fy, m_Width );
fprintf( File, "$EndCOTATION\n" );
return 1;
} }
#endif
/******************************************************/
void COTATION::Rotate(const wxPoint& centre, int angle)
/******************************************************/
/**
* Function Rotate
* @param offset : Rotation point
* @param angle : Rotation angle in 0.1 degrees
*/
{
RotatePoint( &m_Pos, centre, 900 );
RotatePoint( &m_Text->m_Pos, centre, 900 );
m_Text->m_Orient += 900;
if( m_Text->m_Orient >= 3600 )
m_Text->m_Orient -= 3600;
if( (m_Text->m_Orient > 900)
&& (m_Text->m_Orient <2700) )
m_Text->m_Orient -= 1800;
RotatePoint( &Barre_ox, &Barre_oy, centre.x, centre.y, 900 );
RotatePoint( &Barre_fx, &Barre_fy, centre.x, centre.y, 900 );
RotatePoint( &TraitG_ox, &TraitG_oy, centre.x, centre.y, 900 );
RotatePoint( &TraitG_fx, &TraitG_fy, centre.x, centre.y, 900 );
RotatePoint( &TraitD_ox, &TraitD_oy, centre.x, centre.y, 900 );
RotatePoint( &TraitD_fx, &TraitD_fy, centre.x, centre.y, 900 );
RotatePoint( &FlecheG1_ox, &FlecheG1_oy, centre.x, centre.y, 900 );
RotatePoint( &FlecheG1_fx, &FlecheG1_fy, centre.x, centre.y, 900 );
RotatePoint( &FlecheG2_ox, &FlecheG2_oy, centre.x, centre.y, 900 );
RotatePoint( &FlecheG2_fx, &FlecheG2_fy, centre.x, centre.y, 900 );
RotatePoint( &FlecheD1_ox, &FlecheD1_oy, centre.x, centre.y, 900 );
RotatePoint( &FlecheD1_fx, &FlecheD1_fy, centre.x, centre.y, 900 );
RotatePoint( &FlecheD2_ox, &FlecheD2_oy, centre.x, centre.y, 900 );
RotatePoint( &FlecheD2_fx, &FlecheD2_fy, centre.x, centre.y, 900 );
}
/**********************************************/
void COTATION::Mirror(const wxPoint& axis_pos)
/**********************************************/
/**
* Function Mirror
* Mirror the Dimension , relative to a given horizontal axis
* the text is not mirrored. only its position (and angle) is mirrored
* the layer is not changed
* @param axis_pos : vertical axis position
*/
{
#define INVERT( pos ) (pos) = axis_pos.y - ( (pos) - axis_pos.y )
#define INVERT_ANGLE( phi ) (phi) = -(phi)
INVERT( m_Pos.y );
INVERT( m_Text->m_Pos.y );
INVERT_ANGLE( m_Text->m_Orient );
if( m_Text->m_Orient >= 3600 )
m_Text->m_Orient -= 3600;
if( (m_Text->m_Orient > 900) && (m_Text->m_Orient <2700) )
m_Text->m_Orient -= 1800;
INVERT( Barre_oy );
INVERT( Barre_fy );
INVERT( TraitG_oy );
INVERT( TraitG_fy );
INVERT( TraitD_oy );
INVERT( TraitD_fy );
INVERT( FlecheG1_oy );
INVERT( FlecheG1_fy );
INVERT( FlecheG2_oy );
INVERT( FlecheG2_fy );
INVERT( FlecheD1_oy );
INVERT( FlecheD1_fy );
INVERT( FlecheD2_oy );
INVERT( FlecheD2_fy );
}
/****************************************/
bool COTATION::Save( FILE* aFile ) const bool COTATION::Save( FILE* aFile ) const
/****************************************/
{ {
if( GetState( DELETED ) ) if( GetState( DELETED ) )
return true; return true;
@ -571,3 +610,15 @@ bool COTATION::HitTest( const wxPoint& ref_pos )
return false; return false;
} }
/**
* Function HitTest (overlayed)
* tests if the given EDA_Rect intersect this object.
* @param EDA_Rect : the given EDA_Rect
* @return bool - true if a hit, else false
*/
bool COTATION::HitTest( EDA_Rect& refArea )
{
if( refArea.Inside( m_Pos ) )
return true;
return false;
}

32
pcbnew/class_cotation.h
View File

@ -54,8 +54,29 @@ public:
void Copy( COTATION* source ); void Copy( COTATION* source );
void Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset, int mode_color ); void Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset, int mode_color );
/**
* Function Move
* @param offset : moving vector
*/
void Move(const wxPoint& offset);
/**
* Function Rotate
* @param offset : Rotation point
* @param angle : Rotation angle in 0.1 degrees
*/
void Rotate(const wxPoint& centre, int angle);
/**
* Function Mirror
* Mirror the Dimension , relative to a given horizontal axis
* the text is not mirrored. only its position (and angle) is mirrored
* the layer is not changed
* @param axis_pos : vertical axis position
*/
void Mirror(const wxPoint& axis_pos);
/** /**
* Function Display_Infos * Function Display_Infos
* has knowledge about the frame and how and where to put status information * has knowledge about the frame and how and where to put status information
@ -73,6 +94,15 @@ public:
*/ */
bool HitTest( const wxPoint& ref_pos ); bool HitTest( const wxPoint& ref_pos );
/**
* Function HitTest (overlayed)
* tests if the given EDA_Rect intersect this object.
* For now, the anchor must be inside this rect.
* @param refArea : the given EDA_Rect
* @return bool - true if a hit, else false
*/
bool HitTest( EDA_Rect& refArea );
/** /**
* Function GetClass * Function GetClass

13
pcbnew/class_mire.cpp
View File

@ -219,3 +219,16 @@ bool MIREPCB::HitTest( const wxPoint& refPos )
return abs(dX)<=rayon && abs(dY)<=rayon; return abs(dX)<=rayon && abs(dY)<=rayon;
} }
/**
* Function HitTest (overlayed)
* tests if the given EDA_Rect intersect this object.
* @param EDA_Rect : the given EDA_Rect
* @return bool - true if a hit, else false
*/
bool MIREPCB::HitTest( EDA_Rect& refArea )
{
if( refArea.Inside( m_Pos ) )
return true;
return false;
}

10
pcbnew/class_mire.h
View File

@ -50,6 +50,16 @@ public:
* @return bool - true if a hit, else false * @return bool - true if a hit, else false
*/ */
bool HitTest( const wxPoint& refPos ); bool HitTest( const wxPoint& refPos );
/**
* Function HitTest (overlayed)
* tests if the given EDA_Rect intersect this object.
* For now, the anchor must be inside this rect.
* @param refArea : the given EDA_Rect
* @return bool - true if a hit, else false
*/
bool HitTest( EDA_Rect& refArea );
}; };

25
pcbnew/class_module.cpp
View File

@ -1284,6 +1284,31 @@ bool MODULE::HitTest( const wxPoint& refPos )
} }
/**
* Function HitTest (overlayed)
* tests if the given EDA_Rect intersect the bounds of this object.
* @param refArea : the given EDA_Rect
* @return bool - true if a hit, else false
*/
bool MODULE::HitTest( EDA_Rect& refArea )
{
bool is_out_of_box = false;
SetRectangleExinscrit();
if( m_RealBoundaryBox.m_Pos.x < refArea.GetX() )
is_out_of_box = true;
if( m_RealBoundaryBox.m_Pos.y < refArea.GetY() )
is_out_of_box = true;
if( m_RealBoundaryBox.GetRight() > refArea.GetRight() )
is_out_of_box = true;
if( m_RealBoundaryBox.GetBottom() > refArea.GetBottom() )
is_out_of_box = true;
return is_out_of_box ? false : true;
}
// see class_module.h // see class_module.h
SEARCH_RESULT MODULE::Visit( INSPECTOR* inspector, const void* testData, SEARCH_RESULT MODULE::Visit( INSPECTOR* inspector, const void* testData,
const KICAD_T scanTypes[] ) const KICAD_T scanTypes[] )

8
pcbnew/class_module.h
View File

@ -170,6 +170,14 @@ public:
/** /**
* Function HitTest (overlayed)
* tests if the given EDA_Rect intersect the bounds of this object.
* @param refArea : the given EDA_Rect
* @return bool - true if a hit, else false
*/
bool HitTest( EDA_Rect& refArea );
/**
* Function GetReference * Function GetReference
* @return wxString - the reference designator text. * @return wxString - the reference designator text.
*/ */

21
pcbnew/class_pcb_text.cpp
View File

@ -112,27 +112,6 @@ int TEXTE_PCB::ReadTextePcbDescr( FILE* File, int* LineNum )
} }
#if 0 // replaced by Save()
/**************************************************/
int TEXTE_PCB::WriteTextePcbDescr( FILE* File )
/**************************************************/
{
if( GetState( DELETED ) )
return 0;
if( m_Text.IsEmpty() )
return 0;
fprintf( File, "$TEXTPCB\n" );
fprintf( File, "Te \"%s\"\n", CONV_TO_UTF8( m_Text ) );
fprintf( File, "Po %d %d %d %d %d %d\n",
m_Pos.x, m_Pos.y, m_Size.x, m_Size.y, m_Width, m_Orient );
fprintf( File, "De %d %d %lX %d\n", m_Layer, m_Miroir, m_TimeStamp, 0 );
fprintf( File, "$EndTEXTPCB\n" );
return 1;
}
#endif
bool TEXTE_PCB::Save( FILE* aFile ) const bool TEXTE_PCB::Save( FILE* aFile ) const
{ {
if( GetState( DELETED ) ) if( GetState( DELETED ) )

11
pcbnew/class_pcb_text.h
View File

@ -68,6 +68,17 @@ public:
} }
/**
* Function HitTest (overlayed)
* tests if the given EDA_Rect intersect this object.
* @param refArea the given EDA_Rect to test
* @return bool - true if a hit, else false
*/
bool HitTest( EDA_Rect& refArea )
{
return EDA_TextStruct::HitTest( refArea );
}
/** /**
* Function GetClass * Function GetClass
* returns the class name. * returns the class name.

16
pcbnew/class_track.cpp
View File

@ -875,6 +875,22 @@ bool TRACK::HitTest( const wxPoint& ref_pos )
return false; return false;
} }
/**
* Function HitTest (overlayed)
* tests if the given EDA_Rect intersect this object.
* For now, an ending point must be inside this rect.
* @param refArea : the given EDA_Rect
* @return bool - true if a hit, else false
*/
bool TRACK::HitTest( EDA_Rect& refArea )
{
if( refArea.Inside( m_Start ) )
return true;
if( refArea.Inside( m_End ) )
return true;
return false;
}
#if defined (DEBUG) #if defined (DEBUG)

9
pcbnew/class_track.h
View File

@ -201,6 +201,15 @@ public:
bool HitTest( const wxPoint& refPos ); bool HitTest( const wxPoint& refPos );
/** /**
* Function HitTest (overlayed)
* tests if the given wxRect intersect this object.
* For now, an ending point must be inside this rect.
* @param refPos A wxPoint to test
* @return bool - true if a hit, else false
*/
bool HitTest( EDA_Rect& refArea );
/**
* Function GetClass * Function GetClass
* returns the class name. * returns the class name.
* @return wxString * @return wxString

102
pcbnew/class_zone.cpp
View File

@ -10,6 +10,7 @@
#include "common.h" #include "common.h"
#include "PolyLine.h" #include "PolyLine.h"
#include "pcbnew.h" #include "pcbnew.h"
#include "trigo.h"
/**********************/ /**********************/
/* Class EDGE_ZONE */ /* Class EDGE_ZONE */
@ -51,7 +52,7 @@ ZONE_CONTAINER::ZONE_CONTAINER( BOARD* parent ) :
m_PadOption = THERMAL_PAD; m_PadOption = THERMAL_PAD;
utility = 0; // flags used in polygon calculations utility = 0; // flags used in polygon calculations
utility2 = 0; // flags used in polygon calculations utility2 = 0; // flags used in polygon calculations
m_Poly = new CPolyLine( NULL ); // Outlines m_Poly = new CPolyLine(); // Outlines
} }
@ -403,6 +404,29 @@ int ZONE_CONTAINER::HitTestForEdge( const wxPoint& refPos )
return -1; return -1;
} }
/**
* Function HitTest (overlayed)
* tests if the given EDA_Rect contains the bounds of this object.
* @param refArea : the given EDA_Rect
* @return bool - true if a hit, else false
*/
bool ZONE_CONTAINER::HitTest( EDA_Rect& refArea )
{
bool is_out_of_box = false;
CRect rect = m_Poly->GetCornerBounds();
if( rect.left < refArea.GetX() )
is_out_of_box = true;
if( rect.top < refArea.GetY() )
is_out_of_box = true;
if( rect.right > refArea.GetRight() )
is_out_of_box = true;
if( rect.bottom > refArea.GetBottom() )
is_out_of_box = true;
return is_out_of_box ? false : true;
}
/************************************************************/ /************************************************************/
void ZONE_CONTAINER::Display_Infos( WinEDA_DrawFrame* frame ) void ZONE_CONTAINER::Display_Infos( WinEDA_DrawFrame* frame )
@ -448,3 +472,79 @@ void ZONE_CONTAINER::Display_Infos( WinEDA_DrawFrame* frame )
msg.Printf( wxT( "%d" ), m_Poly->m_HatchLines.size() ); msg.Printf( wxT( "%d" ), m_Poly->m_HatchLines.size() );
Affiche_1_Parametre( frame, text_pos, _( "Hatch lines" ), msg, BLUE ); Affiche_1_Parametre( frame, text_pos, _( "Hatch lines" ), msg, BLUE );
} }
/* Geometric transformations: */
/**
* Function Move
* Move the outlines
* @param offset = moving vector
*/
void ZONE_CONTAINER::Move(const wxPoint& offset )
{
for ( unsigned ii = 0; ii < m_Poly->corner.size(); ii++ )
{
m_Poly->corner[ii].x += offset.x;
m_Poly->corner[ii].y += offset.y;
}
m_Poly->Hatch();
}
/**
* Function Move
* Move the outlines
* @param centre = rot centre
* @param angle = in 0.1 degree
*/
void ZONE_CONTAINER::Rotate( const wxPoint& centre, int angle)
{
for ( unsigned ii = 0; ii < m_Poly->corner.size(); ii++ )
{
wxPoint pos;
pos.x = m_Poly->corner[ii].x;
pos.y = m_Poly->corner[ii].y;
RotatePoint(&pos, centre, angle );
m_Poly->corner[ii].x = pos.x;
m_Poly->corner[ii].y = pos.y;
}
m_Poly->Hatch();
}
/**
* Function Mirror
* flip the outlines , relative to a given horizontal axis
* @param mirror_ref = vertical axis position
*/
void ZONE_CONTAINER::Mirror( const wxPoint& mirror_ref)
{
for ( unsigned ii = 0; ii < m_Poly->corner.size(); ii++ )
{
m_Poly->corner[ii].y -= mirror_ref.y;
m_Poly->corner[ii].y = - m_Poly->corner[ii].y;
m_Poly->corner[ii].y += mirror_ref.y;
}
m_Poly->Hatch();
}
/** Function copy
* copy data from the source.
* flags and some poinetrs are NOT copied
*/
void ZONE_CONTAINER::Copy( ZONE_CONTAINER * src )
{
m_Parent = src->m_Parent;
m_Layer = src->m_Layer;
SetNet(src->GetNet());
m_TimeStamp = GetTimeStamp();
m_Poly->Copy(src->m_Poly); // copy outlines
m_CornerSelection = -1; // For corner moving, corner index to drag, or -1 if no selection
m_ZoneClearance = src->m_ZoneClearance; // clearance value
m_GridFillValue = src->m_GridFillValue; // Grid used for filling
m_PadOption = src->m_PadOption;
m_Poly->SetHatch(src->m_Poly->GetHatchStyle());
}

40
pcbnew/class_zone.h
View File

@ -44,6 +44,12 @@ public:
wxPoint & GetPosition( ) { static wxPoint pos ;return pos; } wxPoint & GetPosition( ) { static wxPoint pos ;return pos; }
void UnLink(void) {}; void UnLink(void) {};
/** Function copy
* copy data from the source.
* flags and some poinetrs are NOT copied
*/
void Copy( ZONE_CONTAINER * src );
void Display_Infos( WinEDA_DrawFrame* frame ); void Display_Infos( WinEDA_DrawFrame* frame );
/** Function Draw /** Function Draw
@ -81,6 +87,14 @@ public:
*/ */
int HitTestForEdge( const wxPoint& refPos ); int HitTestForEdge( const wxPoint& refPos );
/**
* Function HitTest (overlayed)
* tests if the given EDA_Rect contains the bounds of this object.
* @param refArea : the given EDA_Rect
* @return bool - true if a hit, else false
*/
bool HitTest( EDA_Rect& refArea );
/** Function Fill_Zone() /** Function Fill_Zone()
* Calculate the zone filling * Calculate the zone filling
* The zone outline is a frontier, and can be complex (with holes) * The zone outline is a frontier, and can be complex (with holes)
@ -92,6 +106,32 @@ public:
* @return error level (0 = no error) * @return error level (0 = no error)
*/ */
int Fill_Zone( WinEDA_PcbFrame* frame, wxDC* DC, bool verbose = TRUE); int Fill_Zone( WinEDA_PcbFrame* frame, wxDC* DC, bool verbose = TRUE);
/* Geometric transformations: */
/**
* Function Move
* Move the outlines
* @param offset = moving vector
*/
void Move(const wxPoint& offset );
/**
* Function Move
* Move the outlines
* @param centre = rot centre
* @param angle = in 0.1 degree
*/
void Rotate( const wxPoint& centre, int angle);
/**
* Function Mirror
* Mirror the outlines , relative to a given horizontal axis
* the layer is not changed
* @param mirror_ref = vertical axis position
*/
void Mirror( const wxPoint& mirror_ref);
}; };
/*******************/ /*******************/

37
pcbnew/classpcb.cpp
View File

@ -85,27 +85,6 @@ void DRAWSEGMENT::Copy( DRAWSEGMENT* source )
m_TimeStamp = source->m_TimeStamp; m_TimeStamp = source->m_TimeStamp;
} }
#if 0 // replaced by Save()
/********************************************************/
bool DRAWSEGMENT::WriteDrawSegmentDescr( FILE* File )
/********************************************************/
{
if( GetState( DELETED ) )
return FALSE;
fprintf( File, "$DRAWSEGMENT\n" );
fprintf( File, "Po %d %d %d %d %d %d\n",
m_Shape,
m_Start.x, m_Start.y,
m_End.x, m_End.y, m_Width );
fprintf( File, "De %d %d %d %lX %X\n",
m_Layer, m_Type, m_Angle,
m_TimeStamp, ReturnStatus() );
fprintf( File, "$EndDRAWSEGMENT\n" );
return TRUE;
}
#endif
bool DRAWSEGMENT::Save( FILE* aFile ) const bool DRAWSEGMENT::Save( FILE* aFile ) const
{ {
@ -270,6 +249,22 @@ bool DRAWSEGMENT::HitTest( const wxPoint& ref_pos )
} }
/**
* Function HitTest (overlayed)
* tests if the given EDA_Rect intersect this object.
* For now, an ending point must be inside this rect.
* @param refArea : the given EDA_Rect
* @return bool - true if a hit, else false
*/
bool DRAWSEGMENT::HitTest( EDA_Rect& refArea )
{
if( refArea.Inside( m_Start ) )
return true;
if( refArea.Inside( m_End ) )
return true;
return false;
}
/**************************************************/ /**************************************************/
/* Class SCREEN: classe de gestion d'un affichage */ /* Class SCREEN: classe de gestion d'un affichage */

1
polygon/CMakeLists.txt
View File

@ -1,5 +1,4 @@
SET(POLYGON_SRCS SET(POLYGON_SRCS
cdisplaylist_stuff.cpp
GenericPolygonClipperLibrary.cpp GenericPolygonClipperLibrary.cpp
math_for_graphics.cpp math_for_graphics.cpp
php_polygon.cpp php_polygon.cpp

316
polygon/PolyLine.cpp
View File

@ -1,10 +1,12 @@
// PolyLine.cpp ... implementation of CPolyLine class // PolyLine.cpp ... implementation of CPolyLine class from FreePCB.
//
// from FreePCB.
// Adaptation for kicad // Adaptation for kicad
// //
using namespace std; using namespace std;
#define SetSize reserve // used in conversion from freePCB to kicad.: The code using it must be rewitten
#include <math.h> #include <math.h>
#include <vector> #include <vector>
@ -12,30 +14,13 @@ using namespace std;
#define to_int(x) (int)round((x)) #define to_int(x) (int)round((x))
/* Stuff to compile PolyLine.cpp, used in std::vector as CArray. does not work. must be redesigned, only for test */
#define SetSize reserve
#define pi 3.14159265359 #define pi 3.14159265359
#define DENOM 10 // to use mils for php clipping #define DENOM 10 // to use mils for php clipping
//#define DENOM 1 // to use internal units for php clipping //#define DENOM 1 // to use internal units for php clipping
// dl is a pointer to CDisplayList for drawing graphic elements
// if dl = NULL, doesn't draw anything but can still hold data
//
CPolyLine::CPolyLine( CDisplayList * dl )
{
m_dlist = dl;
m_HatchStyle = 0;
m_sel_box = 0;
m_gpc_poly = new gpc_polygon;
m_gpc_poly->num_contours = 0;
m_php_poly = new polygon;
}
CPolyLine::CPolyLine() CPolyLine::CPolyLine()
{ {
m_dlist = NULL;
m_HatchStyle = 0; m_HatchStyle = 0;
m_sel_box = 0; m_sel_box = 0;
utility = 0; utility = 0;
@ -496,8 +481,8 @@ int CPolyLine::RestoreArcs( std::vector<CArc> * arc_array, std::vector<CPolyLine
// find arcs and replace them // find arcs and replace them
bool bFound; bool bFound;
int arc_start; int arc_start = 0;
int arc_end; int arc_end = 0;
for( unsigned iarc=0; iarc<arc_array->size(); iarc++ ) for( unsigned iarc=0; iarc<arc_array->size(); iarc++ )
{ {
int arc_xi = (*arc_array)[iarc].xi; int arc_xi = (*arc_array)[iarc].xi;
@ -804,22 +789,6 @@ void CPolyLine::InsertCorner( int ic, int x, int y )
// //
void CPolyLine::Undraw() void CPolyLine::Undraw()
{ {
if( m_dlist && bDrawn )
{
// remove display elements, if present
for( unsigned i=0; i<dl_side.size(); i++ )
m_dlist->Remove( dl_side[i] );
for( unsigned i=0; i<dl_side_sel.size(); i++ )
m_dlist->Remove( dl_side_sel[i] );
for( unsigned i=0; i<dl_corner_sel.size(); i++ )
m_dlist->Remove( dl_corner_sel[i] );
// remove pointers
dl_side.clear();
dl_side_sel.clear();
dl_corner_sel.clear();
}
m_HatchLines.clear(); m_HatchLines.clear();
bDrawn = FALSE; bDrawn = FALSE;
} }
@ -828,274 +797,18 @@ void CPolyLine::Undraw()
// if side style is ARC_CW or ARC_CCW but endpoints are not angled, // if side style is ARC_CW or ARC_CCW but endpoints are not angled,
// convert to STRAIGHT // convert to STRAIGHT
// //
void CPolyLine::Draw( CDisplayList * dl ) void CPolyLine::Draw( )
{ {
// first, undraw if necessary // first, undraw if necessary
if( bDrawn ) if( bDrawn )
Undraw(); Undraw();
// use new display list if provided
if( dl )
m_dlist = dl;
#if 0
int i_start_contour = 0;
if( m_dlist )
{
// set up std::vectors
dl_side.SetSize( corner.size() );
if( m_sel_box )
{
dl_side_sel.SetSize( corner.size() );
dl_corner_sel.SetSize( corner.size() );
}
else
{
dl_side_sel.clear();
dl_corner_sel.clear();
}
// now draw elements
for( int ic=0; ic<corner.size(); ic++ )
{
m_id.ii = ic;
int xi = corner[ic].x;
int yi = corner[ic].y;
int xf, yf;
if( corner[ic].end_contour == FALSE && ic < corner.size()-1 )
{
xf = corner[ic+1].x;
yf = corner[ic+1].y;
}
else
{
xf = corner[i_start_contour].x;
yf = corner[i_start_contour].y;
i_start_contour = ic+1;
}
// draw
if( m_sel_box )
{
m_id.sst = ID_SEL_CORNER;
dl_corner_sel[ic] = m_dlist->AddSelector( m_id, m_ptr, m_layer, DL_HOLLOW_RECT,
1, 0, 0, xi-m_sel_box, yi-m_sel_box,
xi+m_sel_box, yi+m_sel_box, 0, 0 );
}
if( ic<(corner.size()-1) || corner[ic].end_contour )
{
// draw side
if( xi == xf || yi == yf )
{
// if endpoints not angled, make side STRAIGHT
side_style[ic] = STRAIGHT;
}
int g_type = DL_LINE;
if( side_style[ic] == STRAIGHT )
g_type = DL_LINE;
else if( side_style[ic] == ARC_CW )
g_type = DL_ARC_CW;
else if( side_style[ic] == ARC_CCW )
g_type = DL_ARC_CCW;
m_id.sst = ID_SIDE;
dl_side[ic] = m_dlist->Add( m_id, m_ptr, m_layer, g_type,
1, m_w, 0, xi, yi, xf, yf, 0, 0 );
if( m_sel_box )
{
m_id.sst = ID_SEL_SIDE;
dl_side_sel[ic] = m_dlist->AddSelector( m_id, m_ptr, m_layer, g_type,
1, m_w, 0, xi, yi, xf, yf, 0, 0 );
}
}
}
// if( m_HatchStyle )
// Hatch();
}
#endif
Hatch(); Hatch();
bDrawn = TRUE; bDrawn = TRUE;
} }
// start dragging new corner to be inserted into side, make side and hatching invisible
//
void CPolyLine::StartDraggingToInsertCorner( CDC * pDC, int ic, int x, int y )
{
if( !m_dlist )
ASSERT(0);
int icont = GetContour( ic );
int istart = GetContourStart( icont );
int iend = GetContourEnd( icont );
int post_c;
if( ic == iend )
post_c = istart;
else
post_c = ic + 1;
int xi = corner[ic].x;
int yi = corner[ic].y;
int xf = corner[post_c].x;
int yf = corner[post_c].y;
m_dlist->StartDraggingLineVertex( pDC, x, y, xi, yi, xf, yf,
LAY_SELECTION, LAY_SELECTION, 1, 1, DSS_STRAIGHT, DSS_STRAIGHT,
0, 0, 0, 0, 1 );
m_dlist->CancelHighLight();
m_dlist->Set_visible( dl_side[ic], 0 );
/* for( int ih=0; ih<m_nhatch; ih++ )
m_dlist->Set_visible( dl_hatch[ih], 0 );
*/
}
// cancel dragging inserted corner, make side and hatching visible again
//
void CPolyLine::CancelDraggingToInsertCorner( int ic )
{
if( !m_dlist )
ASSERT(0);
int post_c;
if( ic == (int)(corner.size()-1) )
post_c = 0;
else
post_c = ic + 1;
m_dlist->StopDragging();
/* m_dlist->Set_visible( dl_side[ic], 1 );
for( int ih=0; ih<m_nhatch; ih++ )
m_dlist->Set_visible( dl_hatch[ih], 1 );
*/
}
// start dragging corner to new position, make adjacent sides and hatching invisible
//
void CPolyLine::StartDraggingToMoveCorner( CDC * pDC, int ic, int x, int y )
{
if( !m_dlist )
ASSERT(0);
// see if corner is the first or last corner of an open contour
int icont = GetContour( ic );
int istart = GetContourStart( icont );
int iend = GetContourEnd( icont );
if( !GetClosed()
&& icont == GetNumContours() - 1
&& (ic == istart || ic == iend) )
{
// yes
int style, xi, yi, iside;
if( ic == istart )
{
// first corner
iside = ic;
xi = GetX( ic+1 );
yi = GetY( ic+1 );
style = GetSideStyle( iside );
// reverse arc since we are drawing from corner 1 to 0
if( style == CPolyLine::ARC_CW )
style = CPolyLine::ARC_CCW;
else if( style == CPolyLine::ARC_CCW )
style = CPolyLine::ARC_CW;
}
else
{
// last corner
iside = ic - 1;
xi = GetX( ic-1 );
yi = GetY( ic-1);
style = GetSideStyle( iside );
}
m_dlist->StartDraggingArc( pDC, style, GetX(ic), GetY(ic), xi, yi, LAY_SELECTION, 1, 1 );
m_dlist->CancelHighLight();
m_dlist->Set_visible( dl_side[iside], 0 );
/* for( int ih=0; ih<m_nhatch; ih++ )
m_dlist->Set_visible( dl_hatch[ih], 0 );
*/
}
else
{
// no
// get indexes for preceding and following corners
int pre_c, post_c;
int poly_side_style1, poly_side_style2;
int style1 = DSS_STRAIGHT, style2 = DSS_STRAIGHT;
if( ic == istart )
{
pre_c = iend;
post_c = istart+1;
poly_side_style1 = side_style[iend];
poly_side_style2 = side_style[istart];
}
else if( ic == iend )
{
// last side
pre_c = ic-1;
post_c = istart;
poly_side_style1 = side_style[ic-1];
poly_side_style2 = side_style[ic];
}
else
{
pre_c = ic-1;
post_c = ic+1;
poly_side_style1 = side_style[ic-1];
poly_side_style2 = side_style[ic];
}
if( poly_side_style1 == STRAIGHT )
style1 = DSS_STRAIGHT;
else if( poly_side_style1 == ARC_CW )
style1 = DSS_ARC_CW;
else if( poly_side_style1 == ARC_CCW )
style1 = DSS_ARC_CCW;
if( poly_side_style2 == STRAIGHT )
style2 = DSS_STRAIGHT;
else if( poly_side_style2 == ARC_CW )
style2 = DSS_ARC_CW;
else if( poly_side_style2 == ARC_CCW )
style2 = DSS_ARC_CCW;
int xi = corner[pre_c].x;
int yi = corner[pre_c].y;
int xf = corner[post_c].x;
int yf = corner[post_c].y;
m_dlist->StartDraggingLineVertex( pDC, x, y, xi, yi, xf, yf,
LAY_SELECTION, LAY_SELECTION, 1, 1, style1, style2,
0, 0, 0, 0, 1 );
m_dlist->CancelHighLight();
m_dlist->Set_visible( dl_side[pre_c], 0 );
m_dlist->Set_visible( dl_side[ic], 0 );
/* for( int ih=0; ih<m_nhatch; ih++ )
m_dlist->Set_visible( dl_hatch[ih], 0 );
*/ }
}
// cancel dragging corner to new position, make sides and hatching visible again
//
// highlight side by drawing line over it
//
void CPolyLine::HighlightSide( int is )
{
if( !m_dlist )
ASSERT(0);
if( GetClosed() && is >= (int)corner.size() )
return;
if( !GetClosed() && is >= (int)(corner.size()-1) )
return;
int style = DL_LINE;
if( side_style[is] == CPolyLine::STRAIGHT )
style = DL_LINE;
else if( side_style[is] == CPolyLine::ARC_CW )
style = DL_ARC_CW;
else if( side_style[is] == CPolyLine::ARC_CCW )
style = DL_ARC_CCW;
m_dlist->HighLight( style,
m_dlist->Get_x( dl_side_sel[is] ),
m_dlist->Get_y( dl_side_sel[is] ),
m_dlist->Get_xf( dl_side_sel[is] ),
m_dlist->Get_yf( dl_side_sel[is] ),
m_dlist->Get_w( dl_side_sel[is]) );
}
int CPolyLine::GetX( int ic ) int CPolyLine::GetX( int ic )
{ {
return corner[ic].x; return corner[ic].x;
@ -1672,16 +1385,13 @@ int CPolyLine::TestIntersection( CPolyLine * poly )
void CPolyLine::Copy( CPolyLine * src ) void CPolyLine::Copy( CPolyLine * src )
{ {
Undraw(); Undraw();
m_dlist = src->m_dlist;
m_sel_box = src->m_sel_box;
// copy corners // copy corners
for( unsigned i=0; i< src->corner.size(); i++ ) for( unsigned ii=0; ii < src->corner.size(); ii++ )
corner.push_back(src->corner[i]); corner.push_back(src->corner[ii]);
// copy side styles // copy side styles
int nsides = src->GetNumSides(); for( unsigned ii=0; ii < src->side_style.size(); ii++ )
side_style.SetSize(nsides); side_style.push_back(src->side_style[ii]);
for( int i=0; i<nsides; i++ )
side_style[i] = src->side_style[i];
// don't copy the Gpc_poly, just clear the old one // don't copy the Gpc_poly, just clear the old one
FreeGpcPoly(); FreeGpcPoly();
} }

20
polygon/PolyLine.h
View File

@ -10,8 +10,6 @@
// //
// When used for copper areas, the first contour is the outer edge // When used for copper areas, the first contour is the outer edge
// of the area, subsequent ones are "holes" in the copper. // of the area, subsequent ones are "holes" in the copper.
//
// If a CDisplayList pointer is provided, the polyline can draw itself
#ifndef POLYLINE_H #ifndef POLYLINE_H
#define POLYLINE_H #define POLYLINE_H
@ -68,7 +66,7 @@ public:
enum { DEF_SIZE = 50, DEF_ADD = 50 }; // number of array elements to add at a time enum { DEF_SIZE = 50, DEF_ADD = 50 }; // number of array elements to add at a time
// constructors/destructor // constructors/destructor
CPolyLine( CDisplayList * dl ); // CPolyLine( CDisplayList * dl = NULL );
CPolyLine(); CPolyLine();
~CPolyLine(); ~CPolyLine();
@ -84,16 +82,16 @@ public:
void RemoveAllContours( void ); void RemoveAllContours( void );
// drawing functions // drawing functions
void HighlightSide( int is ); /* void HighlightSide( int is );
void HighlightCorner( int ic ); void HighlightCorner( int ic );
void StartDraggingToInsertCorner( CDC * pDC, int ic, int x, int y); void StartDraggingToInsertCorner( CDC * pDC, int ic, int x, int y);
void StartDraggingToMoveCorner( CDC * pDC, int ic, int x, int y); void StartDraggingToMoveCorner( CDC * pDC, int ic, int x, int y);
void CancelDraggingToInsertCorner( int ic ); void CancelDraggingToInsertCorner( int ic );
void CancelDraggingToMoveCorner( int ic ); void CancelDraggingToMoveCorner( int ic );
void Undraw(); */ void Undraw();
void Draw( CDisplayList * dl = NULL ); void Draw( );
void Hatch(); void Hatch();
void MakeVisible( bool visible = TRUE ); // void MakeVisible( bool visible = TRUE );
void MoveOrigin( int x_off, int y_off ); void MoveOrigin( int x_off, int y_off );
// misc. functions // misc. functions
@ -152,7 +150,7 @@ public:
void ClipPhpPolygon( int php_op, CPolyLine * poly ); void ClipPhpPolygon( int php_op, CPolyLine * poly );
private: private:
CDisplayList * m_dlist; // display list // CDisplayList * m_dlist; // display list
int m_layer; // layer to draw on int m_layer; // layer to draw on
int m_Width; // line width int m_Width; // line width
int m_sel_box; // corner selection box width/2 int m_sel_box; // corner selection box width/2
@ -161,9 +159,9 @@ public:
std::vector <CPolyPt> corner; // array of points for corners std::vector <CPolyPt> corner; // array of points for corners
std::vector <int> side_style; // array of styles for sides std::vector <int> side_style; // array of styles for sides
private: private:
std::vector <dl_element*> dl_side; // graphic elements // std::vector <dl_element*> dl_side; // graphic elements
std::vector <dl_element*> dl_side_sel; // std::vector <dl_element*> dl_side_sel;
std::vector <dl_element*> dl_corner_sel; // std::vector <dl_element*> dl_corner_sel;
public: public:
int m_HatchStyle; // hatch style, see enum above int m_HatchStyle; // hatch style, see enum above
std::vector <CSegment> m_HatchLines; // hatch lines std::vector <CSegment> m_HatchLines; // hatch lines

67
polygon/cdisplaylist_stuff.cpp
View File

@ -1,67 +0,0 @@
/* stuff for class CDisplayList */
#include "PolyLine.h"
void CDisplayList::Set_visible( dl_element * el, int visible )
{
}
int CDisplayList::StopDragging()
{
return 0;
}
int CDisplayList::CancelHighLight()
{
return 0;
}
id CDisplayList::Remove( dl_element * element )
{
return 0;
}
int CDisplayList::Get_w( dl_element * el )
{
return 0;
}
int CDisplayList::Get_x( dl_element * el )
{
return 0;
}
int CDisplayList::Get_y( dl_element * el )
{
return 0;
}
int CDisplayList::Get_xf( dl_element * el )
{
return 0;
}
int CDisplayList::Get_yf( dl_element * el )
{
return 0;
}
int CDisplayList::HighLight( int gtype, int x, int y, int xf, int yf, int w, int orig_layer )
{
return 0;
}
int CDisplayList::StartDraggingLineVertex( CDC * pDC, int x, int y, int xi, int yi,
int xf, int yf,
int layer1, int layer2, int w1, int w2,
int style1, int style2,
int layer_no_via, int via_w, int via_holew, int dir,
int crosshair )
{
return 0;
}
int CDisplayList::StartDraggingArc( CDC * pDC, int style, int x, int y, int xi, int yi,
int layer, int w, int crosshair )
{
return 0;
}

230
polygon/freepcbDisplayList.h
View File

@ -4,11 +4,6 @@
#ifndef FP_DISPLAY_LIST_H #ifndef FP_DISPLAY_LIST_H
#define FP_DISPLAY_LIST_H #define FP_DISPLAY_LIST_H
//#define DL_MAX_LAYERS 32
#define DL_MAGIC 2674
#define PCBU_PER_WU 25400 // conversion from PCB units to world units
// graphics element types // graphics element types
enum enum
{ {
@ -31,25 +26,6 @@ enum
DL_X // X DL_X // X
}; };
// dragging line shapes
enum
{
DS_NONE = 0,
DS_LINE_VERTEX, // vertex between two lines
DS_LINE, // line
DS_ARC_STRAIGHT, // straight line (used when drawing polylines)
DS_ARC_CW, // clockwise arc (used when drawing polylines)
DS_ARC_CCW // counterclockwise arc (used when drawing polylines)
};
// styles of line segment when dragging line or line vertex
enum
{
DSS_STRAIGHT = 100, // straight line
DSS_ARC_CW, // clockwise arc
DSS_ARC_CCW // counterclockwise arc
};
// inflection modes for DS_LINE and DS_LINE_VERTEX // inflection modes for DS_LINE and DS_LINE_VERTEX
enum enum
{ {
@ -60,210 +36,4 @@ enum
}; };
class CDisplayList;
// this structure contains an element of the display list
class dl_element
{
friend class CDisplayList;
public:
CDisplayList * dlist;
int magic;
dl_element * prev;
dl_element * next;
id m_id; // identifier (see ids.h)
void * ptr; // pointer to object drawing this element
int gtype; // type of primitive
int visible; // 0 to hide
//private:
int sel_vert; // for selection rectangles, 1 if part is vertical
int w; // width (for round or square shapes)
int holew; // hole width (for round holes)
int x_org, y_org; // x origin (for rotation, reflection, etc.)
int x, y; // starting or center position of element
int xf, yf; // opposite corner (for rectangle or line)
int radius; // radius of corners for DL_RRECT
int layer; // layer to draw on
int orig_layer; // for elements on highlight layer,
// the original layer, the highlight will
// only be drawn if this layer is visible
};
class CDisplayList
{
private:
// display-list parameters for each layer
dl_element m_start[MAX_LAYERS], m_end[MAX_LAYERS];
int m_rgb[MAX_LAYERS][3]; // layer colors
BOOL m_vis[MAX_LAYERS]; // layer visibility flags
int m_layer_in_order[MAX_LAYERS]; // array of layers in draw order
int m_order_for_layer[MAX_LAYERS]; // draw order for each layer
// window parameters
int m_pcbu_per_wu; // i.e. nm per world unit
CRect m_client_r; // client rect (pixels)
CRect m_screen_r; // client rect (screen coords)
int m_pane_org_x; // left border of drawing pane (pixels)
int m_pane_org_y; // bottom border of drawing pane (pixels)
int m_bottom_pane_h; // height of bottom pane
CDC * memDC; // pointer to memory DC
double m_scale; // world units per pixel
int m_org_x; // world x-coord of left side of screen (world units)
int m_org_y; // world y-coord of bottom of screen (world units)
int m_max_x; // world x_coord of right side of screen (world units)
int m_max_y; // world y_coord of top of screen (world units)
int w_ext_x, w_ext_y; // window extents (world units)
int v_ext_x, v_ext_y; // viewport extents (pixels)
double m_wu_per_pixel_x; // ratio w_ext_x/v_ext_x (world units per pixel)
double m_wu_per_pixel_y; // ratio w_ext_y/v_ext_y (world units per pixel)
double m_pcbu_per_pixel_x;
double m_pcbu_per_pixel_y;
// general dragging parameters
int m_drag_angle; // angle of rotation of selection rectangle (starts at 0)
int m_drag_side; // 0 = no change, 1 = switch to opposite
int m_drag_vert; // 1 if item being dragged is a vertical part
// parameters for dragging polyline sides and trace segments
// that can be modified while dragging
int m_drag_flag; // 1 if dragging something
int m_drag_shape; // shape
int m_last_drag_shape; // last shape drawn
int m_drag_x; // last cursor position for dragged shape
int m_drag_y;
int m_drag_xi; // start of rubberband drag line
int m_drag_yi;
int m_drag_xf; // end of rubberband drag line
int m_drag_yf;
int m_drag_layer_1; // line layer
int m_drag_w1; // line width
int m_drag_style1; // line style
int m_inflection_mode; // inflection mode
int m_last_inflection_mode; // last mode drawn
// extra parameters when dragging vertex between 2 line segments
int m_drag_style2;
int m_drag_layer_2;
int m_drag_w2;
// parameters used to draw leading via if necessary
int m_drag_layer_no_via;
int m_drag_via_w;
int m_drag_via_holew;
int m_drag_via_drawn;
// arrays of lines and ratlines being dragged
// these can be rotated and flipped while being dragged
int m_drag_layer; // layer
int m_drag_max_lines; // max size of array for line segments
int m_drag_num_lines; // number of line segments to drag
CPoint * m_drag_line_pt; // array of relative coords for line endpoints
int m_drag_max_ratlines; // max size of ratline array
int m_drag_num_ratlines; // number of ratlines to drag
CPoint * m_drag_ratline_start_pt; // absolute coords for ratline start points
CPoint * m_drag_ratline_end_pt; // relative coords for ratline endpoints
int m_drag_ratline_width;
// cursor parameters
int m_cross_hairs; // 0 = none, 1 = cross-hairs, 2 = diagonals
CPoint m_cross_left, m_cross_right, m_cross_top, m_cross_bottom; // end-points
CPoint m_cross_topleft, m_cross_topright, m_cross_botleft, m_cross_botright;
// grid
int m_visual_grid_on;
double m_visual_grid_spacing; // in world units
public:
CDisplayList( int pcbu_per_wu );
~CDisplayList();
void SetVisibleGrid( BOOL on, double grid );
void SetMapping( CRect *client_r, CRect *screen_r, int pane_org_x, int pane_bottom_h, double scale, int org_x, int org_y );
void SetDCToWorldCoords( CDC * pDC, CDC * mDC, int pcbu_org_x, int pcbu_org_y );
void SetLayerRGB( int layer, int r, int g, int b );
void SetLayerVisible( int layer, BOOL vis );
void SetLayerDrawOrder( int layer, int order )
{ m_layer_in_order[order] = layer; m_order_for_layer[layer] = order; };
dl_element * Add( id id, void * ptr, int glayer, int gtype, int visible,
int w, int holew, int x, int y, int xf, int yf, int xo, int yo,
int radius=0, int orig_layer=LAY_SELECTION );
dl_element * AddSelector( id id, void * ptr, int glayer, int gtype, int visible,
int w, int holew, int x, int y, int xf, int yf, int xo, int yo, int radius=0 );
void RemoveAll();
void RemoveAllFromLayer( int layer );
id Remove( dl_element * element );
void Draw( CDC * pDC );
int HighLight( int gtype, int x, int y, int xf, int yf, int w, int orig_layer=LAY_SELECTION );
int CancelHighLight();
void * TestSelect( int x, int y, id * sel_id, int * layer,
id * exclude_id = NULL, void * exclude_ptr = NULL, id * include_id = NULL,
int n_include_ids=1 );
int StartDraggingArray( CDC * pDC, int x, int y, int vert, int layer, int crosshair = 1 );
int StartDraggingRatLine( CDC * pDC, int x, int y, int xf, int yf, int layer,
int w, int crosshair = 1 );
int StartDraggingRectangle( CDC * pDC, int x, int y, int xi, int yi,
int xf, int yf, int vert, int layer );
int StartDraggingLineVertex( CDC * pDC, int x, int y, int xi, int yi,
int xf, int yf,
int layer1, int layer2, int w1, int w2,
int style1, int style2,
int layer_no_via, int via_w, int via_holew, int dir,
int crosshair );
int StartDraggingLine( CDC * pDC, int x, int y, int xi, int yi, int layer1, int w,
int layer_no_via, int via_w, int via_holew,
int crosshair, int style, int inflection_mode );
int StartDraggingArc( CDC * pDC, int style, int x, int y, int xi, int yi,
int layer, int w, int crosshair );
void SetDragArcStyle( int style );
void Drag( CDC * pDC, int x, int y );
int StopDragging();
void ChangeRoutingLayer( CDC * pDC, int layer1, int layer2, int w );
void IncrementDragAngle( CDC * pDC );
int MakeDragLineArray( int num_lines );
int MakeDragRatlineArray( int num_ratlines, int width );
int AddDragLine( CPoint pi, CPoint pf );
int AddDragRatline( CPoint pi, CPoint pf );
int GetDragAngle();
void FlipDragSide( CDC * pDC );
int GetDragSide();
void SetUpCrosshairs( int type, int x, int y );
void SetInflectionMode( int mode ){ m_inflection_mode = mode; };
CPoint ScreenToPCB( CPoint point );
CPoint PCBToScreen( CPoint point );
CPoint WindowToPCB( CPoint point );
// set element parameters
void Set_gtype( dl_element * el, int gtype );
void Set_visible( dl_element * el, int visible );
void Set_sel_vert( dl_element * el, int sel_vert );
void Set_w( dl_element * el, int w );
void Set_holew( dl_element * el, int holew );
void Set_x_org( dl_element * el, int x_org );
void Set_y_org( dl_element * el, int y_org );
void Set_x( dl_element * el, int x );
void Set_y( dl_element * el, int y );
void Set_xf( dl_element * el, int xf );
void Set_yf( dl_element * el, int yf );
void Set_id( dl_element * el, id * id );
void Set_layer( dl_element * el, int layer );
void Set_radius( dl_element * el, int radius );
void Move( dl_element * el, int dx, int dy );
// get element parameters
void * Get_ptr( dl_element * el );
int Get_gtype( dl_element * el );
int Get_visible( dl_element * el );
int Get_sel_vert( dl_element * el );
int Get_w( dl_element * el );
int Get_holew( dl_element * el );
int Get_x_org( dl_element * el );
int Get_y_org( dl_element * el );
int Get_x( dl_element * el );
int Get_y( dl_element * el );
int Get_xf( dl_element * el );
int Get_yf( dl_element * el );
int Get_radius( dl_element * el );
int Get_layer( dl_element * el );
id Get_id( dl_element * el );
};
#endif // #ifndef FP_DISPLAY_LIST_H #endif // #ifndef FP_DISPLAY_LIST_H

3
polygon/makefile.include
View File

@ -9,8 +9,7 @@ OBJECTS= \
php_polygon.o\ php_polygon.o\
php_polygon_vertex.o\ php_polygon_vertex.o\
PolyLine.o\ PolyLine.o\
math_for_graphics.o\ math_for_graphics.o
cdisplaylist_stuff.o
GenericPolygonClipperLibrary.o: GenericPolygonClipperLibrary.cpp GenericPolygonClipperLibrary.h GenericPolygonClipperLibrary.o: GenericPolygonClipperLibrary.cpp GenericPolygonClipperLibrary.h