/* This file is part of the KDE project
   Copyright (C) 2006 Fredrik Edemar <f_edemar@linux.se>

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License.

   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
*/
#include "kspread_object.h"
#include "kspread_canvas.h"
#include "kspread_doc.h"
#include "kspread_sheet.h"
#include "kspread_view.h"

#include <assert.h>
#include <kapplication.h>
#include <kdebug.h>
#include <kimageeffect.h>
#include <kparts/partmanager.h>
#include <koChart.h>

#include <tqbitmap.h>
#include <tqbuffer.h>
#include <tqcursor.h>
#include <tqdom.h>
#include <tqfileinfo.h>
#include <tqimage.h>
#include <tqpainter.h>
#include <tqpixmap.h>
#include <tqwmatrix.h>

#include <KoDocument.h>
#include <KoDocumentChild.h>
#include <KoDom.h>
#include <KoXmlWriter.h>
#include <KoZoomHandler.h>

using namespace KSpread;

class Sheet;
class View;

/**********************************************************
 *
 * EmbeddedObject
 *
 **********************************************************/
EmbeddedObject::EmbeddedObject( Sheet *_sheet, const KoRect& _tqgeometry )
  : m_tqgeometry( _tqgeometry), m_sheet(_sheet), m_objectName(""), m_selected(false), m_protect(false), m_keepRatio(false), pen( TQt::black, 1, Qt::SolidLine )
{
  angle = 0.0;
  inObjList = true;
  cmds = 0;
}

EmbeddedObject::~EmbeddedObject()
{
}
KoRect EmbeddedObject::tqgeometry()
{
    return m_tqgeometry;
}
void EmbeddedObject::setGeometry( const KoRect &rect )
{
    m_tqgeometry = rect;
}

void EmbeddedObject::moveBy( const KoPoint &_point )
{
  m_tqgeometry.moveTopLeft( m_tqgeometry.topLeft() + _point );
}

void EmbeddedObject::moveBy( double _dx, double _dy )
{
  m_tqgeometry.moveTopLeft( m_tqgeometry.topLeft() + KoPoint( _dx, _dy ) );
}

void EmbeddedObject::resizeBy( const KoSize & _size )
{
  resizeBy( _size.width(), _size.height() );
}

void EmbeddedObject::resizeBy( double _dx, double _dy)
{
  m_tqgeometry.setSize( KoSize( m_tqgeometry.width()+_dx, m_tqgeometry.height()+_dy) );
} // call (possibly reimplemented) setSize

bool EmbeddedObject::load( const TQDomElement& /*element*/ )
{
    kdDebug() << "Loading EmbeddedObject" << endl;
    return false;
}

void EmbeddedObject::loadOasis(const TQDomElement &element, KoOasisLoadingContext & context )
{
  if(element.hasAttributeNS( KoXmlNS::draw, "name" ))
    m_objectName = element.attributeNS( KoXmlNS::draw, "name", TQString());
  m_tqgeometry.setX( KoUnit::parseValue( element.attributeNS( KoXmlNS::svg, "x", TQString() ) ) );
  m_tqgeometry.setY( KoUnit::parseValue( element.attributeNS( KoXmlNS::svg, "y", TQString() ) ) );
  m_tqgeometry.setWidth(KoUnit::parseValue( element.attributeNS( KoXmlNS::svg, "width", TQString() )) );
  m_tqgeometry.setHeight(KoUnit::parseValue( element.attributeNS( KoXmlNS::svg, "height", TQString() ) ) );
    //kdDebug()<<" orig.x() :"<<orig.x() <<" orig.y() :"<<orig.y() <<"ext.width() :"<<ext.width()<<" ext.height(): "<<ext.height()<<endl;
  KoStyleStack &styleStack = context.styleStack();

  styleStack.setTypeProperties( "" ); //no type default type
}


TQDomElement EmbeddedObject::save( TQDomDocument& /*doc*/ )
{
    kdDebug() << "Saving EmbeddedObject..." << endl;
    return TQDomElement();
}

void EmbeddedObject::saveOasisPosObject( KoXmlWriter &xmlWriter, int indexObj ) const
{
    xmlWriter.addAttribute( "draw:id", "object" + TQString::number( indexObj ) );
    //save all into pt
    xmlWriter.addAttributePt( "svg:x", sheet()->doc()->savingWholeDocument() ? m_tqgeometry.x() : m_tqgeometry.x() + 20.0 );
    xmlWriter.addAttributePt( "svg:y", sheet()->doc()->savingWholeDocument() ? m_tqgeometry.y() : m_tqgeometry.y() + 20.0 );
    xmlWriter.addAttributePt( "svg:width", m_tqgeometry.width() );
    xmlWriter.addAttributePt( "svg:height", m_tqgeometry.height() );

//     if ( kAbs( angle ) > 1E-6 )
//     {
//         double value = -1 * ( ( double )angle* M_PI )/180.0;
//         TQString str=TQString( "rotate (%1)" ).tqarg( value );
//         xmlWriter.addAttribute( "draw:transform", str );
//     }
}

bool EmbeddedObject::saveOasisObjectAttributes( KSpreadOasisSaveContext &/* sc */ ) const
{
    kdDebug() << "bool saveOasisObjectAttributes not implemented";
    return true;
}

bool EmbeddedObject::saveOasisObject( KSpreadOasisSaveContext &sc ) const
{
    sc.xmlWriter.startElement( getOasisElementName() );
    //sc.xmlWriter.addAttribute( "draw:style-name", getStyle( sc ) );
    saveOasisPosObject( sc.xmlWriter, sc.indexObj );
    if( !getObjectName().isEmpty())
        sc.xmlWriter.addAttribute( "draw:name", getObjectName() );

    saveOasisObjectAttributes( sc );

    sc.xmlWriter.endElement();
    return true;
}

void EmbeddedObject::draw( TQPainter *_painter )
{
  paintSelection(_painter, SM_MOVERESIZE );
}

TQPixmap EmbeddedObject::toPixmap()
{
	return toPixmap( 1.0 , 1.0 );
}

TQPixmap EmbeddedObject::toPixmap(TQSize size)
{
	double xZoom;
	double yZoom;

	calculateRequiredZoom( size , xZoom , yZoom );

	return toPixmap(xZoom,yZoom);
}

TQPixmap EmbeddedObject::toPixmap(double /*xZoom*/ , double /*yZoom*/)
{
	return TQPixmap();

}

void EmbeddedObject::calculateRequiredZoom( TQSize desiredSize, double& xZoom, double& yZoom)
{
	TQSize actualSize = tqgeometry().size().toTQSize();

	xZoom = (double) desiredSize.width() / (double)actualSize.width();
	yZoom = (double) desiredSize.height() / (double)actualSize.height();
}

