wire.cpp

Go to the documentation of this file.

/*! \file canvas/src/wire.cpp
    \author Michael S�trop

    Copyright: 2003-2004 (c) Michael S�trop

    Licence: wxWidgets Licence

    RCS-ID: $Id: wire.cpp,v 1.71 2008/11/09 11:16:53 bionic-badger Exp $
*/

#include "a2dprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#ifndef WX_PRECOMP
    #include "wx/wx.h"
#endif

#include "wx/canvas/polygon.h"

#include "wx/canvas/wire.h"

#include <float.h>
#include "wx/canvas/canobj.h"
#include "wx/canvas/candoc.h"
#include "wx/canvas/drawer.h"
#include "wx/canvas/cancom.h"
#include "wx/canvas/canvas.h"
#include "wx/canvas/tools.h"
#include "wx/canvas/canglob.h"

//#include "wx/genart/prfl.h"
//#include "wx/genart/prfltmr.h"
//#include "wx/genart/prflcntmean.h"
//#include "wx/genart/prflenbl.h"

//#define DUMP_FINAL

IMPLEMENT_DYNAMIC_CLASS(a2dWirePolylineL, a2dPolylineL)
IMPLEMENT_DYNAMIC_CLASS(a2dWireEnd, a2dCanvasObject)
IMPLEMENT_CLASS( a2dRouteData, a2dObject );

double a2dRouteData::m_raster = 4;

a2dRouteData::BorderQueue::BorderQueue()
{
    m_mincostindex = 0;
    memset( m_costring, 0, sizeof( m_costring ) );
    m_freelist = 0;
    m_memory = new AllocBlock();
    m_memory->m_next = 0;
    m_freememory = 0;
    #ifdef _DEBUG
        m_mincost = 0;
    #endif
    #ifdef PRFL_ENBL
        m_count = 0;
    #endif
}

a2dRouteData::BorderQueue::~BorderQueue()
{
    AllocBlock *current, *next;

    for( current = m_memory; current; current = next )
    {
        next = current->m_next;
        delete current;
    }
}

void a2dRouteData::BorderQueue::Add( const BorderPoint &brdr )
{
    #ifdef PRFL_ENBL
        m_count++;
    #endif

    // Allocate memory
    BorderPoint *newobjc;

    if( m_freelist )
    {
        // an object in the free list
        newobjc = m_freelist;
        m_freelist = m_freelist->m_next;
    }
    else if( m_freememory < AllocBlock::m_pointsperblock )
    {
        // an object in the allocation block
        newobjc = m_memory->m_memory + m_freememory;
        m_freememory ++;
    }
    else
    {
        // create new allocation block
        AllocBlock *newblock = new AllocBlock();
        newblock->m_next = m_memory;
        m_memory = newblock;
        newobjc = m_memory->m_memory;
        m_freememory = 1;
    }

    // insert into allocation ring
    *newobjc = brdr;
    #ifdef _DEBUG
        wxASSERT( brdr.m_cost - m_mincost < m_ncost );
    #endif
    int index = brdr.m_cost & m_costmask;
    newobjc->m_next = m_costring[index];
    m_costring[index] = newobjc;

    if( !m_costring[ m_mincostindex ] )
    {
        // This happens only the first time
        #ifdef _DEBUG
            wxASSERT( m_mincostindex == 0 && m_mincost == 0 );
        #endif
        m_mincostindex = index;
        #ifdef _DEBUG
            m_mincost = brdr.m_cost;
        #endif
    }
}

void a2dRouteData::BorderQueue::RmvBest()
{
    #ifdef PRFL_ENBL
        m_count--;
    #endif

    // Get and remove best object
    BorderPoint *obj = m_costring[ m_mincostindex ];
    wxASSERT( obj );
    m_costring[ m_mincostindex ] = obj->m_next;
    // Insert into free list
    obj->m_next = m_freelist;
    m_freelist = obj;
    // Increent cost
    if( !m_costring[ m_mincostindex ] )
    {
        unsigned int i;
        for( i = m_mincostindex; i < m_ncost; i++ )
        {
            if( m_costring[ i ] )
                goto found;
        }

        for( i = 0; i < m_mincostindex; i++ )
        {
            if( m_costring[ i ] )
                goto found;
        }

        // Queue is empty
        m_mincostindex = 0;
        #ifdef _DEBUG
            m_mincost = 0;
        #endif
        return;

        found:;
        m_mincostindex = i;
        #ifdef _DEBUG
            wxASSERT( m_costring[ m_mincostindex ] );
            wxASSERT( m_costring[ m_mincostindex ]->m_cost > m_mincost );
            wxASSERT( ( m_costring[ m_mincostindex ]->m_cost & m_costmask ) == m_mincostindex );
            m_mincost = m_costring[ m_mincostindex ]->m_cost;
        #endif
    }
}

a2dRouteData::a2dRouteData( a2dCanvasObject *showobject, bool final )
{
    //PRFL_AUTO_TMR( RerouteInit );

    #ifdef DUMP_FINAL
        m_dump = fopen("Routerdump.txt", "w");
    #endif

    m_ok = true;
    m_showobject = showobject;

    // Determine the raster size
    a2dBoundingBox bbox;

    // Go through all direct childs of the show object and add them to the bounding box
    a2dCanvasObjectList::iterator iter;
    for( iter = m_showobject->GetChildObjectList()->begin(); iter != m_showobject->GetChildObjectList()->end(); ++iter )
    {
        a2dCanvasObject *obj = (*iter);

        // toolobjects are not considered directly
        // but if they are the editcopy of another object, they are
        if( a2dCanvasObject::PROPID_ToolObject->GetPropertyValue( obj ) )
            continue;

        a2dCanvasObject *editcopy = a2dCanvasObject::PROPID_Editcopy->GetPropertyValue( obj );
        if( !final && editcopy )
            obj = editcopy;

        a2dBoundingBox objbbox = CalculateRoutingBbox( obj );
        bbox.Expand( objbbox );

        // wxLogDebug("Objc %d %p %p %lg %lg %lg %lg %s", final, obj, editcopy, objbbox.GetMinX(), objbbox.GetMaxX(), objbbox.GetMinY(), objbbox.GetMaxY(), obj->GetClassInfo()->GetClassName() );
    }

    m_rasterborder = 20;
    bbox.Enlarge( m_rasterborder );

    m_rasterinv = 1.0/m_raster;
    m_rasterminx = (int) floor( bbox.GetMinX() * m_rasterinv );
    m_rastermaxx = (int) ceil( bbox.GetMaxX() * m_rasterinv );
    m_rasterminy = (int) floor( bbox.GetMinY() * m_rasterinv );
    m_rastermaxy = (int) ceil( bbox.GetMaxY() * m_rasterinv );

    // wxLogDebug("BBox %d %lg %lg %lg %lg", final, m_rasterminx, m_rastermaxx, m_rasterminy, m_rastermaxy );

    // Limit raster size to something reasonable
    if( m_rastermaxx - m_rasterminx > 10000 )
    {
        m_ok = false;
        return;
    }
    if( m_rastermaxy - m_rasterminy > 10000 )
    {
        m_ok = false;
        return;
    }

    // Allocate and clear memory
    m_width = m_rastermaxx - m_rasterminx;
    m_widthp1 = m_width + 1;
    m_height = m_rastermaxy - m_rasterminy;
    m_heightp1 = m_height + 1;

    m_verticaloccupation = new unsigned short[ m_widthp1 * m_heightp1 ];
    m_horizontaloccupation = new unsigned short[ m_widthp1 * m_heightp1 ];
    m_routepoints = new RoutePoint[ m_widthp1 * m_heightp1 * dir_count ];

    if( !m_verticaloccupation || !m_horizontaloccupation || !m_routepoints )
    {
        m_ok = false;
        return;
    }

    memset( m_verticaloccupation, 0, m_widthp1 * m_heightp1 * sizeof( *m_verticaloccupation ) );
    memset( m_horizontaloccupation, 0, m_widthp1 * m_heightp1 * sizeof( *m_horizontaloccupation ) );
    memset( m_routepoints, 0, m_widthp1 * m_heightp1 * dir_count * sizeof( *m_routepoints ) );

    //PRFL_CNT_MEAN( RerouteInitSize, m_widthp1 * m_heightp1 );

    // Go through all direct childs of the show object and add them to the occupation arrays
    for( iter = m_showobject->GetChildObjectList()->begin(); iter != m_showobject->GetChildObjectList()->end(); ++iter )
    {
        a2dCanvasObject *obj = (*iter);
        // toolobjects are not considered directly
        // but if they are the editcopy of another object, they are
        if( a2dCanvasObject::PROPID_ToolObject->GetPropertyValue( obj ) )
            continue;

        a2dCanvasObject *editcopy = a2dCanvasObject::PROPID_Editcopy->GetPropertyValue( obj );
        if( !final && editcopy )
            obj = editcopy;

        // wires that are to be rerouted are also not added
        if( a2dWirePolylineL::PROPID_Reroute->GetPropertyValue( obj ) )
        {
            obj->RemoveProperty( a2dWirePolylineL::PROPID_Rerouteadded );
            continue;
        }

        if( wxDynamicCast( obj, a2dPolygonL ) )
        {
            AddOccupationPolyline( wxStaticCast( obj, a2dPolygonL )->GetSegments(), obj->GetTransformMatrix(), 1 );
        }
        else
        {
            a2dBoundingBox bbox = CalculateRoutingBbox( obj );
            AddOccupationRect( bbox, 1 );
        }
    }

    #ifdef DUMP_FINAL
        if( final )
        {
            fprintf( m_dump, "Route init\n" );
            DumpOccupation( m_dump );
        }
    #endif
}

