curvegroup.cpp

Go to the documentation of this file.

/*! \file curves/src/curvegroup.cpp
    \author Klaas Holwerda

    Copyright: 2000-2004 (c) Klaas Holwerda

    Licence: wxWidgets Licence

    RCS-ID: $Id: curvegroup.cpp,v 1.42 2008/08/19 23:17:11 titato Exp $
*/

#pragma warning(disable:4786)

#include "a2dprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

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

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

#if wxART2D_USE_CANEXTOBJ
    #include "wx/canextobj/eval.h"
#endif //wxART2D_USE_CANEXTOBJ

#include "wx/curves/meta.h"

#include "wx/canvas/canglob.h"
#include "wx/canvas/canobj.h"
#include "wx/canvas/candoc.h"
#include "wx/canvas/drawer.h"
#include "wx/canvas/canvas.h"
#include "wx/canvas/cancom.h"

#if wxART2D_USE_EDITOR
    #include "wx/editor/edit.h"
#endif //wxART2D_USE_EDITOR

//----------------------------------------------------------------------------
// globals
//----------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(a2dCurvesArea, a2dPolygonLClipper)
IMPLEMENT_DYNAMIC_CLASS(a2dCurvesAreaList, a2dObject)
IMPLEMENT_DYNAMIC_CLASS(a2dCanvasXYDisplayGroupAreas, a2dCanvasObject)
IMPLEMENT_DYNAMIC_CLASS(a2dCanvasXYDisplayGroup, a2dCanvasXYDisplayGroupAreas)


#ifdef wxUSE_INTPOINT
    #define wxMAX_COORDINATE INT_MAX
    #define wxMIN_COORDINATE INT_MIN
#else
    #define wxMAX_COORDINATE 100e99
    #define wxMIN_COORDINATE 100e-99
#endif

a2dBboxHash::a2dBboxHash(void)
: a2dObject()
{
}
a2dBboxHash::a2dBboxHash(const a2dBboxHash& other, CloneOptions options)
: a2dObject(other)
{
}

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

a2dPropertyIdCanvasObject* a2dCurvesArea::PROPID_curvesarea = NULL;
a2dPropertyIdString* a2dCurvesArea::PROPID_text = NULL;


INITIALIZE_PROPERTIES( a2dCurvesArea, a2dPolygonLClipper )
{
    A2D_PROPID_D( a2dPropertyIdCanvasObject, curvesarea, 0 );
    A2D_PROPID_D( a2dPropertyIdString, text,  wxT("") );
    return true;
}

a2dCurvesArea::a2dCurvesArea(const wxString curveAreaName)
    : a2dPolygonLClipper(), m_group(NULL) 
{
    m_showyaxis = true;
    SetName(curveAreaName);

    a2dBoundingBox extbox(0,0, 1,1);
    SetInternalBoundaries( extbox, 0, 0, 1, 1 );

    m_axisY = new a2dCurveAxisLin( 0, true );
    m_axisY->SetCurvesArea(this);
    m_colour = wxNullColour;

#if defined(_DEBUG) && defined (SMART_POINTER_DEBUG)
    //klion: it is because the CurrentSmartPointerOwner can change in other.m_axesarea->Clone()
    CurrentSmartPointerOwner = this;
#endif
}

a2dCurvesArea::a2dCurvesArea(const a2dCurvesArea& other, CloneOptions options)
    : a2dPolygonLClipper(other, options), m_group(NULL)
{
    m_showyaxis = other.m_showyaxis;

    if( options & clone_members )
        m_axisY = (a2dCurveAxis*) other.m_axisY->Clone( CloneOptions( options & ~ clone_seteditcopy ) );
    else
        m_axisY = other.m_axisY;
    m_axisY->SetCurvesArea(this);

    m_intrect = other.m_intrect;
    m_colour = other.m_colour;

    a2dCanvasObjectList::iterator iter = GetChildObjectList()->begin();
    while( iter != GetChildObjectList()->end() )
    {
        a2dCurveObject* item = wxDynamicCast( (*iter).Get(), a2dCurveObject );
        if ( item )
            item->SetCurvesArea( this );
        ++iter;
    }

#if defined(_DEBUG) && defined (SMART_POINTER_DEBUG)
    //klion: it is because the CurrentSmartPointerOwner can change in other.m_axesarea->Clone()
    CurrentSmartPointerOwner = this;
#endif
}

a2dCurvesArea::~a2dCurvesArea()
{
    if(m_markerShow2 != (a2dMarkerShow*)NULL)
    {
        m_markerShow2->SetRelease(true);
    }
    if(m_markerShow != (a2dMarkerShow*)NULL)
    {
        m_markerShow->SetRelease(true);
    }
    m_axisY->ReleaseChildObjects();
}

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

wxString a2dCurvesArea::GetAxisText() const
{
    //first search if a reserved property exists
    const a2dNamedProperty *p = PROPID_text->GetPropertyListOnly( this );
    if (p)
        return p->StringValueRepresentation();
    return GetName();
}

bool a2dCurvesArea::SetAxisText(const wxString& name)
{
    PROPID_text->SetPropertyToObject( this, name );
    return true;
}

void a2dCurvesArea::World2Curve( double xw, double yw, double& xcurve, double& ycurve )
{
    a2dAffineMatrix mat = m_iworld;
    mat.Invert();
    mat.TransformPoint( xw, yw, xcurve, ycurve );
}

void a2dCurvesArea::Curve2World( double xcurve, double ycurve, double& xw, double& yw )
{
    m_iworld.TransformPoint( xcurve, ycurve, xw, yw );
}

void a2dCurvesArea::SetBoundaries(const a2dBoundingBox& extbox)
{
    a2dBoundingBox box(  extbox.GetMinX() , extbox.GetMinY(), extbox.GetMaxX() , extbox.GetMaxY() );
    SetClippingFromBox( box );
}

void a2dCurvesArea::UpdateInternalBoundaries(const a2dBoundingBox& extbox)
{
    m_iworld.Identity();
    m_iworld.Translate(m_intrect.GetMinX() - extbox.GetMinX(), m_intrect.GetMinY() - extbox.GetMinY());

    wxASSERT_MSG( extbox.GetWidth() != 0, wxT("pixel size can not be zero") );
    wxASSERT_MSG( extbox.GetHeight() != 0, wxT("pixel size can not be zero") );

    m_iworld.Scale(m_intrect.GetWidth() / extbox.GetWidth(), m_intrect.GetHeight() / extbox.GetHeight(),
        m_intrect.GetMinX(), m_intrect.GetMinY());
    //the curves are directly transformed to world coordinates by setting the 
    //inverse to the axisarea.
    m_iworld.Invert();
    if(m_axisY)
        m_axisY->SetPending(true);
    SetPending(true);
}

void a2dCurvesArea::AddCurve(a2dCurve* curve, const wxString curvename )
{
    if ( !curvename.IsEmpty() )
        curve->SetName( curvename );
    Append( curve );
    curve->SetCurvesArea( this );
}

void a2dCurvesArea::AddMarker(a2dMarker* marker )
{
    Append( marker); 
    marker->SetCurvesArea( this );
}

void a2dCurvesArea::RemoveMarker(a2dMarker* marker )
{
    ReleaseChild( marker ); 
}

void a2dCurvesArea::InsertCurve( size_t before, a2dCurve* curve, const wxString curvename )
{
    if ( !curvename.IsEmpty() )
        curve->SetName( curvename );

    Insert( before, curve );
}

a2dCurve* a2dCurvesArea::GetCurve( const wxString curvename )
{
    forEachIn( a2dCanvasObjectList, GetChildObjectList() )
    {
        a2dCanvasObject *obj = *iter;
        if(obj->GetName() == curvename)
            return (a2dCurve*)obj;
    }
    return NULL;
}

a2dBoundingBox a2dCurvesArea::GetCurvesBoundaries()
{
    a2dBoundingBox curvebox;

    forEachIn( a2dCanvasObjectList, GetChildObjectList() )
    {
        a2dCurve* curve = wxDynamicCast( (a2dCanvasObject*)*iter, a2dCurve );
        if ( curve )
            curvebox.Expand( curve->GetCurveBoundaries() );
    }

    if ( !curvebox.GetValid() ) //no child or empty child secure
    {
        //no objects, therefore make the bounding box the x,y of this object
        curvebox.Expand(0,0);
    }

    return curvebox;
}

bool a2dCurvesArea::ProcessCanvasObjectEvent( a2dIterC& ic, a2dHitEvent& hitEvent )
{
    a2dPolygonLClipper::ProcessCanvasObjectEvent( ic, hitEvent );
    m_axisY->ProcessCanvasObjectEvent( ic, hitEvent );
    return hitEvent.m_processed;
}

void a2dCurvesArea::DoWalker( wxObject* parent, a2dWalkerIOHandler& handler )
{
    handler.WalkTask( parent, this, a2dWalker_a2dDerivedCanvasObjectStart );
    a2dPolygonLClipper::DoWalker( parent, handler );

    if (m_axisY)
        m_axisY->Walker( this, handler );

    handler.WalkTask( parent, this, a2dWalker_a2dDerivedCanvasObjectEnd );
}

a2dCanvasObject* a2dCurvesArea::IsHitCurvesWorld ( a2dIterC& ic, a2dHitEvent& hitEvent )
{
    return ChildIsHitWorld( ic, hitEvent );
}


a2dBoundingBox& a2dCurvesArea::Expand(a2dBoundingBox& bbox)
{
    bbox.Expand(m_axisY->GetBbox());
    return bbox;
}

void a2dCurvesArea::DoAddPending( a2dIterC& ic )
{
    a2dPolygonLClipper::DoAddPending( ic );
    m_axisY->AddPending( ic );
}

void a2dCurvesArea::DependencyPending( a2dWalkerIOHandler* handler )
{
/*
    a2dCanvasObjectList::iterator iter = GetChildObjectList()->begin();
    while( iter != GetChildObjectList()->end() )
    {
        a2dCurveObject* item = wxDynamicCast( (*iter).Get(), a2dCurveObject );
        if ( item )
            item->SetCurvesArea( this );
        ++iter;
    }

    iter = m_axisY->GetChildObjectList()->begin();
    while( iter != m_axisY->GetChildObjectList()->end() )
    {
        a2dCurveObject* item = wxDynamicCast( (*iter).Get(), a2dCurveObject );
        if ( item )
            item->SetCurvesArea( this );
        ++iter;
    }
*/

    m_axisY->DependencyPending( handler );
    if(m_axisY->GetPending() && !GetPending())
        SetPending(true);
    a2dPolygonLClipper::DependencyPending( handler );
    if(GetPending() && m_group && !m_group->GetPending())
        m_group->SetPending(true);
}

/*
bool a2dCurvesArea::GetPending(void)
{
    bool retCode = false;
    retCode = retCode || a2dPolygonLClipper::GetPending( );
    retCode = retCode || m_axisY->GetPending( );
    return retCode;
}
*/

