recur.cpp

Go to the documentation of this file.

/*! \file canvas/src/recur.cpp
    \author Klaas Holwerda

    Copyright: 2001-2004 (c) Klaas Holwerda

    Licence: wxWidgets Licence

    RCS-ID: $Id: recur.cpp,v 1.107 2009/09/26 20:40:32 titato Exp $
*/

#include "a2dprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

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

#include "wx/canvas/recur.h"
#include "wx/canvas/objlist.h"
#include "wx/canvas/candoc.h"
#include "wx/canvas/drawer.h"

#include <wx/wfstream.h>
#include <math.h>

//----------------------------------------------------------------------------
// globals
//----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(a2dCanvasObjectReference, a2dCanvasObject)
IMPLEMENT_DYNAMIC_CLASS(a2dCanvasObjectArrayReference, a2dCanvasObjectReference)
IMPLEMENT_DYNAMIC_CLASS(a2dLibraryReference, a2dText)
IMPLEMENT_DYNAMIC_CLASS(a2dNameReference, a2dText)
IMPLEMENT_DYNAMIC_CLASS(a2dExternalReference, a2dText)
IMPLEMENT_DYNAMIC_CLASS(a2dCanvasDocumentReference, a2dLibraryReference)

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
// a2dCanvasObjectReference
//----------------------------------------------------------------------------

const a2dPropertyIdCanvasObject a2dCanvasObjectReference::PROPID_refobject( wxT("refobject"), a2dPropertyId::flag_transfer|a2dPropertyId::flag_onlymemberhint, 0 );

a2dCanvasObjectReference::a2dCanvasObjectReference()
   : a2dCanvasObject()
{
    m_object = 0;
    m_flags.m_ignoreLayer = true;
}

a2dCanvasObjectReference::a2dCanvasObjectReference(double x, double y, a2dCanvasObject* obj)
   : a2dCanvasObject()
{
    m_lworld.Translate(x,y);
    m_object = obj;
    m_flags.m_ignoreLayer = true;
}

a2dCanvasObjectReference::~a2dCanvasObjectReference()
{
}

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

a2dCanvasObjectReference::a2dCanvasObjectReference( const a2dCanvasObjectReference &other, CloneOptions options )
   : a2dCanvasObject(other, options)
{
    if ( options & clone_members && other.m_object)
        m_object = other.m_object->TClone( CloneOptions( options & ~ clone_seteditcopy ) );
    else
        m_object = other.m_object;
}

void a2dCanvasObjectReference::DoAddPending( a2dIterC& ic )
{
    if ( m_object )
        m_object->AddPending( ic );
}

bool a2dCanvasObjectReference::LinkReference( a2dObject *other )
{
    if(!other)
        return false;

#if defined(_DEBUG)
    wxString name = other->GetName();
#endif

    if ( m_object.Get() )
        return false;

    m_object = wxStaticCast( other, a2dCanvasObject );
    m_object->SetCheck( true );
    return true;
}

a2dCanvasObject* a2dCanvasObjectReference::GetCanvasObject()
{
    return m_object;
}

void a2dCanvasObjectReference::SetCanvasObject( a2dCanvasObject* object )
{
    m_object = object;
}

void a2dCanvasObjectReference::MakeReferencesUnique()
{
    if ( m_object && m_object->GetOwnedBy() > 1 )
    {
        m_object = wxStaticCast( m_object->Clone( a2dObject::clone_flat ), a2dCanvasObject );
    }
    a2dCanvasObject::MakeReferencesUnique();
}

void a2dCanvasObjectReference::DoWalker( wxObject* parent, a2dWalkerIOHandler& handler )
{ 
    if ( m_object.Get() )
        m_object->Walker( this, handler );
    
    a2dCanvasObject::DoWalker( parent, handler );
}

a2dBoundingBox a2dCanvasObjectReference::DoGetUnTransformedBbox( a2dBboxFlags WXUNUSED(flags) ) const
{
    a2dBoundingBox bbox;
    if ( m_object )
        bbox.Expand( m_object->GetBbox() );
    else
        bbox.Expand( 0,0 );
    return bbox;
}

bool a2dCanvasObjectReference::DoUpdate( UpdateMode mode, const a2dBoundingBox& childbox, const a2dBoundingBox& clipbox, const a2dBoundingBox& propbox )
{
    bool calc = false;
    if ( m_object )
    {
        calc = m_object->Update( mode );
    }

    if ( !m_bbox.GetValid() || calc )
    {
        m_bbox = DoGetUnTransformedBbox();
        m_bbox.MapBbox(m_lworld);
        return true;
    }
    return false;
}