a2dRouteData::~a2dRouteData()
{
    delete [] m_verticaloccupation;
    delete [] m_horizontaloccupation;
    delete [] m_routepoints;
    #ifdef DUMP_FINAL
        //fclose( m_dump );
    #endif
}

// WX_DEFINE_SORTED_ARRAY( a2dRouteData::BorderPoint*, BorderQueue );

void a2dRouteData::AddBorderPoint(
    BorderQueue *queue, RoutePoint *current,
    int nextx, int nexty,
    int dir, int prevdir
)
{
    //PRFL_AUTO_TMR( AddBorderPoint );
    //PRFL_CNT_MEAN( AddBorderPointC, queue->m_count );

    wxASSERT( nextx>=0 && nextx<=m_width );
    wxASSERT( nexty>=0 && nexty<=m_height );
    wxASSERT( dir>=dir_min && dir<=dir_max );
    wxASSERT( prevdir>=dir_min && prevdir<=dir_max );

    RoutePoint *next = &GetRoutePoint( nextx, nexty, dir );
    if( next->m_flags & flag_reachable )
    {
        return;
    }

    // Don't go back to where we came from
    if( ( dir^prevdir ) == dir_invxor )
    {
        return;
    }

    BorderPoint border;

    border.m_x = nextx;
    border.m_y = nexty;
    border.m_direction = dir;
    border.m_prevdir = prevdir;

    border.m_cost = current->m_cost;

    if( next->m_flags & flag_original )
    {
        // general path cost for points along the original wire
        border.m_cost += 1;
    }
    else
    {
        // general path cost for points not along the original wire
        border.m_cost += 3;
    }

    // extra path cost for corners
    if(
        // either point is non-original
        !( ( current->m_flags & flag_original ) && ( next->m_flags & flag_original ) ) &&
        // and this is a corner
        current->m_direction != border.m_direction
    )
    {
        border.m_cost += 10;
    }

    // extra path cost for crossing occupied areas
    if( IsHorizontalOccupied( nextx, nexty ) || IsVerticalOccupied( nextx, nexty ) )
    {
        border.m_cost += 10;
    }

    queue->Add( border );
}