void a2dCurvesArea::DoUpdateViewDependentObjects( a2dIterC& ic )
{
    a2dPolygonLClipper::DoUpdateViewDependentObjects( ic );
    m_axisY->UpdateViewDependentObjects( ic );
}


bool a2dCurvesArea::Update( UpdateMode mode )
{
/*
    a2dCanvasObjectList::iterator iter = GetChildObjectList()->begin();
    while( iter != GetChildObjectList()->end() )
    {
        a2dCurveObject* item = wxDynamicCast( (*iter).Get(), a2dCurveObject );
        if ( item )
            item->SetCurvesArea( this );
        ++iter;
    }
    iter = m_axisY->GetChildObjectList()->begin();
    while( iter != m_axisY->GetChildObjectList()->end() )
    {
        a2dCurveObject* item = wxDynamicCast( (*iter).Get(), a2dCurveObject );
        if ( item )
            item->SetCurvesArea( this );
        ++iter;
    }
*/
    bool retCode = a2dPolygonLClipper::Update( mode );
    retCode = m_axisY->Update(mode) || retCode;
    return retCode;
}


bool a2dCurvesArea::DoUpdate( UpdateMode mode, const a2dBoundingBox& childbox, const a2dBoundingBox& clipbox, const a2dBoundingBox& propbox )
{
/*
    a2dCanvasObjectList::iterator iter = GetChildObjectList()->begin();
    while( iter != GetChildObjectList()->end() )
    {
        a2dCurveObject* item = wxDynamicCast( (*iter).Get(), a2dCurveObject );
        if ( item )
            item->SetCurvesArea( this );
        ++iter;
    }
    iter = m_axisY->GetChildObjectList()->begin();
    while( iter != m_axisY->GetChildObjectList()->end() )
    {
        a2dCurveObject* item = wxDynamicCast( (*iter).Get(), a2dCurveObject );
        if ( item )
            item->SetCurvesArea( this );
        ++iter;
    }
*/
//  bool retCode = m_axisY->Update(mode);
    bool retCode = false;

    //curren state of those flags are known after m_axesarea->Update() etc are called.
    m_flags.m_HasToolObjectsBelow = m_flags.m_HasToolObjectsBelow
        || m_axisY->GetHasToolObjectsBelow();

    m_flags.m_HasSelectedObjectsBelow = m_flags.m_HasSelectedObjectsBelow
        || m_axisY->GetHasSelectedObjectsBelow();
    return retCode;
}

void a2dCurvesArea::SetAxes(const a2dBoundingBox& extbox, double x, double y, double& zerox, double& zeroy, double& ixmin, double& ixmax)
{
    GetCurveAreaTransform().TransformPoint(x, y, zerox, zeroy);
    ixmin = m_intrect.GetMinX();
    ixmax = m_intrect.GetMaxX();

    if ( zerox < extbox.GetMinX())
        zerox = extbox.GetMinX();
    else if ( zerox > extbox.GetMaxX() )
        zerox = extbox.GetMaxX();

    m_axisY->SetPosXY(zerox, extbox.GetMinY());
    m_axisY->SetLength( extbox.GetHeight() );

    m_axisY->SetBoundaries( m_intrect.GetMinY(), m_intrect.GetMaxY() );
    m_axisY->Update(a2dCanvasObject::updatemask_normal);
    if(m_group && !m_group->GetPending())
        m_group->SetPending(true);
}

bool a2dCurvesArea::IsCurvesHighlighted() const
{
    const a2dCanvasObjectList* curvesList = GetCurves();
    const_forEachIn( a2dCanvasObjectList, curvesList )
    {
        a2dCurve* curve = wxDynamicCast( (a2dCanvasObject*)*iter, a2dCurve );
        if ( curve && curve->IsHighlighted())
            return true;
    }
    return false;
}

void a2dCurvesArea::SetMarkerShow(a2dMarkerShow* showm)
{
    m_markerShow = showm;
}


void a2dCurvesArea::SetMarkerShow2(a2dMarkerShow* showm)
{
    m_markerShow2 = showm;
}

a2dMarker* a2dCurvesArea::GetCursorMarker() const
{
    const_forEachIn( a2dCanvasObjectList, GetChildObjectList() )
    {
        a2dMarker* marker = wxDynamicCast((a2dCanvasObject*)*iter, a2dMarker);
        if ( marker )
            return marker;
    }
    return NULL;
}

void a2dCurvesArea::SetGroup(a2dCanvasXYDisplayGroupAreas* aGroup)
{
    m_group = aGroup; 
    if(m_group)
    {
        UpdateInternalBoundaries(m_group->GetPlotAreaRect());
        if(m_group->GetCanvasDocument())
        {
            SetCanvasDocument(m_group->GetCanvasDocument());
            if(m_axisY)
                m_axisY->SetCanvasDocument(m_group->GetCanvasDocument());
        }
    }
}

void a2dCurvesArea::SetShowYaxis(bool showyaxis)
{
    m_showyaxis = showyaxis; 
    if(m_axisY) m_axisY->SetPending(true);
    SetPending(true);
//  if(m_group) m_group->SetPending(true);
}


#if wxART2D_USE_CVGIO
void a2dCurvesArea::DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts, a2dObjectList* towrite )
{
    a2dPolygonLClipper::DoSave( parent, out, xmlparts, towrite );
    //TODO: make serializing for m_colour, m_markerShow and m_markerShow2
    if ( xmlparts == a2dXmlSer_attrib )
    {
        out.WriteAttribute( wxT("showyaxis") , m_showyaxis );
        out.WriteNewLine();

        out.WriteAttribute( wxT("ixmin") , m_intrect.GetMinX() );
        out.WriteAttribute( wxT("iymin") , m_intrect.GetMinY() );
        out.WriteAttribute( wxT("ixmax") , m_intrect.GetMaxX() );
        out.WriteAttribute( wxT("iymax") , m_intrect.GetMaxY() );
        out.WriteNewLine();
    }
    else
    {
        out.WriteStartElement( wxT("derived") );
        m_axisY->Save( this, out, towrite);
        out.WriteEndElement();
    }
}

