pcbnew/controle.cpp File Reference

#include <fctsys.h>
#include <class_drawpanel.h>
#include <pcb_edit_frame.h>
#include <pcbnew_id.h>
#include <class_board.h>
#include <class_module.h>
#include <class_zone.h>
#include <pcbnew.h>
#include <protos.h>
#include <collectors.h>
#include <menus_helpers.h>

Go to the source code of this file.

Functions
bool	Magnetize (PCB_BASE_EDIT_FRAME *frame, int aCurrentTool, wxSize aGridSize, wxPoint on_grid, wxPoint *curpos)
	Function Magnetize tests to see if there are any magnetic items within near reach of the given "curpos". More...
static BOARD_ITEM *	AllAreModulesAndReturnSmallestIfSo (GENERAL_COLLECTOR *aCollector)
	Function AllAreModulesAndReturnSmallestIfSo tests that all items in the collection are MODULEs and if so, returns the smallest MODULE. More...

Function Documentation

static BOARD_ITEM* AllAreModulesAndReturnSmallestIfSo ( GENERAL_COLLECTOR *  aCollector )

static

Function AllAreModulesAndReturnSmallestIfSo tests that all items in the collection are MODULEs and if so, returns the smallest MODULE.

Returns

BOARD_ITEM* - The smallest or NULL.

Definition at line 55 of file pcbnew/controle.cpp.

References MODULE::GetBoundingBox(), COLLECTOR::GetCount(), EDA_RECT::GetHeight(), GENERAL_COLLECTOR::GetPrimaryCount(), EDA_RECT::GetWidth(), i, min, and PCB_MODULE_T.

Referenced by PCB_BASE_FRAME::PcbGeneralLocateAndDisplay().

{
#if 0   // Dick: this is not consistent with name of this function, and does not
        // work correctly using 'M' (move hotkey) when another module's (2nd module) reference
        // is under a module (first module) and you want to move the reference.
        // Another way to fix this would be to
        // treat module text as copper layer content, and put the module text into
        // the primary list.  I like the coded behavior best.  If it breaks something
        // perhaps you need a different test before calling this function, which should
        // do what its name says it does.
    int count = aCollector->GetPrimaryCount();     // try to use preferred layer
    if( 0 == count ) count = aCollector->GetCount();
#else
    int count = aCollector->GetCount();
#endif

    for( int i = 0; i<count;  ++i )
    {
        if( (*aCollector)[i]->Type() != PCB_MODULE_T )
            return NULL;
    }

    // all are modules, now find smallest MODULE

    int minDim = 0x7FFFFFFF;
    int minNdx = 0;

    for( int i = 0;  i<count;  ++i )
    {
        MODULE* module = (MODULE*) (*aCollector)[i];

        int     lx = module->GetBoundingBox().GetWidth();
        int     ly = module->GetBoundingBox().GetHeight();

        int     lmin = std::min( lx, ly );

        if( lmin < minDim )
        {
            minDim = lmin;
            minNdx = i;
        }
    }

    return (*aCollector)[minNdx];
}

bool Magnetize	(	PCB_BASE_EDIT_FRAME *	frame,
		int	aCurrentTool,
		wxSize	aGridSize,
		wxPoint	on_grid,
		wxPoint *	curpos
	)

Function Magnetize tests to see if there are any magnetic items within near reach of the given "curpos".

If yes, then curpos is adjusted appropriately according to that near magnetic item and true is returned.

Parameters

frame	= the current frame
aCurrentTool	= the current tool id (from vertical right toolbar)
aGridSize	= the current grid size
on_grid	= the on grid position near initial position ( often on_grid = curpos)
curpos	The initial position, and what to adjust if a change is needed.

Returns

bool - true if the position was adjusted magnetically, else false.

Definition at line 129 of file magnetic_tracks_functions.cpp.

Referenced by PCB_EDIT_FRAME::GeneralControl().