void EmbeddedObject::paintSelection( TQPainter *_painter, SelectionMode mode )
{
  if ( !m_selected || mode == SM_NONE )
    return;

  _painter->save();
  KoRect bound( tqgeometry().left(), tqgeometry().top(),
                tqgeometry().width() , tqgeometry().height() );
  TQRect zoomedBound = sheet()->doc()->zoomRect( bound ) ;

  //_painter->setPen( TQPen( TQt::black, 1, TQPen::SolidLine ) );
  _painter->setPen( pen );
  _painter->setBrush( kapp->palette().color( TQPalette::Active, TQColorGroup::Highlight ) );

  //KoRect r = rotateRectObject(); // TODO: rotation
  KoRect r = /*KoRect::fromTQRect*/( bound );
  int x = sheet()->doc()->zoomItX( r.left() /*- orig.x()*/);
  int y = sheet()->doc()->zoomItY( r.top() /*- orig.y()*/);
  int zX6 = /*sheet()->doc()->zoomItX*/( 6 );
  int zY6 = /*sheet()->doc()->zoomItY*/( 6 );
  int w = sheet()->doc()->zoomItX(r.width()) - 6;
  int h = sheet()->doc()->zoomItY(r.height()) - 6;

  if ( mode == SM_MOVERESIZE ) {
    _painter->drawRect( x, y,  zX6, zY6 );
    _painter->drawRect( x, y + h / 2, zX6, zY6 );
    _painter->drawRect( x, y + h, zX6, zY6 );
    _painter->drawRect( x + w, y, zX6, zY6 );
    _painter->drawRect( x + w, y + h / 2, zX6, zY6 );
    _painter->drawRect( x + w, y + h, zX6, zY6 );
    _painter->drawRect( x + w / 2, y,zX6, zY6 );
    _painter->drawRect( x + w / 2, y + h, zX6, zY6 );
  }
  else if ( mode == SM_PROTECT) {
    _painter->drawRect( x, y,  zX6, zY6 );
    _painter->drawRect( x, y + h / 2, zX6, zY6 );
    _painter->drawRect( x, y + h, zX6, zY6 );
    _painter->drawRect( x + w, y, zX6, zY6 );
    _painter->drawRect( x + w, y + h / 2, zX6, zY6 );
    _painter->drawRect( x + w, y + h, zX6, zY6 );
    _painter->drawRect( x + w / 2, y,zX6, zY6 );
    _painter->drawRect( x + w / 2, y + h, zX6, zY6 );

    x= x + 1;
    y= y + 1;
    zX6=zX6-2;
    zY6=zY6-2;

    TQBrush brush=kapp->palette().color( TQPalette::Active,TQColorGroup::Base );
    _painter->fillRect( x, y,  zX6, zY6, brush );
    _painter->fillRect( x, y + h / 2, zX6, zY6, brush);
    _painter->fillRect( x, y + h, zX6, zY6, brush );
    _painter->fillRect( x + w, y, zX6, zY6, brush );
    _painter->fillRect( x + w, y + h / 2, zX6, zY6, brush );
    _painter->fillRect( x + w  , y + h , zX6 , zY6 , brush );
    _painter->fillRect( x + w / 2 , y ,zX6 , zY6 , brush );
    _painter->fillRect( x + w / 2, y + h , zX6 , zY6 , brush );
  }
  else if ( mode == SM_ROTATE ) {
    _painter->drawEllipse( x, y,  zX6, zY6 );
    _painter->drawEllipse( x, y + h, zX6, zY6 );
    _painter->drawEllipse( x + w, y, zX6, zY6 );
    _painter->drawEllipse( x + w, y + h, zX6, zY6 );
  }

  _painter->restore();
}

TQCursor EmbeddedObject::getCursor( const TQPoint &_point, ModifyType &_modType, TQRect &tqgeometry) const
{
    int px = /*sheet()->doc()->zoomItX*/(_point.x());
    int py = /*sheet()->doc()->zoomItY*/(_point.y());
    int ox = /*sheet()->doc()->zoomItX*/(/*orig*/tqgeometry.x());
    int oy = /*sheet()->doc()->zoomItY*/(/*orig*/tqgeometry.y());
    int ow = /*sheet()->doc()->zoomItX*/(/*ext*/tqgeometry.width());
    int oh = /*sheet()->doc()->zoomItY*/(/*ext*/tqgeometry.height());

//     if ( angle != 0.0 )
//     {
//         TQRect rr = sheet()->doc()->zoomRect( rotateRectObject() );
//         ox = rr.x();
//         oy = rr.y();
//         ow = rr.width();
//         oh = rr.height();
//     }

    int sz = 4;
    if ( px >= ox && py >= oy && px <= ox + TQMIN( ow / 3, sz ) && py <= oy + TQMIN( oh / 3, sz ) )
    {
        _modType = MT_RESIZE_LU;
        if ( m_protect )
            return TQt::ForbiddenCursor;
        return TQt::sizeFDiagCursor;
    }

    if ( px >= ox && py >= oy + oh / 2 - TQMIN( oh / 6, sz / 2 )
         && px <= ox + TQMIN( ow / 3, sz)
         && py <= oy + oh / 2 + TQMIN( oh / 6, sz / 2 ) )
    {
        _modType = MT_RESIZE_LF;
        if ( m_protect)
            return TQt::ForbiddenCursor;
        return TQt::sizeHorCursor;
    }

    if ( px >= ox && py >= oy + oh - TQMIN( oh / 3, sz ) && px <= ox + TQMIN( ow / 3, sz ) && py <= oy + oh )
    {
        _modType = MT_RESIZE_LD;
        if ( m_protect )
            return TQt::ForbiddenCursor;
        return TQt::sizeBDiagCursor;
    }

    if ( px >= ox + ow / 2 - TQMIN( ow / 6, sz / 2 ) && py >= oy
         && px <= ox + ow / 2 + TQMIN( ow / 6, sz / 2 )
         && py <= oy + TQMIN( oh / 3, sz ) )
    {
        _modType = MT_RESIZE_UP;
        if ( m_protect )
            return TQt::ForbiddenCursor;
        return TQt::sizeVerCursor;
    }

    if ( px >= ox + ow / 2 - TQMIN( ow / 6, sz / 2 ) && py >= oy + oh - TQMIN( oh / 3, sz )
         && px <= ox + ow / 2 + TQMIN( ow / 6, sz / 2 ) && py <= oy + oh )
    {
        _modType = MT_RESIZE_DN;
        if ( m_protect )
            return TQt::ForbiddenCursor;
        return TQt::sizeVerCursor;
    }

    if ( px >= ox + ow - TQMIN( ow / 3, sz ) && py >= oy && px <= ox + ow && py <= oy + TQMIN( oh / 3, sz) )
    {
        _modType = MT_RESIZE_RU;
        if ( m_protect )
            return TQt::ForbiddenCursor;
        return TQt::sizeBDiagCursor;
    }

    if ( px >= ox + ow - TQMIN( ow / 3, sz ) && py >= oy + oh / 2 - TQMIN( oh / 6, sz / 2 )
         && px <= ox + ow && py <= oy + oh / 2 + TQMIN( oh / 6, sz / 2) )
    {
        _modType = MT_RESIZE_RT;
        if ( m_protect )
            return TQt::ForbiddenCursor;
        return TQt::sizeHorCursor;
    }

    if ( px >= ox + ow - TQMIN( ow / 3, sz ) && py >= oy + oh - TQMIN( oh / 3, sz)
         && px <= ox + ow && py <= oy + oh )
    {
        _modType = MT_RESIZE_RD;
        if ( m_protect )
            return TQt::ForbiddenCursor;
        return TQt::sizeFDiagCursor;
    }

    _modType = MT_MOVE;
    return TQt::sizeAllCursor;
}


void EmbeddedObject::doDelete()
{
    if ( cmds == 0 && !inObjList )
        delete this;
}

/**********************************************************
 *
 * EmbeddedKOfficeObject
 *
 **********************************************************/
EmbeddedKOfficeObject::EmbeddedKOfficeObject( Doc *tqparent, Sheet *_sheet, KoDocument* doc, const KoRect& tqgeometry )
    : EmbeddedObject( _sheet, tqgeometry ), m_parent(tqparent)
{
    m_embeddedObject = new KoDocumentChild(tqparent, doc, tqgeometry.toTQRect() );
}

EmbeddedKOfficeObject::EmbeddedKOfficeObject( Doc *tqparent, Sheet *_sheet )
    : EmbeddedObject( _sheet, KoRect() ), m_parent(tqparent)
{
    m_embeddedObject = new KoDocumentChild( tqparent );
}

EmbeddedKOfficeObject::~EmbeddedKOfficeObject()
{
  delete m_embeddedObject;
}

Doc* EmbeddedKOfficeObject::tqparent()
{
    return m_parent;
}

KoDocumentChild* EmbeddedKOfficeObject::embeddedObject()
{
    return m_embeddedObject;
}