void a2dCurvesArea::DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts )
{
    a2dPolygonLClipper::DoLoad( parent, parser, xmlparts );
    //TODO: make serializing for m_colour, m_markerShow and m_markerShow2
    if ( xmlparts == a2dXmlSer_attrib )
    {
        m_showyaxis = parser.RequireAttributeValueBool( wxT("showyaxis") );

        m_intrect.SetMin( parser.RequireAttributeValueDouble( wxT("ixmin") ),
                          parser.RequireAttributeValueDouble( wxT("iymin") ) );
        m_intrect.SetMax( parser.RequireAttributeValueDouble( wxT("ixmax") ),
                          parser.RequireAttributeValueDouble( wxT("iymax") ) );

// TODO call SetInternalBoundaries() with extbox from a2dCanvasXYDisplayGroupAreas
//      SetInternalBoundaries( m_ixmin, m_iymin, m_ixmax, m_iymax);
    }
    else
    {
        parser.Require( START_TAG, wxT("derived") );
        parser.Next();

        m_axisY->Load( parent, parser );
        parser.ResolveOrAdd( (a2dSmrtPtr<class a2dObject>*) &m_axisY );

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

#include <wx/arrimpl.cpp>
WX_DEFINE_OBJARRAY(a2dCurvesAreaListBase);

a2dCurvesAreaList::a2dCurvesAreaList()
    : m_group(NULL)
{
    m_autoshowyaxes = false;
    a2dBoundingBox extbox(0,0,1,1);
    a2dSmrtPtr<a2dCurvesArea> curvesarea = new a2dCurvesArea();
    curvesarea->SetInternalBoundaries(extbox, 0, 0, 1, 1 );
    Add(curvesarea);
    curvesarea->SetGroup(m_group);
    m_leftAxisY = curvesarea;
}

a2dCurvesAreaList::a2dCurvesAreaList( const a2dCurvesAreaList &other, a2dObject::CloneOptions options)
    : m_group(NULL)
{
    m_autoshowyaxes = other.m_autoshowyaxes;
    for(size_t i=0; i < other.GetCount(); i++)
    {
        a2dSmrtPtr<a2dCurvesArea> area = (a2dCurvesArea*)(other.Item(i).Get()->Clone(a2dObject::CloneOptions( options & ~ a2dObject::clone_seteditcopy )));
        Add( area );
        area->SetGroup(m_group);
        if(other[i].Get() == other.m_leftAxisY)
            m_leftAxisY = area;
        if(other[i].Get() == other.m_rightAxisY)
            m_rightAxisY = area;
    }
}

a2dCurvesAreaList::~a2dCurvesAreaList()
{
    Clear();
}

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

a2dCurvesArea* a2dCurvesAreaList::GetCurvesArea(const wxString& curvesAreaName)
{
    a2dCurvesArea* emptyArea = NULL;
    for(size_t i=0; i < GetCount(); i++)
    {
        a2dCurvesArea* area = Item(i);
        if(area->GetName().IsEmpty())
            emptyArea = area;
        else if(area->GetName() == curvesAreaName)
            return area;
    }
    if(emptyArea != NULL && !curvesAreaName.IsEmpty())
        emptyArea->SetName(curvesAreaName);
    return emptyArea;
}

a2dCurvesArea* a2dCurvesAreaList::GetCurvesArea(const wxString& curvesAreaName) const
{
    a2dCurvesArea* emptyArea = NULL;
    for(size_t i=0; i < GetCount(); i++)
    {
        a2dCurvesArea* area = Item(i);
        if(area->GetName() == curvesAreaName)
            return area;
    }
    return emptyArea;
}

void a2dCurvesAreaList::SetBoundaries(const a2dBoundingBox& extbox)
{
    for(size_t i=0; i < GetCount(); i++)
    {
        a2dCurvesArea* area = Item(i);
        area->SetBoundaries(extbox);
    }
}

bool a2dCurvesAreaList::ProcessCanvasObjectEvent( a2dIterC& ic, a2dHitEvent& hitEvent )
{
    for(size_t i=0; i < GetCount(); i++)
    {
        a2dCurvesArea* area = Item(i);
        area->ProcessCanvasObjectEvent(ic, hitEvent );
    }
    return hitEvent.m_processed;
}

void a2dCurvesAreaList::DoWalker( wxObject* parent, a2dWalkerIOHandler& handler )
{
    handler.WalkTask( parent, this, a2dWalker_a2dDerivedCanvasObjectStart );
    a2dObject::DoWalker( parent, handler );

    for(size_t i=0; i < GetCount(); i++)
    {
        a2dCurvesArea* area = Item(i);
        if (area)
            area->Walker( this, handler );

    }
    handler.WalkTask( parent, this, a2dWalker_a2dDerivedCanvasObjectEnd );
}

a2dCanvasObject* a2dCurvesAreaList::IsHitCurvesWorld (a2dCurvesArea* &area, a2dIterC& ic, a2dHitEvent& hitEvent )
{
    for(size_t i=0; i < GetCount(); i++)
    {
        area = Item(i);
        a2dCanvasObject* curve = area->IsHitCurvesWorld ( ic, hitEvent );
        if(curve)
            return curve;
    }
    return NULL;
}

int a2dCurvesAreaList::AppendInternalBoundaries(a2dBboxHash* irectHash)
{
    for(size_t i=0; i < GetCount(); i++)
    {
        a2dCurvesArea* area = Item(i);
        const a2dBoundingBox& aRect = area->GetInternalBoundaries();
        (*irectHash)[area->GetName()] = aRect;
    }
    return GetCount();
}

int a2dCurvesAreaList::AppendCurvesBoundaries(a2dBboxHash* irectHash)
{
    for(size_t i=0; i < GetCount(); i++)
    {
        a2dCurvesArea* area = Item(i);
        a2dBoundingBox abox = area->GetCurvesBoundaries();
        a2dBoundingBox aRect(abox);
        (*irectHash)[area->GetName()] = aRect;
    }
    return GetCount();
}

a2dBoundingBox& a2dCurvesAreaList::Expand(a2dBoundingBox& bbox) const
{
/*
    for(size_t i=0; i < GetCount(); i++)
    {
        a2dCurvesArea* area = Item(i);
        area->Expand(bbox);
    }
*/
    if(m_leftAxisY)
        m_leftAxisY->Expand(bbox);
    if(m_rightAxisY)
        m_rightAxisY->Expand(bbox);
    return bbox;
}

void a2dCurvesAreaList::AddPending( a2dIterC& ic )
{
    for(size_t i=0; i < GetCount(); i++)
    {
        a2dCurvesArea* area = Item(i);
        area->AddPending(ic);
    }
}

bool a2dCurvesAreaList::Update( a2dCanvasObject::UpdateMode mode )
{
    bool retCode = false;
    a2dCurvesArea* leftAxisY = NULL;
    a2dCurvesArea* rightAxisY = NULL;
    bool leftOK = m_leftAxisY != (a2dCurvesArea*)NULL ? m_leftAxisY->IsCurvesHighlighted() : false;
    bool rightOK = m_rightAxisY != (a2dCurvesArea*)NULL ? m_rightAxisY->IsCurvesHighlighted() : false;
    for(size_t i=0; i < GetCount(); i++)
    {
        a2dCurvesArea* area = Item(i);
//      area->SetGroup(m_group);
        if(m_autoshowyaxes)
            area->SetShowYaxis(false);
        //      area->GetAxisY()->SetInvertTic(false);
        retCode = area->Update(mode) || retCode;
        if(m_autoshowyaxes)
        {
            if(!leftOK || !rightOK)
            {
                if(area->IsCurvesHighlighted())
                {
                    if(!leftAxisY)
                        leftAxisY = area;
                    else if(!rightAxisY)
                        rightAxisY = area;
                }
            }
        }
    }

    if(m_autoshowyaxes)
    {
        if(!leftOK)
        {
            if(leftAxisY)
            {
                if(leftAxisY != m_rightAxisY)
                {
                    m_leftAxisY = leftAxisY;
                    leftOK = true;
                }
            }
            if(!leftOK && rightAxisY)
            {
                if(rightAxisY != m_rightAxisY)
                {
                    m_leftAxisY = rightAxisY;
                    leftOK = true;
                }
            }
        }
        if(!rightOK)
        {
            if(rightAxisY)
            {
                if(rightAxisY != m_leftAxisY)
                {
                    m_rightAxisY = rightAxisY;
                    rightOK = true;
                }
            }
            if(!rightOK && leftAxisY)
            {
                if(leftAxisY != m_leftAxisY)
                {
                    m_rightAxisY = leftAxisY;
                    rightOK = true;
                }
            }
        }
    }
    if(m_leftAxisY != (a2dCurvesArea*)NULL)
    {
        if(m_autoshowyaxes)
        {
            m_leftAxisY->SetShowYaxis(true);
            m_leftAxisY->GetAxisY()->SetInvertTic(false);
            retCode = m_leftAxisY->Update(mode) || retCode;
        }
    }
    if(m_rightAxisY != (a2dCurvesArea*)NULL)
    {
        if(m_autoshowyaxes)
        {
            m_rightAxisY->SetShowYaxis(true);
            m_rightAxisY->GetAxisY()->SetInvertTic(true);
            retCode = m_rightAxisY->Update(mode) || retCode;
        }
    }
    return retCode;
}

void a2dCurvesAreaList::SetAxes(const a2dBoundingBox& extbox, double x, double y, double& zerox, double& zeroy, double& ixmin, double& ixmax)
{
    // klion TODO remake
    double tzerox, tzeroy, tixmin, tixmax;
    for(size_t i=0; i < GetCount(); i++)
    {
        a2dCurvesArea* area = Item(i);
        if(area != m_leftAxisY && area != m_rightAxisY)
            area->SetAxes(extbox, area->GetAxisY()->GetPosition(), y, tzerox, tzeroy, tixmin, tixmax);
    }

    if(m_leftAxisY != (a2dCurvesArea*)NULL)
    {
        if(m_autoshowyaxes)
            m_leftAxisY->SetAxes(extbox, m_leftAxisY->m_intrect.GetMinX(), m_leftAxisY->m_intrect.GetMinY(), zerox, zeroy, ixmin, ixmax);
        else
            m_leftAxisY->SetAxes(extbox, m_leftAxisY->GetAxisY()->GetPosition(), y, zerox, zeroy, ixmin, ixmax);

    }
    if(m_rightAxisY != (a2dCurvesArea*)NULL)
    {
        if(m_autoshowyaxes)
            m_rightAxisY->SetAxes(extbox, m_rightAxisY->m_intrect.GetMaxX(), m_rightAxisY->m_intrect.GetMinY(), tzerox, tzeroy, tixmin, tixmax);
        else
            m_rightAxisY->SetAxes(extbox, m_rightAxisY->GetAxisY()->GetPosition(), y, tzerox, tzeroy, tixmin, tixmax);
    }
}

void a2dCurvesAreaList::RenderAxesY ( a2dIterC& ic, OVERLAP clipparent )
{
    if(m_leftAxisY != (a2dCurvesArea*)NULL)
    {
        if(m_leftAxisY->m_showyaxis)
            m_leftAxisY->m_axisY->Render( ic, clipparent );
    }
    if(m_rightAxisY != (a2dCurvesArea*)NULL)
    {
        if(m_rightAxisY->m_showyaxis)
            m_rightAxisY->m_axisY->Render( ic, clipparent );
    }
}

void a2dCurvesAreaList::Render ( a2dIterC& ic, OVERLAP clipparent )
{
    for(size_t i=0; i < GetCount(); i++)
    {
        a2dCurvesArea* area = Item(i);
        ic.GetDrawer2D()->SetDrawerFill( *a2dTRANSPARENT_FILL );
        ic.GetDrawer2D()->SetDrawerStroke( *a2dTRANSPARENT_STROKE );
        area->Render(ic, clipparent);
    }
}

void a2dCurvesAreaList::SetShowLeftYaxis(const wxString& curveAreaName, bool showyaxis)
{
    //disable the previous a2dCurveArea which was set as m_leftAxisY
    //And set the new one
    for(size_t i=0; i < GetCount(); i++)
    {
        a2dCurvesArea* area = Item(i);
        if(area->GetName() == curveAreaName)
        {
            if(area != m_leftAxisY)
            {
                if(m_leftAxisY != (a2dCurvesArea*) NULL)
                    m_leftAxisY->SetShowYaxis(false);
                m_leftAxisY = area;
            }
            m_leftAxisY->SetShowYaxis(showyaxis);
            if(m_autoshowyaxes)
                m_leftAxisY->GetAxisY()->SetInvertTic(false);
            break;
        }
    }
}

void a2dCurvesAreaList::SetShowRightYaxis(const wxString& curveAreaName, bool showyaxis)
{
    //disable the previous a2dCurveArea which was set as m_rightAxisY
    //And set the new one
    for(size_t i=0; i < GetCount(); i++)
    {
        a2dCurvesArea* area = Item(i);
        if(area->GetName() == curveAreaName)
        {
            if(area != m_rightAxisY)
            {
                if(m_rightAxisY != (a2dCurvesArea*) NULL)
                {
                    if(m_autoshowyaxes)
                        m_rightAxisY->GetAxisY()->SetInvertTic(false);
                    m_rightAxisY->SetShowYaxis(false);
                }
                m_rightAxisY = area;
            }
            m_rightAxisY->SetShowYaxis(showyaxis);
            if(m_autoshowyaxes)
                m_rightAxisY->GetAxisY()->SetInvertTic(true);
            break;
        }
    }
}

/*
double a2dBoundsRound(double val, double inc)
{
    double expon = log10(fabs(val));  ///10.));
    int toInt = int(expon+(expon<0. ? -0.5 : 0.5));
    return double((int(val*pow(10.,-toInt)+inc))*pow(10.,toInt));
}
*/

inline double a2dInternal_BoundsRound(double val, bool tics)
{
    double abs_val = fabs(val);
    if(abs_val < 1E-10)
        return 0.;
    double expon = log10(abs_val);  ///10.));
    int toInt = int(expon < 0 ? expon - 1 : expon);
    double standardized = val*pow(10.,-toInt);
    if(tics)
    {
        int sign = val < 0. ? -1 : 1;
        double abs_standardized = fabs(standardized);
        if(abs_standardized <=1.0001)
            return pow(10.,toInt)*sign;
        else if(abs_standardized <=1.2501)
            return 1.25*pow(10.,toInt)*sign;
        else if(abs_standardized <=2.0001)
            return 2.*pow(10.,toInt)*sign;
        else if(abs_standardized <=2.5001)
            return 2.5*pow(10.,toInt)*sign;
        else if(abs_standardized <=5.0001)
            return 5.*pow(10.,toInt)*sign;
        return 10.*pow(10.,toInt)*sign;
    }
//    double expand = val < 0. ? -0.999999 : 0.999999;
    double expand = val < 0. ? -0.5 : 0.5;
    return double((int(standardized+expand))*pow(10.,toInt));
}

double a2dBoundsRound(double val)
{
    return a2dInternal_BoundsRound(val,false);
}

double a2dTicsRound(double val)
{
    return a2dInternal_BoundsRound(val,true);
}

void a2dCurvesAreaList::SetTicY( int numLines )
{
    if(numLines<2)
        numLines = 2;
//    wxASSERT(numLines);
    double numLines2 = numLines/2;
    int precision = 0;
    for(size_t i=0; i < GetCount(); i++)
    {
        a2dCurvesArea* area = Item(i);
        a2dBoundingBox newRect = area->m_intrect;
        // klion TODO: for negative scale values
//      wxMax(fabs(curMaxY),fabs(curMinY);
//      ???????????
        double curHeight = newRect.GetHeight();
        double meanY = newRect.GetMinY() + curHeight/2.;
        double newHeight = a2dTicsRound(curHeight/(double)numLines)*numLines;
        double aTic = newHeight / (double)numLines;
        wxASSERT(aTic > 1E-12);
        double newMeanY = int((meanY/aTic)+(meanY<0. ? -0.5 : 0.5))*aTic;
        double newMinY = newMeanY-newHeight/2.;
        if(newRect.GetMinY() == 0. && newMinY < 0.)
            newMinY = 0.;
//      double newMinY =  a2d Bounds Round((newRect.m_miny-(newHeight - curHeight)/2.)/aTic*2.)*aTic/2.;
        newRect.SetMinY( newMinY );
        double newMaxY = newMinY + newHeight;
        newRect.SetMaxY( newMaxY );
        area->SetInternalBoundaries(m_group->GetPlotAreaRect(),newRect);
        a2dCurveAxis* axisY = area->GetAxisY();
        axisY->SetTic(aTic);
        precision = m_group->SetAxisTicPrecision(axisY,newMinY,newMaxY);
    }
    if(precision)
        m_group->SetCommonTicPrecision(precision);
}

/*
a2dBoundingBox a2dCurvesAreaList::SetMarkersPos(const a2dBoundingBox& bbox)
{
    a2dBoundingBox tbox(bbox.GetMinX(), bbox.GetMaxY(), bbox.GetMinX(), bbox.GetMaxY());

    for(int i=GetCount()-1; i >= 0 ; i--)
    {
        a2dCurvesArea* area = Item(i);
        a2dMarkerShow* marker2 = wxDynamicCast( (a2dMarkerShow*)area->m_markerShow2, a2dMarkerShow );
        if(marker2)
        {
            marker2->SetPosXY(bbox.GetMinX(), tbox.GetMaxY());
//          marker2->SetLineWidth(bbox.GetWidth());
            marker2->Update( a2dCanvasObject::updatemask_normal );
            tbox.Expand(marker2->GetBbox());
        }
        a2dMarkerShow* marker = wxDynamicCast( (a2dMarkerShow*)area->m_markerShow, a2dMarkerShow );
        if(marker)
        {
            marker->SetPosXY(bbox.GetMinX(), tbox.GetMaxY());
//          marker->SetLineWidth(bbox.GetWidth());
            marker->Update( a2dCanvasObject::updatemask_normal );
            tbox.Expand(marker->GetBbox());
        }
    }
    return tbox;
}
*/

/*
void a2dCurvesAreaList::ChangeCursorPos(double shift)
{
    if(m_leftAxisY)
    {
        a2dMarker* marker = m_leftAxisY->GetCursorMarker();
        if(marker)
        {
            a2dBoundingBox ibox = m_leftAxisY->GetInternalBoundaries();
            double curX = marker->GetPosX() + shift;
            if(curX < ibox.GetMinX()) 
                curX = ibox.GetMinX();
            if(curX > ibox.GetMaxX()) 
                curX = ibox.GetMaxX();
            for(size_t i=0; i < GetCount() ; i++)
            {
                a2dCurvesArea* area = Item(i);
                a2dMarker* curMarker = area->GetCursorMarker();
                if(curMarker)
                {
                    a2dPoint2D point;
                    if(curMarker->GetCurve()->GetXyAtSweep(curX,point))
                        curMarker->SetPosXY(curX,point.m_y);
                }
            }
        }

    }
}
*/

void a2dCurvesAreaList::DependencyPending( a2dWalkerIOHandler* handler )
{
    for(size_t i=0; i < GetCount(); i++)
    {
        a2dCurvesArea* area = Item(i);
//      area->SetGroup(m_group);
        area->DependencyPending( handler );
    }
}

bool a2dCurvesAreaList::GetPending(void)
{
    bool retCode = false;
    for(size_t i=0; i < GetCount(); i++)
    {
        a2dCurvesArea* area = Item(i);
        retCode = retCode || area->GetPending();
    }
    return retCode;
}

void a2dCurvesAreaList::UpdateViewDependentObjects( a2dIterC& ic )
{
    for(size_t i=0; i < GetCount(); i++)
    {
        a2dCurvesArea* area = Item(i);
        area->UpdateViewDependentObjects( ic );
    }
}

void a2dCurvesAreaList::SetCursor(a2dCursor* cursor)
{
    cursor->RemoveMarkers();
    for(size_t i=0; i < GetCount(); i++)
    {
        a2dCurvesArea* area = Item(i);
        a2dMarker* marker = area->GetCursorMarker();
        if(marker)
            cursor->AddMarker(marker);
    }
}

bool a2dCurvesAreaList::GetHasSelectedObjectsBelow()
{
    bool retCode = false;
    for(size_t i=0; i < GetCount() && !retCode; i++)
    {
        a2dCurvesArea* area = Item(i);
        retCode = retCode || area->GetHasSelectedObjectsBelow();
    }
    return retCode;
}

bool a2dCurvesAreaList::GetHasToolObjectsBelow()
{
    bool retCode = false;
    for(size_t i=0; i < GetCount() && !retCode; i++)
    {
        a2dCurvesArea* area = Item(i);
        retCode = retCode || area->GetHasToolObjectsBelow();
    }
    return retCode;
}

void a2dCurvesAreaList::SetClippingFromBox(a2dBoundingBox& bbox)
{
    for(size_t i=0; i < GetCount(); i++)
    {
        a2dCurvesArea* area = Item(i);
        area->SetClippingFromBox(bbox);
    }
}

void a2dCurvesAreaList::SetGroup(a2dCanvasXYDisplayGroupAreas* aGroup)
{
    m_group = aGroup; 
    for(size_t i=0; i < GetCount(); i++)
    {
        a2dCurvesArea* area = Item(i);
        area->SetGroup(aGroup);
    }
}

#if wxART2D_USE_CVGIO
void a2dCurvesAreaList::DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts, a2dObjectList* towrite )
{
    a2dObject::DoSave( parent, out, xmlparts, towrite );
    //TODO: make serializing for m_leftAxisY
    //TODO: make serializing for m_rightAxisY
    if ( xmlparts == a2dXmlSer_attrib )
    {
    }
    else
    {
        out.WriteStartElement( wxT("derived") );

        for(size_t i=0; i < GetCount(); i++)
        {
            a2dCurvesArea* area = Item(i);
            area->Save(this, out, towrite);
        }

        out.WriteEndElement();
    }
}

void a2dCurvesAreaList::DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts )
{
    a2dObject::DoLoad( parent, parser, xmlparts );
    //TODO: make serializing for m_leftAxisY
    //TODO: make serializing for m_rightAxisY
    if ( xmlparts == a2dXmlSer_attrib )
    {
    }
    else
    {
        parser.Require( START_TAG, wxT("derived") );
        parser.Next();

        // TODO: loading
        wxASSERT(0);

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

//----------------------------------------------------------------------------
// a2dCanvasXYDisplayGroupAreas
//----------------------------------------------------------------------------
const a2dPropertyIdRefObject a2dCanvasXYDisplayGroupAreas::PROPID_strokegrid( wxT("strokegrid"), a2dPropertyId::flag_none, 0 );
const a2dPropertyIdRefObject a2dCanvasXYDisplayGroupAreas::PROPID_fillAxisArea( wxT("fillAxisArea"), a2dPropertyId::flag_none, 0 );
//const a2dPropertyIdCanvasObject a2dCanvasXYDisplayGroupAreas::PROPID_axesarea(  wxT("axesarea"), a2dPropertyId::flag_none, 0 );

A2D_BEGIN_EVENT_TABLE(a2dCanvasXYDisplayGroupAreas,a2dCanvasObject)
    A2D_EVT_CANVASOBJECT_MOUSE_EVENT( a2dCanvasXYDisplayGroupAreas::OnCanvasObjectMouseEvent )
    A2D_EVT_CHAR( a2dCanvasXYDisplayGroupAreas::OnChar )
A2D_END_EVENT_TABLE()

void a2dCanvasXYDisplayGroupAreas::DoWalker( wxObject* parent, a2dWalkerIOHandler& handler )
{
    handler.WalkTask( parent, this, a2dWalker_a2dDerivedCanvasObjectStart );
    a2dCanvasObject::DoWalker( parent, handler );

    if (m_axesarealist)
        m_axesarealist->Walker( this, handler );

    if( m_axisX )
        m_axisX->Walker( this, handler );
//    if( m_axisY )
//        m_axisY->Walker( this, handler );
    if( m_cursor )
        m_cursor->Walker( this, handler );

    handler.WalkTask( parent, this, a2dWalker_a2dDerivedCanvasObjectEnd );
}

void a2dCanvasXYDisplayGroupAreas::DoAddPending( a2dIterC& ic )
{
    a2dCanvasObject::DoAddPending( ic );

    m_axisX->AddPending( ic );
    if(m_cursor)
        m_cursor->AddPending( ic );
    m_axesarealist->AddPending(ic);
}

bool a2dCanvasXYDisplayGroupAreas::DoStartEdit( wxUint16 editmode, wxEditStyle editstyle )
{
    if ( m_flags.m_editable )
    {
        PROPID_IncludeChildren->SetPropertyToObject( this, false );
        PROPID_Allowrotation->SetPropertyToObject( this, false );
        PROPID_Allowskew->SetPropertyToObject( this, false );

        return a2dCanvasObject::DoStartEdit( editmode, editstyle );
    }

    return false;
}

bool a2dCanvasXYDisplayGroupAreas::ProcessCanvasObjectEvent( a2dIterC& ic, a2dHitEvent& hitEvent )
{
    if ( ic.GetCanvasView()->GetCaptured() == this )
    {
        a2dCanvasObject::ProcessCanvasObjectEvent( ic, hitEvent );
        return hitEvent.m_processed;
    }

    hitEvent.m_isHit = false;

    // prepare relative to object coordinates for derived objects
    ic.GetInverseTransform().TransformPoint( hitEvent.m_x, hitEvent.m_y, hitEvent.m_relx, hitEvent.m_rely );
    if ( GetBbox().PointInBox(hitEvent.m_relx, hitEvent.m_rely, m_worldExtend + ic.GetHitMarginWorld() + ic.ExtendDeviceToWorld( m_pixelExtend ) ) )
    {
        a2dIterCU cu( ic, this );

        m_axesarealist->ProcessCanvasObjectEvent( ic, hitEvent );
        m_axisX->ProcessCanvasObjectEvent( ic, hitEvent );
    }

    a2dCanvasObject::ProcessCanvasObjectEvent( ic, hitEvent );

    return hitEvent.m_processed;
}


void a2dCanvasXYDisplayGroupAreas::OnChar(wxKeyEvent& event)
{
    if ( m_flags.m_editingCopy )
    {
        switch(event.GetKeyCode())
        {
            case WXK_LEFT:
                {              
                    ChangeCursorPos(-1);
                }
                break;
            case WXK_PAGEDOWN:
                {              
                    ChangeCursorPos(-10);
                }
                break;
            case WXK_HOME:
                {              
                    ChangeCursorPos(-1024);
                }
                break;
            case WXK_RIGHT:
                {                 
                    ChangeCursorPos(1);
                }
                break;
            case WXK_PAGEUP:
                {              
                    ChangeCursorPos(10);
                }
                break;
            case WXK_END:
                {              
                    ChangeCursorPos(1024);
                }
                break;
            default:
                event.Skip();
                break;
        }
/*
        switch(event.GetKeyCode())
        {

            case 'Z':
            case 'z':
            {
                a2dZoomTool* zoom = new a2dZoomTool(this);
                PushTool(zoom);
            }
            break;
            case WXK_SPACE:
            {
                StopTool();
            }
            break;
            case WXK_ESCAPE:
            {
                StopTool();
            }
            break;

            default:
                event.Skip();
        }
*/
   }
    else
        event.Skip();
}

void a2dCanvasXYDisplayGroupAreas::OnCanvasObjectMouseEvent( a2dCanvasObjectMouseEvent& event )
{
     a2dIterC* ic = event.GetIterC();

    if ( m_flags.m_editingCopy )
    {
        //to world group coordinates to do hit test in world group coordinates
        double xw,yw;
        xw = event.GetX();
        yw = event.GetY();

        a2dAffineMatrix atWorld = ic->GetTransform();

        if ( event.GetMouseEvent().LeftDown() )
        {
            if ( event.GetMouseEvent().m_shiftDown )
            {
#if wxART2D_USE_EDITOR
                a2dCanvasXYDisplayGroupAreas* original = wxStaticCast( PROPID_Original->GetPropertyValue( this ).Get(), a2dCanvasXYDisplayGroupAreas );
                a2dIterCU cu( *ic, original );
//klion             a2dIterCU cu2( *ic, original->m_axesarea );
                ic->SetCorridorPath( true, NULL );

                a2dStToolContr* controller = wxStaticCast( PROPID_Controller->GetPropertyValue( this ).Get(), a2dStToolContr );
                a2dDrawRectangleTool* drawrec = new a2dDrawRectangleTool( controller );
                controller->PushTool( drawrec );
                drawrec->SetEditAtEnd( true );
#else //wxART2D_USE_EDITOR
    wxMessageBox( wxT("Need editor module enabled for this") );
#endif //wxART2D_USE_EDITOR

                SetPending( true );
                ic->GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_CROSS ) );
            }
            else if ( event.GetMouseEvent().m_controlDown )
            {
#if wxART2D_USE_EDITOR
                a2dCanvasXYDisplayGroupAreas* original = wxStaticCast( PROPID_Original->GetPropertyValue( this ).Get(), a2dCanvasXYDisplayGroupAreas );
                a2dIterCU cu( *ic, original );
//klion             a2dIterCU cu2( *ic, original->m_axesarea );
                ic->SetCorridorPath( true, NULL );

                a2dStToolContr* controller = wxStaticCast( PROPID_Controller->GetPropertyValue( this ).Get(), a2dStToolContr );
                a2dDrawPolygonLTool* draw = new a2dDrawPolygonLTool( controller );
                controller->PushTool( draw );
                draw->SetEditAtEnd( true );
#else //wxART2D_USE_EDITOR
    wxMessageBox( wxT("Need editor module enabled for this") );
#endif //wxART2D_USE_EDITOR

                SetPending( true );
                ic->GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_CROSS ) );
            }
            else
            {
                a2dHitEvent hitevent = a2dHitEvent(xw, yw, false);
                if ( IsHitWorld( *ic, hitevent ) )
                {
//                    a2dAffineMatrix areaworld = m_axesarea->GetTransformMatrix();

                    a2dCanvasXYDisplayGroupAreas* original = wxStaticCast( PROPID_Original->GetPropertyValue( this ).Get(), a2dCanvasXYDisplayGroupAreas );

                    a2dHitEvent hitinfo( xw, yw, false, a2dCANOBJHITOPTION_LAYERS );
                    hitinfo.m_xyRelToChildren = true;
                    a2dCanvasObject* marker = original->ChildIsHitWorld( *ic, hitinfo );
                    if ( marker  && marker->GetEditable() )
                    {
#if wxART2D_USE_EDITOR
                        a2dIterCU cu( *ic, original );
                        a2dStToolContr* controller = wxStaticCast( PROPID_Controller->GetPropertyValue( this ).Get(), a2dStToolContr );

                        ic->SetCorridorPath( true, NULL );
                        controller->StartEditingObject( marker, *ic );

#else //wxART2D_USE_EDITOR
    wxMessageBox( wxT("Need editor module enabled for this") );
#endif //wxART2D_USE_EDITOR

                        SetPending( true );
                        ic->GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_CROSS ) );
                        event.Skip(); //first event for new tool
                        return;
                    }

                    a2dIterCU cu( *ic, original );
//                    a2dCanvasObject* curve = original->m_axesarea->IsHitWorld( *ic, xw, yw, wxLAYER_ALL, a2dCANOBJHITOPTION_NOROOT );
                    a2dCurvesArea* curvesarea;
                    a2dHitEvent hitinfocurve( xw, yw, false, a2dCANOBJHITOPTION_LAYERS );
                    hitinfocurve.m_xyRelToChildren = true;
                    a2dCanvasObject* curve = original->m_axesarealist->IsHitCurvesWorld( curvesarea, *ic, hitinfocurve );
                    if ( curve && curve->GetEditable() )
                    {
#if wxART2D_USE_EDITOR
//                        a2dIterCU cu2( *ic, original->m_axesarea );
                        a2dStToolContr* controller = wxStaticCast( PROPID_Controller->GetPropertyValue( this ).Get(), a2dStToolContr );

                        ic->SetCorridorPath( true, NULL );
                        controller->StartEditingObject( curve, *ic );

#else //wxART2D_USE_EDITOR
    wxMessageBox( wxT("Need editor module enabled for this") );
#endif //wxART2D_USE_EDITOR

                        SetPending( true );
                        ic->GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_CROSS ) );
                        event.Skip(); //first event for new tool
                        return;
                    }