void a2dCanvasObjectReference::DoRender( a2dIterC& ic, OVERLAP clipparent )
{
    if ( !m_object )
    {
        double x1;
        double y1;
        ic.GetTransform().TransformPoint( 0, 0, x1, y1 );
        int dx = ic.GetDrawer2D()->WorldToDeviceX(x1);
        int dy = ic.GetDrawer2D()->WorldToDeviceY(y1);

        ic.GetDrawer2D()->PushIdentityTransform();
        ic.GetDrawer2D()->DrawLine( dx - 3, dy,  dx + 4, dy);
        ic.GetDrawer2D()->DrawLine( dx, dy + 3,  dx, dy - 4);
        ic.GetDrawer2D()->PopTransform();
        return;
    }

    if ( !ic.GetRenderChildDerived() )
        return;
    
    OVERLAP childclip = _IN;
    if ( clipparent != _IN )
        childclip = m_object->GetClipStatus( ic, clipparent );

    if ( childclip != _OUT ) //if a child is _OUT, no need to render it.
    {
        // Translate2D over XY from the structurereference
        m_object->Render( ic, childclip );
    }
}

void a2dCanvasObjectReference::DoWalkerWithContext( a2dIterC& ic, wxObject *parent, a2dWalkerIOHandlerWithContext& handler )
{
    if ( !m_object )
        return;

    a2dCanvasObject::DoWalkerWithContext( ic, parent, handler );

    m_object->WalkerWithContext( ic, this, handler );
}

#if wxART2D_USE_CVGIO
void a2dCanvasObjectReference::DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite )
{
    a2dCanvasObject::DoSave( parent, out, xmlparts, towrite );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        if ( m_object )
            out.WriteAttribute( wxT("object"), m_object->GetUniqueSerializationId() );
    }
    else
    {
        //if object is not saved yet, we need to save it here.
        if ( m_object && !m_object->GetCheck() )
        {
            //trick the system to have multiple refs on those objects, else we will not get an id attribute
            a2dCanvasObjectPtr multiRef = m_object;

            out.WriteStartElement( wxT("derived") );
                m_object->Save( this, out, towrite);
            out.WriteEndElement();
        }
    }
}

void a2dCanvasObjectReference::DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts )
{   
    a2dCanvasObject::DoLoad( parent, parser, xmlparts );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        if ( parser.HasAttribute( wxT("object") ) )
        {
            parser.ResolveOrAdd( (a2dSmrtPtr<class a2dObject>*) &m_object, parser.GetAttributeValue( wxT("object") ) );
        }
    }
    else
    {
        if ( parser.GetTagName() != wxT("derived") )
            return;

        parser.Require( START_TAG, wxT("derived") );
        parser.Next();

        DoLoadOneObject( this, parser, xmlparts );

        parser.Require( END_TAG, wxT("derived") );
        parser.Next();
    }
}
#endif //wxART2D_USE_CVGIO

bool a2dCanvasObjectReference::DoIsHitWorld( a2dIterC& ic, a2dHitEvent& hitEvent )
{
    if ( !m_object )
        return false;
    return m_object->IsHitWorld( ic, hitEvent ) != 0;
}

void a2dCanvasObjectReference::RemoveHierarchy()
{
    if ( m_object && !m_object->GetRelease() )
    {
        CreateChildObjectList()->push_front( m_object );
    }

    m_object = NULL;

    a2dCanvasObject::RemoveHierarchy();
}

//----------------------------------------------------------------------------
// a2dCanvasObjectArrayReference
//----------------------------------------------------------------------------

a2dCanvasObjectArrayReference::a2dCanvasObjectArrayReference()
   : a2dCanvasObjectReference()
{
}

a2dCanvasObjectArrayReference::a2dCanvasObjectArrayReference( double x, double y, int rows, int columns, double horzSpace, double vertSpace, a2dCanvasObject* obj )
   : a2dCanvasObjectReference( x, y, obj )
{
    m_horzSpace = horzSpace;    
    m_vertSpace = vertSpace;
    m_rows = rows;
    m_columns = columns;
}

a2dCanvasObjectArrayReference::~a2dCanvasObjectArrayReference()
{
}

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

a2dCanvasObjectArrayReference::a2dCanvasObjectArrayReference( const a2dCanvasObjectArrayReference &other, CloneOptions options )
   : a2dCanvasObjectReference(other, options)
{
    m_horzSpace = other.m_horzSpace;    
    m_vertSpace = other.m_vertSpace;
    m_rows = other.m_rows;
    m_columns = other.m_columns;
}