bool a2dRouteData::RerouteWire( a2dWirePolylineL *wire, a2dPin *dispin, a2dPin *startpin, bool startisbegin, bool final )
{
    // Note on parameteres:
    // startpin may be Null if a wire was half routed

    // wxLogDebug("Route %p %d", wire, wire->GetSegments()->GetCount() );

    //PRFL_AUTO_TMR( RerouteWire );
    if( !m_ok )
    {
        return false;
    }

    // Clear routing point data
    memset( m_routepoints, 0, m_widthp1 * m_heightp1 * dir_count * sizeof( *m_routepoints ) );

/*  This is for dumping the last pre-final and the final route
    After the first routing you have 2 seconds to get close to final, then after
    2 seconds make a final move and release the mouse
    static clock_t start = clock();
    if( clock()-start > 2000 || final )
    {
        wxLogDebug("Route %p %d", wire, final );
        DumpOccupation();
    }
*/

    #ifdef DUMP_FINAL
        if( final )
        {
            fprintf( m_dump, "Route Final 1 %p %d\n", wire, wire->GetSegments()->GetCount() );
            DumpOccupation( m_dump );
        }
    #endif

    //PRFL_BGN_TMR( RerouteWireInit );
    // Set the original flags for all points on the wire
    SetFlagPolyline( wire->GetSegments(), wire->GetTransformMatrix(), flag_original );

    // Set the wire as not occupied
    if( a2dWirePolylineL::PROPID_Rerouteadded->GetPropertyValue( wire ) )
    {
        AddOccupationPolyline( wire->GetSegments(), wire->GetTransformMatrix(), -1 );
    }

    a2dBoundingBox bboxStartPin;
    a2dBoundingBox bboxDisPin;

    //if a connected pin is internal, make sure that the parent of that object is not occupied.
    //This here works for original and editcopies, because for editcopies a a2dWireEnd,
    //instead of the real object which is there,
    //is added at the ends of the non editing objects which are indirectly connected via wires.
    //Wires itself are already non occupied.
    //In case of a a2dWireEnd the original object is found via the property PROPID_Original.
    if ( startpin && startpin->ConnectedTo() && startpin->ConnectedTo()->IsInternal() )
    {
        a2dWireEnd* end = wxDynamicCast( startpin->ConnectedTo()->GetParent(), a2dWireEnd );
        if ( end )
        {
            a2dCanvasObject* org = a2dCanvasObject::PROPID_Original->GetPropertyValue( startpin->ConnectedTo()->GetParent() );
            bboxStartPin = CalculateRoutingBbox( org );
        }
        else
        {
            bboxStartPin = CalculateRoutingBbox( startpin->ConnectedTo()->GetParent() );
        }
        AddOccupationRect( bboxStartPin, -1 );
    }

    if ( dispin->ConnectedTo() && dispin->ConnectedTo()->IsInternal() )
    {
        a2dWireEnd* end = wxDynamicCast( dispin->ConnectedTo()->GetParent(), a2dWireEnd );
        if ( end )
        {
            a2dCanvasObject* org = a2dCanvasObject::PROPID_Original->GetPropertyValue( dispin->ConnectedTo()->GetParent() );
            bboxDisPin = CalculateRoutingBbox( org );
        }
        else
        {
            bboxDisPin = CalculateRoutingBbox( dispin->ConnectedTo()->GetParent() );
        }
        AddOccupationRect( bboxDisPin, -1 );
    }

    // Check if the target is a wire
    if( wxDynamicCast( dispin->ConnectedTo()->GetParent(), a2dWirePolylineL ) )
    {
        // Target is a wire
        a2dWirePolylineL *target = wxStaticCast( dispin->ConnectedTo()->GetParent(), a2dWirePolylineL );

        SetFlagPolyline( target->GetSegments(), target->GetTransformMatrix(), flag_targetwire );
    }
    else if( startpin && startpin->ConnectedTo() && wxDynamicCast( startpin->ConnectedTo()->GetParent(), a2dWirePolylineL ) )
    {
        // we start on a wire to an object, so routing in reverse direction is usually better
        // because we have more freedom, so swap the route
        a2dPin *h;
        h = dispin;
        dispin = startpin;
        startpin = h;
        startisbegin = !startisbegin;

        a2dWirePolylineL *target = wxStaticCast( dispin->ConnectedTo()->GetParent(), a2dWirePolylineL );

        // The startpin is dislocated, so first relocate it
        // Get the wire local coordinate of the new position of the start pin
        a2dPoint2D newstartpos = startpin->ConnectedTo()->GetAbsXY();
        a2dAffineMatrix trns = wire->GetTransformMatrix();
        trns.Invert();
        trns.TransformPoint( &newstartpos );
        // Set this position to the start pin
        if ( target->GetCanvasDocument()->GetCommandProcessor() )
            target->GetCanvasDocument()->GetCommandProcessor()->Submit(
                        new a2dCommand_SetCanvasProperty( startpin, a2dCanvasObject::PROPID_Position, newstartpos, -1, true ), final );
        else
            startpin->SetPosXyPoint( newstartpos );


        SetFlagPolyline( target->GetSegments(), target->GetTransformMatrix(), flag_targetwire );
    }

    // Check if the target pin is at an exact grid location
    a2dPoint2D targetpos = dispin->ConnectedTo()->GetAbsXY();

    if(
        floor( targetpos.m_x * m_rasterinv ) * m_raster == targetpos.m_x &&
        floor( targetpos.m_y * m_rasterinv ) * m_raster == targetpos.m_y
    )
    {
        // Pin is at exact raster location
        int x = (int) floor( ( targetpos.m_x + 0.5*m_raster ) * m_rasterinv ) - m_rasterminx;
        int y = (int) floor( ( targetpos.m_y + 0.5*m_raster ) * m_rasterinv ) - m_rasterminy;
        SetFlagRoutePointAllDirs( x, y, flag_targetpin );
    }
    else
    {
        // Approximate raster location
        int x1 = (int) floor( targetpos.m_x * m_rasterinv ) - m_rasterminx;
        int y1 = (int) floor( targetpos.m_y * m_rasterinv ) - m_rasterminy;
        int x2 = (int) ceil( targetpos.m_x * m_rasterinv ) - m_rasterminx;
        int y2 = (int) ceil( targetpos.m_y * m_rasterinv ) - m_rasterminy;
        SetFlagRoutePointAllDirs(x1, y1, flag_targetapprox);
        SetFlagRoutePointAllDirs(x2, y1, flag_targetapprox);
        SetFlagRoutePointAllDirs(x1, y2, flag_targetapprox);
        SetFlagRoutePointAllDirs(x2, y2, flag_targetapprox);
    }

    #ifdef DUMP_FINAL
        if( final )
        {
            fprintf( m_dump, "Route Final 2 %p %d\n", wire, wire->GetSegments()->GetCount() );
            DumpOccupation( m_dump );
        }
    #endif

    // Start routing
    a2dPoint2D startpos;
    if( !startpin )
    {
        // There might be no startpin when a wire is dangling
        // In this case use wire vertex coordinates
        startpos = startisbegin ? wire->GetSegments()->front()->GetPoint() : wire->GetSegments()->back()->GetPoint();
        wire->GetTransformMatrix().TransformPoint( &startpos );
    }
    else
    {
        startpos = startpin->GetAbsXY();
    }

    int startx = (int) floor( ( startpos.m_x + 0.5*m_raster ) * m_rasterinv ) - m_rasterminx;
    int starty = (int) floor( ( startpos.m_y + 0.5*m_raster ) * m_rasterinv ) - m_rasterminy;

    BorderQueue queue;

    for( int dir=dir_min; dir<=dir_max; dir++ )
    {
        BorderPoint start;
        start.m_x = startx;
        start.m_y = starty;
        start.m_direction = dir;
        start.m_prevdir = dir_start;
        start.m_cost = 0;

        queue.Add( start );
    }

    RoutePoint *end = 0;

    //PRFL_END_TMR( RerouteWireInit );

    while( queue.IsNotEmpty())
    {
        // Get current minimum cost point
        const BorderPoint &border = queue.GetBest();

        RoutePoint *point = &GetRoutePoint( border.m_x, border.m_y, border.m_direction );

        if( point->m_flags & flag_reachable )
        {
            // The point was already reached at lower cost
            queue.RmvBest();
            continue;
        }

        point->m_x = border.m_x;
        point->m_y = border.m_y;
        point->m_direction = border.m_direction;
        point->m_prevdir = border.m_prevdir;
        point->m_cost = border.m_cost;

        // Check if we reached a target point
        if( point->m_flags & ( flag_targetwire | flag_targetpin | flag_targetapprox ) )
        {
            // Ok, target reached
            end = point;
            break;
        }

        // Check occupation of this point depending on direction
        if( border.m_prevdir != dir_start )
        {
            switch( border.m_direction )
            {
            case dir_xminus:
            case dir_xplus:
                if( IsHorizontalOccupied( border.m_x, border.m_y ) )
                {
                    // The point is occupied in this direction
                    queue.RmvBest();
                    continue;
                }
                break;
            case dir_yminus:
            case dir_yplus:
                if( IsVerticalOccupied( border.m_x, border.m_y ) )
                {
                    // The point is occupied in this direction
                    queue.RmvBest();
                    continue;
                }
                break;
            }
        }

        // the point is reachable
        point->m_flags |= flag_reachable;

        //PRFL_BGN_TMR( RerouteWireAddBlock );

        if( !IsVerticalOccupied( point->m_x, point->m_y ) || border.m_prevdir == dir_start )
        {
            // Check going into Y- (top) direction
            // The dir_xxx given is the direction of source viewed from the target, so it is inverse
            if( point->m_y > 0 )
            {
                AddBorderPoint(
                    &queue, point,
                    point->m_x, point->m_y-1,
                    dir_yplus, point->m_direction
                );
            }

            // Check going into Y+ (bottom) direction
            // The dir_xxx given is the direction of source viewed from the target, so it is inverse
            if( point->m_y < m_height )
            {
                AddBorderPoint(
                    &queue, point,
                    point->m_x, point->m_y+1,
                    dir_yminus, point->m_direction
                );
            }
        }

        if( !IsHorizontalOccupied( point->m_x, point->m_y ) || border.m_prevdir == dir_start  )
        {
            // Check going into X- (left) direction
            // The dir_xxx given is the direction of source viewed from the target, so it is inverse
            if( point->m_x > 0 )
            {
                AddBorderPoint(
                    &queue, point,
                    point->m_x-1, point->m_y,
                    dir_xplus, point->m_direction
                );
            }

            // Check going into X+ (right) direction
            // The dir_xxx given is the direction of source viewed from the target, so it is inverse
            if( point->m_x < m_width )
            {
                AddBorderPoint(
                    &queue, point,
                    point->m_x+1, point->m_y,
                    dir_xminus, point->m_direction
                );
            }
        }

        //PRFL_END_TMR( RerouteWireAddBlock );

        wxASSERT( &queue.GetBest() == &border );
        queue.RmvBest();
    }

    // queue.Clear();

    #ifdef DUMP_FINAL
        if( final )
        {
            fprintf( m_dump, "Route Final 3 %p %d\n", wire, wire->GetSegments()->GetCount() );
            DumpOccupation( m_dump );
        }
    #endif

    if ( bboxStartPin.GetValid() )
    {
        AddOccupationRect( bboxStartPin, 1 );
    }

    if ( bboxDisPin.GetValid() )
    {
        AddOccupationRect( bboxDisPin, 1 );
    }

    if( !end )
    {
        // Target not reached => create a straight line wire
        a2dVertexList *newpoints = new a2dVertexList;
        if( startisbegin )
        {
            newpoints->push_back( new a2dLineSegment( startpos ) );
            newpoints->push_back( new a2dLineSegment( targetpos ) );
        }
        else
        {
            newpoints->push_back( new a2dLineSegment( targetpos ) );
            newpoints->push_back( new a2dLineSegment( startpos ) );
        }
        // Adjust the existing vertex list to the new vertex list
        if ( wire->GetCanvasDocument()->GetCommandProcessor() )
            wire->GetCanvasDocument()->GetCommandProcessor()->Submit( new a2dCommand_SetSegments( wire, newpoints, true ), final );
        else
            wire->SetSegments( newpoints );

        // Set the wire as occupied
        AddOccupationPolyline( wire->GetSegments(), wire->GetTransformMatrix(), 1 );
        a2dWirePolylineL::PROPID_Rerouteadded->SetPropertyToObject( wire, true );
        return false;
    }
    else
    {
        // Create a new vertex list for the wire
        a2dVertexList *newpoints = new a2dVertexList;
        RoutePoint *current = end;
        int prevdir = -1;

        a2dPoint2D endpoint( ( current->m_x + m_rasterminx ) * m_raster, ( current->m_y + m_rasterminy ) * m_raster );

        if( end->m_flags & flag_targetapprox )
        {
            // Target is only approximate, so add a point at the real target
            if( startisbegin )
                newpoints->push_front( new a2dLineSegment( targetpos ) );
            else
                newpoints->push_back( new a2dLineSegment( targetpos ) );

            // Add extra point, to avoid 45 degree line pieces
            a2dLineSegment *p = NULL;
            a2dPoint2D point( ( current->m_x + m_rasterminx ) * m_raster, ( current->m_y + m_rasterminy ) * m_raster );
            if (current->m_direction == dir_xminus || current->m_direction == dir_xplus )
            {
                if ( point.m_y != targetpos.m_y )
                    p = new a2dLineSegment( targetpos.m_x, point.m_y );
                prevdir = current->m_direction;
            }
            else if (current->m_direction == dir_yminus || current->m_direction == dir_yplus )
            {
                if ( point.m_x != targetpos.m_x )
                    p = new a2dLineSegment( point.m_x, targetpos.m_y );
                prevdir = current->m_direction;
            }
            if ( p )
            {
                if( startisbegin )
                    newpoints->push_front( p );
                else
                    newpoints->push_back( p );
            }
        }
        else if( end->m_flags & flag_targetwire )
        {
            // Target is a wire, which might also be approximate
            // We also need to shift around the dynamic pin
            a2dWirePolylineL *targetwire = wxStaticCast( dispin->ConnectedTo()->GetParent(), a2dWirePolylineL );
            targetwire->MoveDynamicPinCloseTo( dispin->ConnectedTo(), endpoint, final );

            // If this doesn't fit exactly, insert a line
            a2dPoint2D dispinpos = dispin->ConnectedTo()->GetAbsXY();

            if( dispinpos != endpoint )
            {
                if( startisbegin )
                    newpoints->push_front( new a2dLineSegment( dispinpos ) );
                else
                    newpoints->push_back( new a2dLineSegment( dispinpos ) );

                // Add extra point, to avoid 45 degree line pieces
                a2dLineSegment *p = NULL;
                a2dPoint2D point( ( current->m_x + m_rasterminx ) * m_raster, ( current->m_y + m_rasterminy ) * m_raster );
                if (current->m_direction == dir_xminus || current->m_direction == dir_xplus )
                {
                    if ( point.m_y != dispinpos.m_y )
                        p = new a2dLineSegment( dispinpos.m_x, point.m_y );
                    prevdir = current->m_direction;
                }
                else if (current->m_direction == dir_yminus || current->m_direction == dir_yplus )
                {
                    if ( point.m_x != dispinpos.m_x )
                        p = new a2dLineSegment( point.m_x, dispinpos.m_y );
                    prevdir = current->m_direction;
                }
                if ( p )
                {
                    if( startisbegin )
                        newpoints->push_front( p );
                    else
                        newpoints->push_back( p );
                }
            }
        }

        for(;;)
        {
            current->m_flags |= flag_final;

            a2dLineSegment point( ( current->m_x + m_rasterminx ) * m_raster, ( current->m_y + m_rasterminy ) * m_raster );

            if( current->m_prevdir == dir_start )
            {   //reached the special marked point, with direction dir_start.
                if( startisbegin )
                    newpoints->push_front( new a2dLineSegment( point ) );
                else
                    newpoints->push_back( new a2dLineSegment( point ) );

                // at the beginning the startpin location was rounded to the grid.
                // if the startpin was not on the grid, add an extra segment to reach it.
                if( startpin &&
                    floor( point.m_x * m_rasterinv ) * m_raster == startpin->GetPosX() &&
                    floor( point.m_y * m_rasterinv ) * m_raster == startpin->GetPosY()
                )
                    //DONE reconstruction of wire from routing points.
                    break;
                else
                {
                    if( startisbegin )
                        newpoints->push_front( new a2dLineSegment( startpin->GetPosX(), startpin->GetPosY()) );
                    else
                        newpoints->push_back( new a2dLineSegment( startpin->GetPosX(), startpin->GetPosY()) );
                }
                //DONE reconstruction of wire from routing points.
                break;
            }

            if( current->m_direction != prevdir )
            {
                if( startisbegin )
                    newpoints->push_front( new a2dLineSegment( point ) );
                else
                    newpoints->push_back( new a2dLineSegment( point ) );
                prevdir = current->m_direction;
            }

            int x = current->m_x;
            int y = current->m_y;
            switch( current->m_direction )
            {
            case dir_xminus:
                x--;
                break;
            case dir_xplus:
                x++;
                break;
            case dir_yminus:
                y--;
                break;
            case dir_yplus:
                y++;
                break;
            }

            current = &GetRoutePoint( x, y, current->m_prevdir );
        }

        // Adjust the existing vertex list to the new vertex list
        if ( wire->GetCanvasDocument()->GetCommandProcessor() )
            wire->GetCanvasDocument()->GetCommandProcessor()->Submit( new a2dCommand_SetSegments( wire, newpoints, true ), final );
        else
            wire->SetSegments( newpoints );

        // Set the wire as occupied
        AddOccupationPolyline( wire->GetSegments(), wire->GetTransformMatrix(), 1 );
        a2dWirePolylineL::PROPID_Rerouteadded->SetPropertyToObject( wire, true );

        #ifdef DUMP_FINAL
            if( final )
            {
                fprintf( m_dump, "Route Final 4 %p %d\n", wire, wire->GetSegments()->GetCount() );
                DumpOccupation( m_dump );
            }
        #endif

        return true;
    }
}