/*
                    a2dHitEvent hitinfomarkerY( xw, yw, false, a2dCANOBJHITOPTION_LAYERS );
                    hitinfomarkerY.m_xyRelToChildren = true;
                    a2dCanvasObject* axisMarker = original->m_axisY->ChildIsHitWorld( *ic, hitinfomarkerY );
                    if ( axisMarker )
                    {
#if wxART2D_USE_EDITOR
                        a2dIterCU cu2( *ic, original->m_axisY );
                        ic->SetCorridorPath( true, NULL );
                        a2dStToolContr* controller = wxStaticCast( PROPID_controller->GetPropertyValue( this ).Get(), a2dStToolContr );

                        ic->SetCorridorPath( true, NULL );
                        controller->StartEditingObject( curve, *ic );

#else //wxART2D_USE_EDITOR
    wxMessageBox( wxT("Need editor module enabled for this") );
#endif //wxART2D_USE_EDITOR

                        SetPending( true );
                        ic->GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_CROSS ) );
                        event.Skip(); //first event for new tool
                        return;
                    }
*/

                    a2dHitEvent hitinfomarker( xw, yw, false, a2dCANOBJHITOPTION_LAYERS );
                    hitinfomarker.m_xyRelToChildren = true;
                    a2dCanvasObject* axisMarker = original->m_axisX->ChildIsHitWorld( *ic, hitinfomarker );
                    if ( axisMarker && axisMarker->GetEditable() )
                    {
#if wxART2D_USE_EDITOR
                        a2dIterCU cu2( *ic, original->m_axisX );

                        a2dStToolContr* controller = wxStaticCast( PROPID_Controller->GetPropertyValue( this ).Get(), a2dStToolContr );

                        ic->SetCorridorPath( true, NULL );
                        controller->StartEditingObject( axisMarker, *ic );

#else //wxART2D_USE_EDITOR
    wxMessageBox( wxT("Need editor module enabled for this") );
#endif //wxART2D_USE_EDITOR

                        SetPending( true );
                        ic->GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_CROSS ) );
                        event.Skip(); //first event for new tool
                        return;
                    }

                    else
                        event.Skip();
                }
                else
                    EndEdit();
                }
        }
        else if ( event.GetMouseEvent().LeftDClick()  )
        {
            EndEdit();
        }
        else if ( event.GetMouseEvent().Moving() )
        {
/*
            a2dAffineMatrix cworld;
            a2dHit how;
            a2dAffineMatrix areaworld = m_axesarea->GetTransformMatrix();
            a2dAffineMatrix tworld;
            tworld *= m_lworld;
            tworld *= areaworld;

            a2dCanvasObject* curve = m_axesarea->WhichIsHitWorld( &tworld, xw, yw, NULL, how );
            if ( curve )
            {
                event.Skip();
            }
            else
            {
                event.Skip();
            }
*/
            event.Skip();
        }
        else
            event.Skip();
    }
    else
        event.Skip();
}

