imageioh.cpp

Go to the documentation of this file.

/*! \file canextobj/src/imageioh.cpp
    \author Klaas Holwerda

    Copyright: 2001-2004 (c) Klaas Holwerda

    Licence: wxWidgets Licence

    RCS-ID: $Id: imageioh.cpp,v 1.27 2009/10/01 19:22:35 titato Exp $
*/

#include "a2dprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

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

#include "wx/canextobj/imageioh.h"


//----------------------------------------------------------------------------
// a2dCanvasDocumentIOHandlerImageIn
//----------------------------------------------------------------------------

a2dCanvasDocumentIOHandlerImageIn::a2dCanvasDocumentIOHandlerImageIn( wxBitmapType type )
{
    m_type = type;
    m_imageSize = wxSize( 1000, 1000 );
    m_docClassInfo = &a2dCanvasDocument::ms_classInfo;
}

a2dCanvasDocumentIOHandlerImageIn::~a2dCanvasDocumentIOHandlerImageIn()
{
}

wxBitmapType a2dCanvasDocumentIOHandlerImageIn::DetectImageType()
{
    wxASSERT_MSG( m_streami , wxT("m_stream not set") );

    wxImageHandler* handlerfound = NULL;
    wxList::compatibility_iterator node = wxImage::GetHandlers().GetFirst();
    while (node)
    {
        SeekI( 0 );
        wxImageHandler *handler = (wxImageHandler*)node->GetData();
#if wxUSE_STD_IOSTREAM
        wxASSERT_MSG( 0 , wxT("this type of stream, not implemented") );
#else 
        if ( handler->CanRead( *m_streami ) )
#endif
        {
            handlerfound = handler;
            break;
        }
        node = node->GetNext();
    }
    SeekI( 0 );
    if ( handlerfound )
        return (wxBitmapType) handlerfound->GetType();
    return wxBITMAP_TYPE_ANY;
}

bool a2dCanvasDocumentIOHandlerImageIn::CanLoad( a2dDocumentInputStream& stream, const wxObject* obj, wxClassInfo* docClassInfo )
{
    if ( obj && !wxDynamicCast( obj, a2dCanvasDocument) )
        return false;

    if ( docClassInfo && m_docClassInfo && !docClassInfo->IsKindOf( m_docClassInfo ) )
        return false;

    m_streami = &stream;

    wxImageHandler* handlerfound = NULL;
    if ( m_type == wxBITMAP_TYPE_ANY )
    {
        long type = DetectImageType();
        m_streami = NULL;
        if ( type == wxBITMAP_TYPE_ANY )
            return false;
    }
    else
    {
        m_streami = NULL;
        if ( !wxImage::FindHandler( m_type ) )
            return false;
    }

    m_streami = NULL;
    return true;
}

bool a2dCanvasDocumentIOHandlerImageIn::Load( a2dDocumentInputStream& stream , wxObject* obj )
{
    m_streami = &stream;
    m_doc = wxStaticCast( obj, a2dCanvasDocument);

    bool oke = true;

    wxImageHandler* handler = NULL;
    if ( m_type == wxBITMAP_TYPE_ANY )
    {
        wxBitmapType type = DetectImageType();
        if ( type == wxBITMAP_TYPE_ANY )
            return false;
        handler = wxImage::FindHandler( type );
    }
    else 
        handler = wxImage::FindHandler( m_type );

    if ( !handler )
        return false;

    try
    {
      InitializeLoad();

      wxImage image;

#if !wxUSE_STD_IOSTREAM 
      if ( handler->LoadFile( &image, stream ) )
      {
          m_doc->Append( new a2dImage(image, 0, 0, m_imageSize.GetWidth(), m_imageSize.GetHeight() ) );
          return true;
      } 
#else
          return false;
#endif

    }
    catch ( ... )
    {
       oke = false;
       a2dDocviewGlobals->ReportErrorF( a2dError_NotSpecified, _("error in Image file reading\n %s \n"),_(""));
    }

    ResetLoad();

    return oke;
}

//----------------------------------------------------------------------------
// a2dCanvasDocumentIOHandlerImageOut
//----------------------------------------------------------------------------

void a2dCanvasDocumentIOHandlerImageOut::SetViewRectangle( double minx, double miny, double maxx, double maxy )
{
    m_viewBox = a2dBoundingBox( minx, miny, maxx, maxy );
}

void a2dCanvasDocumentIOHandlerImageOut::SetBorder( wxUint16 border, bool percentual )
{ 
    m_border = border; 
    m_borderpercentual = percentual;
    if ( m_borderpercentual )
    {
        wxASSERT_MSG( m_border >= 0 && m_border <= 100 , wxT("percentage must be >=0 and <= 100") );
    }
}

a2dCanvasDocumentIOHandlerImageOut::a2dCanvasDocumentIOHandlerImageOut( wxBitmapType type )
{
    m_border = 0;
    m_borderpercentual = true;
    m_typeDetectedFromFilename = m_type = type;
    m_imageSize = wxSize( 0, 0 );
    m_showObject = NULL;
    m_yaxis = true;
    m_drawer2D = NULL;
    m_maxWidthHeight = 0;
}

a2dCanvasDocumentIOHandlerImageOut::~a2dCanvasDocumentIOHandlerImageOut()
{
    if ( m_drawer2D )
        delete m_drawer2D;
}

void a2dCanvasDocumentIOHandlerImageOut::SetDrawer2D( a2dDrawer2D* drawer2d ) 
{ 
    if ( m_drawer2D )
        delete m_drawer2D;

    m_drawer2D = drawer2d; 
    if ( m_drawer2D )
    {
        m_drawer2D->SetBufferSize( m_imageSize.GetWidth(), m_imageSize.GetHeight() );
    }
}