a2dBoundingBox a2dCanvasObjectArrayReference::DoGetUnTransformedBbox( a2dBboxFlags WXUNUSED(flags) ) const
{
    a2dBoundingBox tmp; 

    if ( m_object )
        tmp = m_object->GetBbox();
    else
        tmp.Expand ( 0, 0);

    a2dBoundingBox bbox;
    bbox.Expand( tmp );

    tmp.Translate( (m_columns-1)*m_horzSpace, 0 );
    bbox.Expand( tmp );

    tmp.Translate( 0, (m_rows-1)*m_vertSpace );
    bbox.Expand( tmp );

    tmp.Translate( -(m_columns-1)*m_horzSpace, 0 );
    bbox.Expand( tmp );
    return bbox;
}

bool a2dCanvasObjectArrayReference::DoUpdate( UpdateMode mode, const a2dBoundingBox& childbox, const a2dBoundingBox& clipbox, const a2dBoundingBox& propbox )
{
    if ( !m_bbox.GetValid())
    {
        m_bbox = DoGetUnTransformedBbox();
        m_bbox.MapBbox(m_lworld);
        return true;
    }
    return false;
}

void a2dCanvasObjectArrayReference::DoRender( a2dIterC& ic, OVERLAP clipparent )
{
    if ( !m_object )
        return;

    a2dAffineMatrix offsetXY;

    int i,j;
    for ( i = 0  ; i < m_rows; i++)
    {
        for ( j = 0  ; j < m_columns; j++)
        {          
            a2dIterCU cu( ic, offsetXY );
            
            OVERLAP childclip = _IN;
            if ( clipparent != _IN )
                childclip = m_object->GetClipStatus( ic, clipparent );

            if ( childclip != _OUT ) //if a child is _OUT, no need to render it.
            {
                // Translate2D over XY from the structurereference
                m_object->Render( ic, childclip );
            }

            offsetXY.Translate( m_horzSpace, 0 );
        }
        //translate back (one row of columns) and add one row
        offsetXY.Translate( -m_horzSpace*m_columns, m_vertSpace );
    }
}

#if wxART2D_USE_CVGIO
void a2dCanvasObjectArrayReference::DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite )
{
    a2dCanvasObjectReference::DoSave( parent, out, xmlparts, towrite );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        out.WriteAttribute( wxT("columns"), m_columns );
        out.WriteAttribute( wxT("rows"), m_rows );
        out.WriteAttribute( wxT("horzspace"), m_horzSpace );
        out.WriteAttribute( wxT("vertspace"), m_vertSpace );
        out.WriteNewLine();
    }
    else
    {
    }
}

void a2dCanvasObjectArrayReference::DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts )
{
    a2dCanvasObjectReference::DoLoad( parent, parser, xmlparts );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        m_columns = parser.RequireAttributeValueInt( wxT("columns") );
        m_rows    = parser.RequireAttributeValueInt( wxT("rows") );
        m_horzSpace = parser.RequireAttributeValueDouble( wxT("horzspace") );
        m_vertSpace = parser.RequireAttributeValueDouble( wxT("vertspace") );
    }
    else
    {
    }
}
#endif //wxART2D_USE_CVGIO

bool a2dCanvasObjectArrayReference::DoIsHitWorld( a2dIterC& ic, a2dHitEvent& hitEvent )
{
    if ( !m_object )
        return false;

    double pw = ic.GetTransformedHitMargin();
    double margin = ic.GetTransformedHitMargin();

    a2dBoundingBox tmp = DoGetUnTransformedBbox();

    double xmin = tmp.GetMinX();
    double ymin = tmp.GetMinY();
    double xmax = tmp.GetMaxX();
    double ymax = tmp.GetMaxY();

    hitEvent.m_how = HitTestRectangle( hitEvent.m_relx, hitEvent.m_rely, xmin, ymin, xmax, ymax, pw+margin );
    return hitEvent.m_how.IsHit();
}

void a2dCanvasObjectArrayReference::RemoveHierarchy()
{
    if ( m_object && !m_object->GetRelease() )
    {
        a2dCanvasObjectPtr cobj;

        a2dAffineMatrix currentWorld = a2dIDENTITY_MATRIX;
        a2dAffineMatrix offsetXY;

        int i,j;
        for ( i = 0  ; i < GetRows(); i++)
        {
            for ( j = 0  ; j < GetColumns(); j++)
            {       
                a2dAffineMatrix tworld = offsetXY;
                tworld *= m_lworld;
                
                cobj = (a2dCanvasObject*) m_object->Clone( clone_deep ); 
                //cobj->Transform( offsetXY );
                //cobj->Transform( m_lworld );
                cobj->SetTransformMatrix( tworld );
                cobj->SetRelease( false );

                CreateChildObjectList()->push_back( cobj );

                offsetXY.Translate( GetHorzSpace(), 0 );                           
            }
            //translate back (one row of columns) and add one row
            offsetXY.Translate( -GetHorzSpace()*GetColumns(), GetVertSpace() );
        }
        m_object = NULL;
    }

    a2dCanvasObject::RemoveHierarchy();
}