bool EmbeddedKOfficeObject::saveOasisObjectAttributes( KSpreadOasisSaveContext &sc ) const
{
    kdDebug() << "EmbeddedKOfficeObject::saveOasisPart " << sc.partIndexObj << endl;

    sc.xmlWriter.startElement( "draw:object" );
    const TQString name = TQString( "Object_%1" ).tqarg( sc.partIndexObj + 1 );
    ++sc.partIndexObj;
    m_embeddedObject->saveOasisAttributes( sc.xmlWriter, name );

    if ( getType() != OBJECT_CHART )
        sc.xmlWriter.endElement();
    return true;
}

const char * EmbeddedKOfficeObject::getOasisElementName() const
{
    return "draw:frame";
}

bool EmbeddedKOfficeObject::load( const TQDomElement& element )
{
    kdDebug() << "Loading EmbeddedKOfficeObject" << endl;
    bool result = embeddedObject()->load( element );
    setGeometry( KoRect::fromTQRect( embeddedObject()->tqgeometry() ) );
    return result;
}

void EmbeddedKOfficeObject::loadOasis(const TQDomElement &element, KoOasisLoadingContext &context/*, KPRLoadingInfo *info*/)
{
    kdDebug()<<"void EmbeddedKOfficeObject::loadOasis(const TQDomElement &element)******************\n";
    EmbeddedObject::loadOasis( element, context );

    TQDomElement objectElement = KoDom::namedItemNS( element, KoXmlNS::draw, "object" );
    m_embeddedObject->loadOasis( element, objectElement );
    if( element.hasAttributeNS( KoXmlNS::draw, "name" ) )
        m_objectName = element.attributeNS( KoXmlNS::draw, "name", TQString());
    (void)m_embeddedObject->loadOasisDocument( context.store(), context.manifestDocument() );
}

TQDomElement EmbeddedKOfficeObject::save( TQDomDocument& doc )
{
    kdDebug() << "Saving EmbeddedKOfficeObject" << endl;
    embeddedObject()->setGeometry( tqgeometry().toTQRect() );
    return m_embeddedObject->save( doc );
}

void EmbeddedKOfficeObject::draw( TQPainter *_painter )
{
  kdDebug() << "Painting..." << endl;

  int const penw = pen.width() ;
  KoRect bound( 0, 0,
                tqgeometry().width() - ( 2 * penw ), tqgeometry().height() - ( 2 * penw ) );
  TQRect const zoomedBound = sheet()->doc()->zoomRect( bound );

  _painter->save();
  int const xOffset = sheet()->doc()->zoomItX( tqgeometry().left() + penw);
  int const yOffset = sheet()->doc()->zoomItY( tqgeometry().top() + penw );

  TQRect new_tqgeometry = zoomedBound;

  //if ( translate )
  //{
  	_painter->translate( xOffset , yOffset );

  	new_tqgeometry.moveBy(  xOffset , yOffset );
  	new_tqgeometry.moveBy( -_painter->window().x(), -_painter->window().y() );
  //}

  _painter->setClipRect( zoomedBound, TQPainter::CoordPainter );

   assert( embeddedObject()->document() != 0 );

   double zoomX = static_cast<double>( sheet()->doc()->zoom() ) / 100;
   double zoomY = static_cast<double>( sheet()->doc()->zoom() ) / 100;
   embeddedObject()->document()->paintEverything( *_painter,
        zoomedBound,
        embeddedObject()->isTransparent(),
        0 /* View isn't known from here - is that a problem? */,
        zoomX,
        zoomY );


   embeddedObject()->setGeometry( new_tqgeometry );
  _painter->restore();

  EmbeddedObject::draw( _painter );
}

TQPixmap EmbeddedKOfficeObject::toPixmap( double xZoom , double yZoom )
{
	TQPixmap pixmap( (int)( tqgeometry().width()*xZoom ), (int)( tqgeometry().height()*yZoom ) );

	TQPainter painter(&pixmap);
	TQRect  bound( 0,0,(int)( tqgeometry().width()*xZoom ), (int)(tqgeometry().height()*yZoom) );
	embeddedObject()->document()->paintEverything(painter,bound,
					embeddedObject()->isTransparent(),
					0,
					xZoom,
					yZoom);
	return pixmap;
}

void EmbeddedKOfficeObject::activate( View *_view, Canvas* /* canvas */ )
{
    KoDocument* part = embeddedObject()->document();
    if ( !part )
        return;
    kdDebug() << "Activating..." << endl;

    _view->partManager()->addPart( part, false );
    _view->partManager()->setActivePart( part, _view );
}

void EmbeddedKOfficeObject::deactivate()
{
}


void EmbeddedKOfficeObject::updateChildGeometry()
{
//   KoZoomHandler* zh = m_sheet->doc();
//   embeddedObject()->setGeometry( zh->zoomRect( tqgeometry() ), true );

//   return;
//   TQRect r = sheet()->doc()->zoomRect( tqgeometry() );
//   if ( _canvas )
//   {
//     kdDebug() << "_canvas->xOffset():" << _canvas->xOffset() << endl;
//     kdDebug() << "         _canvas->xOffset()*_canvas->doc()->zoomedResolutionX():" << _canvas->xOffset() * _canvas->doc()->zoomedResolutionX() << endl;
//     kdDebug() << "_canvas->yOffset():" << _canvas->yOffset() << endl;
//     kdDebug() << "         _canvas->yOffset()*_canvas->doc()->zoomedResolutionY():" << _canvas->yOffset() * _canvas->doc()->zoomedResolutionY() << endl;
//     r.moveBy( -_canvas->xOffset() / _canvas->doc()->zoomedResolutionX() , -_canvas->yOffset() / _canvas->doc()->zoomedResolutionY() );
//   }
//   embeddedObject()->setGeometry( r , true );
}

/**********************************************************
 *
 * EmbeddedChart
 *
 **********************************************************/

EmbeddedChart::EmbeddedChart( Doc *_spread, Sheet *_sheet, KoDocument* doc, const KoRect& tqgeometry )
  : EmbeddedKOfficeObject( _spread, _sheet, doc, tqgeometry )
{
    m_pBinding = 0;
}

EmbeddedChart::EmbeddedChart( Doc *_spread, Sheet *_sheet )
  : EmbeddedKOfficeObject( _spread, _sheet )
{
    m_pBinding = 0;
}

EmbeddedChart::~EmbeddedChart()
{
  if ( m_embeddedObject->isDeleted() )
    delete m_pBinding;
}

void EmbeddedChart::setDataArea( const TQRect& _data )
{
    if ( m_pBinding == 0L )
        m_pBinding = new ChartBinding( m_sheet, _data, this );
    else
        m_pBinding->setDataArea( _data );
}

void EmbeddedChart::update()
{
    if ( m_pBinding )
        m_pBinding->cellChanged( 0 );
}

const char * EmbeddedChart::getOasisElementName() const
{
    return "draw:frame";
}

bool EmbeddedChart::load( const TQDomElement& element )
{
    kdDebug() << "Loading EmbeddedChart" << endl;
    if ( !EmbeddedKOfficeObject::load( element ) )
        return false;

    if ( element.hasAttribute( "left-cell" ) &&
         element.hasAttribute( "top-cell" ) &&
         element.hasAttribute( "right-cell" ) &&
         element.hasAttribute( "bottom-cell" ) )
    {
        TQRect r;
        r.setCoords( element.attribute( "left-cell" ).toInt(),
                     element.attribute( "top-cell" ).toInt(),
                     element.attribute( "right-cell" ).toInt(),
                     element.attribute( "bottom-cell" ).toInt() );

        setDataArea( r );
    }

    return true;
}

