Werner Almesberger's patches (30932a46) · Commits · Elphel / kicad-source-mirror

pcbnew/class_track.cpp

+2 −4

Original line number	Diff line number	Diff line
		@@ -890,10 +890,8 @@ bool TRACK::HitTest( const wxPoint& ref_pos )

		if( Type() == TYPEVIA ) /* VIA rencontree */
		{
		if( (abs( spot_cX ) <= l_piste ) && (abs( spot_cY ) <=l_piste) )
		return true;
		else
		return false;
		return (int64_t) spot_cXspot_cX + (int64_t) spot_cYspot_cY <=
		(int64_t) l_piste*l_piste;
		}
		else
		{

pcbnew/controle.cpp

+167 −29

Original line number	Diff line number	Diff line
		@@ -219,6 +219,152 @@ BOARD_ITEM* WinEDA_BasePcbFrame::PcbGeneralLocateAndDisplay( int aHotKeyCode )
		}


		/*
		* "Join" finds the point where b0+x(b1-b0) intersects with a0+y(a1-a0).
		* If that point would be outside of a0-a1, the respective endpoint is used.
		* Join returns the point in "res" and "true" if a suitable point was found,
		* "false" if both lines are parallel.
		*/
		static bool Join( wxPoint& res, wxPoint a0, wxPoint a1, wxPoint b0, wxPoint b1 )
		{
		int64_t denom;
		double t;

		a1 -= a0;
		b1 -= b0;
		b0 -= a0;

		denom = (int64_t) b1.ya1.x - (int64_t) b1.xa1.y;
		if (!denom)
		return false; // parallel

		t = ((int64_t) b1.yb0.x - (int64_t) b1.xb0.y)/(double) denom;

		t = min( max( t, 0.0 ), 1.0 );

		res.x = (int) round(a0.x+t*a1.x);
		res.y = (int) round(a0.y+t*a1.y);

		return true;
		}


		/*
		* "Project" finds the projection of a grid point on a track. This is the point
		* from where we want to draw new orthogonal tracks when starting on a track.
		*/
		bool Project( wxPoint& res, wxPoint on_grid, const TRACK* track )
		{
		wxPoint vec;
		double t;

		if( track->m_Start == track->m_End )
		return false;

		vec = track->m_End-track->m_Start;

		t = (int64_t) (on_grid.x-track->m_Start.x)*vec.x +
		(int64_t) (on_grid.y-track->m_Start.y)*vec.y;

		t /= (int64_t) vec.xvec.x + (int64_t) vec.yvec.y;
		t = min( max( t, 0.0 ), 1.0 );

		res.x = (int) round( track->m_Start.x + t*vec.x );
		res.y = (int) round( track->m_Start.y + t*vec.y );

		return true;
		}


		static bool Magnetize( BOARD* m_Pcb, WinEDA_PcbFrame* frame,
		int m_ID_current_state, wxSize grid, wxPoint on_grid, wxPoint& curpos )
		{
		const D_PAD* pad;
		const TRACK* curr = NULL;
		const TRACK* via, * track;
		int layer, layer_mask;

		bool sometimes = g_MagneticPadOption != capture_always && Drc_On;

		curr = g_CurrentTrackSegment;
		if( frame->GetCurItem() != curr )
		curr = NULL;

		switch( g_MagneticPadOption )
		{
		case capture_cursor_in_track_tool:
		if( m_ID_current_state != ID_TRACK_BUTT )
		return false;
		break;

		case capture_always:
		break;

		case no_effect:
		default:
		return false;
		}

		pad = Locate_Any_Pad( m_Pcb, CURSEUR_OFF_GRILLE, TRUE );
		if( pad )
		{
		if( curr && curr->GetNet() != pad->GetNet() && sometimes )
		return false;
		curpos = pad->m_Pos;
		return true;
		}

		layer = ( (PCB_SCREEN*) ActiveScreen )->m_Active_Layer;

		via = Locate_Via_Area( m_Pcb, curpos, layer );
		if( via )
		{
		if( curr && curr->GetNet() != via->GetNet() && sometimes )
		return false;
		curpos = via->m_Start;
		return true;
		}

		layer_mask = g_TabOneLayerMask[layer];

		if( !curr )
		{
		track = Locate_Pistes( m_Pcb->m_Track, layer_mask, CURSEUR_OFF_GRILLE );
		if( !track \|\| track->Type() != TYPETRACK )
		return false;

		return Project( curpos, on_grid, track );
		}

		/*
		* In two segment mode, ignore the final segment if it's inside a grid
		* square.
		*/
		if( g_TwoSegmentTrackBuild && curr->Pback
		&& curr->m_Start.x - grid.x < curr->m_End.x
		&& curr->m_Start.x + grid.x > curr->m_End.x
		&& curr->m_Start.y - grid.y < curr->m_End.y
		&& curr->m_Start.y + grid.y > curr->m_End.y )
		curr = curr->Back();

		track = Locate_Pistes( m_Pcb->m_Track, layer_mask, CURSEUR_OFF_GRILLE );
		for( ; track; track = track->Next() )
		{
		if( track->Type() != TYPETRACK )
		continue;

		if( curr->GetNet() != track->GetNet() && sometimes )
		continue;

		if( Join( curpos, track->m_Start, track->m_End,
		curr->m_Start, curr->m_End ) )
		return true;
		}

		return false;
		}


		/****************************************************************/
		void WinEDA_BasePcbFrame::GeneralControle( wxDC* DC, wxPoint Mouse )
		/*****************************************************************/
		@@ -341,7 +487,6 @@ void WinEDA_BasePcbFrame::GeneralControle( wxDC* DC, wxPoint Mouse )
		* But if the tool DELETE is active the cursor is left off grid
		* this is better to reach items to delete off grid
		*/
		D_PAD* pad;
		bool keep_on_grid = TRUE;
		if( m_ID_current_state == ID_PCB_DELETE_ITEM_BUTT )
		keep_on_grid = FALSE;
		@@ -354,34 +499,27 @@ void WinEDA_BasePcbFrame::GeneralControle( wxDC* DC, wxPoint Mouse )
		if( DrawStruct && DrawStruct->m_Flags )
		keep_on_grid = TRUE;

		switch( g_MagneticPadOption )
		{
		case capture_cursor_in_track_tool:
		case capture_always:
		pad = Locate_Any_Pad( m_Pcb, CURSEUR_OFF_GRILLE, TRUE );
		if( (m_ID_current_state != ID_TRACK_BUTT )
		&& (g_MagneticPadOption == capture_cursor_in_track_tool) )
		pad = NULL;
		if (keep_on_grid) {
		wxPoint on_grid = curpos;

		if( keep_on_grid )
		{
		if( pad ) // Put cursor on the pad
		GetScreen()->m_Curseur = curpos = pad->m_Pos;
		else
		// Put cursor on grid
		PutOnGrid( &GetScreen()->m_Curseur );
		}
		break;

		case no_effect:
		default:
		PutOnGrid(&on_grid);
		if (Magnetize(m_Pcb, (WinEDA_PcbFrame *) this, m_ID_current_state,
		GetScreen()->GetGrid(), on_grid, curpos))
		GetScreen()->m_Curseur = curpos;
		else {
		extern TRACK LocateIntrusion(TRACK start, int net, int width);

		// If we are not in delete function, put cursor on grid
		if( keep_on_grid )
		{
		PutOnGrid( &GetScreen()->m_Curseur );
		/*
		* If there's an intrusion and DRC is active, we pass the cursor
		* "as is", and let ShowNewTrackWhenMovingCursor figure our what to
		* do.
		*/
		if (!Drc_On \|\| !g_CurrentTrackSegment \|\|
		g_CurrentTrackSegment != this->GetCurItem() \|\|
		!LocateIntrusion(m_Pcb->m_Track, g_CurrentTrackSegment->GetNet(),
		g_CurrentTrackSegment->m_Width))
		GetScreen()->m_Curseur = on_grid;
		}
		break;
		}

		if( oldpos != GetScreen()->m_Curseur )

pcbnew/editrack.cpp

+135 −16

Original line number	Diff line number	Diff line
		@@ -18,7 +18,7 @@
		static void Exit_Editrack( WinEDA_DrawPanel* panel, wxDC* DC );
		void ShowNewTrackWhenMovingCursor( WinEDA_DrawPanel* panel,
		wxDC* DC, bool erase );
		static void ComputeBreakPoint( TRACK* track, int n );
		static void ComputeBreakPoint( TRACK* track, int n, wxPoint end );
		static TRACK* DeleteNullTrackSegments( BOARD* pcb, TRACK* track, int* segmcount );
		static void EnsureEndTrackOnPad( D_PAD* Pad );

		@@ -493,6 +493,120 @@ void WinEDA_PcbFrame::End_Route( TRACK* track, wxDC* DC )
		SetCurItem( NULL );
		}

		/*
		* PushTrack detecs if the mouse is pointing into a conflicting track.
		* In this case, it tries to push the new track out of the conflicting track's
		* clearance zone. This gives us a cheap mechanism for drawing tracks that
		* tightly follow others, independent of grid settings.
		*
		* KNOWN BUGS:
		* - we do the same sort of search and calculation up to three times:
		* 1) we search for magnetic hits (in controle.cpp)
		* 2) we check if there's a DRC violation in the making (also controle.cpp)
		* 3) we try to fix the DRC violation (here)
		* - if we have a magnetic hit and a DRC violation at the same time, we choose
		* the magnetic hit instead of solving the violation
		* - should locate conflicting tracks also when we're crossing over them
		* - we obviously shouldn't access functions through "extern" or have #includes
		* in the middle of the file
		*/

		#include "trigo.h"

		extern bool Project(wxPoint &res, wxPoint on_grid, const TRACK *track);


		TRACK LocateIntrusion(TRACK start, int net, int width)
		{
		int layer = ((PCB_SCREEN *) ActiveScreen)->m_Active_Layer;
		int layer_mask = g_TabOneLayerMask[layer];
		wxPoint ref = ActiveScreen->RefPos(1);
		TRACK track, found = NULL;

		for (track = start; track; track = track->Next()) {
		int dist;
		wxPoint pos, vec;
		int64_t tmp;

		/* Locate_Pistes */
		if (track->GetState(BUSY \| DELETED))
		continue;
		if (!(g_TabOneLayerMask[track->GetLayer()] & layer_mask))
		continue;
		if (track->GetNet() == net)
		continue;
		if (track->Type() == TYPEVIA)
		continue;

		/* TRACK::HitTest */
		dist = width/2 + track->m_Width/2 + g_DesignSettings.m_TrackClearence;
		pos = ref-track->m_Start;
		vec = track->m_End-track->m_Start;
		if (!DistanceTest(dist, vec.x, vec.y, pos.x, pos.y))
		continue;
		found = track;

		/* prefer intrusions from the side, not the end */
		tmp = (int64_t) pos.xvec.x + (int64_t) pos.yvec.y;
		if (tmp >= 0 && tmp <= (int64_t) vec.xvec.x + (int64_t) vec.yvec.y)
		break;
		}
		return found;
		}



		static void PushTrack(WinEDA_DrawPanel *panel)
		{
		BOARD pcb = ((WinEDA_BasePcbFrame ) (panel->m_Parent))->m_Pcb;
		wxPoint cursor = ActiveScreen->m_Curseur;
		wxPoint cv, vec, n;
		TRACK *track = g_CurrentTrackSegment;
		TRACK *other;
		int64_t det;
		int dist;
		double f;

		other = LocateIntrusion(pcb->m_Track, track->GetNet(), track->m_Width);

		/* are we currently pointing into a conflicting trace ? */
		if (!other)
		return;
		if (other->GetNet() == track->GetNet())
		return;

		cv = cursor-other->m_Start;
		vec = other->m_End-other->m_Start;

		det = (int64_t) cv.xvec.y - (int64_t) cv.yvec.x;

		/* cursor is right at the center of the old track */
		if (!det)
		return;

		dist = (track->m_Width+1)/2 + (other->m_Width+1)/2 +
		g_DesignSettings.m_TrackClearence+2;
		/*
		* DRC wants >, so +1.
		* We may have a quantization error of 1/sqrt(2), so +1 again.
		*/

		/* Vector "n" is perpendicular to "other", pointing towards the cursor. */
		if (det > 0) {
		n.x = vec.y;
		n.y = -vec.x;
		}
		else {
		n.x = -vec.y;
		n.y = vec.x;
		}
		f = dist/hypot(n.x, n.y);
		n.x = (int) round(f*n.x);
		n.y = (int) round(f*n.y);

		Project(track->m_End, cursor, other);
		track->m_End += n;
		}

		/****************************************************************************/
		void ShowNewTrackWhenMovingCursor( WinEDA_DrawPanel* panel, wxDC* DC, bool erase )
		@@ -538,8 +652,13 @@ void ShowNewTrackWhenMovingCursor( WinEDA_DrawPanel* panel, wxDC* DC, bool erase

		if( Track_45_Only )
		{
		if( g_TwoSegmentTrackBuild )
		ComputeBreakPoint( g_CurrentTrackSegment, g_TrackSegmentCount );
		if( g_TwoSegmentTrackBuild ) {
		g_CurrentTrackSegment->m_End = ActiveScreen->m_Curseur;
		if (Drc_On)
		PushTrack(panel);
		ComputeBreakPoint( g_CurrentTrackSegment, g_TrackSegmentCount,
		g_CurrentTrackSegment->m_End);
		}
		else
		{
		/* Calcul de l'extremite de la piste pour orientations permises:
		@@ -625,7 +744,7 @@ void Calcule_Coord_Extremite_45( int ox, int oy, int* fx, int* fy )


		/********************************************************/
		void ComputeBreakPoint( TRACK* track, int SegmentCount )
		void ComputeBreakPoint( TRACK* track, int SegmentCount, wxPoint end )
		/********************************************************/

		/**
		@@ -646,8 +765,8 @@ void ComputeBreakPoint( TRACK* track, int SegmentCount )
		SegmentCount--;
		if( track )
		{
		iDx = ActiveScreen->m_Curseur.x - track->m_Start.x;
		iDy = ActiveScreen->m_Curseur.y - track->m_Start.y;
		iDx = end.x - track->m_Start.x;
		iDy = end.y - track->m_Start.y;

		iDx = abs( iDx );
		iDy = abs( iDy );
		@@ -680,10 +799,10 @@ void ComputeBreakPoint( TRACK* track, int SegmentCount )
		break;

		case 0:
		if( (ActiveScreen->m_Curseur.x - track->m_Start.x) < 0 )
		track->m_End.x = ActiveScreen->m_Curseur.x + iDy;
		if( (end.x - track->m_Start.x) < 0 )
		track->m_End.x = end.x + iDy;
		else
		track->m_End.x = ActiveScreen->m_Curseur.x - iDy;
		track->m_End.x = end.x - iDy;
		track->m_End.y = track->m_Start.y;
		break;

		@@ -691,19 +810,19 @@ void ComputeBreakPoint( TRACK* track, int SegmentCount )
		iDx = MIN( iDx, iDy );
		iDy = iDx;
		/* recalcul des signes de deltax et deltay */
		if( (ActiveScreen->m_Curseur.x - track->m_Start.x) < 0 )
		if( (end.x - track->m_Start.x) < 0 )
		iDx = -iDx;
		if( (ActiveScreen->m_Curseur.y - track->m_Start.y) < 0 )
		if( (end.y - track->m_Start.y) < 0 )
		iDy = -iDy;
		track->m_End.x = track->m_Start.x + iDx;
		track->m_End.y = track->m_Start.y + iDy;
		break;

		case 90:
		if( (ActiveScreen->m_Curseur.y - track->m_Start.y) < 0 )
		track->m_End.y = ActiveScreen->m_Curseur.y + iDx;
		if( (end.y - track->m_Start.y) < 0 )
		track->m_End.y = end.y + iDx;
		else
		track->m_End.y = ActiveScreen->m_Curseur.y - iDx;
		track->m_End.y = end.y - iDx;
		track->m_End.x = track->m_Start.x;
		break;
		}
		@@ -711,10 +830,10 @@ void ComputeBreakPoint( TRACK* track, int SegmentCount )
		if( track )
		{
		if( track->IsNull() )
		track->m_End = ActiveScreen->m_Curseur;
		track->m_End = end;
		NewTrack->m_Start = track->m_End;
		}
		NewTrack->m_End = ActiveScreen->m_Curseur;
		NewTrack->m_End = end;
		}

pcbnew/locate.cpp

+28 −0

Original line number	Diff line number	Diff line
		@@ -111,6 +111,34 @@ TRACK* Locate_Via( BOARD* Pcb, const wxPoint& pos, int layer )
		}


		/*******************************************************************/
		TRACK* Locate_Via_Area( BOARD* Pcb, const wxPoint& pos, int layer )
		/*******************************************************************/

		/*
		* Like Locate_Via, but finds any via covering the cursor position
		*/
		{
		TRACK* Track;

		for( Track = Pcb->m_Track; Track != NULL; Track = Track->Next() )
		{
		if( Track->Type() != TYPEVIA )
		continue;
		if(!Track->HitTest(pos))
		continue;
		if( Track->GetState( BUSY \| DELETED ) )
		continue;
		if( layer < 0 )
		return Track;
		if( Track->IsOnLayer( layer ) )
		return Track;
		}

		return NULL;
		}


		/********************************************************************/
		D_PAD* Locate_Pad_Connecte( BOARD* Pcb, TRACK* ptr_piste, int extr )
		/********************************************************************/

pcbnew/protos.h

+307 −265

File changed.

Preview size limit exceeded, changes collapsed.

Admin message