//----------------------------------------------------------------------------
// a2dLibraryReference
//----------------------------------------------------------------------------

a2dLibraryReference::a2dLibraryReference()
   : a2dImage()
{
    m_layer = wxLAYER_SYMBOL;
    SetName( wxT("libraryref") );
    m_symbol = 0;

    m_height = 100;
    m_width  = 0;

    m_text = new a2dText( wxT("libraryref"), -m_height/2 ,-m_height/2 -m_height/5, a2dFont( m_height/5, wxSWISS ) );

    m_object = 0;
}


a2dLibraryReference::a2dLibraryReference( double x, double y, a2dCanvasObject* obj, const wxString &name,
                                        double totalheight, a2dCanvasObject* symbol,
                                         const a2dFont& font, int imagew, int imageh )

   : a2dImage( wxImage(imagew, imageh), x, y, totalheight, totalheight )
{
    m_object = obj;
    m_symbol = symbol;

    m_layer = wxLAYER_SYMBOL;

    RenderObject( symbol ? symbol: obj, imagew, imageh );

    SetName( name );

    if ( !name.IsEmpty() )
    {
        a2dFont lfont = font;
        lfont.SetSize( totalheight / 5.0 );
        m_text = new a2dText( name, -totalheight/2, -totalheight/2 -totalheight/5, lfont );
        m_text->SetStroke( *a2dBLACK_STROKE );
        m_text->SetFill( *a2dTRANSPARENT_FILL );
        m_text->SetLayer( wxLAYER_SYMBOL );
    }
    else
    {
        m_text = 0;
    }

    m_flags.m_visiblechilds = false;

    m_height = totalheight;
    m_width  = totalheight;

    SetFill( *a2dTRANSPARENT_FILL );
}

a2dLibraryReference::a2dLibraryReference( const a2dLibraryReference& other, CloneOptions options )
   : a2dImage( other, options )
{
    m_object = other.m_object;

    m_height = other.m_height;
    m_width = other.m_width;
    m_description = other.m_description;
    m_text = (a2dText*)other.m_text->Clone( clone_deep );
    m_symbol = other.m_symbol;
#if defined(_DEBUG) && defined (SMART_POINTER_DEBUG)
    //it is because the CurrentSmartPointerOwner can change in property->TClone()
    CurrentSmartPointerOwner = this;
#endif
}

a2dLibraryReference::~a2dLibraryReference()
{
}

void a2dLibraryReference::DoWalker( wxObject *parent, a2dWalkerIOHandler& handler )
{
    a2dCanvasObject::DoWalker( parent, handler );
    if (m_symbol)
        m_symbol->Walker( this, handler );

    if ( m_text )
        m_text->Walker( this, handler );
}

a2dCanvasObject* a2dLibraryReference::GetCanvasObject()
{
    return m_object;
}

void a2dLibraryReference::SetCanvasObject( a2dCanvasObject* object )
{
    m_object = object;
}


void a2dLibraryReference::SetSymbol( a2dCanvasObject* symbol )
{
    SetPending(true);
    m_symbol = symbol;
    if (m_symbol && m_root  )
        m_symbol->SetCanvasDocument( m_root );

    RenderObject( m_symbol? m_symbol.Get() : GetCanvasObject() );

}

a2dCanvasObject* a2dLibraryReference::GetSymbol()
{
    return m_symbol;
}

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

a2dBoundingBox a2dLibraryReference::DoGetUnTransformedBbox( a2dBboxFlags flags ) const
{
    a2dBoundingBox bbox = a2dImage::DoGetUnTransformedBbox( flags );

    bbox.Expand( m_text->GetUnTransformedBbox() );
    return bbox;
}

bool a2dLibraryReference::DoUpdate( UpdateMode mode, const a2dBoundingBox& childbox, const a2dBoundingBox& clipbox, const a2dBoundingBox& propbox )
{
    if ( !m_bbox.GetValid())
    {
        RenderObject( m_symbol? m_symbol: m_object, (int) m_width, (int) m_height );

        a2dImage::DoUpdate( mode, childbox, clipbox, propbox );
        if ( m_text )
        {
            a2dBoundingBox tbbox;
            m_text->Update( mode );
            tbbox.Expand( m_text->GetBbox() );
            tbbox.MapBbox(m_lworld);
            m_bbox.Expand( tbbox );
        }

        m_width = m_bbox.GetWidth();

        return true;
    }
    return false;
}