bool a2dCanvasDocumentIOHandlerImageOut::CanSave( const wxObject* obj )
{
    // if type is ANY, it will find the one liking the extension
    wxImageHandler* handler = NULL;
    handler = wxImage::FindHandler( wxBITMAP_TYPE_ANY == m_type? (wxBitmapType) -1 : m_type );
    if ( !handler )
        return false;

    m_typeDetectedFromFilename = m_type;
    return true;
}

bool a2dCanvasDocumentIOHandlerImageOut::Save( a2dDocumentOutputStream& stream, const wxObject* doc )
{
    m_doc = wxStaticCast( doc, a2dCanvasDocument);
    m_streamo = &stream;
    //int isOK = stream.IsOk ();

    InitializeSave();

    bool res = false;

    wxImage image = RenderImage( m_doc );

    wxImageHandler* handler = wxImage::FindHandler( wxBITMAP_TYPE_ANY == m_type? m_typeDetectedFromFilename : m_type );
    if ( handler )
    {
#if wxUSE_STD_IOSTREAM

#else //wxUSE_STD_IOSTREAM
        res = image.SaveFile( *m_streamo, m_type );
#endif //wxUSE_STD_IOSTREAM
    }
    ResetSave();

    return res;
}

wxImage a2dCanvasDocumentIOHandlerImageOut::RenderImage( a2dCanvasDocument* document )
{
    m_doc = document;

    if ( !m_showObject )
    {
        m_showObject = m_doc->GetRootObject();
    }

    if ( !m_viewBox.GetValid() )
    {   // view will be based on showobject its boundingbox  
        m_viewBox = m_showObject->GetBbox();
        a2dAffineMatrix cworld = m_showObject->GetTransformMatrix();
        cworld.Invert();
        m_viewBox.MapBbox(cworld);
    }

    double w = m_viewBox.GetWidth();
    double h = m_viewBox.GetHeight();

    if ( w == 0 )
        w=1000;
    if ( h== 0 )
        h=1000;

    //virtual coordinates box its miminum X ( calculated to 
    double virt_minX;
    //virtual coordinates box its miminum Y
    double virt_minY;
    //user units per pixel in x
    double xpp;
    //user units per pixel in y
    double ypp;


    if ( m_imageSize.GetWidth() == 0 || m_imageSize.GetHeight() == 0 )
    {
        m_maxWidthHeight = wxGetNumberFromUser(_("Give Maximum pixel size in width and height:"), _("Pixels:"), _("Pixel"), m_maxWidthHeight, 0, 50000 );       
        m_imageSizeCalc = wxSize( m_maxWidthHeight, m_maxWidthHeight );

        //first calculate an image size that fits the maximum size.
        xpp = w/m_maxWidthHeight;
        ypp = h/m_maxWidthHeight;
        if ( xpp > ypp )
            m_imageSizeCalc = wxSize( m_maxWidthHeight, (int) (h/xpp) );
        else
            m_imageSizeCalc = wxSize( (int) (w/ypp), m_maxWidthHeight );
    }
    else 
        m_imageSizeCalc = m_imageSize;

    // the rect to show in world coordinates is calculated, 
    // such that it fits within the image.
    double uppx;
    double uppy;
    int clientw = m_imageSizeCalc.GetWidth();
    int clienth = m_imageSizeCalc.GetHeight();

    int border = m_border;
    if ( m_borderpercentual )
        border = (int) (wxMin( clientw, clienth ) * m_border/100.0) ;

    if ( clientw - border > 0 )
        clientw = clientw - border;

    if ( clienth - border > 0 )
        clienth = clienth - border;

    uppx = w/clientw;
    uppy = h/clienth;
    if ( uppx < uppy )
        uppx = uppy;

    double middlexworld = m_viewBox.GetMinX()+w/2.0;
    double middleyworld = m_viewBox.GetMinY()+h/2.0;
    virt_minX = middlexworld - ( clientw + border )/2.0*uppx;
    virt_minY = middleyworld - ( clienth + border )/2.0*uppx;
    xpp = uppx;
    ypp = uppx;
  
    if ( !m_drawer2D )
        m_drawer2D = new a2dMemDcDrawer( m_imageSizeCalc.GetWidth(), m_imageSizeCalc.GetHeight() );
    else
        m_drawer2D->SetBufferSize( m_imageSizeCalc.GetWidth(), m_imageSizeCalc.GetHeight() );
    m_drawer2D->SetMappingDeviceRect( 0, 0, m_imageSizeCalc.GetWidth(), m_imageSizeCalc.GetHeight() );

    a2dCanvasView* bitmapview = new a2dCanvasView( m_imageSizeCalc.GetWidth(), m_imageSizeCalc.GetHeight(), m_drawer2D );
    bitmapview->SetDocument( m_doc );
    bitmapview->SetShowObject( m_showObject );
    bitmapview->GetDrawer2D()->SetYaxis( m_yaxis );
    
    // ensure all pending objects are reported
    bitmapview->Update( a2dCANVIEW_UPDATE_OLDNEW );
    bitmapview->GetDrawer2D()->SetMappingUpp( virt_minX , virt_minY, xpp, ypp );
    bitmapview->Update( a2dCANVIEW_UPDATE_ALL | a2dCANVIEW_UPDATE_AREAS | a2dCANVIEW_UPDATE_BLIT );

    wxImage image = bitmapview->GetDrawer2D()->GetBuffer().ConvertToImage(); 

    bitmapview->SetDrawer2D( NULL, true ); 
    bitmapview->SetClosed();

    return image;
}

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