void EmbeddedChart::loadOasis(const TQDomElement &element, KoOasisLoadingContext &context/*, KPRLoadingInfo *info*/)
{
    kdDebug()<<"void EmbeddedChart::loadOasis(const TQDomElement &element)******************\n";
    EmbeddedKOfficeObject::loadOasis( element, context );

    TQDomElement objectElement = KoDom::namedItemNS( element, KoXmlNS::draw, "object" );
    TQString str_range = objectElement.attributeNS( KoXmlNS::draw, "notify-on-update-of-ranges", TQString());

    if ( !str_range.isNull() )
    {
      str_range = Oasis::decodeFormula( str_range );
      Range range( str_range );
      if ( range.isValid() )
        setDataArea( range.range() );
    }

    KoChart::Part* chartPart = chart();
    if ( chartPart )
        chartPart->setCanChangeValue( false  );
}


bool EmbeddedChart::saveOasisObjectAttributes( KSpreadOasisSaveContext &sc ) const
{
    kdDebug() << "EmbeddedChart::saveOasisPart " << sc.partIndexObj << endl;

    EmbeddedKOfficeObject::saveOasisObjectAttributes( sc );

    if(m_pBinding) { // see http://bugs.kde.org/show_bug.cgi?id=120395
        TQRect dataArea = m_pBinding->dataArea();
        TQString rangeName = util_rangeName( dataArea);
        rangeName.insert( rangeName.find(':') +1, sheet()->sheetName() + "." );
        rangeName.prepend( sheet()->sheetName() + "." );
        sc.xmlWriter.addAttribute( "draw:notify-on-update-of-ranges", rangeName );
    }
    else {
        kdDebug() << "EmbeddedChart::saveOasisPart m_pBinding is NULL" << endl;
    }
    sc.xmlWriter.endElement();

    return true;
}

TQDomElement EmbeddedChart::save( TQDomDocument& doc )
{
    kdDebug() << "Saving EmbeddedChart" << endl;
    TQDomElement element = EmbeddedKOfficeObject::save( doc );
    element.setTagName( "chart" );

    element.setAttribute( "left-cell", m_pBinding->dataArea().left() );
    element.setAttribute( "right-cell", m_pBinding->dataArea().right() );
    element.setAttribute( "top-cell", m_pBinding->dataArea().top() );
    element.setAttribute( "bottom-cell", m_pBinding->dataArea().bottom() );

    return element;
}
void EmbeddedChart::draw( TQPainter *_painter )
{
  EmbeddedKOfficeObject::draw( _painter );
}

bool EmbeddedChart::loadDocument( KoStore* _store )
{
    bool res = /*EmbeddedKOfficeObject::*/m_embeddedObject->loadDocument( _store );
    if ( !res )
        return res;

    // Did we see a cell rectangle ?
    if ( !m_pBinding )
        return true;

    update();

    KoChart::Part* chartPart = chart();
    if ( chartPart )
        chartPart->setCanChangeValue( false  );
    return true;
}

KoChart::Part* EmbeddedChart::chart()
{
    // Returns 0 when the chart couldn't be loaded and we get KoUnavailPart instead.
    return ::tqqt_cast<KoChart::Part *>( m_embeddedObject->document() );
}

/**********************************************************
 *
 * EmbeddedPictureObject
 *
 **********************************************************/
EmbeddedPictureObject::EmbeddedPictureObject( Sheet *_sheet, const KoRect& _tqgeometry, KoPictureCollection *_imageCollection )
   : EmbeddedObject( _sheet, _tqgeometry )
{
    imageCollection = _imageCollection;
    pen = KoPen( TQt::black, 1.0, Qt::NoPen );
    mirrorType = PM_NORMAL;
    depth = 0;
    swapRGB = false;
    grayscal = false;
    bright = 0;
    m_effect = IE_NONE;
    m_ie_par1 = TQVariant();
    m_ie_par2 = TQVariant();
    m_ie_par3 = TQVariant();
    // Forbid TQPixmap to cache the X-Window resources (Yes, it is slower!)
    m_cachedPixmap.setOptimization(TQPixmap::MemoryOptim);
}


EmbeddedPictureObject::EmbeddedPictureObject( Sheet *_sheet, const KoRect& _tqgeometry, KoPictureCollection *_imageCollection, const KoPictureKey & key )
    : EmbeddedObject( _sheet, _tqgeometry )
{
    imageCollection = _imageCollection;

    //ext = KoSize(); // invalid size means unset
    pen = KoPen( TQt::black, 1.0, Qt::NoPen );
    mirrorType = PM_NORMAL;
    depth = 0;
    swapRGB = false;
    grayscal = false;
    bright = 0;
    m_effect = IE_NONE;
    m_ie_par1 = TQVariant();
    m_ie_par2 = TQVariant();
    m_ie_par3 = TQVariant();
    // Forbid TQPixmap to cache the X-Window resources (Yes, it is slower!)
    m_cachedPixmap.setOptimization(TQPixmap::MemoryOptim);

    setPicture( key );
}

EmbeddedPictureObject::EmbeddedPictureObject( Sheet *_sheet, KoPictureCollection *_imageCollection )
  : EmbeddedObject( _sheet, KoRect(0,0,0,0) )
{
  imageCollection = _imageCollection;

  //ext = KoSize(); // invalid size means unset
  pen = KoPen( TQt::black, 1.0, Qt::NoPen );
  mirrorType = PM_NORMAL;
  depth = 0;
  swapRGB = false;
  grayscal = false;
  bright = 0;
  m_effect = IE_NONE;
  m_ie_par1 = TQVariant();
  m_ie_par2 = TQVariant();
  m_ie_par3 = TQVariant();
    // Forbid TQPixmap to cache the X-Window resources (Yes, it is slower!)
  m_cachedPixmap.setOptimization(TQPixmap::MemoryOptim);
}

EmbeddedPictureObject::~EmbeddedPictureObject()
{
}

bool EmbeddedPictureObject::load( const TQDomElement& /*element*/ )
{
    return false;
}

TQDomElement EmbeddedPictureObject::save( TQDomDocument& /*doc*/ )
{
    kdDebug() << "Saving EmbeddedPictureObject" << endl;
    return TQDomElement();
}

TQString EmbeddedPictureObject::convertValueToPercent( int val ) const
{
   return TQString::number( val )+"%";
}

void EmbeddedPictureObject::saveOasisPictureElement( KoGenStyle &styleobjectauto ) const
{

    if ( bright != 0 )
    {
        styleobjectauto.addProperty( "draw:luminance", convertValueToPercent( bright ) );
    }
    if ( grayscal )
    {
        styleobjectauto.addProperty( "draw:color-mode","greyscale" );
    }

    switch (m_effect)
    {
    case IE_NONE:
        //nothing
        break;
    case IE_CHANNEL_INTENSITY:
    {
        //for the moment kpresenter support just one channel
        TQString percent = convertValueToPercent( m_ie_par1.toInt() );
        KImageEffect::RGBComponent channel = static_cast<KImageEffect::RGBComponent>( m_ie_par2.toInt() );
        switch( channel )
        {
        case KImageEffect::Red:
            styleobjectauto.addProperty( "draw:red", percent );
            styleobjectauto.addProperty( "draw:blue", "0%" );
            styleobjectauto.addProperty( "draw:green", "0%" );
            break;
        case KImageEffect::Green:
            styleobjectauto.addProperty( "draw:green", percent );
            styleobjectauto.addProperty( "draw:red", "0%" );
            styleobjectauto.addProperty( "draw:blue", "0%" );
            break;
        case KImageEffect::Blue:
            styleobjectauto.addProperty( "draw:blue", percent );
            styleobjectauto.addProperty( "draw:red", "0%" );
            styleobjectauto.addProperty( "draw:green", "0%" );
            break;
        case KImageEffect::Gray:
            break;
        case KImageEffect::All:
            break;
        }
    }
    break;
    case IE_FADE:
        break;
    case IE_FLATTEN:
        break;
    case IE_INTENSITY:
        break;
    case IE_DESATURATE:
        break;
    case IE_CONTRAST:
    {
        //kpresenter use value between -255 and 255
        //oo impress between -100% and 100%
        int val =  m_ie_par1.toInt();
        val = ( int )( ( double )val*100.0/255.0 );
        styleobjectauto.addProperty( "draw:contrast", convertValueToPercent( val ) );
    }
    break;
    case IE_NORMALIZE:
        break;
    case IE_EQUALIZE:
        break;
    case IE_THRESHOLD:
        break;
    case IE_SOLARIZE:
        break;
    case IE_EMBOSS:
        break;
    case IE_DESPECKLE:
        break;
    case IE_CHARCOAL:
        break;
    case IE_NOISE:
        break;
    case IE_BLUR:
        break;
    case IE_EDGE:
        break;
    case IE_IMPLODE:
        break;
    case IE_OIL_PAINT:
        break;
    case IE_SHARPEN:
        break;
    case IE_SPREAD:
        break;
    case IE_SHADE:
        break;
    case IE_SWIRL:
        break;
    case IE_WAVE:
        break;
    }
}