void a2dRouteData::AddOccupationRect( const a2dBoundingBox &bbox, short incr )
{
    int minx = (int) floor( ( bbox.GetMinX() + 0.75 * m_raster ) * m_rasterinv );
    int maxx = (int) ceil ( ( bbox.GetMaxX() - 0.75 * m_raster ) * m_rasterinv );
    int miny = (int) floor( ( bbox.GetMinY() + 0.75 * m_raster ) * m_rasterinv );
    int maxy = (int) ceil ( ( bbox.GetMaxY() - 0.75 * m_raster ) * m_rasterinv );

    if( minx < m_rasterminx ) minx = m_rasterminx;
    if( maxx > m_rastermaxx ) maxx = m_rastermaxx;
    if( miny < m_rasterminy ) miny = m_rasterminy;
    if( maxy > m_rastermaxy ) maxy = m_rastermaxy;

    int minxi = ( minx-m_rasterminx );
    int maxxi = ( maxx-m_rasterminx );
    int minyi = ( miny-m_rasterminy );
    int maxyi = ( maxy-m_rasterminy );

    int x,y;

    for( y=minyi; y<=maxyi; y++ )
    {
        for( x=minxi; x<=maxxi; x++ )
        {
            unsigned short& h = GetHorizontalOccupation( x, y );
            unsigned short& v = GetVerticalOccupation( x, y );
            if ( incr < 0 )
            {
                wxASSERT( h >= -incr &&  v >= -incr );
            }
            h += incr;
            v += incr;
        }
    }
}

void a2dRouteData::AddOccupationPolyline( const a2dVertexList *points, const a2dAffineMatrix &trns, short incr )
{
    a2dVertexList::const_iterator iter = points->begin();
    a2dVertexList::const_iterator prev = iter;
    iter++;

    for( ; iter != points->end(); ++iter )
    {
        double x1l = (*prev)->m_x;
        double y1l = (*prev)->m_y;
        double x2l = (*iter)->m_x;
        double y2l = (*iter)->m_y;
        double x1,y1,x2,y2;

        trns.TransformPoint( x1l, y1l, x1, y1 );
        trns.TransformPoint( x2l, y2l, x2, y2 );

        int minx = (int) floor( ( wxMin( x1, x2 ) + 0.5 * m_raster ) * m_rasterinv );
        int maxx = (int) ceil ( ( wxMax( x1, x2 ) - 0.5 * m_raster ) * m_rasterinv );
        int miny = (int) floor( ( wxMin( y1, y2 ) + 0.5 * m_raster ) * m_rasterinv );
        int maxy = (int) ceil ( ( wxMax( y1, y2 ) - 0.5 * m_raster ) * m_rasterinv );

        if( minx < m_rasterminx ) minx = m_rasterminx;
        if( maxx > m_rastermaxx ) maxx = m_rastermaxx;
        if( miny < m_rasterminy ) miny = m_rasterminy;
        if( maxy > m_rastermaxy ) maxy = m_rastermaxy;

        int minxi = ( minx-m_rasterminx );
        int maxxi = ( maxx-m_rasterminx );
        int minyi = ( miny-m_rasterminy );
        int maxyi = ( maxy-m_rasterminy );

        if( minxi == maxxi )
        {
            // vertical line
            for( int y=minyi; y<=maxyi; y++ )
            {
                GetVerticalOccupation( minxi, y ) += incr;
            }
        }
        else if( minyi == maxyi )
        {
            // horizontal line
            for( int x=minxi; x<=maxxi; x++ )
            {
                GetHorizontalOccupation( x, minyi ) += incr;
            }
        }
        // Diagonal lines don't accupy anything

        prev = iter;
    }
}

void a2dRouteData::SetFlagRect( const a2dBoundingBox &bbox, RoutePointFlag flag )
{
    int minx = (int) floor( ( bbox.GetMinX() + 0.5 * m_raster ) * m_rasterinv );
    int maxx = (int) ceil ( ( bbox.GetMaxX() - 0.5 * m_raster ) * m_rasterinv );
    int miny = (int) floor( ( bbox.GetMinY() + 0.5 * m_raster ) * m_rasterinv );
    int maxy = (int) ceil ( ( bbox.GetMaxY() - 0.5 * m_raster ) * m_rasterinv );

    if( minx < m_rasterminx ) minx = m_rasterminx;
    if( maxx > m_rastermaxx ) maxx = m_rastermaxx;
    if( miny < m_rasterminy ) miny = m_rasterminy;
    if( maxy > m_rastermaxy ) maxy = m_rastermaxy;

    int minxi = ( minx-m_rasterminx );
    int maxxi = ( maxx-m_rasterminx );
    int minyi = ( miny-m_rasterminy );
    int maxyi = ( maxy-m_rasterminy );

    int x,y;

    for( y=minyi; y<=maxyi; y++ )
    {
        for( x=minxi; x<=maxxi; x++ )
        {
            SetFlagRoutePointAllDirs( x, y, flag );
        }
    }
}