void a2dLibraryReference::DoRender( a2dIterC& ic, OVERLAP clipparent )
{
    a2dImage::DoRender( ic, clipparent );
    if ( m_text )
        m_text->Render( ic, clipparent );
}

#if wxART2D_USE_CVGIO
void a2dLibraryReference::DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite )
{
    a2dImage::DoSave( parent, out, xmlparts, towrite );
}

void a2dLibraryReference::DoLoad( wxObject* WXUNUSED(parent), a2dIOHandlerXmlSerIn& WXUNUSED(parser), a2dXmlSer_flag WXUNUSED(xmlparts) )
{
}
#endif //wxART2D_USE_CVGIO

bool a2dLibraryReference::DoIsHitWorld( a2dIterC& ic, a2dHitEvent& hitEvent )
{
    if ( m_text && m_text->IsHitWorld( ic, hitEvent ) )
         return true;

    return a2dImage::DoIsHitWorld( ic, hitEvent );
}


//----------------------------------------------------------------------------
// a2dExternalReference
//----------------------------------------------------------------------------
a2dExternalReference::a2dExternalReference()
   : a2dText( wxT("") , 0, 0 )
{
    m_text = wxT("nameref");
    m_object = 0;
}

a2dExternalReference::a2dExternalReference( double x, double y, a2dCanvasObject* obj, const wxString &text, double angle,  const a2dFont& font )
   : a2dText( text, x, y, font, angle )
{
    if ( m_text.IsEmpty() && obj )
        m_text = obj->GetName();
    else
        m_text = text;

    m_object = obj;
}

a2dExternalReference::a2dExternalReference( const a2dExternalReference& other, CloneOptions options )
   : a2dText( other, options )
{
    m_object = other.m_object;
}

a2dExternalReference::~a2dExternalReference()
{
}

void a2dExternalReference::DoWalker( wxObject *parent, a2dWalkerIOHandler& handler )
{
    a2dCanvasObject::DoWalker( parent, handler );
}

a2dCanvasObject* a2dExternalReference::GetCanvasObject()
{
    return m_object;
}

void a2dExternalReference::SetCanvasObject( a2dCanvasObject* object )
{
    m_object = object;
}

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

//----------------------------------------------------------------------------
// a2dNameReference
//----------------------------------------------------------------------------
a2dNameReference::a2dNameReference()
   : a2dText( wxT("") , 0, 0 )
{
    m_text = wxT("nameref");
}

a2dNameReference::a2dNameReference( double x, double y, a2dCanvasObject* obj, const wxString &text, double angle,  const a2dFont& font )
   : a2dText( text, x, y, font, angle )
{
    if ( m_text.IsEmpty() && obj )
        m_text = obj->GetName();
    else
        m_text = text;

    m_objectRef = obj;
}

a2dNameReference::a2dNameReference( const a2dNameReference &other, CloneOptions options )
   : a2dText( other, options )
{
}

a2dNameReference::~a2dNameReference()
{
}

a2dCanvasObject* a2dNameReference::GetCanvasObject()
{
    return m_objectRef;
}

void a2dNameReference::SetCanvasObject( a2dCanvasObject* object )
{
    m_objectRef = object;
}

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


//----------------------------------------------------------------------------
// a2dCanvasDocumentReference
//----------------------------------------------------------------------------

a2dCanvasDocumentReference::a2dCanvasDocumentReference( double x, double y, a2dCanvasDocument* doc, double totalheight,
                                           const a2dFont& font, int imagew, int imageh, a2dCanvasObject* symbol )
    :a2dLibraryReference( x, y, doc->GetRootObject() ,
     doc->GetFilename().GetFullName() != wxT( "" )? doc->GetFilename().GetFullName(): doc->GetPrintableName(),
     totalheight, symbol, font, imagew, imageh )
{

    SetObjectTip( doc->GetFilename().GetFullPath(), m_height/2 , 0, m_height/5 );

    m_doc = doc;
}

a2dCanvasDocumentReference::~a2dCanvasDocumentReference()
{
}

void a2dCanvasDocumentReference::DependencyPending(a2dWalkerIOHandler* WXUNUSED(handler))
{
    if ( !m_flags.m_pending && m_doc->GetRootObject()->GetPending() )
        SetPending(true);
}

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