a2dCanvasXYDisplayGroupAreas::a2dCanvasXYDisplayGroupAreas( double x, double y )
    : a2dCanvasObject(), m_plotrect(0,0,1,1)
{
    m_lworld.Translate(x,y);

    m_layer = wxLAYER_DEFAULT;
    m_cursorOnlyByCurves = true;

    m_showgrid = true;
    m_showxaxis = true;
    m_autoTicYPrecision = true;

    m_strokegrid = a2dStroke(wxColour(10,17,25),16,a2dSTROKE_LONG_DASH  );
    m_fillAxisArea = *a2dTRANSPARENT_FILL;
    m_strokeAxisArea = *a2dTRANSPARENT_STROKE;

    m_axesarealist = new a2dCurvesAreaList();
    m_axesarealist->SetGroup(this);

    m_axisX = new a2dCurveAxisLin();
}

a2dCanvasXYDisplayGroupAreas::~a2dCanvasXYDisplayGroupAreas()
{
//  m_axisY->ReleaseChildObjects();
    m_axisX->ReleaseChildObjects();
    if(m_cursor) {
        m_cursor->RemoveMarkers();
        m_cursor = NULL;
    }
/*
    Dump();
    DumpOwners();
    m_axisX->Dump();
    m_axisX->DumpOwners();
    m_axisY->Dump();
    m_axisY->DumpOwners();
*/
}