void a2dRouteData::SetFlagPolyline( const a2dVertexList *points, const a2dAffineMatrix &trns, RoutePointFlag flag )
{
    a2dVertexList::const_iterator iter = points->begin();
    a2dVertexList::const_iterator prev = iter;
    iter++;

    for( ; iter != points->end(); ++iter )
    {
        // klion: warning C4189: 'obj' : local variable is initialized but not referenced
        // a2dLineSegment *obj = (*iter);

        double x1l = (*prev)->m_x;
        double y1l = (*prev)->m_y;
        double x2l = (*iter)->m_x;
        double y2l = (*iter)->m_y;
        double x1,y1,x2,y2;

        trns.TransformPoint( x1l, y1l, x1, y1 );
        trns.TransformPoint( x2l, y2l, x2, y2 );

        //calculate the bbox of the line segment in raster coordinates.
        int minx = (int) floor( ( wxMin( x1, x2 ) + 0.5 * m_raster ) * m_rasterinv );
        int maxx = (int) ceil ( ( wxMax( x1, x2 ) - 0.5 * m_raster ) * m_rasterinv );
        int miny = (int) floor( ( wxMin( y1, y2 ) + 0.5 * m_raster ) * m_rasterinv );
        int maxy = (int) ceil ( ( wxMax( y1, y2 ) - 0.5 * m_raster ) * m_rasterinv );

        if( minx < m_rasterminx ) minx = m_rasterminx;
        if( maxx > m_rastermaxx ) maxx = m_rastermaxx;
        if( miny < m_rasterminy ) miny = m_rasterminy;
        if( maxy > m_rastermaxy ) maxy = m_rastermaxy;

        int minxi = ( minx-m_rasterminx );
        int maxxi = ( maxx-m_rasterminx );
        int minyi = ( miny-m_rasterminy );
        int maxyi = ( maxy-m_rasterminy );

        if( minxi == maxxi )
        {
            // vertical line
            for( int y=minyi; y<=maxyi; y++ )
            {
                SetFlagRoutePointAllDirs( minxi, y, flag );
            }
        }
        else if( minyi == maxyi )
        {
            // horizontal line
            for( int x=minxi; x<=maxxi; x++ )
            {
                SetFlagRoutePointAllDirs( x, minyi, flag );
            }
        }
        // Diagonal lines don't occupy anything

        prev = iter;
    }
}

a2dBoundingBox a2dRouteData::CalculateRoutingBbox( a2dCanvasObject *object )
{
    // This is not quite optimal.
    // It would probably be best to have a flag parameter to GetCalculatedBbox
    a2dBoundingBox box = object->GetUnTransformedBbox( false );

    forEachIn( a2dCanvasObjectList, object->GetChildObjectList() )
    {
        a2dCanvasObject *obj = *iter;
        if( !wxDynamicCast( obj, a2dPin ) )
        {
            box.Expand( obj->GetCalculatedBoundingBox( 0 ) );
        }
    }

    box.MapBbox( object->GetTransformMatrix() );

    return box;

}


void a2dRouteData::DumpOccupation( FILE *file )
{
#ifdef _DEBUG
    if( file )
        fprintf( file, "\nOccupation %d x %d\n", m_width, m_height);
    else
        wxLogDebug(_T("\nOccupation %d x %d"), m_width, m_height);

    int x,y;

    wxChar *buffer = new wxChar [ m_widthp1*2+1 ];
    wxChar *pos;

    for( y = 0; y <= m_height; y++ )
    {
        // First Dump horizontal edges and points
        pos = buffer;
        for( x = 0; x <= m_width; x++ )
        {
            unsigned short ho = GetHorizontalOccupation( x, y );
            unsigned short vo = GetVerticalOccupation( x, y );
            RoutePoint *point0 = &GetRoutePoint( x, y, 0 );
            RoutePoint *point1 = &GetRoutePoint( x, y, 1 );
            RoutePoint *point2 = &GetRoutePoint( x, y, 2 );
            RoutePoint *point3 = &GetRoutePoint( x, y, 3 );

            if( ho==0 && vo==0 )
                *pos++ = wxT('.');
            else if( ho==1 && vo==0 )
                *pos++ = wxT('-');
            else if( ho==0 && vo==1 )
                *pos++ = wxT('|');
            else if( ho==1 && vo==1 )
                *pos++ = wxT('x');
            else if( ho==2 && vo==0 )
                *pos++ = wxT('=');
            else if( ho==0 && vo==2 )
                *pos++ = wxT('"');
            else
                *pos++ = wxT('X');

            if(
                ( point0->m_flags & flag_final ) ||
                ( point1->m_flags & flag_final ) ||
                ( point2->m_flags & flag_final ) ||
                ( point3->m_flags & flag_final )
            )
                *pos++ = wxT('#');
            else if( point0->m_flags & flag_targetpin )
                *pos++ = wxT('P');
            else if( point0->m_flags & flag_targetapprox )
                *pos++ = wxT('A');
            else if( point0->m_flags & flag_targetwire )
                *pos++ = wxT('W');
            else if(
                ( point0->m_flags & flag_reachable ) ||
                ( point1->m_flags & flag_reachable ) ||
                ( point2->m_flags & flag_reachable ) ||
                ( point3->m_flags & flag_reachable )
            )
                *pos++ = wxT('R');
            else
                *pos++ = wxT(' ');
        }
        *pos++ = 0;
        if( file )
            fprintf( file, "%s\n", buffer );
        else
            wxLogDebug( buffer );
    }

    delete [] buffer;
#endif
}

void a2dRouteData::DumpCost()
{
#ifdef _DEBUG
    wxLogDebug(_T("\nCost"));
    int x,y;

    wxChar *buffer = new wxChar [ m_widthp1*3*2+1 ];
    wxChar *pos;

    for( y = 0; y <= m_height; y++ )
    {
        pos = buffer;
        for( x = 0; x <= m_width; x++ )
        {
            RoutePoint *point = &GetRoutePoint( x, y, dir_xminus );
            int val = point->m_cost;

            *pos++ = val/10%10 + wxT('0');
            *pos++ = val%10 + wxT('0');
            *pos++ = wxT(' ');

            point = &GetRoutePoint( x, y, dir_yminus );
            val = point->m_cost;

            *pos++ = val/10%10 + wxT('0');
            *pos++ = val%10 + wxT('0');
            *pos++ = wxT('|');
        }
        *pos++ = 0;
        wxLogDebug( buffer );

        pos = buffer;
        for( x = 0; x <= m_width; x++ )
        {
            RoutePoint *point = &GetRoutePoint( x, y, dir_yplus );
            int val = point->m_cost;

            *pos++ = val/10%10 + wxT('0');
            *pos++ = val%10 + wxT('0');
            *pos++ = wxT(' ');

            point = &GetRoutePoint( x, y, dir_xplus );
            val = point->m_cost;

            *pos++ = val/10%10 + wxT('0');
            *pos++ = val%10 + wxT('0');
            *pos++ = wxT('|');
        }
        *pos++ = 0;
        wxLogDebug( buffer );
        wxLogDebug( _T("") );
    }

    delete [] buffer;
#endif
}

void a2dRouteData::DumpVertexList( a2dVertexList *list )
{
#ifdef _DEBUG
    wxLogDebug( wxT("VertexList") );
    forEachIn( a2dVertexList, list )
    {
        wxLogDebug( wxT("%12.3lf %12.3lf"), (*iter)->m_x, (*iter)->m_y );
    }
#endif
};


//----------------------------------------------------------------------------
// a2dWirePolylineL
//----------------------------------------------------------------------------

a2dPropertyIdBool* a2dWirePolylineL::PROPID_Reroute = NULL;
a2dPropertyIdBool* a2dWirePolylineL::PROPID_Rerouteadded = NULL;

A2D_BEGIN_EVENT_TABLE( a2dWirePolylineL, a2dPolylineL )
A2D_END_EVENT_TABLE()

INITIALIZE_PROPERTIES( a2dWirePolylineL, a2dPolylineL )
{
    A2D_PROPID_D_F( a2dPropertyIdBool, Reroute, false, a2dPropertyId::flag_temporary|a2dPropertyId::flag_listfirst );
    A2D_PROPID_D_F( a2dPropertyIdBool, Rerouteadded, false, a2dPropertyId::flag_temporary|a2dPropertyId::flag_listfirst );

    return true;
}

a2dWirePolylineL::a2dWirePolylineL()
{
    m_inverted   = false;
    m_objBegin   = NULL;
    m_wireBegin  = NULL;
    m_wireEnd    = NULL;
    m_objEnd     = NULL;
    m_flags.m_draggable = false;
    m_wasVertical = false;
    m_oneLine = false;
}