bool EmbeddedPictureObject::saveOasisObjectAttributes( KSpreadOasisSaveContext &sc ) const
{
    sc.xmlWriter.startElement( "draw:image" );
    sc.xmlWriter.addAttribute( "xlink:type", "simple" );
    sc.xmlWriter.addAttribute( "xlink:show", "embed" );
    sc.xmlWriter.addAttribute( "xlink:actuate", "onLoad" );
    sc.xmlWriter.addAttribute( "xlink:href", imageCollection->getOasisFileName( image ) );
    sc.xmlWriter.endElement();

    return true;
}

const char * EmbeddedPictureObject::getOasisElementName() const
{
    return "draw:frame";
}


void EmbeddedPictureObject::loadPicture( const TQString & fileName )
{
    image = imageCollection->loadPicture( fileName );
}

EmbeddedPictureObject &EmbeddedPictureObject::operator=( const EmbeddedPictureObject & )
{
    return *this;
}

void EmbeddedPictureObject::setPicture( const KoPictureKey & key )
{
    image = imageCollection->findPicture( key );
}

void EmbeddedPictureObject::reload( void )
{
    // ### FIXME: this seems wrong, KoPictureCollection will never reload it (or perhaps it is the function name that is wrong)
    setPicture( image.getKey() );
}

// KSpread doesn't support pictures in it's old XML file format.
// TQDomDocumentFragment EmbeddedPictureObject::save( TQDomDocument& doc, double offset )
// {
//     TQDomDocumentFragment fragment=KP2DObject::save(doc, offset);
//     TQDomElement elem=doc.createElement("KEY");
//     image.getKey().saveAttributes(elem);
//     fragment.appendChild(elem);
//
//     TQDomElement elemSettings = doc.createElement( "PICTURESETTINGS" );
//
//     elemSettings.setAttribute( "mirrorType", static_cast<int>( mirrorType ) );
//     elemSettings.setAttribute( "depth", depth );
//     elemSettings.setAttribute( "swapRGB", static_cast<int>( swapRGB ) );
//     elemSettings.setAttribute( "grayscal", static_cast<int>( grayscal ) );
//     elemSettings.setAttribute( "bright", bright );
//     fragment.appendChild( elemSettings );
//
//     if (m_effect!=IE_NONE) {
//         TQDomElement imageEffects = doc.createElement("EFFECTS");
//         imageEffects.setAttribute("type", static_cast<int>(m_effect));
//         if (m_ie_par1.isValid())
//             imageEffects.setAttribute("param1", m_ie_par1.toString());
//         if (m_ie_par2.isValid())
//             imageEffects.setAttribute("param2", m_ie_par2.toString());
//         if (m_ie_par3.isValid())
//             imageEffects.setAttribute("param3", m_ie_par3.toString());
//         fragment.appendChild( imageEffects );
//     }
//
//     return fragment;
// }

void EmbeddedPictureObject::loadOasisPictureEffect(KoOasisLoadingContext & context )
{
    KoStyleStack &styleStack = context.styleStack();
    styleStack.setTypeProperties( "graphic" );
    if ( styleStack.hasAttributeNS( KoXmlNS::draw, "color-mode" ) &&  ( styleStack.attributeNS( KoXmlNS::draw, "color-mode" )=="greyscale" ) )
    {
        grayscal = true;
    }

    if ( styleStack.hasAttributeNS( KoXmlNS::draw, "contrast" ) )
    {
        TQString str( styleStack.attributeNS( KoXmlNS::draw, "contrast" ) );
        str = str.remove( '%' );
        int val = str.toInt();
        m_effect = IE_CONTRAST;
        val = ( int )( 255.0 *val/100.0 );
        m_ie_par1 = TQVariant(val);
    }
    if ( styleStack.hasAttributeNS( KoXmlNS::draw, "red" ) && styleStack.attributeNS( KoXmlNS::draw, "red" ) != "0%" )
    {
        TQString str( styleStack.attributeNS( KoXmlNS::draw, "red" ) );
        str = str.remove( '%' );
        int val = str.toInt();
        m_effect = IE_CHANNEL_INTENSITY;
        m_ie_par1 = TQVariant(val);
        m_ie_par2 = TQVariant( ( int )KImageEffect::Red );
    }
    if ( styleStack.hasAttributeNS( KoXmlNS::draw, "green" ) && styleStack.attributeNS( KoXmlNS::draw, "green" ) != "0%" )
    {
        TQString str( styleStack.attributeNS( KoXmlNS::draw, "green" ) );
        str = str.remove( '%' );
        int val = str.toInt();
        m_effect = IE_CHANNEL_INTENSITY;
        m_ie_par1 = TQVariant(val);
        m_ie_par2 = TQVariant( ( int )KImageEffect::Green );
    }
    if ( styleStack.hasAttributeNS( KoXmlNS::draw, "blue" ) && styleStack.attributeNS( KoXmlNS::draw, "blue" ) != "0%" )
    {
        TQString str( styleStack.attributeNS( KoXmlNS::draw, "blue" ) );
        str = str.remove( '%' );
        int val = str.toInt();
        m_effect = IE_CHANNEL_INTENSITY;
        m_ie_par1 = TQVariant(val);
        m_ie_par2 = TQVariant( ( int )KImageEffect::Blue );
    }
    if ( styleStack.hasAttributeNS( KoXmlNS::draw, "luminance" ) )
    {
       TQString str( styleStack.attributeNS( KoXmlNS::draw, "luminance" ) );
       str = str.remove( '%' );
       bright = str.toInt();
    }
}

void EmbeddedPictureObject::fillStyle( KoGenStyle& styleObjectAuto, KoGenStyles& /*mainStyles*/ ) const
{
     //KP2DObject::fillStyle( styleObjectAuto, mainStyles );
     saveOasisPictureElement( styleObjectAuto );
}

void EmbeddedPictureObject::loadOasis(const TQDomElement &element, KoOasisLoadingContext & context/*, KPRLoadingInfo *info*/)
{
    //load it into kpresenter_doc
    EmbeddedObject::loadOasis( element, context );
    loadOasisPictureEffect( context );
    TQDomNode imageBox = KoDom::namedItemNS( element, KoXmlNS::draw, "image" );
    const TQString href( imageBox.toElement().attributeNS( KoXmlNS::xlink, "href", TQString()) );
    kdDebug()<<" href: "<<href<<endl;
    if ( !href.isEmpty() /*&& href[0] == '#'*/ )
    {
        TQString strExtension;
        const int result=href.findRev(".");
        if (result>=0)
        {
            strExtension=href.mid(result+1); // As we are using KoPicture, the extension should be without the dot.
        }
        TQString filename(href/*.mid(1)*/);
        const KoPictureKey key(filename, TQDateTime::tqcurrentDateTime(Qt::UTC));
        image.setKey(key);

        KoStore* store = context.store();
        if ( store->open( filename ) )
        {
            KoStoreDevice dev(store);
            if ( !image.load( &dev, strExtension ) )
                kdWarning() << "Cannot load picture: " << filename << " " << href << endl;
            store->close();
        }
        imageCollection->insertPicture( key, image );
    }
    // ### TODO: load remote file
}