a2dCanvasXYDisplayGroupAreas::a2dCanvasXYDisplayGroupAreas( const a2dCanvasXYDisplayGroupAreas &other, CloneOptions options )
    :a2dCanvasObject( other, options )
{
    m_cursorOnlyByCurves = other.m_cursorOnlyByCurves;
    m_showgrid = other.m_showgrid;
    m_showxaxis = other.m_showxaxis;
    m_autoTicYPrecision = other.m_autoTicYPrecision;

    if( options & clone_members )
    {
        m_axisX = (a2dCurveAxis*) other.m_axisX->Clone( CloneOptions( options & ~ clone_seteditcopy ) );
        if(other.m_cursor)
            m_cursor = (a2dCursor*) other.m_cursor->Clone( CloneOptions( options & ~ clone_seteditcopy ) );
        m_strokegrid = other.m_strokegrid;
        m_fillAxisArea = other.m_fillAxisArea;
        m_strokeAxisArea = other.m_strokeAxisArea;
    }
    else
    {
        m_axisX = other.m_axisX;
        m_cursor = other.m_cursor;
        m_strokegrid = other.m_strokegrid;
        m_fillAxisArea = other.m_fillAxisArea;
        m_strokeAxisArea = other.m_strokeAxisArea;
    }

    m_plotrect = other.m_plotrect;

    if( options & clone_members )
        m_axesarealist = (a2dCurvesAreaList*) other.m_axesarealist->Clone( CloneOptions( options & ~ clone_seteditcopy ) );
    else
        m_axesarealist = other.m_axesarealist;
    m_axesarealist->SetGroup(this);
    if(m_axisX && GetCanvasDocument())
        m_axisX->SetCanvasDocument(GetCanvasDocument());

#if defined(_DEBUG) && defined (SMART_POINTER_DEBUG)
    //klion: it is because the CurrentSmartPointerOwner can change in other.m_axesarea->Clone()
    CurrentSmartPointerOwner = this;
#endif
}

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

a2dCurvesArea* a2dCanvasXYDisplayGroupAreas::AddCurvesArea(const wxString& curveAreaName )
{
    a2dSmrtPtr<a2dCurvesArea> curvesarea = m_axesarealist->GetCurvesArea(curveAreaName);
    if(curvesarea == (a2dCurvesArea*)NULL)
    {
        curvesarea = new a2dCurvesArea(curveAreaName);
        wxASSERT_MSG(curvesarea != (a2dCurvesArea*)NULL, wxString::Format(wxT("can't create curves area with name '%s' "), curveAreaName.c_str()) );
        //      curvesarea->SetCanvasDocument(GetCanvasDocument());
        curvesarea->SetBoundaries(m_plotrect);
        m_axesarealist->Add(curvesarea);
        curvesarea->SetGroup(this);

        if(m_axesarealist->m_leftAxisY == (a2dCurvesArea*)NULL)
            m_axesarealist->m_leftAxisY = curvesarea;
        else if(m_axesarealist->m_rightAxisY == (a2dCurvesArea*)NULL)
        {
            m_axesarealist->m_rightAxisY = curvesarea;
            if(m_axesarealist->GetAutoShowYAxes())
                m_axesarealist->m_rightAxisY->GetAxisY()->SetInvertTic(true);
        }
        else 
        {
            m_axesarealist->m_rightAxisY->SetShowYaxis(false);
            //          m_axesarealist->m_rightAxisY->GetAxisY()->SetInvertTic(false);
            m_axesarealist->m_rightAxisY = curvesarea;
            if(m_axesarealist->GetAutoShowYAxes())
                m_axesarealist->m_rightAxisY->GetAxisY()->SetInvertTic(true);
        }
        SetPending(true);
    }
    return curvesarea;
}

void a2dCanvasXYDisplayGroupAreas::AddCurveToArea(const wxString& curveAreaName, a2dCurve* curve, const wxString curvename )
{
    a2dSmrtPtr<a2dCurvesArea> curvesarea = AddCurvesArea(curveAreaName);
    if(curvesarea)
    {
        curvesarea->AddCurve(curve, curvename);
        SetPending(true);
    }
}

void a2dCanvasXYDisplayGroupAreas::InsertCurveToArea( const wxString& curveAreaName, size_t before, a2dCurve* curve, const wxString curvename )
{
    a2dSmrtPtr<a2dCurvesArea> curvesarea = AddCurvesArea(curveAreaName);
    if(curvesarea)
    {
        curvesarea->InsertCurve(before, curve, curvename);
        SetPending(true);
    }
}

void a2dCanvasXYDisplayGroupAreas::AddMarkerToArea(const wxString& curveAreaName, a2dMarker* marker )
{
    a2dCurvesArea* curvesarea = m_axesarealist->GetCurvesArea(curveAreaName);
    wxASSERT_MSG(curvesarea != NULL, wxString::Format(wxT("not found curves area by name '%s' "), curveAreaName.c_str()));
    if(curvesarea)
    {
        curvesarea->AddMarker(marker);
        SetPending(true);
    }
    if(m_cursor)
        m_cursor->AddMarker(marker);
}

void a2dCanvasXYDisplayGroupAreas::RemoveMarkerFromArea(const wxString& curveAreaName, a2dMarker* marker )
{
    a2dCurvesArea* curvesarea = m_axesarealist->GetCurvesArea(curveAreaName);
    wxASSERT_MSG(curvesarea != NULL, wxString::Format(wxT("not found curves area by name '%s' "), curveAreaName.c_str()));
    if(curvesarea)
    {
        curvesarea->RemoveMarker(marker);
        SetPending(true);
    }
    if(m_cursor)
        m_cursor->RemoveMarker(marker);
}

void a2dCanvasXYDisplayGroupAreas::SetCursor(a2dCursor* cursor)
{
    a2dCursor* oldcursor = m_cursor;
    m_cursor = NULL;
    if(oldcursor)
        ReleaseChild(m_cursor);
    m_cursor = cursor;

    if(m_cursor)
        m_axesarealist->SetCursor(m_cursor);

    SetPending(true);
}

void a2dCanvasXYDisplayGroupAreas::ChangeCursorPos(double step)
{
    if(!m_cursor)
        return;
    a2dCurvesArea* baseArea = m_axesarealist->GetBaseCurvesArea();
    double newposx, tempposy;
    a2dAffineMatrix mat = baseArea->GetCurveAreaTransform();
    a2dBoundingBox ibox = baseArea->GetInternalBoundaries();
    mat.Invert();
    mat.TransformPoint(m_cursor->GetPosX(),ibox.GetMinY(),newposx,tempposy);

    double currentPosition = newposx;
    double smallStep = step/(fabs(step));
    newposx += step;
    if(newposx < ibox.GetMinX())
    {
        newposx = ibox.GetMinX();
        smallStep = 1;
    }
    if(newposx > ibox.GetMaxX())
    {
        newposx = ibox.GetMaxX();
        smallStep = -1;
    }
    if(m_cursorOnlyByCurves)
    {
        bool currentPositionOK = m_cursor->CheckPosition(currentPosition);
        double newposition = newposx;
        while(!m_cursor->CheckPosition(newposx))
        {
            newposx += smallStep;
            if(newposx < ibox.GetMinX() || newposx > ibox.GetMaxX())
            {
                newposx = newposition;
                while(!m_cursor->CheckPosition(newposx))
                {
                    newposx -= smallStep;
                    if(newposx < ibox.GetMinX() || newposx > ibox.GetMaxX())
                    {
                        if(currentPositionOK)
                            return;
                        newposx = newposition;
                        m_cursor->SetPosition(newposx,tempposy,baseArea->GetCurveAreaTransform());
                        return;
                    }
                }
            }
        }
    }
    m_cursor->SetPosition(newposx,tempposy,baseArea->GetCurveAreaTransform());
}

a2dCurve* a2dCanvasXYDisplayGroupAreas::GetCurveFromArea(const wxString& curveAreaName, const wxString curvename )
{
    a2dCurvesArea* curvesarea = m_axesarealist->GetCurvesArea(curveAreaName);
    wxASSERT_MSG(curvesarea != NULL, wxString::Format(wxT("not found curve by name '%s' "), curveAreaName.c_str()));
    if(curvesarea)
        return curvesarea->GetCurve(curvename);
    return NULL;
}

a2dCanvasObjectList* a2dCanvasXYDisplayGroupAreas::GetCurvesFromArea(const wxString& curveAreaName)
{
    a2dCurvesArea* curvesarea = m_axesarealist->GetCurvesArea(curveAreaName);
    wxASSERT_MSG(curvesarea != NULL, wxString::Format(wxT("not found curves area by name '%s' "), curveAreaName.c_str()));
    if(curvesarea)
        return curvesarea->GetCurves();
    return NULL;
}

a2dBoundingBox a2dCanvasXYDisplayGroupAreas::GetCurvesBoundariesFromArea(const wxString& curveAreaName)
{
    a2dCurvesArea* curvesarea = m_axesarealist->GetCurvesArea(curveAreaName);
    wxASSERT_MSG(curvesarea != NULL, wxString::Format(wxT("not found curves area by name '%s' "), curveAreaName.c_str()));
    if(curvesarea)
    {
        return curvesarea->GetCurvesBoundaries();
    }
    a2dBoundingBox ibbox;
    return ibbox;
}

a2dCurveAxis* a2dCanvasXYDisplayGroupAreas::GetAreaAxisY(const wxString& curveAreaName) const
{
    a2dCurvesArea* curvesarea = m_axesarealist->GetCurvesArea(curveAreaName);
    wxASSERT_MSG(curvesarea != NULL, wxString::Format(wxT("not found curves area by name '%s' "), curveAreaName.c_str()));
    return curvesarea->GetAxisY();
}

void a2dCanvasXYDisplayGroupAreas::SetAreaAxisY( const wxString& curveAreaName, a2dCurveAxis* axisY )
{
    a2dCurvesArea* curvesarea = m_axesarealist->GetCurvesArea(curveAreaName);
    wxASSERT_MSG(curvesarea != NULL, wxString::Format(wxT("not found curves area by name '%s' "), curveAreaName.c_str()));
    curvesarea->SetAxisY(axisY);
    SetPending(true); 
}

void a2dCanvasXYDisplayGroupAreas::SetShowLeftYaxis(const wxString& curveAreaName, bool showyaxis)
{ 
    m_axesarealist->SetShowLeftYaxis(curveAreaName, showyaxis);
    SetPending(true); 
}

void a2dCanvasXYDisplayGroupAreas::SetShowRightYaxis(const wxString& curveAreaName, bool showyaxis)
{ 
    m_axesarealist->SetShowRightYaxis(curveAreaName, showyaxis);
    SetPending(true); 
}

void a2dCanvasXYDisplayGroupAreas::SetGridStroke( const a2dStroke& stroke)
{
    m_strokegrid = stroke;
    SetPending(true);
}

void a2dCanvasXYDisplayGroupAreas::SetAxisAreaFill( const a2dFill& fill)
{
    m_fillAxisArea = fill;
    SetPending(true);
}

void a2dCanvasXYDisplayGroupAreas::SetAxisAreaStroke( const a2dStroke& stroke)
{
    m_strokeAxisArea = stroke;
    SetPending(true);
}

void a2dCanvasXYDisplayGroupAreas::SetBoundaries(const a2dBoundingBox& extbox)
{
    SetPending(true);
    m_plotrect = extbox;

    m_axesarealist->SetBoundaries(extbox);
}