a2dWirePolylineL::a2dWirePolylineL(a2dVertexList* points, bool spline )
    : a2dPolylineL( points, spline )
{
    m_inverted   = false;
    m_objBegin   = NULL;
    m_wireBegin  = NULL;
    m_wireEnd    = NULL;
    m_objEnd     = NULL;
    m_flags.m_draggable = false;
    m_wasVertical = false;
    m_oneLine = false;
}

a2dWirePolylineL::a2dWirePolylineL( const a2dWirePolylineL& poly, CloneOptions options )
    : a2dPolylineL( poly, options )
{
    // wxLogDebug( "Cloing a2dWirePolylineL %p into %p", &poly, this );

    m_flags.m_draggable = poly.m_flags.m_draggable;
    m_wasVertical = poly.m_wasVertical;
    m_inverted   = poly.m_inverted;
    m_objBegin   = poly.m_objBegin;
    m_wireBegin  = poly.m_wireBegin;
    m_wireEnd    = poly.m_wireEnd;
    m_objEnd     = poly.m_objEnd;
    m_oneLine    = poly.m_oneLine;
}

a2dWirePolylineL::~a2dWirePolylineL()
{
}

a2dObject* a2dWirePolylineL::Clone( CloneOptions options ) const
{
    return new a2dWirePolylineL( *this, options );
}

void a2dWirePolylineL::SetConnectionInfo(
    bool inverted,
    a2dPinClass* objBegin,
    a2dPinClass* objEnd
)
{
    m_inverted   = inverted;
    m_objBegin   = objBegin;
    m_objEnd     = objEnd;
}

bool a2dWirePolylineL::IsConnect() const
{
    return true;
}

bool a2dWirePolylineL::NeedsUpdateWhenConnected() const
{
    return true;
}