// double EmbeddedPictureObject::load(const TQDomElement &element)
// {
//     double offset=KP2DObject::load(element);
//     TQDomElement e=element.namedItem("KEY").toElement();
//     if(!e.isNull()) {
//         KoPictureKey key;
//         key.loadAttributes( e );
//         image.clear();
//         image.setKey(key);
//     }
//     else {
//         // try to find a PIXMAP tag if the KEY is not available...
//         e=element.namedItem("PIXMAP").toElement();
//         if (e.isNull()) {
//             // try to find a FILENAME tag (old cliparts...)
//             e=element.namedItem("FILENAME").toElement();
//             if(!e.isNull()) {
//                 // Loads from the disk directly (unless it's in the collection already?)
//                 image = imageCollection->loadPicture( e.attribute("filename") );
//             }
//         } else {
//             bool openPic = true;
//             TQString _data;
//             TQString _fileName;
//             if(e.hasAttribute("data"))
//                 _data=e.attribute("data");
//             if ( _data.isEmpty() )
//                 openPic = true;
//             else
//                 openPic = false;
//             if(e.hasAttribute("filename"))
//                 _fileName=e.attribute("filename");
//             if ( !_fileName.isEmpty() )
//             {
//                 if ( int _envVarB = _fileName.find( '$' ) >= 0 )
//                 {
//                     int _envVarE = _fileName.find( '/', _envVarB );
//                     // ### FIXME: it should be TQString::local8Bit instead of TQFile::encodeName, shouldn't it?
//                     TQString path = getenv( TQFile::encodeName(_fileName.mid( _envVarB, _envVarE-_envVarB )) );
//                     _fileName.replace( _envVarB-1, _envVarE-_envVarB+1, path );
//                 }
//             }
//
//             if ( openPic )
//                 // !! this loads it from the disk (unless it's in the image collection already)
//                 image = imageCollection->loadPicture( _fileName );
//             else
//             {
//                 KoPictureKey key( _fileName );
//                 image.clear();
//                 image.setKey(key);
//                 TQByteArray rawData=_data.utf8(); // XPM is normally ASCII, therefore UTF-8
//                 rawData[rawData.size()-1]=char(10); // Replace the NULL character by a LINE FEED
//                 TQBuffer buffer(rawData); // ### TODO: open?
//                 image.loadXpm(&buffer);
//             }
//         }
//     }
//
//     e = element.namedItem( "PICTURESETTINGS" ).toElement();
//     if ( !e.isNull() ) {
//         PictureMirrorType _mirrorType = PM_NORMAL;
//         int _depth = 0;
//         bool _swapRGB = false;
//         bool _grayscal = false;
//         int _bright = 0;
//
//         if ( e.hasAttribute( "mirrorType" ) )
//             _mirrorType = static_cast<PictureMirrorType>( e.attribute( "mirrorType" ).toInt() );
//         if ( e.hasAttribute( "depth" ) )
//             _depth = e.attribute( "depth" ).toInt();
//         if ( e.hasAttribute( "swapRGB" ) )
//             _swapRGB = static_cast<bool>( e.attribute( "swapRGB" ).toInt() );
//         if ( e.hasAttribute( "grayscal" ) )
//             _grayscal = static_cast<bool>( e.attribute( "grayscal" ).toInt() );
//         if ( e.hasAttribute( "bright" ) )
//             _bright = e.attribute( "bright" ).toInt();
//
//         mirrorType = _mirrorType;
//         depth = _depth;
//         swapRGB = _swapRGB;
//         grayscal = _grayscal;
//         bright = _bright;
//     }
//     else {
//         mirrorType = PM_NORMAL;
//         depth = 0;
//         swapRGB = false;
//         grayscal = false;
//         bright = 0;
//     }
//
//     e = element.namedItem( "EFFECTS" ).toElement();
//     if (!e.isNull()) {
//         if (e.hasAttribute("type"))
//             m_effect = static_cast<ImageEffect>(e.attribute("type").toInt());
//         if (e.hasAttribute("param1"))
//             m_ie_par1 = TQVariant(e.attribute("param1"));
//         else
//             m_ie_par1 = TQVariant();
//         if (e.hasAttribute("param2"))
//             m_ie_par2 = TQVariant(e.attribute("param2"));
//         else
//             m_ie_par2 = TQVariant();
//         if (e.hasAttribute("param3"))
//             m_ie_par3 = TQVariant(e.attribute("param3"));
//         else
//             m_ie_par3 = TQVariant();
//     }
//     else
//         m_effect = IE_NONE;
//
//     return offset;
// }

void EmbeddedPictureObject::drawShadow( TQPainter* /*_painter*/,  KoZoomHandler* /*_zoomHandler*/)
{
//     const double ox = /*orig*/m_tqgeometry.x();
//     const double oy = /*orig*/m_tqgeometry.y();
//     const double ow = /*ext*/m_tqgeometry.width();
//     const double oh = /*ext*/m_tqgeometry.height();
//
//     _painter->save();
//
//     TQPen pen2 = pen.zoomedPen( _zoomHandler );
//     _painter->setPen( pen2 );
//     _painter->setBrush( getBrush() );
//
//     double sx = 0;
//     double sy = 0;
//
//     getShadowCoords( sx, sy );
//
//     _painter->translate( _zoomHandler->zoomItX( ox ), _zoomHandler->zoomItY( oy ) );
//     _painter->setPen( TQPen( shadowColor ) );
//     _painter->setBrush( shadowColor );
//     if ( kAbs(angle) <= DBL_EPSILON )
//         _painter->drawRect( _zoomHandler->zoomItX( sx ), _zoomHandler->zoomItY( sy ),
//                             _zoomHandler->zoomItX( ext.width() ), _zoomHandler->zoomItY( ext.height() ) );
//     else
//     {
//         TQSize bs = TQSize( _zoomHandler->zoomItX( ow ), _zoomHandler->zoomItY( oh ) );
//         TQRect br = TQRect( 0, 0, bs.width(), bs.height() );
//         int pw = br.width();
//         int ph = br.height();
//         TQRect rr = br;
//         int pixYPos = -rr.y();
//         int pixXPos = -rr.x();
//         br.moveTopLeft( TQPoint( -br.width() / 2, -br.height() / 2 ) );
//         rr.moveTopLeft( TQPoint( -rr.width() / 2, -rr.height() / 2 ) );
//
//         TQWMatrix m;
//         m.translate( pw / 2, ph / 2 );
//         m.rotate( angle );
//         m.translate( rr.left() + pixXPos + _zoomHandler->zoomItX( sx ),
//                      rr.top() + pixYPos + _zoomHandler->zoomItY( sy ) );
//
//         _painter->setWorldMatrix( m, true );
//
//         _painter->drawRect( 0, 0, bs.width(), bs.height() );
//     }
//
//     _painter->restore();
}

TQPixmap EmbeddedPictureObject::toPixmap( double xZoom , double yZoom )
{
 	KoZoomHandler zoomHandler;
 	zoomHandler.setZoomedResolution( xZoom /* *zoomHandler.resolutionX()*/ , yZoom /* *zoomHandler.resolutionY()*/ );
 	return generatePixmap( &zoomHandler );
}

