koffice/filters/karbon/wmf/wmfexport.cpp

/* This file is part of the KDE project
 * Copyright (c) 2003 thierry lorthiois (lorthioist@wanadoo.fr)
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License version 2 as published by the Free Software Foundation.
 *
 * 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 <config.h>
#include <tqdom.h>
#include <tqcstring.h>
#include <kdebug.h>
#include <kgenericfactory.h>
#include <KoFilterChain.h>
#include <KoStore.h>
#include <KoStoreDevice.h>
#include "vdocument.h"
#include "vcolor.h"
#include "vcomposite.h"
#include "vdashpattern.h"
#include "vdocument.h"
#include "vlayer.h"
#include "vpath.h"
#include "vsegment.h"
#include "vfill.h"
#include "vstroke.h"
#include "vtext.h"
#include "vflattencmd.h"

#include "wmfexport.h"
#include "kowmfwrite.h"

/*
TODO: bs.wmf stroke in red with MSword and in brown with Kword ??
*/

typedef KGenericFactory<WmfExport, KoFilter> WmfExportFactory;
K_EXPORT_COMPONENT_FACTORY( libwmfexport, WmfExportFactory( "kofficefilters" ) )


WmfExport::WmfExport( KoFilter *, const char *, const TQStringList&) :
        KoFilter()
{
}

WmfExport::~WmfExport()
{
}

KoFilter::ConversionStatus WmfExport::convert( const TQCString& from, const TQCString& to )
{
    if( to != "image/x-wmf" || from != "application/x-karbon" ) {
        return KoFilter::NotImplemented;
    }

    KoStoreDevice* storeIn = m_chain->storageFile( "root", KoStore::Read );

    if( !storeIn ) {
        return KoFilter::StupidError;
    }

    // open Placeable Wmf file
    mWmf = new KoWmfWrite( m_chain->outputFile() );
    if( !mWmf->begin() ) {
        delete mWmf;
        return KoFilter::WrongFormat;
    }

    TQDomDocument domIn;
    domIn.setContent( storeIn );
    TQDomElement docNode = domIn.documentElement();

    // Load the document.
    mDoc = new VDocument;
    mDoc->load( docNode );

    // Process the document.
    mDoc->accept( *this );

    mWmf->end();

    delete mWmf;
    delete mDoc;

    return KoFilter::OK;
}


void WmfExport::visitVDocument( VDocument& document ) {
    int width;
    int height;

    mDoc = &document;
    mListPa.setAutoDelete( true );

    // resolution
    mDpi = 1000;
    width = (int)(POINT_TO_INCH( document.width() ) * mDpi);
    height = (int)(POINT_TO_INCH( document.height() ) * mDpi);

    mWmf->setDefaultDpi( mDpi );
    mWmf->setWindow( 0, 0, width, height );

    if ( (document.width() != 0) && (document.height() != 0) ) {
        mScaleX = (double)width / document.width();
        mScaleY = (double)height / document.height();
    }

    // Export layers.
    VVisitor::visitVDocument( document );

}


void WmfExport::visitVPath( VPath& composite ) {
    TQPen      pen;
    TQBrush    brush;

    getPen( pen, composite.stroke() );
    getBrush( brush, composite.fill() );

    VVisitor::visitVPath( composite );

    if ( mListPa.count() > 0 ) {
        mWmf->setPen( pen );
        if( (brush.style() == TQt::NoBrush)
            && (mListPa.count() == 1) ) {
            mWmf->drawPolyline( *mListPa.first() );
        }
        else {
            mWmf->setBrush( brush );

            if ( mListPa.count() == 1 ) {
                mWmf->drawPolygon( *mListPa.first() );
            }
            else {
                // combined path
                mWmf->drawPolyPolygon( mListPa );
            }
        }
    }
    mListPa.clear();
}


// Export segment.
void WmfExport::visitVSubpath( VSubpath& path ) {
    VSubpath *newPath;
    VSubpathIterator itr( path );
    VFlattenCmd cmd( 0L, INCH_TO_POINT(0.3 / (double)mDpi) );
    TQPointArray *pa = new TQPointArray( path.count() );
    int  nbrPoint=0;      // number of points in the path

    for( ; itr.current(); ++itr ) {
	VSegment *segment= itr.current();
	if (segment->isCurve()) {
	    newPath = new VSubpath( mDoc );

	    // newPath duplicate the list of curve
	    newPath->moveTo( itr.current()->prev()->knot() );
	    newPath->append( itr.current()->clone() );
	    while( itr.current()->next() ) {
		if ( itr.current()->next()->isCurve() ) {
		    newPath->append( itr.current()->next()->clone() );
		}
		else {
		    break;
		}
		++itr;
	    }

	    // flatten the curve
	    cmd.visit( *newPath );

	    // adjust the number of points
	    pa->resize( pa->size() + newPath->count() - 2 );

	    // Ommit the first segment and insert points
	    newPath->first();
	    while( newPath->next() ) {
		pa->setPoint( nbrPoint++, coordX( newPath->current()->knot().x() ),
			coordY( newPath->current()->knot().y() ) );
	    }
	    delete newPath;
	} else if (segment->isLine()) {
	    pa->setPoint( nbrPoint++, coordX( itr.current()->knot().x() ),
		    coordY( itr.current()->knot().y() ) );
	} else if (segment->isBegin()) {
	    // start a new polygon
	    pa->setPoint( nbrPoint++, coordX( itr.current()->knot().x() ),
		    coordY( itr.current()->knot().y() ) );
        }
    }

    // adjust the number of points
    if ( nbrPoint > 1 ) {
        pa->resize( nbrPoint );
        mListPa.append( pa );
    }
    else {
        delete pa;
        // TODO: check why we have empty path
        kdDebug() << "WmfExport::visitVSubpath : Empty path ?" << endl;
    }
}


void WmfExport::visitVText( VText& text ) {
    // TODO: export text
    visitVSubpath( text.basePath() );
}


void WmfExport::getBrush( TQBrush& brush, const VFill *fill ) {
    if( (fill->type() == VFill::solid) || (fill->type() == VFill::grad)
        || (fill->type() == VFill::patt) ) {
        if ( fill->color().opacity() < 0.1 ) {
            brush.setStyle( TQt::NoBrush );
        }
        else {
            brush.setStyle( TQt::SolidPattern );
            brush.setColor( fill->color() );
        }
    }
    else {
        brush.setStyle( TQt::NoBrush );
    }
}


void WmfExport::getPen( TQPen& pen, const VStroke *stroke ) {
    if( (stroke->type() == VStroke::solid) || (stroke->type() == VStroke::grad)
        || (stroke->type() == VStroke::patt) ) {
        // TODO : Dash pattern.

        if ( stroke->lineCap() == VStroke::capRound ) {
            pen.setCapStyle( TQt::RoundCap );
        }
        else {
            pen.setCapStyle( TQt::SquareCap );
        }
        pen.setStyle( TQt::SolidLine );
        pen.setColor( stroke->color() );
        pen.setWidth( coordX( stroke->lineWidth() ) );
    }
    else {
        pen.setStyle( TQt::NoPen );
    }
}


#include <wmfexport.moc>