void a2dWirePolylineL::DoUpdateImmediate( a2dDoUpdateImmediateData *data )
{
    bool oneLine = m_oneLine || a2dCanvasGlobals->GetRouteOneLine();

    switch ( data->m_phase )
    {
    case 0:
        // In phase 0 we restore the original situation for all "editcopy" wires
        if( data->m_phase_first )
        {
            // Need the next phase as well
            data->RequestPhase( 1 );

            if( data->m_final )
                break;

            // Check if there is an original property, that indicates we do want it,
            // because only editcopies have this property.
            a2dWirePolylineL *original = wxStaticCastNull( PROPID_Original->GetPropertyValue( this ).Get(), a2dWirePolylineL );
            a2dWirePolylineL *target = this;

            // Only do this for editcopy wires
            if( !original )
                break;

            // Reassign the original location to the point list of the editcopy
            {
                a2dVertexList *newpoints = new a2dVertexList;
                *newpoints = *original->GetSegments();
                target->SetSegments( newpoints );
            }

            // Reassign the pin positions
            for( a2dCanvasObjectList::iterator iter = target->m_childobjects->begin(); iter != target->m_childobjects->end(); ++iter )
            {
                a2dCanvasObject *obj = *iter;
                a2dPin* pin = wxDynamicCast( obj, a2dPin );
                if( !pin ) continue;

                a2dPin *pinori = wxStaticCast( PROPID_Original->GetPropertyValue( pin ).Get(), a2dPin );

                pin->SetTransformMatrix( pinori->GetTransformMatrix() );
            }

            // One Adjust at the beginning also shouldn't hurt
            // In draging modes this shouldn't do anything, because the wires don't change
            // So this will only have an effect for wire editing tools
            target->AdjustAfterChange( data->m_final );
        }
        break;

    case 1:
        // In phase 1, the routing order of wires is determined
        // First all wires that connect objects with objects are routed
        // A wire that is connected to a wire is routed after that wire.
        {
            // Need the next phase as well
            if ( oneLine )
                data->RequestPhase( 3 );
            else
                data->RequestPhase( 2 );

            data->RequestSortPriorityBeforeNextPhase();

            a2dWirePolylineL *original = wxStaticCastNull( PROPID_Original->GetPropertyValue( this ).Get(), a2dWirePolylineL );
            a2dWirePolylineL *target = data->m_final && !data->m_original ? original : this;

            int oldpriority = PROPID_UpdateImmediatePriority->GetPropertyValue( target );
            int priority = 0;

            // Go through all pins and adjust priority to connected wires
            for( a2dCanvasObjectList::iterator iter = target->GetChildObjectList()->begin(); iter != target->GetChildObjectList()->end(); ++iter )
            {
                a2dCanvasObject *obj = *iter;
                a2dPin* pin = wxDynamicCast( obj, a2dPin );
                if( !pin )
                    continue;

                // Only begin or end pins
                if( pin->GetName()!=wxT("begin") && pin->GetName()!=wxT("end") )
                    continue;

                // Only connected pins can delay routing
                if( !pin->ConnectedTo() )
                    continue;

                // Only pins connected to a wire can delay routing
                if( !pin->ConnectedTo()->GetParent()->IsConnect() )
                    continue;

                int minpriority = 1 + PROPID_UpdateImmediatePriority->GetPropertyValue( pin->ConnectedTo()->GetParent() );
                if( minpriority > priority )
                    priority = minpriority;

            }

            PROPID_UpdateImmediatePriority->SetPropertyToObject( target, priority );
            PROPID_Reroute->SetPropertyToObject( target, true );

            if( oldpriority != priority )
            {
                // redo this, because the priority of other wires could depend on us
                data->RequestPhase( 1 );
            }
        }
        break;

    case 2:
        // In phase 2 the routing data is created if it doesn't exist and the wire
        // is added to the occupation array
        // This cannot be done in phase 0, because the wires must be added to the occupation array in their proper state
        if( data->m_phase_first )
        {
            // Need the next phase as well
            data->RequestPhase( 3 );
            a2dRouteData *routedata = wxStaticCastNull( a2dCanvasObject::a2dDoUpdateImmediateData::PROPID_RouteData->GetPropertyValue( data ).Get(), a2dRouteData );
            if( !routedata )
            {
                routedata = new a2dRouteData( data->m_parent, data->m_final );
                a2dCanvasObject::a2dDoUpdateImmediateData::PROPID_RouteData->SetPropertyToObject( data, routedata );
            }
        }
        break;

    case 3:
        // In phase 3, the wires will be rerouted
        // Check if any pin got dislocated
        {
            a2dWirePolylineL *original = wxStaticCastNull( PROPID_Original->GetPropertyValue( this ).Get(), a2dWirePolylineL );
            a2dWirePolylineL *target = data->m_final && !data->m_original ? original : this;

            // Note: target is zero for dynamically created wires
            if ( target )
            {
                target->RemoveProperty( PROPID_UpdateImmediatePriority );
                target->RemoveProperty( PROPID_Reroute );

                for( a2dCanvasObjectList::iterator iter = target->GetChildObjectList()->begin(); iter != target->GetChildObjectList()->end(); ++iter )
                {
                    a2dCanvasObject *obj = *iter;
                    a2dPin* pin = wxDynamicCast( obj, a2dPin );
                    if( !pin ) continue;

                    if( pin->IsDislocated() )
                    {
                        a2dPin *otherPin = pin->ConnectedTo();
                        // only connected pins can be dislocated
                        wxASSERT( otherPin );

                        if( pin->IsDynamicPin() )
                        {
                            a2dPoint2D otherPos = otherPin->GetAbsXY();
                            if( target->MoveDynamicPinCloseTo( pin, otherPos, data && data->m_final ) )
                            {
                                // This could dislocate other pins, so repeat routing
                                if( data )
                                    data->RequestPhase( 3 );
                            }
                        }
                        else
                        {
                            // If this pin is connected to a wire, first give the wire a chance
                            if( otherPin->GetParent()->IsConnect() )
                            {
                                bool originalsave = data->m_original;
                                data->m_original = true;
                                otherPin->GetParent()->DoUpdateImmediate( data );
                                data->m_original = originalsave;
                                //otherPos = otherPin->GetAbsXY();
                            }

                            if( pin->GetName() == wxT("begin") )
                            {
                                if( data->m_allowreconnectbegin && data->m_final )
                                {
                                    pin->AutoConnect( data->m_parent, 1.0 );
                                }

                                if( pin->IsDislocated() )
                                {
                                    if ( oneLine )
                                    {
                                        a2dPoint2D otherEnd = FindEndPin()->GetAbsXY();
                                        // Target not reached => create a straight line wire
                                        a2dVertexList *newpoints = new a2dVertexList;
                                        newpoints->push_back( new a2dLineSegment( pin->ConnectedTo()->GetAbsXY()) );
                                        newpoints->push_back( new a2dLineSegment( otherEnd ) );
                                        // Adjust the existing vertex list to the new vertex list
                                        if ( GetCanvasDocument()->GetCommandProcessor() )
                                            GetCanvasDocument()->GetCommandProcessor()->Submit( new a2dCommand_SetSegments( target, newpoints, true ), data->m_final );
                                        else
                                            target->SetSegments( newpoints );
                                        a2dWirePolylineL::PROPID_Rerouteadded->SetPropertyToObject( target, true );
                                    }
                                    else
                                    {
                                        // Reroute wire
                                        a2dRouteData *routedata = wxStaticCast( a2dCanvasObject::a2dDoUpdateImmediateData::PROPID_RouteData->GetPropertyValue( data ).Get(), a2dRouteData );
                                        routedata->RerouteWire( target, pin, FindEndPin(), false, data->m_final );
                                        // target->SetEndPoint( 0, 1, otherPos.m_x, otherPos.m_y, data->m_final );
                                    }
                                }

                                // This could dislocate other pins, so repeat routing
                                if( target->AdjustAfterChange( data->m_final ) )
                                {
                                    //if ( !data->m_final )
                                        data->RequestPhase( 3 );
                                    //else ?? KLAAS
                                }
                            }
                            else if( pin->GetName() == wxT("end") )
                            {
                                if( data->m_allowreconnectend && data->m_final )
                                {
                                    pin->AutoConnect( data->m_parent, 1.0 );
                                }

                                if( pin->IsDislocated() )
                                {
                                    if ( oneLine )
                                    {
                                        a2dPoint2D otherEnd = FindBeginPin()->GetAbsXY();
                                        // Target not reached => create a straight line wire
                                        a2dVertexList *newpoints = new a2dVertexList;
                                        newpoints->push_back( new a2dLineSegment( otherEnd ) );
                                        newpoints->push_back( new a2dLineSegment( pin->ConnectedTo()->GetAbsXY()) );
                                        // Adjust the existing vertex list to the new vertex list
                                        if ( GetCanvasDocument()->GetCommandProcessor() )
                                            GetCanvasDocument()->GetCommandProcessor()->Submit( new a2dCommand_SetSegments( target, newpoints, true ), data->m_final );
                                        else
                                            target->SetSegments( newpoints );
                                        a2dWirePolylineL::PROPID_Rerouteadded->SetPropertyToObject( target, true );
                                    }
                                    else
                                    {
                                        // Reroute wire
                                        a2dRouteData *routedata = wxStaticCast( a2dCanvasObject::a2dDoUpdateImmediateData::PROPID_RouteData->GetPropertyValue( data ).Get(), a2dRouteData );
                                        routedata->RerouteWire( target, pin, FindBeginPin(), true, data->m_final  );
                                        // target->SetEndPoint( GetNumberOfSegments()-1, GetNumberOfSegments()-2, otherPos.m_x, otherPos.m_y, data->m_final );
                                    }
                                }

                                // This could dislocate other pins, so repeat routing
                                if( target->AdjustAfterChange( data->m_final ) )
                                {
                                    //if ( !data->m_final )
                                        data->RequestPhase( 3 );
                                    //else ?? KLAAS
                                }
                            }
                            else
                            {
                                wxASSERT_MSG( 0, wxT("Unknown pin type in wire") );
                            }

                        }
                    }
                    else if( !pin->ConnectedTo() )
                    {
                        // Try autoconnecting the pin
                        if( pin->GetName() == wxT("begin") )
                        {
                            if( data->m_allowreconnectbegin && data->m_final )
                            {
                                pin->AutoConnect( data->m_parent, 1.0 );
                            }
                        }
                        else if( pin->GetName() == wxT("end") )
                        {
                            if( data->m_allowreconnectend && data->m_final )
                            {
                                pin->AutoConnect( data->m_parent, 1.0 );
                            }
                        }
                    }
                }
            }
        }
        break;
    }

/*
    switch ( data->m_phase )
    {
    case 0:
        // In phase 0 we restore the original situation
        // This is done for all edited wires before any other changes are done
        // And this is done only once, even if phase0 is executed more than once

        if( data->m_phase_first )
        {
            // In phase 1 we adjust wires to pin dislocations
            data->RequestPhase( 1 );

            // Check if there is an original property
            a2dWirePolylineL *original = wxStaticCastNull( PROPID_Original->GetPropertyValue( this ).Get(), a2dWirePolylineL );
            a2dWirePolylineL *target = data->m_final ? original : this;

            // Note: target is zero for dynamically created wires
            if ( target )
            {
                // Reassign the point positions
                if( original && !data->m_final )
                {
                    // Reassign the original location to the point list
                    {
                        a2dVertexList::compatibility_iterator nodeori = original->m_lsegments->GetFirst();
                        a2dVertexList::compatibility_iterator node = target->m_lsegments->GetFirst();
                        while( nodeori )
                        {
                            wxASSERT( node );
                            *node->GetData() = *nodeori->GetData();
                            nodeori = nodeori->GetNext();
                            node = node->GetNext();
                        }
                    }

                    // Reassign the pin positions
                    a2dCanvasObjectList::compatibility_iterator node = target->m_childobjects->GetFirst();
                    for( ; node; node = node->GetNext() )
                    {
                        a2dPin *pin = wxDynamicCast( node->GetData(), a2dPin );
                        if( !pin ) continue;

                        a2dPin *pinori = wxStaticCast( PROPID_Original->GetPropertyValue( pin ).Get(), a2dPin );

                        pin->SetTransformMatrix( pinori->GetTransformMatrix() );
                    }
                }

                // One Adjust at the beginning also shouldn't hurt
                // In draging modes this shouldn't do anything, because the wires don't change
                // Sp this will only have an effect for wire editing tools
                target->AdjustAfterChange( data );
            }
        }
        break;

    case 1:
        // Check if any pin got dislocated
        {
            a2dWirePolylineL *original = wxStaticCastNull( PROPID_Original->GetPropertyValue( this ).Get(), a2dWirePolylineL );
            a2dWirePolylineL *target = data->m_final && !data->m_original ? original : this;

            // Note: target is zero for dynamically created wires
            if ( target )
            {
                a2dCanvasObjectList::compatibility_iterator node = target->m_childobjects->GetFirst();
                for( ; node; node = node->GetNext() )
                {
                    a2dPin *pin = wxDynamicCast( node->GetData(), a2dPin );
                    if( !pin ) continue;

                    if( pin->IsDislocated() )
                    {
                        // OK, the pin got dislocated
                        if( pin->IsDynamicPin() )
                        {
                            a2dPin *otherPin = pin->ConnectedTo();
                            a2dPoint2D otherPos = otherPin->GetAbsXY();
                            if( target->MoveDynamicPinNearTo( pin, otherPos, data && data->m_final ) )
                            {
                                if( data )
                                    data->RequestPhase( 1 );
                            }
                        }
                        else
                        {
                            // If this pin is connected to a wire, first give the wire a chance
                            if( otherPin->GetParent()->IsConnect() )
                            {
                                bool originalsave = data->m_original;
                                data->m_original = true;
                                otherPin->GetParent()->DoUpdateImmediate( data );
                                data->m_original = originalsave;
                                otherPos = otherPin->GetAbsXY();
                            }

                            if( pin->GetName() == wxT("begin") )
                            {
                                if( data->m_allowreconnectbegin && data->m_final )
                                {
                                    pin->AutoConnect( data->m_parent, 1.0 );
                                }

                                if( pin->IsDislocated() )
                                {
                                    a2dPin *otherPin = pin->ConnectedTo();
                                    a2dPoint2D otherPos = otherPin->GetAbsXY();
                                    target->SetEndPoint( 0, 1, otherPos.m_x, otherPos.m_y, data->m_final );
                                }

                                target->AdjustAfterChange( data );
                            }
                            else if( pin->GetName() == wxT("end") )
                            {
                                if( data->m_allowreconnectend && data->m_final )
                                {
                                    pin->AutoConnect( data->m_parent, 1.0 );
                                }
                                if( pin->IsDislocated() )
                                {
                                    a2dPin *otherPin = pin->ConnectedTo();
                                    a2dPoint2D otherPos = otherPin->GetAbsXY();
                                    target->SetEndPoint( GetNumberOfSegments()-1, GetNumberOfSegments()-2, otherPos.m_x, otherPos.m_y, data->m_final );
                                }

                                target->AdjustAfterChange( data );
                            }
                            else
                            {
                                wxASSERT_MSG( 0, wxT("Unknown pin type in wire") );
                            }

                        }
                    }
                }
            }
        }
        break;
    }
*/

}