TQPixmap EmbeddedPictureObject::generatePixmap(KoZoomHandler*_zoomHandler)
{
    const double penw = _zoomHandler->zoomItX( ( ( pen.style() == Qt::NoPen ) ? 1 : pen.width() ) / 2.0 );

    TQSize size( _zoomHandler->zoomSize( m_tqgeometry.size() /*ext*/ ) );
    //kdDebug(33001) << "EmbeddedPictureObject::generatePixmap size= " << size << endl;
    TQPixmap pixmap(size);
    TQPainter paint;

    paint.begin( &pixmap );
    pixmap.fill( TQt::white );

    // Draw background
    paint.setPen( Qt::NoPen );
    paint.setBrush( getBrush() );

    TQRect rect( (int)( penw ), (int)( penw ),
                 (int)( _zoomHandler->zoomItX( /*ext*/m_tqgeometry.width() ) - 2.0 * penw ),
                 (int)( _zoomHandler->zoomItY( /*ext*/m_tqgeometry.height() ) - 2.0 * penw ) );

//      if ( getFillType() == FT_BRUSH || !gradient )
         paint.drawRect( rect );
//     else {
        // ### TODO: this was also drawn for drawContour==true, but why?
//         gradient->setSize( size );
//         paint.drawPixmap( (int)( penw ), (int)( penw ),
//                           gradient->pixmap(), 0, 0,
//                           (int)( _zoomHandler->zoomItX( m_tqgeometry/*ext*/.width() ) - 2 * penw ),
//                           (int)( _zoomHandler->zoomItY( m_tqgeometry/*ext*/.height() ) - 2 * penw ) );
//    }


    image.draw(paint, 0, 0, size.width(), size.height(), 0, 0, -1, -1, false); // Always slow mode!
    image.clearCache(); // Release the memoy of the picture cache

//     image.setAlphaBuffer(true);
//     TQBitmap tmpMask;
//     tmpMask = image.createAlphaMask().scale(size);
//     pixmap.setMask(tmpMask);

    paint.end();
    return pixmap;
}

void EmbeddedPictureObject::draw( TQPainter *_painter/*, KoZoomHandler*_zoomHandler,
                           int pageNum, SelectionMode selectionMode, bool drawContour*/ )
{
    bool drawContour = false;
    KoZoomHandler*_zoomHandler = sheet()->doc();


    if ( image.isNull() ) return;

//     if ( shadowDistance > 0 && !drawContour )
//         drawShadow(_painter, _zoomHandler);

    const double ox = /*orig*/m_tqgeometry.x();
    const double oy = /*orig*/m_tqgeometry.y();
    const double ow = /*ext*/m_tqgeometry.width();
    const double oh = /*ext*/m_tqgeometry.height();
    //const double penw = _zoomHandler->zoomItX( ( ( pen.style() == Qt::NoPen ) ? 1.0 : pen.width() ) / 2.0 );

    _painter->save();

    _painter->translate( _zoomHandler->zoomItX( ox ), _zoomHandler->zoomItY( oy ) );

    if ( kAbs(angle)> DBL_EPSILON ) {
        TQSize bs = TQSize( _zoomHandler->zoomItX( ow ), _zoomHandler->zoomItY( oh ) );
        TQRect br = TQRect( 0, 0, bs.width(), bs.height() );
        int pw = br.width();
        int ph = br.height();
        TQRect rr = br;
        int pixYPos = -rr.y();
        int pixXPos = -rr.x();
        br.moveTopLeft( TQPoint( -br.width() / 2, -br.height() / 2 ) );
        rr.moveTopLeft( TQPoint( -rr.width() / 2, -rr.height() / 2 ) );

        TQWMatrix m;
        m.translate( pw / 2, ph / 2 );
        m.rotate( angle );
        m.translate( rr.left() + pixXPos, rr.top() + pixYPos );
        _painter->setWorldMatrix( m, true );
    }

    if ( !drawContour )
    {
        TQRect rect( 0, 0, (int)( _zoomHandler->zoomItX( ow ) ),
                    (int)( _zoomHandler->zoomItY(  oh ) ) );
        // ### HACK QT seems not to be able to correctly compare TQVariant
        bool variants1;
        if (m_ie_par1.isNull())
            variants1=m_cachedPar1.isNull();
        else
            variants1=(m_ie_par1 == m_cachedPar1);
        bool variants2;
        if (m_ie_par2.isNull())
            variants2=m_cachedPar2.isNull();
        else
            variants2=(m_ie_par2 == m_cachedPar2);
        bool variants3;
        if (m_ie_par3.isNull())
            variants3=m_cachedPar3.isNull();
        else
            variants3=(m_ie_par3 == m_cachedPar3);

        if (m_cachedRect == rect
            // All what EmbeddedPictureObject::changePictureSettings needs
            && m_cachedMirrorType == mirrorType && m_cachedSwapRGB == swapRGB && m_cachedGrayscal == grayscal
            && m_cachedBright == bright && m_cachedEffect == m_effect
            // Who needs it?
            && m_cachedDepth == depth
#if 0
            && m_ie_par1 == m_cachedPar1 && m_ie_par2 == m_cachedPar2 && m_ie_par3 == m_cachedPar3
#else
            && variants1 && variants2 && variants3
#endif
            )
        {
            //kdDebug(33001) << "Drawing cached pixmap " << (void*) this << " " << k_funcinfo << endl;
        }
        else
        {
            if (mirrorType != PM_NORMAL || depth != 0 || swapRGB || grayscal || bright != 0 || m_effect!=IE_NONE)
                m_cachedPixmap = changePictureSettings( generatePixmap( _zoomHandler ) );
            else
                m_cachedPixmap = generatePixmap( _zoomHandler );
            m_cachedRect = rect;
            m_cachedMirrorType = mirrorType;
            m_cachedSwapRGB = swapRGB;
            m_cachedGrayscal = grayscal;
            m_cachedBright = bright;
            m_cachedEffect = m_effect;
            m_cachedDepth = depth;
            m_cachedPar1 = m_ie_par1;
            m_cachedPar2 = m_ie_par2;
            m_cachedPar3 = m_ie_par3;
            //kdDebug(33001) <<  "Drawing non-cached pixmap " << (void*) this << " " << k_funcinfo << endl;
        }
        _painter->eraseRect( rect );
        _painter->drawPixmap( rect, m_cachedPixmap);
    }

    // Draw border
    // ### TODO port to KoBorder::drawBorders() (after writing a simplified version of it, that takes the same border on each size)
//     TQPen pen2;
//     if ( drawContour ) {
//         pen2 = TQPen( TQt::black, 1, TQt::DotLine );
//         _painter->setRasterOp( TQt::NotXorROP );
//     }
//     else {
//         pen2 = pen;
//         pen2.setWidth( _zoomHandler->zoomItX( ( pen.style() == Qt::NoPen ) ? 1.0 : (double)pen.width() ) );
//     }
//     _painter->setPen( pen2 );
//     _painter->setBrush( TQt::NoBrush );
//     _painter->drawRect( (int)( penw ), (int)( penw ),
//                         (int)( _zoomHandler->zoomItX( ow ) - 2.0 * penw ),
//                         (int)( _zoomHandler->zoomItY( oh ) - 2.0 * penw ) );


    _painter->restore();

    //KPObject::draw( _painter, _zoomHandler, pageNum, selectionMode, drawContour );
    EmbeddedObject::draw( _painter );
}

TQPixmap EmbeddedPictureObject::getOriginalPixmap()
{
    TQSize _pixSize = image.getOriginalSize();
    kdDebug(33001) << "EmbeddedPictureObject::getOriginalPixmap size= " << _pixSize << endl;
    TQPixmap _pixmap = image.generatePixmap( _pixSize, true );
    image.clearCache(); // Release the memoy of the picture cache

    return _pixmap;
}

