haskal
/
kicad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
kicad/pcbnew/move_or_drag_track.cpp

871 lines
25 KiB
C++
Raw Blame History

/****************************************************/
/* Track editing */
/* routines to move and drag track segments or node */
/****************************************************/
#include "fctsys.h"
#include "gr_basic.h"
#include "common.h"
#include "pcbnew.h"
#include "autorout.h"
#include "trigo.h"
#include "drag.h"
#include "id.h"
#include "protos.h"
/* local functions */
static void Show_MoveNode(WinEDA_DrawPanel * panel, wxDC * DC, bool erase);
static void Show_Drag_Track_Segment_With_Cte_Slope(WinEDA_DrawPanel * panel, wxDC * DC, bool erase);
static void Abort_MoveTrack(WinEDA_DrawPanel * Panel, wxDC *DC);
static bool InitialiseDragParameters(void);
/* variables locales */
static wxPoint PosInit, s_LastPos;
static TRACK * NewTrack; /* Nouvelle piste creee ou piste deplacee */
static int NbPtNewTrack;
static int Old_HightLigth_NetCode;
static bool Old_HightLigt_Status;
static double s_StartSegmentSlope, s_EndSegmentSlope, s_MovingSegmentSlope,
s_StartSegment_Yorg, s_EndSegment_Yorg,
s_MovingSegment_Yorg; //slope and intercept parameters of lines
bool s_StartPointVertical,s_EndPointVertical,
s_MovingSegmentVertical,s_MovingSegmentHorizontal,
s_StartPointHorizontal,s_EndPointHorizontal; // vertical or horizontal line indicators
bool s_StartSegmentPresent, s_EndSegmentPresent;
/**************************************************************/
static void Abort_MoveTrack(WinEDA_DrawPanel * Panel, wxDC *DC)
/***************************************************************/
/* routine d'annulation de la commande drag, copy ou move track si une piste est en cours
de tracage, ou de sortie de l'application EDITRACK.
*/
{
TRACK * NextS;
int ii;
/* Erase the current drawings */
wxPoint oldpos = Panel->GetScreen()->m_Curseur;
Panel->GetScreen()->m_Curseur = PosInit;
if ( Panel->ManageCurseur ) Panel->ManageCurseur(Panel, DC, TRUE);
Panel->GetScreen()->m_Curseur = oldpos;
g_HightLigt_Status = FALSE;
( (WinEDA_PcbFrame *)Panel->m_Parent)->DrawHightLight( DC, g_HightLigth_NetCode) ;
if( NewTrack )
{
if (NewTrack->m_Flags & IS_NEW )
{
for( ii = 0; ii < NbPtNewTrack; ii++, NewTrack = NextS)
{
if(NewTrack == NULL) break;
NextS = (TRACK*) NewTrack->Pnext;
delete NewTrack;
}
}
else /* Move : remise en ancienne position */
{
TRACK * Track = NewTrack;
int dx = s_LastPos.x - PosInit.x;
int dy = s_LastPos.y - PosInit.y;
for( ii = 0; ii < NbPtNewTrack; ii++, Track = (TRACK*) Track->Pnext)
{
if( Track == NULL ) break;
Track->m_Start.x -= dx;
Track->m_Start.y -= dy;
Track->m_End.x -= dx;
Track->m_End.y -= dy;
Track->m_Flags = 0;
}
Trace_Une_Piste(Panel, DC, NewTrack,NbPtNewTrack,GR_OR);
}
NewTrack = NULL;
}
Panel->ManageCurseur = NULL;
Panel->ForceCloseManageCurseur = NULL;
Panel->GetScreen()->m_CurrentItem = NULL;
Panel->m_Parent->EraseMsgBox();
/* Annulation deplacement et Redessin des segments dragges */
DRAG_SEGM * pt_drag = g_DragSegmentList;
for( ; pt_drag != NULL; pt_drag = pt_drag->Pnext)
{
TRACK * Track = pt_drag->m_Segm;
pt_drag->SetInitialValues();
Track->SetState(EDIT,OFF);
Track->m_Flags = 0;
Track->Draw(Panel, DC, GR_OR);
}
g_HightLigth_NetCode = Old_HightLigth_NetCode;
g_HightLigt_Status = Old_HightLigt_Status;
if(g_HightLigt_Status)
( (WinEDA_PcbFrame *)Panel->m_Parent)->DrawHightLight( DC, g_HightLigth_NetCode) ;
EraseDragListe();
}
/*************************************************************************/
static void Show_MoveNode(WinEDA_DrawPanel * panel, wxDC * DC, bool erase)
/*************************************************************************/
/* Redraw the moved node according to the mouse cursor position */
{
int ii, dx, dy;
TRACK * Track;
BASE_SCREEN * screen = panel->GetScreen();
int track_fill_copy = DisplayOpt.DisplayPcbTrackFill;
int draw_mode = GR_XOR | GR_SURBRILL;
DisplayOpt.DisplayPcbTrackFill = FALSE ;
erase = TRUE;
/* erase the current moved track segments from screen */
if( erase )
{
if ( NewTrack ) Trace_Une_Piste(panel, DC, NewTrack,NbPtNewTrack,draw_mode) ;
}
/* set the new track coordinates */
wxPoint Pos = screen->m_Curseur;
dx = Pos.x - s_LastPos.x;
dy = Pos.y - s_LastPos.y;
s_LastPos = Pos;
ii = NbPtNewTrack, Track = NewTrack;
for( ; (ii > 0) && (Track != NULL); ii--, Track = Track->Next() )
{
if( Track->m_Flags & STARTPOINT)
{
Track->m_Start.x += dx; Track->m_Start.y += dy;
}
if( Track->m_Flags & ENDPOINT)
{
Track->m_End.x += dx; Track->m_End.y += dy;
}
}
/* Redraw the current moved track segments */
Trace_Une_Piste(panel, DC, NewTrack,NbPtNewTrack,GR_XOR) ;
DRAG_SEGM * pt_drag = g_DragSegmentList;
for( ; pt_drag != NULL; pt_drag = pt_drag->Pnext)
{
Track = pt_drag->m_Segm;
if ( erase ) Track->Draw(panel, DC, draw_mode);
if( Track->m_Flags & STARTPOINT)
{
Track->m_Start.x += dx; Track->m_Start.y += dy;
}
if( Track->m_Flags & ENDPOINT)
{
Track->m_End.x += dx; Track->m_End.y += dy;
}
Track->Draw(panel, DC, draw_mode);
}
DisplayOpt.DisplayPcbTrackFill = track_fill_copy ;
}
/*************************************************************************/
static void Show_Drag_Track_Segment_With_Cte_Slope(WinEDA_DrawPanel * panel,
wxDC * DC, bool erase)
/*************************************************************************/
/* drawing the track segment movement
> s_MovingSegmentSlope slope = moving track segment slope
> s_StartSegmentSlope slope = slope of the segment connected to the start point of the moving segment
> s_EndSegmentSlope slope = slope of the segment connected to the end point of the moving segment
moved segment function :
yt=s_MovingSegmentSlope * x + s_MovingSegment_Yorg
segment connected to moved segment's start:
y1 = s_StartSegmentSlope * x + s_StartSegment_Yorg
segment connected to moved segment's end:
y2=s_EndSegmentSlope * x + s_EndSegment_Yorg
first intersection point will be located at
y1=yt ->
xi1=(s_MovingSegment_Yorg-s_StartSegment_Yorg)/(s_StartSegmentSlope-s_MovingSegmentSlope)
yi1=s_MovingSegmentSlope*xi1+s_MovingSegment_Yorg
or yi1=s_StartSegmentSlope*xi1+s_MovingSegment_Yorg
second intersection point
y2=yt ->
xi2=(s_MovingSegment_Yorg-s_StartSegment_Yorg)/(s_MovingSegmentSlope-s_MovingSegmentSlope)
yi2=s_MovingSegmentSlope*xi2+s_MovingSegment_Yorg
or yi1=s_EndSegmentSlope*xi2+s_MovingSegment_Yorg
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!! special attention to vertical segments because
!!!!! their slope=infinite
!!!!! intersection point will be calculated using the
!!!!! segment intersecting it
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
Slope parametres are computed once, because they can become undetermined when moving segments
(i.e. when a segment lenght is 0) and we want keep them constant
*/
{
double xi1=0,yi1=0,xi2=0,yi2=0; // calculated intersection points
double tx1,tx2,ty1,ty2; // temporary storage of points
int dx, dy;
BASE_SCREEN * screen = panel->GetScreen();
bool update=true;
TRACK * Track;
DRAG_SEGM * TrackSegWrapper = g_DragSegmentList;
TRACK * tSegmentToStart = NULL, * tSegmentToEnd = NULL;
if ( TrackSegWrapper == NULL ) return;
Track = TrackSegWrapper->m_Segm; if (Track == NULL ) return;
TrackSegWrapper = TrackSegWrapper->Pnext;
if ( TrackSegWrapper )
{
if ( s_EndSegmentPresent )
{
tSegmentToEnd = TrackSegWrapper->m_Segm; // Get the segment connected to the end point
TrackSegWrapper = TrackSegWrapper->Pnext;
}
if ( s_StartSegmentPresent )
{
if ( TrackSegWrapper )
tSegmentToStart = TrackSegWrapper->m_Segm; // Get the segment connected to the start point
}
}
int draw_mode = GR_XOR | GR_SURBRILL;
/* Undraw the current moved track segments before modification*/
// if( erase )
{
Track->Draw(panel, DC, draw_mode);
if ( tSegmentToStart ) tSegmentToStart->Draw(panel, DC, draw_mode);
if ( tSegmentToEnd ) tSegmentToEnd->Draw(panel, DC, draw_mode);
}
/* Compute the new track segment position */
wxPoint Pos = screen->m_Curseur;
dx = Pos.x - s_LastPos.x;
dy = Pos.y - s_LastPos.y;
//move the line by dx and dy
tx1 = (double)(Track->m_Start.x + dx);
ty1 = (double)(Track->m_Start.y + dy);
tx2 = (double)(Track->m_End.x + dx);
ty2 = (double)(Track->m_End.y + dy);
// recalculate the segments new parameters and intersection points
// only the intercept will change, segment slopes does not change
// because we are moving parallel with is initial state
if (!s_MovingSegmentVertical) {
s_MovingSegment_Yorg = ty1 - (s_MovingSegmentSlope * tx1);
}
if ((!s_EndPointVertical) && (!s_MovingSegmentVertical)) {
xi2 = (s_MovingSegment_Yorg - s_EndSegment_Yorg) / (s_EndSegmentSlope - s_MovingSegmentSlope);
} else {
if (!s_EndPointVertical) {
xi2 = tx2;
} else {
//P1=P2
if (!s_EndPointHorizontal) {
xi2 = tx2-dx;
} else {
update=false;
}
}
}
if (!s_MovingSegmentVertical)
{
yi2 = s_MovingSegmentSlope * (xi2) + s_MovingSegment_Yorg;
}
else
{
if (!s_EndPointVertical) {
yi2 = s_EndSegmentSlope * (xi2) + s_EndSegment_Yorg;
}
else
{
if (!s_EndPointHorizontal) {
update=false;
}
else {
yi2 = s_MovingSegmentSlope * (xi2) + s_MovingSegment_Yorg;
}
}
}
if ((!s_StartPointVertical) && (!s_MovingSegmentVertical))
{
xi1 = (s_MovingSegment_Yorg - s_StartSegment_Yorg) / (s_StartSegmentSlope - s_MovingSegmentSlope);
}
else
{
if (!s_StartPointVertical) {
xi1 = tx1;
}
else
{
//P1=P2
if (!s_StartPointHorizontal) {
xi1 = tx1-dx;
}
else
{
if (!s_StartPointHorizontal) {
update=false;
}
}
}
}
if (!s_MovingSegmentVertical) {
yi1 = s_MovingSegmentSlope * (xi1) + s_MovingSegment_Yorg;
}
else {
if (!s_StartPointVertical) {
yi1 = s_StartSegmentSlope * (xi1) + s_StartSegment_Yorg;
} else {
if (!s_StartPointHorizontal) {
update=false;
} else {
yi2 = s_MovingSegmentSlope * (xi1) + s_MovingSegment_Yorg;
}
}
}
// update the segment coordinates (if possible)
if ( tSegmentToStart == NULL )
{
xi1 = tx1; yi1 = ty1;
}
if ( tSegmentToEnd == NULL )
{
xi2 = tx2; yi2 = ty2;
}
if (update)
{
s_LastPos=Pos;
Track->m_Start.x = (int) round(xi1);
Track->m_Start.y = (int) round(yi1);
Track->m_End.x = (int) round(xi2);
Track->m_End.y = (int) round(yi2);
if ( tSegmentToEnd )
{
if ( tSegmentToEnd->m_Flags & STARTPOINT )
tSegmentToEnd->m_Start = Track->m_End;
else tSegmentToEnd->m_End = Track->m_End;
}
if ( tSegmentToStart )
{
if ( tSegmentToStart->m_Flags & STARTPOINT )
tSegmentToStart->m_Start = Track->m_Start;
else tSegmentToStart->m_End = Track->m_Start;
}
}
Track->Draw(panel, DC, draw_mode);
if ( tSegmentToStart ) tSegmentToStart->Draw(panel, DC, draw_mode);
if ( tSegmentToEnd ) tSegmentToEnd->Draw(panel, DC, draw_mode);
}
/**********************************/
bool InitialiseDragParameters(void)
/**********************************/
/* Init variables (slope, Y intersect point, flags) for Show_Drag_Track_Segment_With_Cte_Slope()
return TRUE if Ok, FALSE if dragging is not possible
(2 colinear segments)
*/
{
double tx1,tx2,ty1,ty2; // temporary storage of points
TRACK * Track;
DRAG_SEGM * TrackSegWrapper = g_DragSegmentList;
TRACK * tSegmentToStart = NULL, * tSegmentToEnd = NULL;
if ( TrackSegWrapper == NULL ) return FALSE;
Track = TrackSegWrapper->m_Segm;
if (Track == NULL ) return FALSE;
TrackSegWrapper = TrackSegWrapper->Pnext;
if ( TrackSegWrapper )
{
if ( s_EndSegmentPresent )
{
tSegmentToEnd = TrackSegWrapper->m_Segm; // Get the segment connected to the end point
TrackSegWrapper = TrackSegWrapper->Pnext;
}
if ( s_StartSegmentPresent )
{
if ( TrackSegWrapper )
tSegmentToStart = TrackSegWrapper->m_Segm; // Get the segment connected to the start point
}
}
s_StartPointVertical=false;
s_EndPointVertical=false;
s_MovingSegmentVertical=false;
s_StartPointHorizontal=false;
s_EndPointHorizontal=false;
s_MovingSegmentHorizontal=false;
// Init parameters for the starting point of the moved segment
if ( tSegmentToStart )
{
if ( tSegmentToStart->m_Flags & ENDPOINT )
{
tx1=(double)tSegmentToStart->m_Start.x;
ty1=(double)tSegmentToStart->m_Start.y;
tx2=(double)tSegmentToStart->m_End.x;
ty2=(double)tSegmentToStart->m_End.y;
}
else
{
tx1=(double)tSegmentToStart->m_End.x;
ty1=(double)tSegmentToStart->m_End.y;
tx2=(double)tSegmentToStart->m_Start.x;
ty2=(double)tSegmentToStart->m_Start.y;
}
}
else // move the start point on a line starting at Track->m_Start, and perpendicular to Track
{
tx1 = (double)Track->m_Start.x;
ty1 = (double)Track->m_Start.y;
tx2 = (double)Track->m_End.x;
ty2 = (double)Track->m_End.y;
RotatePoint(&tx2, &ty2, tx1, ty1, 900);
}
if (tx1!=tx2) {
s_StartSegmentSlope = (ty2 - ty1) / (tx2 - tx1);
s_StartSegment_Yorg = ty1 - (ty2 - ty1) * tx1 / (tx2 - tx1);
} else {
s_StartPointVertical=true; //signal first segment vertical
}
if (ty1==ty2) {
s_StartPointHorizontal=true;
}
// Init parameters for the ending point of the moved segment
if ( tSegmentToEnd )
{
//check if second line is vertical
if ( tSegmentToEnd->m_Flags & STARTPOINT )
{
tx1=(double)tSegmentToEnd->m_Start.x;
ty1=(double)tSegmentToEnd->m_Start.y;
tx2=(double)tSegmentToEnd->m_End.x;
ty2=(double)tSegmentToEnd->m_End.y;
}
else
{
tx1=(double)tSegmentToEnd->m_End.x;
ty1=(double)tSegmentToEnd->m_End.y;
tx2=(double)tSegmentToEnd->m_Start.x;
ty2=(double)tSegmentToEnd->m_Start.y;
}
}
else // move the start point on a line starting at Track->m_End, and perpendicular to Track
{
tx1 = (double)Track->m_End.x;
ty1 = (double)Track->m_End.y;
tx2 = (double)Track->m_Start.x;
ty2 = (double)Track->m_Start.y;
RotatePoint(&tx2, &ty2, tx1, ty1, -900);
}
if (tx2!=tx1) {
s_EndSegmentSlope = (ty2 - ty1) / (tx2 - tx1);
s_EndSegment_Yorg = ty1 - (ty2 - ty1) * tx1 / (tx2 - tx1);
} else {
s_EndPointVertical = true; //signal second segment vertical
}
if (ty1==ty2) {
s_EndPointHorizontal = true;
}
// Init parameters for the moved segment
tx1 = (double)Track->m_Start.x;
ty1 = (double)Track->m_Start.y;
tx2 = (double)Track->m_End.x;
ty2 = (double)Track->m_End.y;
if (tx2 != tx1) {
s_MovingSegmentSlope = (ty2 - ty1) / (tx2 - tx1);
} else {
s_MovingSegmentVertical = true; //signal vertical line
}
if (ty1==ty2) {
s_MovingSegmentHorizontal=true;
}
// Test if drag is possible:
if( s_MovingSegmentVertical )
{
if ( s_EndPointVertical || s_StartPointVertical ) return false;
}
else
{ if ( ! s_EndPointVertical && (s_MovingSegmentSlope == s_EndSegmentSlope) ) return false;
if ( ! s_StartPointVertical && (s_MovingSegmentSlope == s_StartSegmentSlope) ) return false;
}
return TRUE;
}
/*************************************************************************************/
void WinEDA_PcbFrame::Start_MoveOneNodeOrSegment(TRACK * track, wxDC * DC, int command)
/*************************************************************************************/
/* Init parametres to move one node:
a via or/and a terminal point of a track segment
The terminal point of other connected segments (if any) are moved too.
*/
{
if ( ! track ) return;
NewTrack = NULL;
NbPtNewTrack = 0;
EraseDragListe();
/* Change hight light net: the new one will be hightlighted */
Old_HightLigt_Status = g_HightLigt_Status;
Old_HightLigth_NetCode = g_HightLigth_NetCode;
if(g_HightLigt_Status) Hight_Light(DC);
PosInit = GetScreen()->m_Curseur;
if ( track->m_StructType == TYPEVIA)
{
track->m_Flags = IS_DRAGGED|STARTPOINT|ENDPOINT;
if ( command != ID_POPUP_PCB_MOVE_TRACK_SEGMENT )
{
Collect_TrackSegmentsToDrag(DrawPanel, DC, track->m_Start,
track->ReturnMaskLayer(), track->m_NetCode);
}
NewTrack = track;
NbPtNewTrack = 1;
PosInit = track->m_Start;
}
else
{
int diag = track->IsPointOnEnds(GetScreen()->m_Curseur, -1);
wxPoint pos;
switch ( command )
{
case ID_POPUP_PCB_MOVE_TRACK_SEGMENT:
track->m_Flags |= IS_DRAGGED|ENDPOINT|STARTPOINT;
AddSegmentToDragList(DrawPanel, DC, track->m_Flags, track);
break;
case ID_POPUP_PCB_DRAG_TRACK_SEGMENT:
pos = track->m_Start;
Collect_TrackSegmentsToDrag(DrawPanel, DC, pos,
track->ReturnMaskLayer(), track->m_NetCode);
pos = track->m_End;
track->m_Flags |= IS_DRAGGED|ENDPOINT|STARTPOINT;
Collect_TrackSegmentsToDrag(DrawPanel, DC, pos,
track->ReturnMaskLayer(), track->m_NetCode);
break;
case ID_POPUP_PCB_MOVE_TRACK_NODE:
pos = (diag & STARTPOINT) ? track->m_Start : track->m_End;
Collect_TrackSegmentsToDrag(DrawPanel, DC, pos,
track->ReturnMaskLayer(), track->m_NetCode);
PosInit = pos;
break;
}
track->m_Flags |= IS_DRAGGED;
}
s_LastPos = PosInit;
DrawPanel->ManageCurseur = Show_MoveNode;
DrawPanel->ForceCloseManageCurseur = Abort_MoveTrack;
g_HightLigth_NetCode = track->m_NetCode;
g_HightLigt_Status = TRUE;
DrawHightLight( DC, g_HightLigth_NetCode) ;
DrawPanel->ManageCurseur(DrawPanel, DC, TRUE);
}
/***********************************************************************************/
void WinEDA_PcbFrame::Start_DragTrackSegmentAndKeepSlope(TRACK * track, wxDC * DC)
/***********************************************************************************/
{
TRACK * TrackToStartPoint = NULL;
TRACK * TrackToEndPoint = NULL;
bool error = FALSE;
if ( ! track ) return;
s_StartSegmentPresent = s_EndSegmentPresent = TRUE;
if ( (track->start == NULL) || (track->start->m_StructType == TYPETRACK) )
TrackToStartPoint = (TRACK*) Locate_Piste_Connectee( track, m_Pcb->m_Track, NULL, START);
// Test if more than one segment is connected to this point
if ( TrackToStartPoint )
{
TrackToStartPoint->SetState(BUSY,ON);
if ( Locate_Piste_Connectee( track, m_Pcb->m_Track, NULL, START) ) error = TRUE;
TrackToStartPoint->SetState(BUSY,OFF);
}
if ( (track->end == NULL) || (track->end->m_StructType == TYPETRACK) )
TrackToEndPoint = (TRACK*) Locate_Piste_Connectee( track, m_Pcb->m_Track, NULL, END);
// Test if more than one segment is connected to this point
if ( TrackToEndPoint )
{
TrackToEndPoint->SetState(BUSY,ON);
if ( Locate_Piste_Connectee( track, m_Pcb->m_Track, NULL, END) ) error = TRUE;
TrackToEndPoint->SetState(BUSY,OFF);
}
if ( error )
{
DisplayError( this, _("Unable to drag this segment: too many segments connected") );
return;
}
if ( !TrackToStartPoint || (TrackToStartPoint->m_StructType != TYPETRACK) )
s_StartSegmentPresent = FALSE;
if ( !TrackToEndPoint || (TrackToEndPoint->m_StructType != TYPETRACK) )
s_EndSegmentPresent = FALSE;
/* Change hight light net: the new one will be hightlighted */
Old_HightLigt_Status = g_HightLigt_Status;
Old_HightLigth_NetCode = g_HightLigth_NetCode;
if(g_HightLigt_Status) Hight_Light(DC);
EraseDragListe();
NewTrack = NULL;
NbPtNewTrack = 0;
track->m_Flags = IS_DRAGGED;
if( TrackToStartPoint )
{
int flag = STARTPOINT;
if ( track->m_Start != TrackToStartPoint->m_Start ) flag = ENDPOINT;
AddSegmentToDragList(DrawPanel, DC, flag, TrackToStartPoint);
track->m_Flags |= STARTPOINT;
}
if( TrackToEndPoint )
{
int flag = STARTPOINT;
if ( track->m_End != TrackToEndPoint->m_Start ) flag = ENDPOINT;
AddSegmentToDragList(DrawPanel, DC, flag, TrackToEndPoint);
track->m_Flags |= ENDPOINT;
}
AddSegmentToDragList(DrawPanel, DC, track->m_Flags, track);
PosInit=GetScreen()->m_Curseur;
s_LastPos = GetScreen()->m_Curseur;
DrawPanel->ManageCurseur = Show_Drag_Track_Segment_With_Cte_Slope;
DrawPanel->ForceCloseManageCurseur = Abort_MoveTrack;
g_HightLigth_NetCode = track->m_NetCode;
g_HightLigt_Status = TRUE;
DrawHightLight( DC, g_HightLigth_NetCode) ;
if ( ! InitialiseDragParameters() )
{
DisplayError( this, _("Unable to drag this segment: two colinear segments") );
DrawPanel->ManageCurseur = NULL;
Abort_MoveTrack(DrawPanel, DC);
return;
}
}
/**********************************************************************/
bool WinEDA_PcbFrame::PlaceDraggedTrackSegment(TRACK * Track, wxDC * DC)
/**********************************************************************/
/* Place a dragged (or moved) track segment or via */
{
int errdrc;
DRAG_SEGM * pt_drag;
if(Track == NULL ) return FALSE;
int current_net_code = Track->m_NetCode;
// DRC control:
if(Drc_On)
{
errdrc = Drc(this, DC, Track, m_Pcb->m_Track,1);
if(errdrc == BAD_DRC) return FALSE;
/* Redraw the dragged segments */
pt_drag = g_DragSegmentList;
for( ; pt_drag != NULL; pt_drag = pt_drag->Pnext)
{
errdrc = Drc(this, DC, pt_drag->m_Segm, m_Pcb->m_Track,1);
if(errdrc == BAD_DRC) return FALSE;
}
}
int draw_mode = GR_OR | GR_SURBRILL;
// DRC Ok: place track segments
Track->m_Flags = 0;
Track->SetState(EDIT,OFF);
Track->Draw(DrawPanel, DC, draw_mode);
/* Tracage des segments dragges */
pt_drag = g_DragSegmentList;
for( ; pt_drag; pt_drag = pt_drag->Pnext)
{
Track = pt_drag->m_Segm;
Track->SetState(EDIT,OFF);
Track->m_Flags = 0;
Track->Draw(DrawPanel, DC, draw_mode);
/* Test the connections modified by the move
(only pad connection must be tested, track connection will be tested by test_1_net_connexion() ) */
int masque_layer = g_TabOneLayerMask[Track->m_Layer];
Track->start = Fast_Locate_Pad_Connecte(m_Pcb, Track->m_Start, masque_layer);
Track->end = Fast_Locate_Pad_Connecte(m_Pcb, Track->m_End, masque_layer);
}
EraseDragListe();
GetScreen()->SetModify();
DrawPanel->ManageCurseur = NULL;
DrawPanel->ForceCloseManageCurseur = NULL;
if ( current_net_code > 0 ) test_1_net_connexion(DC, current_net_code);
return TRUE;
}
/************************************************************************/
EDA_BaseStruct * LocateLockPoint(BOARD * Pcb, wxPoint pos, int LayerMask)
/************************************************************************/
/* Routine trouvant le point " d'accrochage " d'une extremite de piste.
Ce point peut etre un PAD ou un autre segment de piste
Retourne:
- pointeur sur ce PAD ou:
- pointeur sur le segment ou:
- NULL
Parametres d'appel:
coord pX, pY du point tst
masque des couches a tester
*/
{
D_PAD * pt_pad;
TRACK * ptsegm;
MODULE * Module;
/* detection du point type PAD */
pt_pad = NULL;
Module = Pcb->m_Modules;
for( ; Module != NULL; Module = (MODULE*)Module->Pnext )
{
pt_pad = Locate_Pads(Module, pos, LayerMask);
if (pt_pad) return(pt_pad);
}
/* ici aucun pad n'a ete localise: detection d'un segment de piste */
ptsegm = Fast_Locate_Piste( Pcb->m_Track, NULL, pos, LayerMask);
if( ptsegm == NULL )
ptsegm = Locate_Pistes( Pcb->m_Track, pos, LayerMask);
return(ptsegm);
}
/******************************************************************************/
TRACK * CreateLockPoint(int *pX, int *pY, TRACK * ptsegm, TRACK * refsegm)
/******************************************************************************/
/* Routine de creation d'un point intermediaire sur un segment
le segment ptsegm est casse en 2 segments se raccordant au point pX, pY
retourne:
NULL si pas de nouveau point ( c.a.d si pX, pY correspondait deja
a une extremite ou:
pointeur sur le segment cree
si refsegm != NULL refsegm est pointeur sur le segment incident,
et le point cree est l'intersection des 2 axes des segments ptsegm et
refsegm
retourne la valeur exacte de pX et pY
Si ptsegm pointe sur une via:
retourne la valeur exacte de pX et pY et ptsegm,
mais ne cree pas de point supplementaire
*/
{
int cX, cY;
int dx, dy; /* Coord de l'extremite du segm ptsegm / origine */
int ox, oy, fx , fy; /* coord de refsegm / origine de prsegm */
TRACK * NewTrack;
if( (ptsegm->m_Start.x == *pX) && (ptsegm->m_Start.y == *pY) ) return(NULL);
if( (ptsegm->m_End.x == *pX) && (ptsegm->m_End.y == *pY) ) return(NULL);
/* le point n'est pas sur une extremite de piste */
if(ptsegm->m_StructType == TYPEVIA )
{
*pX = ptsegm->m_Start.x; *pY = ptsegm->m_Start.y;
return(ptsegm);
}
/* calcul des coord vraies du point intermediaire dans le repere d'origine
= origine de ptsegm */
cX = *pX - ptsegm->m_Start.x;
cY = *pY - ptsegm->m_Start.y;
dx = ptsegm->m_End.x - ptsegm->m_Start.x;
dy = ptsegm->m_End.y - ptsegm->m_Start.y;
// ***** A COMPLETER : non utilise
if ( refsegm )
{
ox = refsegm->m_Start.x - ptsegm->m_Start.x;
oy = refsegm->m_Start.y - ptsegm->m_Start.y;
fx = refsegm->m_End.x - ptsegm->m_Start.x;
fy = refsegm->m_End.y - ptsegm->m_Start.y;
}
/* pour que le point soit sur le segment ptsegm: cY/cX = dy/dx */
if ( dx == 0 ) cX = 0; /* segm horizontal */
else cY = (cX * dy) / dx;
/* creation du point intermediaire ( c'est a dire creation d'un nouveau
segment, debutant au point intermediaire */
cX += ptsegm->m_Start.x; cY += ptsegm->m_Start.y;
NewTrack = ptsegm->Copy();
NewTrack->Insert(NULL, ptsegm);
/* correction du pointeur de fin du nouveau segment */
NewTrack->end = ptsegm->end;
/* le segment primitif finit au nouveau point : */
ptsegm->m_End.x = cX; ptsegm->m_End.y = cY;
ptsegm->SetState(END_ONPAD, OFF);
/* le nouveau segment debute au nouveau point : */
ptsegm = NewTrack;;
ptsegm->m_Start.x = cX; ptsegm->m_Start.y = cY;
ptsegm->SetState(BEGIN_ONPAD, OFF);
*pX = cX; *pY = cY;
return(ptsegm);
}
Reference in New Issue View Git Blame Copy Permalink