void a2dCanvasXYDisplayGroupAreas::SetInternalBoundaries( double ximin, double yimin, double ximax, double yimax, const wxString& curveAreaName )
{
    a2dCurvesArea* curvesarea = AddCurvesArea(curveAreaName);
    wxASSERT_MSG(curvesarea != NULL, wxString::Format(wxT("not found curve area by name '%s' "), curveAreaName.c_str()));
    if(curvesarea)
    {
        curvesarea->SetInternalBoundaries(m_plotrect, ximin, yimin, ximax, yimax);
    }
    SetPending(true);
}

void a2dCanvasXYDisplayGroupAreas::SetInternalXBoundaries(double ximin, double ximax)
{
    for(size_t i=0; i < m_axesarealist->GetCount(); i++)
    {
        a2dCurvesArea* area = m_axesarealist->Item(i);
        a2dBoundingBox newRect = area->GetInternalBoundaries();
        newRect.SetMinX( ximin );
        newRect.SetMaxX( ximax );
        area->SetInternalBoundaries(m_plotrect,newRect);
    }
}

a2dBoundingBox a2dCanvasXYDisplayGroupAreas::GetInternalBoundaries(const wxString& curveAreaName) const
{
    a2dCurvesArea* curvesarea = m_axesarealist->GetCurvesArea(curveAreaName);
    wxASSERT_MSG(curvesarea != NULL, wxString::Format(wxT("not found curves area by name '%s' "), curveAreaName.c_str()));
    if(curvesarea)
    {
        return curvesarea->GetInternalBoundaries();
    }
    a2dBoundingBox ibbox;
    return ibbox;
}

int a2dCanvasXYDisplayGroupAreas::AppendInternalBoundaries(a2dBboxHash* irectHash)
{
    return m_axesarealist->AppendInternalBoundaries(irectHash);
}

int a2dCanvasXYDisplayGroupAreas::AppendCurvesBoundaries(a2dBboxHash* irectHash)
{
    return m_axesarealist->AppendCurvesBoundaries(irectHash);
}

a2dAffineMatrix a2dCanvasXYDisplayGroupAreas::GetCurvesAreaTransform(const wxString& curveAreaName)
{
    a2dCurvesArea* curvesarea = m_axesarealist->GetCurvesArea(curveAreaName);
    wxASSERT_MSG(curvesarea != NULL, wxString::Format(wxT("not found curves area by name '%s' "), curveAreaName.c_str()));
    if(curvesarea)
    {
        return curvesarea->GetCurveAreaTransform();
    }
    a2dAffineMatrix amatrix;
    return amatrix;
}

void a2dCanvasXYDisplayGroupAreas::DependencyPending( a2dWalkerIOHandler* handler )
{
/*
    m_axesarealist->SetGroup(this);
    a2dCurvesArea* curvesarea = m_axesarealist->GetBaseCurvesArea();
    if(curvesarea)
    {
        a2dCanvasObjectList::iterator iter = m_axisX->GetChildObjectList()->begin();
        while( iter != m_axisX->GetChildObjectList()->end() )
        {
            a2dCurveObject* item = wxDynamicCast( (*iter).Get(), a2dCurveObject );
            if ( item )
                item->SetCurvesArea( curvesarea );
            ++iter;
        }
    }
*/
    if ( m_flags.m_HighLight )
    {
        bool pendingchild = false;
        pendingchild = pendingchild || m_axesarealist->GetPending();
        pendingchild = pendingchild || m_axisX->GetPending();
        if(m_cursor)
            pendingchild = pendingchild || m_cursor->GetPending();

        if ( !m_flags.m_pending )
            SetPending( pendingchild );
    }
    a2dCanvasObject::DependencyPending( handler );
}

void a2dCanvasXYDisplayGroupAreas::DoUpdateViewDependentObjects( a2dIterC& ic )
{
    a2dCanvasObject::DoUpdateViewDependentObjects( ic );
    m_axesarealist->UpdateViewDependentObjects( ic );
    m_axisX->UpdateViewDependentObjects( ic );
    if(m_cursor)
        m_cursor->UpdateViewDependentObjects( ic );
}

a2dBoundingBox a2dCanvasXYDisplayGroupAreas::GetPlotAreaBbox() const
{
    return m_plotrect;
}

a2dBoundingBox a2dCanvasXYDisplayGroupAreas::DoGetUnTransformedBbox( a2dBboxFlags flags ) const
{
    a2dBoundingBox bbox = GetPlotAreaBbox();

    bbox.Expand( m_axisX->GetBbox() );
    m_axesarealist->Expand(bbox);
//  if(m_cursor)
//      bbox.Expand( m_cursor->GetBbox());

    return bbox;
}

bool a2dCanvasXYDisplayGroupAreas::DoUpdate( UpdateMode mode, const a2dBoundingBox& childbox, const a2dBoundingBox& clipbox, const a2dBoundingBox& propbox )
{
    bool calc = false;

    calc = m_axesarealist->Update( mode );
    calc = m_axisX->Update( mode ) || calc;
    if(m_cursor)
        calc = m_cursor->Update( mode ) || calc;

    //current state of those flags are known after m_axesarea->Update() etc are called.
    m_flags.m_HasToolObjectsBelow = m_flags.m_HasToolObjectsBelow
                                    || m_axesarealist->GetHasToolObjectsBelow()
                                    || m_axisX->GetHasToolObjectsBelow();
                                    //|| m_axisY->GetHasToolObjectsBelow();

    m_flags.m_HasSelectedObjectsBelow = m_flags.m_HasSelectedObjectsBelow
                                    || m_axesarealist->GetHasSelectedObjectsBelow()
                                    || m_axisX->GetHasSelectedObjectsBelow();
                                    //|| m_axisY->GetHasSelectedObjectsBelow();

    if ( !m_bbox.GetValid() || calc )
    {
        if ( m_flags.m_isOnCorridorPath || m_flags.m_editingCopy )
        {
            a2dBoundingBox bbox = GetPlotAreaBbox();
            bbox.Enlarge( bbox.GetWidth()/10 );
            m_axesarealist->SetClippingFromBox( bbox );
        }
        else
        {
            a2dBoundingBox bbox = GetPlotAreaBbox();
            m_axesarealist->SetClippingFromBox( bbox );
        }

        //where is the origin in plot coordinates
        double zerox, zeroy;
        double ixmin, ixmax;
        m_axesarealist->SetAxes(m_plotrect, 0, m_axisX->GetPosition(), zerox, zeroy, ixmin, ixmax);

        if ( zerox < m_plotrect.GetMinX())
            zerox = m_plotrect.GetMinX();
        else if ( zerox > m_plotrect.GetMaxX() )
            zerox = m_plotrect.GetMaxX();

        if ( zeroy < m_plotrect.GetMinY() )
            zeroy = m_plotrect.GetMinY();
        else if ( zeroy > m_plotrect.GetMaxY() )
            zeroy = m_plotrect.GetMaxY();

        if(m_cursor)
        {
            a2dCurvesArea* baseArea = m_axesarealist->GetBaseCurvesArea();
            a2dBoundingBox ibox = baseArea->GetInternalBoundaries();
            a2dAffineMatrix mat = baseArea->GetCurveAreaTransform();
            m_cursor->SetHSize(m_plotrect.GetHeight());
            m_cursor->SetWSize(m_plotrect.GetWidth());
//klion200602           m_cursor->UpdatePosition(m_plotrect.GetMinX(),zeroy, mat);
            m_cursor->UpdatePosition(m_plotrect.GetMinX(),m_plotrect.GetMinY(), mat);
            m_cursor->Update(a2dCanvasObject::updatemask_normal);
        }

        m_axisX->SetPosXY( m_plotrect.GetMinX(), zeroy );
        m_axisX->SetLength( m_plotrect.GetWidth() );
        m_axisX->SetBoundaries( ixmin, ixmax );

        m_bbox = DoGetUnTransformedBbox();
        m_bbox.MapBbox(m_lworld);

        return true;
    }

    return false;
}

void a2dCanvasXYDisplayGroupAreas::DoRender( a2dIterC& ic, OVERLAP clipparent )
{
    //the text objects like all children are rendered after this
    a2dBoundingBox bbox = DoGetUnTransformedBbox();
    ic.GetDrawer2D()->DrawRoundedRectangle( bbox.GetMinX(), bbox.GetMinY(), bbox.GetWidth(), bbox.GetHeight() ,0 );

    //rectangle for the background of the axisarea
    //The fill and outline set for this object will be used for it.
    ic.GetDrawer2D()->SetDrawerFill( m_fillAxisArea );
    ic.GetDrawer2D()->SetDrawerStroke( m_strokeAxisArea );
    ic.GetDrawer2D()->DrawRoundedRectangle( m_plotrect.GetMinX(), m_plotrect.GetMinY(), m_plotrect.GetWidth(), m_plotrect.GetHeight(), 0 );

    if (m_showgrid)
        DrawGrid( ic );

    if(m_cursor)
        m_cursor->Render( ic, clipparent);

    if (m_showxaxis)
        m_axisX->Render( ic, clipparent );
    m_axesarealist->RenderAxesY( ic, clipparent );
    //curves are rendered last
    m_axesarealist->Render( ic, clipparent );
}

void a2dCanvasXYDisplayGroupAreas::DrawGrid( a2dIterC& ic )
{
    double ticx = m_axisX->GetTic();
    double ticy = m_axesarealist->GetTicY();

    double x;
    double y;

    double ticstartx;
    double ticstarty;

    a2dSmrtPtr<a2dCurvesArea> baseArea = m_axesarealist->GetBaseCurvesArea();
    a2dBoundingBox intrect = baseArea->GetInternalBoundaries();

    ic.GetDrawer2D()->SetDrawerFill( *a2dTRANSPARENT_FILL );
    ic.GetDrawer2D()->SetDrawerStroke( m_strokegrid );

    a2dAffineMatrix mat = m_axesarealist->GetBaseCurvesArea()->GetCurveAreaTransform();

    ticstartx = floor( intrect.GetMinX() / ticx + 0.5) * ticx;
    if ( (ticx > 0. && ticstartx <= intrect.GetMinX()) || (ticx < 0. && ticstartx >= intrect.GetMinX()) )
        ticstartx += ticx;
    ticstarty = floor( intrect.GetMinY() / ticy + 0.5) * ticy;
    if ( (ticy > 0. && ticstarty <= intrect.GetMinY()) || (ticy < 0. && ticstarty >= intrect.GetMinY()) )
        ticstarty += ticy;

    //draw gridlines
    for ( x = ticstartx; (ticx > 0. && x < intrect.GetMaxX()) || (ticx < 0. && x > intrect.GetMaxX()) ; x = x+ticx)
    {
        double xw, yw;
        //where is the x in world coordinates
        mat.TransformPoint(x, 0, xw, yw);
        ic.GetDrawer2D()->DrawLine( xw, m_plotrect.GetMinY(), xw, m_plotrect.GetMaxY() );
    }

    for ( y = ticstarty; (ticy > 0. && y < intrect.GetMaxY()) || (ticy < 0. && y > intrect.GetMaxY()) ; y = y+ticy)
    {
        double xw, yw;
        //where is the y in world coordinates
        mat.TransformPoint(0, y, xw, yw);
        ic.GetDrawer2D()->DrawLine( m_plotrect.GetMinX(), yw, m_plotrect.GetMaxX(), yw );
    }
}