TQPixmap EmbeddedPictureObject::changePictureSettings( TQPixmap _tmpPixmap )
{
    TQImage _tmpImage = _tmpPixmap.convertToImage();

    if (_tmpImage.isNull())
        return _tmpPixmap;

    bool _horizontal = false;
    bool _vertical = false;
    if ( mirrorType == PM_HORIZONTAL )
        _horizontal = true;
    else if ( mirrorType == PM_VERTICAL )
        _vertical = true;
    else if ( mirrorType == PM_HORIZONTALANDVERTICAL ) {
        _horizontal = true;
        _vertical = true;
    }

    _tmpImage = _tmpImage.mirror( _horizontal, _vertical );

    if ( depth != 0 ) {
        TQImage tmpImg = _tmpImage.convertDepth( depth );
        if ( !tmpImg.isNull() )
            _tmpImage = tmpImg;
    }

    if ( swapRGB )
        _tmpImage = _tmpImage.swapRGB();

    if ( grayscal ) {
        if ( depth == 1 || depth == 8 ) {
            for ( int i = 0; i < _tmpImage.numColors(); ++i ) {
                TQRgb rgb = _tmpImage.color( i );
                int gray = tqGray( rgb );
                rgb = tqRgb( gray, gray, gray );
                _tmpImage.setColor( i, rgb );
            }
        }
        else {
            int _width = _tmpImage.width();
            int _height = _tmpImage.height();
            int _x = 0;
            int _y = 0;

            for ( _x = 0; _x < _width; ++_x ) {
                for ( _y = 0; _y < _height; ++_y ) {
                    if ( _tmpImage.valid( _x, _y ) ) {
                        TQRgb rgb = _tmpImage.pixel( _x, _y );
                        int gray = tqGray( rgb );
                        rgb = tqRgb( gray, gray, gray );
                        _tmpImage.setPixel( _x, _y, rgb );
                    }
                }
            }
        }
    }

    if ( bright != 0 ) {
        if ( depth == 1 || depth == 8 ) {
            for ( int i = 0; i < _tmpImage.numColors(); ++i ) {
                TQRgb rgb = _tmpImage.color( i );
                TQColor c( rgb );

                if ( bright > 0 )
                    rgb = c.light( 100 + bright ).rgb();
                else
                    rgb = c.dark( 100 + abs( bright ) ).rgb();

                _tmpImage.setColor( i, rgb );
            }
        }
        else {
            int _width = _tmpImage.width();
            int _height = _tmpImage.height();
            int _x = 0;
            int _y = 0;

            for ( _x = 0; _x < _width; ++_x ) {
                for ( _y = 0; _y < _height; ++_y ) {
                    if ( _tmpImage.valid( _x, _y ) ) {
                        TQRgb rgb = _tmpImage.pixel( _x, _y );
                        TQColor c( rgb );

                        if ( bright > 0 )
                            rgb = c.light( 100 + bright ).rgb();
                        else
                            rgb = c.dark( 100 + abs( bright ) ).rgb();

                        _tmpImage.setPixel( _x, _y, rgb );
                    }
                }
            }
        }
    }

    switch (m_effect) {
    case IE_CHANNEL_INTENSITY: {
        _tmpImage = KImageEffect::channelIntensity(_tmpImage, m_ie_par1.toDouble()/100.0,
                                                   static_cast<KImageEffect::RGBComponent>(m_ie_par2.toInt()));
        break;
    }
    case IE_FADE: {
        _tmpImage = KImageEffect::fade(_tmpImage, m_ie_par1.toDouble(), m_ie_par2.toColor());
        break;
    }
    case IE_FLATTEN: {
        _tmpImage = KImageEffect::flatten(_tmpImage, m_ie_par1.toColor(), m_ie_par2.toColor());
        break;
    }
    case IE_INTENSITY: {
        _tmpImage = KImageEffect::intensity(_tmpImage, m_ie_par1.toDouble()/100.0);
        break;
    }
    case IE_DESATURATE: {
        _tmpImage = KImageEffect::desaturate(_tmpImage, m_ie_par1.toDouble());
        break;
    }
    case IE_CONTRAST: {
        _tmpImage = KImageEffect::contrast(_tmpImage, m_ie_par1.toInt());
        break;
    }
    case IE_NORMALIZE: {
        KImageEffect::normalize(_tmpImage);
        break;
    }
    case IE_EQUALIZE: {
        KImageEffect::equalize(_tmpImage);
        break;
    }
    case IE_THRESHOLD: {
        KImageEffect::threshold(_tmpImage, m_ie_par1.toInt());
        break;
    }
    case IE_SOLARIZE: {
        KImageEffect::solarize(_tmpImage, m_ie_par1.toDouble());
        break;
    }
    case IE_EMBOSS: {
        _tmpImage = KImageEffect::emboss(_tmpImage);
        break;
    }
    case IE_DESPECKLE: {
        _tmpImage = KImageEffect::despeckle(_tmpImage);
        break;
    }
    case IE_CHARCOAL: {
        _tmpImage = KImageEffect::charcoal(_tmpImage, m_ie_par1.toDouble());
        break;
    }
    case IE_NOISE: {
        _tmpImage = KImageEffect::addNoise(_tmpImage, static_cast<KImageEffect::NoiseType>(m_ie_par1.toInt()));
        break;
    }
    case IE_BLUR: {
        _tmpImage = KImageEffect::blur(_tmpImage, m_ie_par1.toDouble());
        break;
    }
    case IE_EDGE: {
        _tmpImage = KImageEffect::edge(_tmpImage, m_ie_par1.toDouble());
        break;
    }
    case IE_IMPLODE: {
        _tmpImage = KImageEffect::implode(_tmpImage, m_ie_par1.toDouble());
        break;
    }
    case IE_OIL_PAINT: {
        _tmpImage = KImageEffect::oilPaint(_tmpImage, m_ie_par1.toInt());
        break;
    }
    case IE_SHARPEN: {
        _tmpImage = KImageEffect::sharpen(_tmpImage, m_ie_par1.toDouble());
        break;
    }
    case IE_SPREAD: {
        _tmpImage = KImageEffect::spread(_tmpImage, m_ie_par1.toInt());
        break;
    }
    case IE_SHADE: {
        _tmpImage = KImageEffect::shade(_tmpImage, m_ie_par1.toBool(), m_ie_par2.toDouble(), m_ie_par3.toDouble());
        break;
    }
    case IE_SWIRL: {
        _tmpImage = KImageEffect::swirl(_tmpImage, m_ie_par1.toDouble());
        break;
    }
    case IE_WAVE: {
        _tmpImage = KImageEffect::wave(_tmpImage, m_ie_par1.toDouble(), m_ie_par2.toDouble());
        break;
    }
    case IE_NONE:
    default:
        break;
    }

    _tmpPixmap.convertFromImage( _tmpImage );

    return _tmpPixmap;
}

void EmbeddedPictureObject::flip( bool /*horizontal*/ )
{
//     KP2DObject::flip( horizontal );
//     if ( horizontal )
//     {
//         switch ( mirrorType )
//         {
//             case PM_NORMAL:
//                 mirrorType = PM_HORIZONTAL;
//                 break;
//             case PM_HORIZONTAL:
//                 mirrorType = PM_NORMAL;
//                 break;
//             case PM_VERTICAL:
//                 mirrorType = PM_HORIZONTALANDVERTICAL;
//                 break;
//             case PM_HORIZONTALANDVERTICAL:
//                 mirrorType = PM_VERTICAL;
//                 break;
//         }
//     }
//     else
//     {
//         switch ( mirrorType )
//         {
//             case PM_NORMAL:
//                 mirrorType = PM_VERTICAL;
//                 break;
//             case PM_HORIZONTAL:
//                 mirrorType = PM_HORIZONTALANDVERTICAL;
//                 break;
//             case PM_VERTICAL:
//                 mirrorType = PM_NORMAL;
//                 break;
//             case PM_HORIZONTALANDVERTICAL:
//                 mirrorType = PM_HORIZONTAL;
//                 break;
//         }
//     }
}