bool a2dWirePolylineL::AdjustAfterChange( bool final )
{
    bool changed = false;
    for( a2dCanvasObjectList::iterator iter = GetChildObjectList()->begin(); iter != GetChildObjectList()->end(); ++iter )
    {
        a2dCanvasObject *obj = *iter;
        a2dPin* pin = wxDynamicCast( obj, a2dPin );
        if( !pin ) continue;

        double xOld = pin->GetPosX();
        double yOld = pin->GetPosY();

//        a2dPin *pinori = wxStaticCastNull( PROPID_Original->GetPropertyValue( pin ).Get(), a2dPin );

        if( pin->IsDynamicPin() )
        {
            // intermediate "dynamic" pin
            if( MoveDynamicPinCloseTo( pin, pin->GetAbsXY(), final ) )
                changed = true;
        }
        else if( pin->GetName() == wxT("begin") )
        {
            // regular begin pin
            double xNew, yNew;
            GetPosXYSegment( 0, xNew, yNew, false );
            if( xNew != xOld || yNew != yOld )
            {
                if ( m_root->GetCommandProcessor() )
                    m_root->GetCommandProcessor()->Submit( new a2dCommand_SetCanvasProperty( pin, PROPID_Position, a2dPoint2D( xNew, yNew ), -1, false ), final );
                else
                    pin->SetPosXY( xNew, yNew );

                changed = true;
            }
        }
        else if( pin->GetName() == wxT("end") )
        {
            // regular end pin
            double xNew, yNew;
            GetPosXYSegment( GetNumberOfSegments()-1, xNew, yNew, false );
            if( xNew != xOld || yNew != yOld )
            {
                if ( m_root->GetCommandProcessor() )
                    m_root->GetCommandProcessor()->Submit( new a2dCommand_SetCanvasProperty( pin, PROPID_Position, a2dPoint2D( xNew, yNew ), -1, false ), final );
                else
                    pin->SetPosXY( xNew, yNew );

                changed = true;
            }
        }
    }

    return changed;
}

#if wxART2D_USE_CVGIO
void a2dWirePolylineL::DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite )
{
    a2dPolylineL::DoSave( parent, out, xmlparts, towrite );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        out.WriteAttribute( wxT("invert"),      m_inverted );
        out.WriteAttribute( wxT("pcobjbegin"),  m_objBegin->GetName() );
        out.WriteAttribute( wxT("pcwirebegin"), m_wireBegin->GetName() );
        out.WriteAttribute( wxT("pcwireend"),   m_wireEnd->GetName() );
    }
    else
    {
    }
}
void a2dWirePolylineL::DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts )
{
    a2dPolylineL::DoLoad( parent, parser, xmlparts );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        m_inverted = parser.RequireAttributeValueBool( wxT("invert") );

        wxString pinclass;

        pinclass = parser.RequireAttributeValue( wxT("pcobjbegin") );
        m_objBegin = a2dPinClass::GetClassByName( pinclass );
        if( !m_objBegin )
        {
            m_objBegin = a2dPinClass::Standard;
            wxString reference_name = GetName();
            a2dDocviewGlobals->ReportErrorF( a2dError_NoPinClass, _("a2dWirePolylineL with name %s \n Pin class %s not found (replaced with Standard)"), reference_name.c_str(), pinclass.c_str() );
        }

        pinclass = parser.RequireAttributeValue( wxT("pcwirebegin") );
        m_wireBegin = a2dPinClass::GetClassByName( pinclass );
        if( !m_wireBegin )
        {
            m_wireBegin = a2dPinClass::Standard;
            wxString reference_name = GetName();
            a2dDocviewGlobals->ReportErrorF( a2dError_NoPinClass, _("a2dWirePolylineL with name %s \n Pin class %s not found (replaced with Standard)"), reference_name.c_str(), pinclass.c_str() );
        }

        pinclass = parser.RequireAttributeValue( wxT("pcwireend") );
        m_wireEnd = a2dPinClass::GetClassByName( pinclass );
        if( !m_wireEnd )
        {
            m_wireEnd = a2dPinClass::Standard;
            wxString reference_name = GetName();
            a2dDocviewGlobals->ReportErrorF( a2dError_NoPinClass, _("a2dWirePolylineL with name %s \n Pin class %s not found (replaced with Standard)"), reference_name.c_str(), pinclass.c_str() );
        }
    }
    else
    {
    }
}
#endif //wxART2D_USE_CVGIO

void a2dWirePolylineL::SetEndPoint( int iEnd, int iNext, double x, double y, bool final )
{
    double xPre, yPre;
    GetPosXYSegment(iEnd, xPre, yPre, true );
    m_root->GetCommandProcessor()->Submit( new a2dCommand_MoveSegment( this, x, y, iEnd, true), final );

    if( GetNumberOfSegments()>2 )
    {
        double xNext, yNext;
        GetPosXYSegment(iNext, xNext, yNext, true );
        bool isHor = fabs( yPre - yNext ) <= 1e-10 * wxMax( fabs( yPre ), fabs( yNext ) );
        bool isVert = fabs( xPre - xNext ) <= 1e-10 * wxMax( fabs( xPre ), fabs( xNext ) );
        // If the line segment adjacent to the end point is horizontal
        // move the adjacent point only vertically
        if( isHor && ! isVert || isHor && isVert && !m_wasVertical )
        {
            m_root->GetCommandProcessor()->Submit( new a2dCommand_MoveSegment( this, xNext, yNext+y-yPre, iNext, true), final );
            m_wasVertical = false;
        }
        // If the line segment adjacent to the end point is vertical
        // move the adjacent point only horizontally
        if( isVert && ! isHor || isHor && isVert && m_wasVertical )
        {
            m_root->GetCommandProcessor()->Submit( new a2dCommand_MoveSegment( this, xNext+x-xPre, yNext, iNext, true), final );
            m_wasVertical = true;
        }
    }
}

bool a2dWirePolylineL::IsDislocated()
{
    return FindBeginPin()->IsDislocated() || FindEndPin()->IsDislocated();
}

void a2dWirePolylineL::EditFeedback( a2dIterC& ic, const a2dFeedbackId *id, a2dCanvasObject *currentEdit, int depth, a2dCanvasObjectFlagsMask flags, double x, double y )
{
    a2dPolylineL::EditFeedback( ic, id, currentEdit, depth, flags, x, y );
}

bool a2dWirePolylineL::GeneratePins( a2dPinClass* toConnectTo, a2dConnectTask task, double x, double y )
{
    a2dPinClass* toCreate = toConnectTo->GetPinClassForTask( task, this );
    if ( GetGeneratePins() && ( toCreate == m_wireBegin || toCreate == m_wireEnd ) )
    {
        m_flags.m_visiblechilds = true;
        bool end = false;
        bool begin = false;
        if ( !HasPinNamed( wxT("begin")) )
        {
            a2dVertexList::iterator iter = m_lsegments->begin();
            assert( m_lsegments->size() );
            AddPin( wxT("begin"), (*iter)->m_x, (*iter)->m_y, a2dPin::temporary, m_wireBegin );
        }
        else
            begin = true;

        if ( !HasPinNamed( wxT("end")) )
        {
            a2dVertexList::iterator iter = m_lsegments->end();
            assert( m_lsegments->size() );
            iter--;
            AddPin( wxT("end"), (*iter)->m_x, (*iter)->m_y, a2dPin::temporary, m_wireEnd );
        }
        else
            end = true;

        if ( /*begin && end &&*/ m_lsegments->size() > 0 )
        {
            // Find the rastered point on the line closest to the polygon line
            double xNear, yNear;
            if( FindNearPoint( &m_lworld, x, y, &xNear, &yNear ) )
            {
                a2dAffineMatrix inverse = m_lworld;
                inverse.Invert();
                double xNearLocal, yNearLocal;
                inverse.TransformPoint( xNear, yNear, xNearLocal, yNearLocal );

                //now we create a dynamic pin of the same class as a connected pin.
                a2dPin *pin = AddPin( wxT("dynamic"), xNearLocal, yNearLocal, a2dPin::temporary | a2dPin::dynamic, toCreate );
                pin->SetMode( a2dPin::sm_PinCanConnectToPinClass );
                pin->SetMouseInObject( true );
            }
        }

        wxASSERT( HasPins() );
        m_childobjects->SetSpecificFlags( false, a2dCanvasOFlags::PRERENDERASCHILD, wxT("a2dPin") );

        return true;
    }
    return false;
}

//----------------------------------------------------------------------------
// a2dWireEnd
//----------------------------------------------------------------------------
a2dWireEnd::a2dWireEnd( double x , double y )
    : a2dCanvasObject( x, y )
{
}

a2dWireEnd::a2dWireEnd( const a2dWireEnd& obj, CloneOptions options )
    : a2dCanvasObject( obj, options )
{
}

a2dObject* a2dWireEnd::Clone( CloneOptions options ) const
{
    return new a2dWireEnd( *this, options );
}

wire.cpp Source File -- Tue Aug 31 17:56:40 2010 -- 31 Aug 2010 -- 1.5.5 -- wxArt2D -- . -- Reference Documentation