bool a2dCanvasXYDisplayGroupAreas::DoIsHitWorld( a2dIterC& WXUNUSED(ic), a2dHitEvent& hitEvent )
{
    hitEvent.m_how = a2dHit::stock_fill;
    return true;
}

wxString a2dCanvasXYDisplayGroupAreas::GetLeftAxisText() const 
{ 
    return m_axesarealist->m_leftAxisY != (a2dCurvesArea*)NULL 
        ? m_axesarealist->m_leftAxisY->GetAxisText() : wxT("");
}

wxString a2dCanvasXYDisplayGroupAreas::GetRightAxisText() const 
{ 
    return m_axesarealist->m_rightAxisY != (a2dCurvesArea*)NULL 
        ? m_axesarealist->m_rightAxisY->GetAxisText() : wxT("");
}

void a2dCanvasXYDisplayGroupAreas::SetAxisText(const wxString& curveAreaName, const wxString& text, const wxColour& color)
{
    a2dCurvesArea* curvesarea = m_axesarealist->GetCurvesArea(curveAreaName);
    wxASSERT_MSG(curvesarea != NULL, wxString::Format(wxT("not found curve by name '%s' "), curveAreaName.c_str()));
    curvesarea->SetAxisText(text);
    curvesarea->SetColor(color);
}

void a2dCanvasXYDisplayGroupAreas::ClearCurvesAreas()
{
    m_axesarealist->m_leftAxisY = (a2dCurvesArea*) NULL;
    m_axesarealist->m_rightAxisY = (a2dCurvesArea*) NULL;
    if(m_cursor) 
        m_cursor->RemoveMarkers();
    m_axesarealist->Empty();
}

void a2dCanvasXYDisplayGroupAreas::SetAreaMarkerShow(const wxString& curveAreaName, a2dMarkerShow* showm)
{
    a2dCurvesArea* curvesarea = m_axesarealist->GetCurvesArea(curveAreaName);
    wxASSERT_MSG(curvesarea != NULL, wxString::Format(wxT("not found curves area by name '%s' "), curveAreaName.c_str()));
    curvesarea->SetMarkerShow(showm);
    SetPending(true);
}

void a2dCanvasXYDisplayGroupAreas::SetAreaMarkerShow2(const wxString& curveAreaName, a2dMarkerShow* showm)
{
    a2dCurvesArea* curvesarea = m_axesarealist->GetCurvesArea(curveAreaName);
    wxASSERT_MSG(curvesarea != NULL, wxString::Format(wxT("not found curves area by name '%s' "), curveAreaName.c_str()));
    curvesarea->SetMarkerShow2(showm);
    SetPending(true);
}

a2dMarkerShow* a2dCanvasXYDisplayGroupAreas::GetAreaMarkerShow(const wxString& curveAreaName) const
{
    a2dCurvesArea* curvesarea = m_axesarealist->GetCurvesArea(curveAreaName);
    wxASSERT_MSG(curvesarea != NULL, wxString::Format(wxT("not found curves area by name '%s' "), curveAreaName.c_str()));
    return curvesarea->GetMarkerShow();
}

a2dMarkerShow* a2dCanvasXYDisplayGroupAreas::GetAreaMarkerShow2(const wxString& curveAreaName) const
{
    a2dCurvesArea* curvesarea = m_axesarealist->GetCurvesArea(curveAreaName);
    wxASSERT_MSG(curvesarea != NULL, wxString::Format(wxT("not found curves area by name '%s' "), curveAreaName.c_str()));
    return curvesarea->GetMarkerShow2();
}

void a2dCanvasXYDisplayGroupAreas::SetTicY(int numLines)
{
    m_axesarealist->SetTicY(numLines);
}

int a2dCanvasXYDisplayGroupAreas::SetAxisTicPrecision(a2dCurveAxis* axisY, double newMinY, double newMaxY)
{
    if(m_autoTicYPrecision)
    {
        double aTic = axisY->GetTic();
        double abs_tic = fabs(aTic);
        int precision = 1;
        double maxVal = wxMax(fabs(newMinY),fabs(newMaxY));
        if( maxVal > 999999. )
        {
            axisY->SetTicFormat(wxT("%.6e"));
            precision = 5;
        }
        else if(abs_tic<=1E-6)
        {
            axisY->SetTicFormat(wxT("%.6e"));
            if(precision != 5)
                precision = 4;
        }
        else if(abs_tic<=1E-4)
        {
            axisY->SetTicFormat(wxT("%.4e"));
            if(precision != 4 && precision != 5)
                precision = 3;
        }
        else if(abs_tic<=0.026)
        {
            axisY->SetTicFormat(wxT("%.3f"));
            if(precision != 1)
                precision = 2;
        }
        else if(abs_tic>=1.)
        {
            if(int(abs_tic)*10 == int(abs_tic*10.) )
                axisY->SetTicFormat(wxT("%.0f"));
            else if(int(abs_tic*10)*10 == int(abs_tic*100.))
                axisY->SetTicFormat(wxT("%.1f"));
            else
                axisY->SetTicFormat(wxT("%.2f"));
        }
        else
            axisY->SetTicFormat(wxT("%.2f"));
        return precision;
    }
    return 0;
}

void a2dCanvasXYDisplayGroupAreas::SetCommonTicPrecision(int precision)
{
    if(m_autoTicYPrecision)
    {
        wxString commonTicFormat;
        switch(precision)
        {
        default:
        case 1: commonTicFormat = wxT("-99.99"); break;
        case 2: commonTicFormat = wxT("-99.999"); break;
        case 3: commonTicFormat = wxT("-9.9999E+99"); break;
        case 4: case 5: commonTicFormat = wxT("-9.999999E+99"); break;
        }
        for(size_t i=0; i < m_axesarealist->GetCount(); i++)
        {
            a2dCurvesArea* area = m_axesarealist->Item(i);
            area->GetAxisY()->SetCommonTicFormat(commonTicFormat);
        }
    }
}

#if wxART2D_USE_CVGIO
void a2dCanvasXYDisplayGroupAreas::DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite )
{
    a2dCanvasObject::DoSave( parent, out, xmlparts, towrite );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        out.WriteAttribute( wxT("cursorOnlyByCurves") , m_cursorOnlyByCurves );
        out.WriteAttribute( wxT("showgrid") , m_showgrid );
        out.WriteAttribute( wxT("showxaxis") , m_showxaxis );
        out.WriteAttribute( wxT("autoTicYPrecision") , m_autoTicYPrecision );
        out.WriteNewLine();

        out.WriteAttribute( _T("xmin") , m_plotrect.GetMinX() );
        out.WriteAttribute( wxT("ymin") , m_plotrect.GetMinY() );
        out.WriteAttribute( _T("xmax") , m_plotrect.GetMaxX() );
        out.WriteAttribute( wxT("ymax") , m_plotrect.GetMaxY() );
        out.WriteNewLine();
    }
    else
    {
        out.WriteStartElement( wxT("derived") );

        m_strokegrid.Save( this, out, towrite );
        m_fillAxisArea.Save( this, out, towrite );
        m_strokeAxisArea.Save( this, out, towrite );

        m_axesarealist->Save( this, out, towrite);

        m_axisX->Save( this, out, towrite);
//        m_axisY->Save( this, out, towrite);

        if(m_cursor)
            m_cursor->Save( this, out, towrite);

        out.WriteEndElement();
    }
}

void a2dCanvasXYDisplayGroupAreas::DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts )
{
    a2dCanvasObject::DoLoad( parent, parser, xmlparts );
    if ( xmlparts == a2dXmlSer_attrib )
    {
        m_cursorOnlyByCurves = parser.RequireAttributeValueBool( wxT("cursorOnlyByCurves") );
        m_showgrid = parser.RequireAttributeValueBool( wxT("showgrid") );
        m_showxaxis = parser.RequireAttributeValueBool( wxT("showxaxis") );
        m_autoTicYPrecision = parser.RequireAttributeValueBool( wxT("autoTicYPrecision") );

        m_plotrect.SetMin( parser.RequireAttributeValueDouble( wxT("xmin") ),
                          parser.RequireAttributeValueDouble( wxT("ymin") ) );
        m_plotrect.SetMax( parser.RequireAttributeValueDouble( wxT("xmax") ),
                          parser.RequireAttributeValueDouble( wxT("ymax") ) );
    }
    else
    {
        parser.Require( START_TAG, wxT("derived") );
        parser.Next();

        // new strokes, since the current ones might be shared by other objects too.
        m_strokegrid = m_strokegrid;
        m_fillAxisArea = m_fillAxisArea;
        m_strokeAxisArea = m_strokeAxisArea;

        m_strokegrid.Load( parent, parser );
        parser.ResolveOrAdd( (a2dSmrtPtr<class a2dObject>*) &m_strokegrid );
        m_fillAxisArea.Load( parent, parser );
        parser.ResolveOrAdd( (a2dSmrtPtr<class a2dObject>*) &m_fillAxisArea );
        m_strokeAxisArea.Load( parent, parser );
        parser.ResolveOrAdd( (a2dSmrtPtr<class a2dObject>*) &m_strokeAxisArea );

        m_axesarealist->Load( parent, parser );
        parser.ResolveOrAdd( (a2dSmrtPtr<class a2dObject>*) &m_axesarealist );

        m_axisX->Load( parent, parser );
        parser.ResolveOrAdd( (a2dSmrtPtr<class a2dObject>*) &m_axisX );

        if ( parser.HasAttribute( wxT("cursor") ) )
        {
            parser.ResolveOrAdd( (a2dSmrtPtr<class a2dObject>*) &m_cursor, parser.GetAttributeValue( wxT("cursor") ) );
        }

        parser.Require( END_TAG, wxT("derived") );
        parser.Next();
    }
}

a2dCanvasXYDisplayGroup::a2dCanvasXYDisplayGroup( double x, double y )
: a2dCanvasXYDisplayGroupAreas(x, y)
{
#if defined(_DEBUG) && defined (SMART_POINTER_DEBUG)
    //klion: it is because the CurrentSmartPointerOwner can change in other.m_axesarea->Clone()
    CurrentSmartPointerOwner = this;
#endif
}

a2dCanvasXYDisplayGroup::~a2dCanvasXYDisplayGroup()
{
}

a2dCanvasXYDisplayGroup::a2dCanvasXYDisplayGroup( const a2dCanvasXYDisplayGroup &other, CloneOptions options )
:a2dCanvasXYDisplayGroupAreas( other, options )
{

#if defined(_DEBUG) && defined (SMART_POINTER_DEBUG)
    //klion: it is because the CurrentSmartPointerOwner can change in other.m_axesarea->Clone()
    CurrentSmartPointerOwner = this;
#endif
}

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


#endif //wxART2D_USE_CVGIO

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