{
    // Note: only used for routing in the Legacy Toolset and for the measurement tool in the
    // Modern Toolset.  Can be greatly simplified when the Legacy Toolset is retired.

    bool    doCheckNet = frame->Settings().m_magneticPads != CAPTURE_ALWAYS && frame->Settings().m_legacyDrcOn;
    bool    doCheckLayer = aCurrentTool == ID_TRACK_BUTT;
    bool    doTrack = false;
    bool    doPad = false;
    bool    amMovingVia = false;

    BOARD*      m_Pcb = frame->GetBoard();
    TRACK*      currTrack = g_CurrentTrackSegment;
    BOARD_ITEM* currItem  = frame->GetCurItem();
    PCB_SCREEN* screen = frame->GetScreen();
    wxPoint     pos = frame->RefPos( true );

    // D( printf( "currTrack=%p currItem=%p currTrack->Type()=%d currItem->Type()=%d\n",  currTrack, currItem, currTrack ? currTrack->Type() : 0, currItem ? currItem->Type() : 0 ); )

    if( !currTrack && currItem && currItem->Type()==PCB_VIA_T && currItem->GetFlags() )
    {
        // moving a VIA
        currTrack = (TRACK*) currItem;
        amMovingVia = true;

        return false;   // comment this return out and play with it.
    }
    else if( currItem != currTrack )
    {
        currTrack = NULL;
    }

    if( frame->Settings().m_magneticPads == CAPTURE_ALWAYS )
        doPad = true;

    if( frame->Settings().m_magneticTracks == CAPTURE_ALWAYS )
        doTrack = true;

    if( aCurrentTool == ID_TRACK_BUTT || amMovingVia )
    {
        int q = CAPTURE_CURSOR_IN_TRACK_TOOL;

        if( frame->Settings().m_magneticPads == q )
            doPad = true;

        if( frame->Settings().m_magneticTracks == q )
            doTrack = true;
    }

    //  The search precedence order is pads, then tracks/vias
    if( doPad )
    {
        D_PAD*  pad;
        if( doCheckLayer )
            pad = m_Pcb->GetPad( pos, LSET( screen->m_Active_Layer ) );
        else
            pad = m_Pcb->GetPad( pos );

        if( pad )
        {
            if( doCheckNet && currTrack && currTrack->GetNetCode() != pad->GetNetCode() )
                return false;

            *curpos = pad->GetPosition();
            return true;
        }
    }

    // after pads, only track & via tests remain, skip them if not desired
    if( doTrack )
    {
        PCB_LAYER_ID layer = screen->m_Active_Layer;

        for( TRACK* via = m_Pcb->m_Track;
                via && (via = via->GetVia( *curpos, layer )) != NULL;
                via = via->Next() )
        {
            if( via != currTrack )   // a via cannot influence itself
            {
                if( !doCheckNet || !currTrack || currTrack->GetNetCode() == via->GetNetCode() )
                {
                    *curpos = via->GetStart();
                    // D(printf("via hit\n");)
                    return true;
                }
            }
        }

        if( !currTrack )
        {
            LSET layers( layer );

            TRACK* track = m_Pcb->GetVisibleTrack( m_Pcb->m_Track, pos, layers );

            if( !track || track->Type() != PCB_TRACE_T )
            {
                return false;
            }

            return FindBestGridPointOnTrack( curpos, on_grid, track );
        }

        /*
         * In two segment mode, ignore the final segment if it's inside a grid square.
         */
        if( !amMovingVia && currTrack && frame->Settings().m_legacyUseTwoSegmentTracks && currTrack->Back()
            && currTrack->GetStart().x - aGridSize.x < currTrack->GetEnd().x
            && currTrack->GetStart().x + aGridSize.x > currTrack->GetEnd().x
            && currTrack->GetStart().y - aGridSize.y < currTrack->GetEnd().y
            && currTrack->GetStart().y + aGridSize.y > currTrack->GetEnd().y )
        {
            currTrack = currTrack->Back();
        }


        for( TRACK* track = m_Pcb->m_Track; track; track = track->Next() )
        {
            if( track->Type() != PCB_TRACE_T )
                continue;

            if( doCheckNet && currTrack && currTrack->GetNetCode() != track->GetNetCode() )
                continue;

            if( m_Pcb->IsLayerVisible( track->GetLayer() ) == false )
                continue;

            // omit the layer check if moving a via
            if( !amMovingVia && !track->IsOnLayer( layer ) )
                continue;

            if( !track->HitTest( *curpos ) )
                continue;

            if( Join( curpos, track->GetStart(), track->GetEnd(), currTrack->GetStart(), currTrack->GetEnd() ) )
            {
                return true;
            }

            if( aCurrentTool == ID_TRACK_BUTT || amMovingVia )
            {
                // At this point we have a drawing mouse on a track, we are drawing
                // a new track and that new track is parallel to the track the
                // mouse is on. Find the nearest end point of the track under mouse
                // to the mouse and return that.
                double distStart = GetLineLength( *curpos, track->GetStart() );
                double distEnd   = GetLineLength( *curpos, track->GetEnd() );

                // if track not via, or if its a via dragging but not with its adjacent track
                if( currTrack->Type() != PCB_VIA_T ||
                    ( currTrack->GetStart() != track->GetStart() && currTrack->GetStart() != track->GetEnd() ))
                {
                    double max_dist = currTrack->GetWidth() / 2.0f;

                    if( distStart <= max_dist )
                    {
                        // D(printf("nearest end is start\n");)
                        *curpos = track->GetStart();
                        return true;
                    }

                    if( distEnd <= max_dist )
                    {
                        // D(printf("nearest end is end\n");)
                        *curpos = track->GetEnd();
                        return true;
                    }

                    // @todo otherwise confine curpos such that it stays centered within "track"
                }
            }
        }
    }

    return false;
}