|
|
|
/* This file is part of the KDE project
|
|
|
|
Copyright (C) 2002 Laurent Montel <lmontel@mandrakesoft.com>
|
|
|
|
Copyright (c) 2003 Lukas Tinkl <lukas@kde.org>
|
|
|
|
|
|
|
|
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, or (at your option) any later version.
|
|
|
|
|
|
|
|
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 "ooimpressimport.h"
|
|
|
|
|
|
|
|
#include <math.h>
|
|
|
|
|
|
|
|
#include <tqregexp.h>
|
|
|
|
#include <tqdatetime.h>
|
|
|
|
#include <tqfileinfo.h>
|
|
|
|
#include <tqdir.h>
|
|
|
|
|
|
|
|
#include <kzip.h>
|
|
|
|
#include <karchive.h>
|
|
|
|
#include <kdebug.h>
|
|
|
|
#include <KoUnit.h>
|
|
|
|
#include <KoDocumentInfo.h>
|
|
|
|
#include <KoDocument.h>
|
|
|
|
|
|
|
|
#include <kgenericfactory.h>
|
|
|
|
#include <KoFilterChain.h>
|
|
|
|
#include <KoGlobal.h>
|
|
|
|
#include <ooutils.h>
|
|
|
|
#include <KoDom.h>
|
|
|
|
#include <KoOasisSettings.h>
|
|
|
|
|
|
|
|
typedef KGenericFactory<OoImpressImport, KoFilter> OoImpressImportFactory;
|
|
|
|
K_EXPORT_COMPONENT_FACTORY( libooimpressimport, OoImpressImportFactory( "kofficefilters" ) )
|
|
|
|
|
|
|
|
|
|
|
|
OoImpressImport::OoImpressImport( KoFilter *, const char *, const TQStringList & )
|
|
|
|
: KoFilter(),
|
|
|
|
m_numPicture( 1 ),
|
|
|
|
m_numSound(1),
|
|
|
|
m_styles( 23, true ),
|
|
|
|
m_styleStack( ooNS::style, ooNS::fo )
|
|
|
|
{
|
|
|
|
m_styles.setAutoDelete( true );
|
|
|
|
m_listStyles.setAutoDelete( true );
|
|
|
|
}
|
|
|
|
|
|
|
|
OoImpressImport::~OoImpressImport()
|
|
|
|
{
|
|
|
|
TQDictIterator<animationList> it( m_animations ); // See TQDictIterator
|
|
|
|
for( ; it.current(); ++it )
|
|
|
|
{
|
|
|
|
delete it.current()->element;
|
|
|
|
}
|
|
|
|
m_animations.clear();
|
|
|
|
}
|
|
|
|
|
|
|
|
KoFilter::ConversionStatus OoImpressImport::convert( TQCString const & from, TQCString const & to )
|
|
|
|
{
|
|
|
|
kdDebug(30518) << "Entering Ooimpress Import filter: " << from << " - " << to << endl;
|
|
|
|
|
|
|
|
if ( (from != "application/vnd.sun.xml.impress" && from != "application/vnd.sun.xml.impress.template" )
|
|
|
|
|| to != "application/x-kpresenter" )
|
|
|
|
{
|
|
|
|
kdWarning(30518) << "Invalid mimetypes " << from << " " << to << endl;
|
|
|
|
return KoFilter::NotImplemented;
|
|
|
|
}
|
|
|
|
|
|
|
|
m_zip = new KZip( m_chain->inputFile() );
|
|
|
|
|
|
|
|
if ( !m_zip->open( IO_ReadOnly ) )
|
|
|
|
{
|
|
|
|
kdError(30518) << "Couldn't open the requested file "<< m_chain->inputFile() << endl;
|
|
|
|
delete m_zip;
|
|
|
|
return KoFilter::FileNotFound;
|
|
|
|
}
|
|
|
|
|
|
|
|
KoFilter::ConversionStatus preStatus = openFile();
|
|
|
|
|
|
|
|
if ( preStatus != KoFilter::OK )
|
|
|
|
{
|
|
|
|
m_zip->close();
|
|
|
|
delete m_zip;
|
|
|
|
return preStatus;
|
|
|
|
}
|
|
|
|
|
|
|
|
TQDomDocument docinfo;
|
|
|
|
createDocumentInfo( docinfo );
|
|
|
|
|
|
|
|
// store document info
|
|
|
|
KoStoreDevice* out = m_chain->storageFile( "documentinfo.xml", KoStore::Write );
|
|
|
|
if( out )
|
|
|
|
{
|
|
|
|
TQCString info = docinfo.toCString();
|
|
|
|
//kdDebug(30518) << " info :" << info << endl;
|
|
|
|
// WARNING: we cannot use KoStore::write(const TQByteArray&) because it gives an extra NULL character at the end.
|
|
|
|
out->writeBlock( info , info.length() );
|
|
|
|
}
|
|
|
|
|
|
|
|
TQDomDocument doccontent;
|
|
|
|
createDocumentContent( doccontent );
|
|
|
|
|
|
|
|
// store document content
|
|
|
|
out = m_chain->storageFile( "maindoc.xml", KoStore::Write );
|
|
|
|
if( out )
|
|
|
|
{
|
|
|
|
TQCString content = doccontent.toCString();
|
|
|
|
kdDebug(30518) << " content :" << content << endl;
|
|
|
|
out->writeBlock( content , content.length() );
|
|
|
|
}
|
|
|
|
|
|
|
|
m_zip->close();
|
|
|
|
delete m_zip;
|
|
|
|
|
|
|
|
kdDebug(30518) << "######################## OoImpressImport::convert done ####################" << endl;
|
|
|
|
return KoFilter::OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Very related to OoWriterImport::openFile()
|
|
|
|
KoFilter::ConversionStatus OoImpressImport::openFile()
|
|
|
|
{
|
|
|
|
KoFilter::ConversionStatus status = loadAndParse( "content.xml", m_content );
|
|
|
|
if ( status != KoFilter::OK )
|
|
|
|
{
|
|
|
|
kdError(30518) << "Content.xml could not be parsed correctly! Aborting!" << endl;
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
// We do not stop if the following calls fail.
|
|
|
|
TQDomDocument styles;
|
|
|
|
loadAndParse( "styles.xml", styles );
|
|
|
|
loadAndParse( "meta.xml", m_meta );
|
|
|
|
loadAndParse( "settings.xml", m_settings );
|
|
|
|
|
|
|
|
emit sigProgress( 10 );
|
|
|
|
createStyleMap( styles );
|
|
|
|
|
|
|
|
return KoFilter::OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
KoFilter::ConversionStatus OoImpressImport::loadAndParse(const TQString& filename, TQDomDocument& doc)
|
|
|
|
{
|
|
|
|
return OoUtils::loadAndParse( filename, doc, m_zip);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Very related to OoWriterImport::createDocumentInfo
|
|
|
|
void OoImpressImport::createDocumentInfo( TQDomDocument &docinfo )
|
|
|
|
{
|
|
|
|
docinfo = KoDocument::createDomDocument( "document-info" /*DTD name*/, "document-info" /*tag name*/, "1.1" );
|
|
|
|
|
|
|
|
OoUtils::createDocumentInfo(m_meta, docinfo);
|
|
|
|
//kdDebug(30518) << " meta-info :" << m_meta.toCString() << endl;
|
|
|
|
}
|
|
|
|
|
|
|
|
void OoImpressImport::createDocumentContent( TQDomDocument &doccontent )
|
|
|
|
{
|
|
|
|
TQDomDocument doc = KoDocument::createDomDocument( "kpresenter", "DOC", "1.2" );
|
|
|
|
TQDomElement docElement = doc.documentElement();
|
|
|
|
docElement.setAttribute( "editor", "KPresenter" );
|
|
|
|
docElement.setAttribute( "mime", "application/x-kpresenter" );
|
|
|
|
docElement.setAttribute( "syntaxVersion", "2" );
|
|
|
|
|
|
|
|
TQDomElement content = m_content.documentElement();
|
|
|
|
|
|
|
|
// content.xml contains some automatic-styles that we need to store
|
|
|
|
TQDomNode automaticStyles = KoDom::namedItemNS( content, ooNS::office, "automatic-styles" );
|
|
|
|
if ( !automaticStyles.isNull() )
|
|
|
|
insertStyles( automaticStyles.toElement() );
|
|
|
|
|
|
|
|
TQDomNode body = KoDom::namedItemNS( content, ooNS::office, "body" );
|
|
|
|
if ( body.isNull() )
|
|
|
|
return;
|
|
|
|
|
|
|
|
TQDomElement customSlideShow = doc.createElement( "CUSTOMSLIDESHOWCONFIG" );
|
|
|
|
|
|
|
|
// presentation settings
|
|
|
|
TQDomElement settings = KoDom::namedItemNS( body, ooNS::presentation, "settings");
|
|
|
|
if (!settings.isNull())
|
|
|
|
{
|
|
|
|
if (settings.attributeNS( ooNS::presentation, "endless", TQString())=="true")
|
|
|
|
{
|
|
|
|
TQDomElement infElem = doc.createElement("INFINITLOOP");
|
|
|
|
infElem.setAttribute("value", 1);
|
|
|
|
docElement.appendChild(infElem);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (settings.attributeNS( ooNS::presentation, "show-end-of-presentation-slide", TQString())=="true")
|
|
|
|
{
|
|
|
|
TQDomElement infElem = doc.createElement("SHOWENDOFPRESENTATIONSLIDE");
|
|
|
|
infElem.setAttribute("value", 1);
|
|
|
|
docElement.appendChild(infElem);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (settings.attributeNS( ooNS::presentation, "force-manual", TQString())=="true")
|
|
|
|
{
|
|
|
|
TQDomElement manualElem = doc.createElement("MANUALSWITCH");
|
|
|
|
manualElem.setAttribute("value", 1);
|
|
|
|
docElement.appendChild(manualElem);
|
|
|
|
}
|
|
|
|
if ( settings.hasAttributeNS( ooNS::presentation, "show") )
|
|
|
|
{
|
|
|
|
TQDomElement defaultPage = doc.createElement("DEFAULTCUSTOMSLIDESHOWNAME");
|
|
|
|
defaultPage.setAttribute("name", settings.attributeNS( ooNS::presentation, "show", TQString()) );
|
|
|
|
docElement.appendChild(defaultPage);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
TQDomElement presentationShow;
|
|
|
|
forEachElement( presentationShow, settings )
|
|
|
|
{
|
|
|
|
if ( presentationShow.localName()=="show" && presentationShow.namespaceURI() == ooNS::presentation )
|
|
|
|
{
|
|
|
|
if ( presentationShow.hasAttributeNS( ooNS::presentation, "pages") &&
|
|
|
|
presentationShow.hasAttributeNS( ooNS::presentation, "name"))
|
|
|
|
{
|
|
|
|
TQDomElement slide=doc.createElement("CUSTOMSLIDESHOW");
|
|
|
|
slide.setAttribute( "pages", presentationShow.attributeNS( ooNS::presentation, "pages", TQString() ));
|
|
|
|
slide.setAttribute( "name", presentationShow.attributeNS( ooNS::presentation, "name", TQString() ));
|
|
|
|
customSlideShow.appendChild( slide );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// it seems that ooimpress has different paper-settings for every slide.
|
|
|
|
// we take the settings of the first slide for the whole document.
|
|
|
|
TQDomElement drawPage = KoDom::namedItemNS( body, ooNS::draw, "page" );
|
|
|
|
if ( drawPage.isNull() ) // no slides? give up.
|
|
|
|
return;
|
|
|
|
|
|
|
|
TQDomElement objectElement = doc.createElement( "OBJECTS" );
|
|
|
|
TQDomElement pictureElement = doc.createElement( "PICTURES" );
|
|
|
|
TQDomElement pageTitleElement = doc.createElement( "PAGETITLES" );
|
|
|
|
TQDomElement pageNoteElement = doc.createElement( "PAGENOTES" );
|
|
|
|
TQDomElement backgroundElement = doc.createElement( "BACKGROUND" );
|
|
|
|
TQDomElement soundElement = doc.createElement( "SOUNDS" );
|
|
|
|
TQDomElement selSlideElement = doc.createElement( "SELSLIDES" );
|
|
|
|
TQDomElement helpLineElement = doc.createElement( "HELPLINES" );
|
|
|
|
TQDomElement attributeElement = doc.createElement( "ATTRIBUTES" );
|
|
|
|
TQDomElement *master = m_styles[drawPage.attributeNS( ooNS::draw, "master-page-name", TQString() )];
|
|
|
|
|
|
|
|
appendObject(*master, doc, soundElement,pictureElement,pageNoteElement,objectElement, 0, true);
|
|
|
|
|
|
|
|
TQDomElement *style = m_styles[master->attributeNS( ooNS::style, "page-master-name", TQString() )];
|
|
|
|
TQDomElement properties = KoDom::namedItemNS( *style, ooNS::style, "properties" );
|
|
|
|
//kdDebug(30518)<<" master->attribute( draw:style-name ) :"<<master->attributeNS( ooNS::draw, "style-name", TQString() )<<endl;
|
|
|
|
TQDomElement *backgroundStyle = m_stylesPresentation[ master->attributeNS( ooNS::draw, "style-name", TQString() ).isEmpty() ? "Standard-background" : master->attributeNS( ooNS::draw, "style-name", TQString() ) ];
|
|
|
|
|
|
|
|
//kdDebug(30518)<<" backgroundStyle :"<<backgroundStyle<<endl;
|
|
|
|
double pageHeight;
|
|
|
|
TQDomElement paperElement = doc.createElement( "PAPER" );
|
|
|
|
if ( properties.isNull() )
|
|
|
|
{
|
|
|
|
paperElement.setAttribute( "ptWidth", CM_TO_POINT(28) );
|
|
|
|
paperElement.setAttribute( "ptHeight", CM_TO_POINT(21) );
|
|
|
|
paperElement.setAttribute( "unit", 0 );
|
|
|
|
paperElement.setAttribute( "format", 5 );
|
|
|
|
paperElement.setAttribute( "tabStopValue", 42.5198 );
|
|
|
|
paperElement.setAttribute( "orientation", 0 );
|
|
|
|
pageHeight = 21;
|
|
|
|
|
|
|
|
TQDomElement paperBorderElement = doc.createElement( "PAPERBORDERS" );
|
|
|
|
paperBorderElement.setAttribute( "ptRight", 0 );
|
|
|
|
paperBorderElement.setAttribute( "ptBottom", 0 );
|
|
|
|
paperBorderElement.setAttribute( "ptLeft", 0 );
|
|
|
|
paperBorderElement.setAttribute( "ptTop", 0 );
|
|
|
|
paperElement.appendChild( paperBorderElement );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
paperElement.setAttribute( "ptWidth", KoUnit::parseValue(properties.attributeNS( ooNS::fo, "page-width", TQString() ) ) );
|
|
|
|
paperElement.setAttribute( "ptHeight", KoUnit::parseValue(properties.attributeNS( ooNS::fo, "page-height", TQString() ) ) );
|
|
|
|
// paperElement.setAttribute( "unit", 0 );
|
|
|
|
// paperElement.setAttribute( "format", 5 );
|
|
|
|
// paperElement.setAttribute( "tabStopValue", 42.5198 );
|
|
|
|
// paperElement.setAttribute( "orientation", 0 );
|
|
|
|
// Keep pageHeight in cm to avoid rounding-errors that would
|
|
|
|
// get multiplied with every new slide.
|
|
|
|
|
|
|
|
if (properties.attributeNS( ooNS::style, "print-orientation", TQString())=="portrait")
|
|
|
|
paperElement.setAttribute("orientation", 0);
|
|
|
|
else if (properties.attributeNS( ooNS::style, "print-orientation", TQString())=="landscape")
|
|
|
|
paperElement.setAttribute("orientation", 1);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
pageHeight = properties.attributeNS( ooNS::fo, "page-height", TQString() ).remove( "cm" ).toDouble();
|
|
|
|
|
|
|
|
TQDomElement paperBorderElement = doc.createElement( "PAPERBORDERS" );
|
|
|
|
paperBorderElement.setAttribute( "ptRight", KoUnit::parseValue( properties.attributeNS( ooNS::fo, "margin-right", TQString() ) ) );
|
|
|
|
paperBorderElement.setAttribute( "ptBottom", KoUnit::parseValue( properties.attributeNS( ooNS::fo, "margin-bottom", TQString() ) ) );
|
|
|
|
paperBorderElement.setAttribute( "ptLeft", KoUnit::parseValue( properties.attributeNS( ooNS::fo, "margin-left", TQString() ) ) );
|
|
|
|
paperBorderElement.setAttribute( "ptTop", KoUnit::parseValue( properties.attributeNS( ooNS::fo, "margin-top", TQString() ) ) );
|
|
|
|
paperElement.appendChild( paperBorderElement );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// parse all pages
|
|
|
|
forEachElement( drawPage, body )
|
|
|
|
{
|
|
|
|
if ( drawPage.localName()=="page" && drawPage.namespaceURI() == ooNS::draw && drawPage.hasAttributeNS( ooNS::draw, "id" ))
|
|
|
|
{
|
|
|
|
m_styleStack.clear(); // remove all styles
|
|
|
|
fillStyleStack( drawPage );
|
|
|
|
m_styleStack.save();
|
|
|
|
int pagePos = drawPage.attributeNS( ooNS::draw, "id", TQString() ).toInt() - 1;
|
|
|
|
// take care of a possible page background or slide transition or sound
|
|
|
|
if ( m_styleStack.hasAttributeNS( ooNS::draw, "fill" )
|
|
|
|
|| m_styleStack.hasAttributeNS( ooNS::presentation, "transition-style" ))
|
|
|
|
{
|
|
|
|
appendBackgroundPage( doc, backgroundElement,pictureElement, soundElement );
|
|
|
|
}
|
|
|
|
else if ( !m_styleStack.hasAttributeNS( ooNS::draw, "fill" ) && backgroundStyle)
|
|
|
|
{
|
|
|
|
m_styleStack.save();
|
|
|
|
m_styleStack.push( *backgroundStyle );
|
|
|
|
appendBackgroundPage( doc, backgroundElement,pictureElement, soundElement );
|
|
|
|
m_styleStack.restore();
|
|
|
|
kdDebug(30518)<<" load standard bacground \n";
|
|
|
|
}
|
|
|
|
if ( m_styleStack.hasAttributeNS( ooNS::presentation, "visibility" ) )
|
|
|
|
{
|
|
|
|
TQString str = m_styleStack.attributeNS( ooNS::presentation, "visibility" );
|
|
|
|
TQDomElement slide = doc.createElement("SLIDE");
|
|
|
|
slide.setAttribute( "nr", pagePos );
|
|
|
|
slide.setAttribute( "show", ( ( str=="hidden" ) ? "0" : "1" ));
|
|
|
|
selSlideElement.appendChild( slide );
|
|
|
|
|
|
|
|
//todo add support
|
|
|
|
kdDebug(30518)<<"m_styleStack.hasAttribute( presentation:visibility ) :"<<str<<" position page "<<pagePos<<endl;
|
|
|
|
}
|
|
|
|
// set the pagetitle
|
|
|
|
TQDomElement titleElement = doc.createElement( "Title" );
|
|
|
|
titleElement.setAttribute( "title", drawPage.attributeNS( ooNS::draw, "name", TQString() ) );
|
|
|
|
pageTitleElement.appendChild( titleElement );
|
|
|
|
|
|
|
|
// The '+1' is necessary to avoid that objects that start on the first line
|
|
|
|
// of a slide will show up on the last line of the previous slide.
|
|
|
|
double offset = CM_TO_POINT( ( drawPage.attributeNS( ooNS::draw, "id", TQString() ).toInt() - 1 ) * pageHeight ) + 1;
|
|
|
|
|
|
|
|
// animations (object effects)
|
|
|
|
createPresentationAnimation(KoDom::namedItemNS( drawPage, ooNS::presentation, "animations") );
|
|
|
|
|
|
|
|
// parse all objects
|
|
|
|
appendObject(drawPage, doc, soundElement,pictureElement,pageNoteElement,objectElement, offset);
|
|
|
|
|
|
|
|
//m_animations.clear();
|
|
|
|
m_styleStack.restore();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
docElement.appendChild( paperElement );
|
|
|
|
docElement.appendChild( backgroundElement );
|
|
|
|
if ( parseSettings( doc, helpLineElement, attributeElement ) )
|
|
|
|
docElement.appendChild( helpLineElement );
|
|
|
|
docElement.appendChild( attributeElement );
|
|
|
|
docElement.appendChild( pageTitleElement );
|
|
|
|
docElement.appendChild( pageNoteElement );
|
|
|
|
docElement.appendChild( objectElement );
|
|
|
|
docElement.appendChild( selSlideElement );
|
|
|
|
docElement.appendChild( customSlideShow );
|
|
|
|
docElement.appendChild( soundElement );
|
|
|
|
docElement.appendChild( pictureElement );
|
|
|
|
|
|
|
|
doccontent.appendChild( doc );
|
|
|
|
}
|
|
|
|
|
|
|
|
bool OoImpressImport::parseSettings( TQDomDocument &doc, TQDomElement &helpLineElement, TQDomElement &attributeElement )
|
|
|
|
{
|
|
|
|
bool foundElement = false;
|
|
|
|
KoOasisSettings settings( m_settings, ooNS::office, ooNS::config );
|
|
|
|
KoOasisSettings::Items viewSettings = settings.itemSet( "view-settings" );
|
|
|
|
//setUnit(KoUnit::unit(viewSettings.parseConfigItemString("unit")));
|
|
|
|
KoOasisSettings::IndexedMap viewMap = viewSettings.indexedMap( "Views" );
|
|
|
|
KoOasisSettings::Items firstView = viewMap.entry( 0 );
|
|
|
|
//<config:config-item config:name="SnapLinesDrawing" config:type="string">V7939H1139</config:config-item>
|
|
|
|
//by default show line
|
|
|
|
|
|
|
|
if ( !firstView.isNull() )
|
|
|
|
{
|
|
|
|
TQString str = firstView.parseConfigItemString( "SnapLinesDrawing" );
|
|
|
|
if ( !str.isEmpty() )
|
|
|
|
{
|
|
|
|
parseHelpLine( doc, helpLineElement, str );
|
|
|
|
//display it by default
|
|
|
|
helpLineElement.setAttribute( "show", true );
|
|
|
|
foundElement = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
int gridX = firstView.parseConfigItemInt( "GridFineWidth" );
|
|
|
|
int gridY = firstView.parseConfigItemInt( "GridFineHeight" );
|
|
|
|
bool snapToGrid = firstView.parseConfigItemBool( "IsSnapToGrid" );
|
|
|
|
int selectedPage = firstView.parseConfigItemInt( "SelectedPage" );
|
|
|
|
|
|
|
|
attributeElement.setAttribute( "activePage", selectedPage );
|
|
|
|
attributeElement.setAttribute( "gridx", MM_TO_POINT( gridX / 100.0 ) );
|
|
|
|
attributeElement.setAttribute( "gridy", MM_TO_POINT( gridY / 100.0 ) );
|
|
|
|
attributeElement.setAttribute( "snaptogrid", (int)snapToGrid );
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
//kdDebug(30518)<<" gridX :"<<gridX<<" gridY :"<<gridY<<" snapToGrid :"<<snapToGrid<<" selectedPage :"<<selectedPage<<endl;
|
|
|
|
return foundElement;
|
|
|
|
}
|
|
|
|
|
|
|
|
void OoImpressImport::parseHelpLine( TQDomDocument &doc,TQDomElement &helpLineElement, const TQString &text )
|
|
|
|
{
|
|
|
|
TQString str;
|
|
|
|
int newPos = text.length()-1; //start to element = 1
|
|
|
|
for ( int pos = text.length()-1; pos >=0;--pos )
|
|
|
|
{
|
|
|
|
if ( text[pos]=='P' )
|
|
|
|
{
|
|
|
|
|
|
|
|
//point
|
|
|
|
str = text.mid( pos+1, ( newPos-pos ) );
|
|
|
|
TQDomElement point=doc.createElement("HelpPoint");
|
|
|
|
|
|
|
|
//kdDebug(30518)<<" point element :"<< str <<endl;
|
|
|
|
TQStringList listVal = TQStringList::split( ",", str );
|
|
|
|
int posX = ( listVal[0].toInt()/100 );
|
|
|
|
int posY = ( listVal[1].toInt()/100 );
|
|
|
|
point.setAttribute("posX", MM_TO_POINT( posX ));
|
|
|
|
point.setAttribute("posY", MM_TO_POINT( posY ));
|
|
|
|
|
|
|
|
helpLineElement.appendChild( point );
|
|
|
|
newPos = pos-1;
|
|
|
|
}
|
|
|
|
else if ( text[pos]=='V' )
|
|
|
|
{
|
|
|
|
TQDomElement lines=doc.createElement("Vertical");
|
|
|
|
//vertical element
|
|
|
|
str = text.mid( pos+1, ( newPos-pos ) );
|
|
|
|
//kdDebug(30518)<<" vertical :"<< str <<endl;
|
|
|
|
int posX = ( str.toInt()/100 );
|
|
|
|
lines.setAttribute( "value", MM_TO_POINT( posX ) );
|
|
|
|
helpLineElement.appendChild( lines );
|
|
|
|
|
|
|
|
newPos = ( pos-1 );
|
|
|
|
|
|
|
|
}
|
|
|
|
else if ( text[pos]=='H' )
|
|
|
|
{
|
|
|
|
//horizontal element
|
|
|
|
TQDomElement lines=doc.createElement("Horizontal");
|
|
|
|
str = text.mid( pos+1, ( newPos-pos ) );
|
|
|
|
//kdDebug(30518)<<" horizontal :"<< str <<endl;
|
|
|
|
int posY = ( str.toInt()/100 );
|
|
|
|
lines.setAttribute( "value", MM_TO_POINT( posY ) );
|
|
|
|
helpLineElement.appendChild( lines );
|
|
|
|
newPos = pos-1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void OoImpressImport::appendObject(TQDomNode & drawPage, TQDomDocument & doc, TQDomElement & soundElement, TQDomElement & pictureElement, TQDomElement & pageNoteElement, TQDomElement &objectElement, double offset, bool sticky)
|
|
|
|
{
|
|
|
|
TQDomElement o;
|
|
|
|
forEachElement( o, drawPage )
|
|
|
|
{
|
|
|
|
const TQString localName = o.localName();
|
|
|
|
const TQString ns = o.namespaceURI();
|
|
|
|
const TQString drawID = o.attributeNS( ooNS::draw, "id", TQString());
|
|
|
|
m_styleStack.save();
|
|
|
|
|
|
|
|
TQDomElement e;
|
|
|
|
if ( localName == "text-box" && ns == ooNS::draw ) // textbox
|
|
|
|
{
|
|
|
|
fillStyleStack( o, sticky );
|
|
|
|
e = doc.createElement( "OBJECT" );
|
|
|
|
e.setAttribute( "type", 4 );
|
|
|
|
if ( sticky )
|
|
|
|
e.setAttribute( "sticky", "1" );
|
|
|
|
append2DGeometry( doc, e, o, (int)offset );
|
|
|
|
appendName(doc, e, o);
|
|
|
|
appendPen( doc, e );
|
|
|
|
appendBrush( doc, e );
|
|
|
|
appendRounding( doc, e, o );
|
|
|
|
appendShadow( doc, e );
|
|
|
|
appendObjectEffect(doc, e, o, soundElement);
|
|
|
|
e.appendChild( parseTextBox( doc, o ) );
|
|
|
|
}
|
|
|
|
else if ( localName == "rect" && ns == ooNS::draw ) // rectangle
|
|
|
|
{
|
|
|
|
fillStyleStack( o, sticky );
|
|
|
|
e = doc.createElement( "OBJECT" );
|
|
|
|
e.setAttribute( "type", 2 );
|
|
|
|
if ( sticky )
|
|
|
|
e.setAttribute( "sticky", "1" );
|
|
|
|
append2DGeometry( doc, e, o, (int)offset );
|
|
|
|
appendName(doc, e, o);
|
|
|
|
appendPen( doc, e );
|
|
|
|
appendBrush( doc, e );
|
|
|
|
appendRounding( doc, e, o );
|
|
|
|
appendShadow( doc, e );
|
|
|
|
|
|
|
|
appendObjectEffect(doc, e, o, soundElement);
|
|
|
|
}
|
|
|
|
else if ( ( localName == "circle" || localName == "ellipse" ) && ns == ooNS::draw )
|
|
|
|
{
|
|
|
|
fillStyleStack( o, sticky );
|
|
|
|
e = doc.createElement( "OBJECT" );
|
|
|
|
if ( sticky )
|
|
|
|
e.setAttribute( "sticky", "1" );
|
|
|
|
append2DGeometry( doc, e, o, (int)offset );
|
|
|
|
appendName(doc, e, o);
|
|
|
|
appendPen( doc, e );
|
|
|
|
appendShadow( doc, e );
|
|
|
|
appendLineEnds( doc, e );
|
|
|
|
appendObjectEffect(doc, e, o, soundElement);
|
|
|
|
|
|
|
|
if ( o.hasAttributeNS( ooNS::draw, "kind" ) ) // pie, chord or arc
|
|
|
|
{
|
|
|
|
e.setAttribute( "type", 8 );
|
|
|
|
appendPie( doc, e, o );
|
|
|
|
TQDomElement type = doc.createElement( "PIETYPE" );
|
|
|
|
|
|
|
|
TQString kind = o.attributeNS( ooNS::draw, "kind", TQString() );
|
|
|
|
if ( kind == "section" )
|
|
|
|
{
|
|
|
|
appendBrush( doc, e );
|
|
|
|
type.setAttribute( "value", 0 );
|
|
|
|
}
|
|
|
|
else if ( kind == "cut" )
|
|
|
|
{
|
|
|
|
appendBrush( doc, e );
|
|
|
|
type.setAttribute( "value", 2 );
|
|
|
|
}
|
|
|
|
else if ( kind == "arc" )
|
|
|
|
{
|
|
|
|
// arc has no brush
|
|
|
|
type.setAttribute( "value", 1 );
|
|
|
|
}
|
|
|
|
e.appendChild( type );
|
|
|
|
}
|
|
|
|
else // circle or ellipse
|
|
|
|
{
|
|
|
|
e.setAttribute( "type", 3 );
|
|
|
|
appendBrush( doc, e );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if ( localName == "line" && ns == ooNS::draw ) // line
|
|
|
|
{
|
|
|
|
fillStyleStack( o, sticky );
|
|
|
|
e = doc.createElement( "OBJECT" );
|
|
|
|
e.setAttribute( "type", 1 );
|
|
|
|
if ( sticky )
|
|
|
|
e.setAttribute( "sticky", "1" );
|
|
|
|
bool orderEndStartLine = appendLineGeometry( doc, e, o, (int)offset );
|
|
|
|
appendName(doc, e, o);
|
|
|
|
appendPen( doc, e );
|
|
|
|
appendBrush( doc, e );
|
|
|
|
appendShadow( doc, e );
|
|
|
|
appendLineEnds( doc, e, orderEndStartLine );
|
|
|
|
appendObjectEffect(doc, e, o, soundElement);
|
|
|
|
}
|
|
|
|
else if ( localName=="polyline" && ns == ooNS::draw ) { // polyline
|
|
|
|
fillStyleStack(o, sticky);
|
|
|
|
e = doc.createElement("OBJECT");
|
|
|
|
e.setAttribute("type", 12);
|
|
|
|
if ( sticky )
|
|
|
|
e.setAttribute( "sticky", "1" );
|
|
|
|
append2DGeometry(doc, e, o, (int)offset);
|
|
|
|
appendName(doc, e, o);
|
|
|
|
appendPoints(doc, e, o);
|
|
|
|
appendPen(doc, e);
|
|
|
|
appendBrush(doc, e);
|
|
|
|
appendLineEnds(doc, e);
|
|
|
|
//appendShadow(doc, e);
|
|
|
|
appendObjectEffect(doc, e, o, soundElement);
|
|
|
|
}
|
|
|
|
else if ( localName=="polygon" && ns == ooNS::draw ) { // polygon
|
|
|
|
fillStyleStack(o, sticky);
|
|
|
|
e = doc.createElement("OBJECT");
|
|
|
|
e.setAttribute("type", 16);
|
|
|
|
if ( sticky )
|
|
|
|
e.setAttribute( "sticky", "1" );
|
|
|
|
append2DGeometry(doc, e, o, (int)offset);
|
|
|
|
appendName(doc, e, o);
|
|
|
|
appendPoints(doc, e, o);
|
|
|
|
appendPen(doc, e);
|
|
|
|
appendBrush(doc, e);
|
|
|
|
//appendLineEnds(doc, e);
|
|
|
|
//appendShadow(doc, e);
|
|
|
|
appendObjectEffect(doc, e, o, soundElement);
|
|
|
|
}
|
|
|
|
else if ( localName == "image" && ns == ooNS::draw ) // image
|
|
|
|
{
|
|
|
|
fillStyleStack( o, sticky );
|
|
|
|
e = doc.createElement( "OBJECT" );
|
|
|
|
e.setAttribute( "type", 0 );
|
|
|
|
if ( sticky )
|
|
|
|
e.setAttribute( "sticky", "1" );
|
|
|
|
append2DGeometry( doc, e, o, (int)offset );
|
|
|
|
appendName(doc, e, o);
|
|
|
|
appendImage( doc, e, pictureElement, o );
|
|
|
|
appendObjectEffect(doc, e, o, soundElement);
|
|
|
|
}
|
|
|
|
else if ( localName == "object" && ns == ooNS::draw )
|
|
|
|
{
|
|
|
|
//todo add part object
|
|
|
|
}
|
|
|
|
else if ( localName == "g" && ns == ooNS::draw )
|
|
|
|
{
|
|
|
|
//todo add group object
|
|
|
|
}
|
|
|
|
else if ( localName == "path" && ns == ooNS::draw )
|
|
|
|
{
|
|
|
|
//todo add path object (freehand/cubic/quadricbeziercurve
|
|
|
|
}
|
|
|
|
else if ( localName == "notes" && ns == ooNS::presentation ) // notes
|
|
|
|
{
|
|
|
|
TQDomNode textBox = KoDom::namedItemNS( o, ooNS::draw, "text-box" );
|
|
|
|
if ( !textBox.isNull() )
|
|
|
|
{
|
|
|
|
TQString note;
|
|
|
|
TQDomElement t;
|
|
|
|
forEachElement( t, textBox )
|
|
|
|
{
|
|
|
|
// We don't care about styles as they are not supported in kpresenter.
|
|
|
|
// Only add a linebreak for every child.
|
|
|
|
note += t.text() + "\n";
|
|
|
|
}
|
|
|
|
TQDomElement notesElement = doc.createElement( "Note" );
|
|
|
|
notesElement.setAttribute( "note", note );
|
|
|
|
pageNoteElement.appendChild( notesElement );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
kdDebug(30518) << "Unsupported object '" << localName << "'" << endl;
|
|
|
|
m_styleStack.restore();
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
objectElement.appendChild( e );
|
|
|
|
m_styleStack.restore();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void OoImpressImport::appendBackgroundPage( TQDomDocument &doc, TQDomElement &backgroundElement, TQDomElement & pictureElement, TQDomElement &soundElement)
|
|
|
|
{
|
|
|
|
TQDomElement bgPage = doc.createElement( "PAGE" );
|
|
|
|
|
|
|
|
// background
|
|
|
|
if ( m_styleStack.hasAttributeNS( ooNS::draw, "fill" ) )
|
|
|
|
{
|
|
|
|
const TQString fill = m_styleStack.attributeNS( ooNS::draw, "fill" );
|
|
|
|
if ( fill == "solid" )
|
|
|
|
{
|
|
|
|
TQDomElement backColor1 = doc.createElement( "BACKCOLOR1" );
|
|
|
|
backColor1.setAttribute( "color", m_styleStack.attributeNS( ooNS::draw, "fill-color" ) );
|
|
|
|
bgPage.appendChild( backColor1 );
|
|
|
|
|
|
|
|
TQDomElement bcType = doc.createElement( "BCTYPE" );
|
|
|
|
bcType.setAttribute( "value", 0 ); // plain
|
|
|
|
bgPage.appendChild( bcType );
|
|
|
|
|
|
|
|
TQDomElement backType = doc.createElement( "BACKTYPE" );
|
|
|
|
backType.setAttribute( "value", 0 ); // color/gradient
|
|
|
|
bgPage.appendChild( backType );
|
|
|
|
}
|
|
|
|
else if ( fill == "gradient" )
|
|
|
|
{
|
|
|
|
TQString style = m_styleStack.attributeNS( ooNS::draw, "fill-gradient-name" );
|
|
|
|
TQDomElement* draw = m_draws[style];
|
|
|
|
appendBackgroundGradient( doc, bgPage, *draw );
|
|
|
|
}
|
|
|
|
else if ( fill == "bitmap" )
|
|
|
|
{
|
|
|
|
TQString style = m_styleStack.attributeNS( ooNS::draw, "fill-image-name" );
|
|
|
|
TQDomElement* draw = m_draws[style];
|
|
|
|
appendBackgroundImage( doc, bgPage, pictureElement, *draw );
|
|
|
|
|
|
|
|
TQDomElement backView = doc.createElement( "BACKVIEW" );
|
|
|
|
if ( m_styleStack.hasAttributeNS( ooNS::style, "repeat" ) )
|
|
|
|
{
|
|
|
|
TQString repeat = m_styleStack.attributeNS( ooNS::style, "repeat" );
|
|
|
|
if ( repeat == "stretch" )
|
|
|
|
backView.setAttribute( "value", 0 ); // zoomed
|
|
|
|
else if ( repeat == "no-repeat" )
|
|
|
|
backView.setAttribute( "value", 1 ); // centered
|
|
|
|
else
|
|
|
|
backView.setAttribute( "value", 2 ); // use tiled as default
|
|
|
|
}
|
|
|
|
else
|
|
|
|
backView.setAttribute( "value", 2 ); // use tiled as default
|
|
|
|
bgPage.appendChild( backView );
|
|
|
|
|
|
|
|
TQDomElement backType = doc.createElement( "BACKTYPE" );
|
|
|
|
backType.setAttribute( "value", 1 ); // image
|
|
|
|
bgPage.appendChild( backType );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( m_styleStack.hasAttributeNS( ooNS::presentation, "duration" ) )
|
|
|
|
{
|
|
|
|
TQString str = m_styleStack.attributeNS( ooNS::presentation, "duration");
|
|
|
|
kdDebug(30518)<<"styleStack.hasAttribute(presentation:duration ) :"<<str<<endl;
|
|
|
|
//convert date duration
|
|
|
|
int hour( str.mid( 2, 2 ).toInt() );
|
|
|
|
int minute( str.mid( 5, 2 ).toInt() );
|
|
|
|
int second( str.mid( 8, 2 ).toInt() );
|
|
|
|
int pageTimer = second + minute*60 + hour*60*60;
|
|
|
|
TQDomElement pgEffect = doc.createElement("PGTIMER");
|
|
|
|
pgEffect.setAttribute( "timer", pageTimer );
|
|
|
|
bgPage.appendChild(pgEffect);
|
|
|
|
}
|
|
|
|
// slide transition
|
|
|
|
if (m_styleStack.hasAttributeNS( ooNS::presentation, "transition-style"))
|
|
|
|
{
|
|
|
|
TQDomElement pgEffect = doc.createElement("PGEFFECT");
|
|
|
|
|
|
|
|
const TQString effect = m_styleStack.attributeNS( ooNS::presentation, "transition-style");
|
|
|
|
//kdDebug(30518) << "Transition name: " << effect << endl;
|
|
|
|
int pef;
|
|
|
|
|
|
|
|
if (effect=="vertical-stripes" || effect=="vertical-lines") // PEF_BLINDS_VER
|
|
|
|
pef=14;
|
|
|
|
else if (effect=="horizontal-stripes" || effect=="horizontal-lines") // PEF_BLINDS_HOR
|
|
|
|
pef=13;
|
|
|
|
else if (effect=="spiralin-left" || effect=="spiralin-right"
|
|
|
|
|| effect== "spiralout-left" || effect=="spiralout-right") // PEF_SURROUND1
|
|
|
|
pef=11;
|
|
|
|
else if (effect=="fade-from-upperleft") // PEF_STRIPS_RIGHT_DOWN
|
|
|
|
pef=39;
|
|
|
|
else if (effect=="fade-from-upperright") // PEF_STRIPS_LEFT_DOWN
|
|
|
|
pef=37;
|
|
|
|
else if (effect=="fade-from-lowerleft") // PEF_STRIPS_RIGHT_UP
|
|
|
|
pef=38;
|
|
|
|
else if (effect=="fade-from-lowerright") // PEF_STRIPS_LEFT_UP
|
|
|
|
pef=36;
|
|
|
|
else if (effect=="fade-from-top") // PEF_COVER_DOWN
|
|
|
|
pef=19;
|
|
|
|
else if (effect=="fade-from-bottom") // PEF_COVER_UP
|
|
|
|
pef=21;
|
|
|
|
else if (effect=="fade-from-left") // PEF_COVER_RIGHT
|
|
|
|
pef=25;
|
|
|
|
else if (effect=="fade-from-right") // PEF_COVER_LEFT
|
|
|
|
pef=23;
|
|
|
|
else if (effect=="fade-to-center") // PEF_CLOSE_ALL
|
|
|
|
pef=3;
|
|
|
|
else if (effect=="fade-from-center") // PEF_OPEN_ALL
|
|
|
|
pef=6;
|
|
|
|
else if (effect=="open-vertical") // PEF_OPEN_HORZ; really, no kidding ;)
|
|
|
|
pef=4;
|
|
|
|
else if (effect=="open-horizontal") // PEF_OPEN_VERT
|
|
|
|
pef=5;
|
|
|
|
else if (effect=="close-vertical") // PEF_CLOSE_HORZ
|
|
|
|
pef=1;
|
|
|
|
else if (effect=="close-horizontal") // PEF_CLOSE_VERT
|
|
|
|
pef=2;
|
|
|
|
else if (effect=="dissolve") // PEF_DISSOLVE; perfect hit ;)
|
|
|
|
pef=35;
|
|
|
|
else if (effect=="horizontal-checkerboard") // PEF_CHECKBOARD_ACROSS
|
|
|
|
pef=17;
|
|
|
|
else if (effect=="vertical-checkerboard") // PEF_CHECKBOARD_DOWN
|
|
|
|
pef=18;
|
|
|
|
else if (effect=="roll-from-left") // PEF_UNCOVER_RIGHT
|
|
|
|
pef=26;
|
|
|
|
else if (effect=="roll-from-right") // PEF_UNCOVER_LEFT
|
|
|
|
pef=24;
|
|
|
|
else if (effect=="roll-from-bottom") // PEF_UNCOVER_UP
|
|
|
|
pef=22;
|
|
|
|
else if (effect=="roll-from-top") // PEF_UNCOVER_DOWN
|
|
|
|
pef=20;
|
|
|
|
else if (effect=="random") // PEF_RANDOM
|
|
|
|
pef=-1;
|
|
|
|
else // we choose a random transition instead of the unsupported ones ;)
|
|
|
|
pef=-1;
|
|
|
|
|
|
|
|
pgEffect.setAttribute("value", pef);
|
|
|
|
bgPage.appendChild(pgEffect);
|
|
|
|
}
|
|
|
|
|
|
|
|
// slide transition sound
|
|
|
|
if (m_styleStack.hasChildNodeNS( ooNS::presentation, "sound"))
|
|
|
|
{
|
|
|
|
TQString soundUrl = storeSound(m_styleStack.childNodeNS( ooNS::presentation, "sound"),
|
|
|
|
soundElement, doc);
|
|
|
|
|
|
|
|
if (!soundUrl.isNull())
|
|
|
|
{
|
|
|
|
TQDomElement pseElem = doc.createElement("PGSOUNDEFFECT");
|
|
|
|
pseElem.setAttribute("soundEffect", 1);
|
|
|
|
pseElem.setAttribute("soundFileName", soundUrl);
|
|
|
|
|
|
|
|
bgPage.appendChild(pseElem);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
backgroundElement.appendChild(bgPage);
|
|
|
|
}
|
|
|
|
|
|
|
|
void OoImpressImport::appendName(TQDomDocument& doc, TQDomElement& e, const TQDomElement& object)
|
|
|
|
{
|
|
|
|
if( object.hasAttributeNS( ooNS::draw, "name" ))
|
|
|
|
{
|
|
|
|
TQDomElement name = doc.createElement( "OBJECTNAME" );
|
|
|
|
name.setAttribute( "objectName", object.attributeNS( ooNS::draw, "name", TQString() ));
|
|
|
|
e.appendChild( name );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void OoImpressImport::append2DGeometry( TQDomDocument& doc, TQDomElement& e, const TQDomElement& object, int offset )
|
|
|
|
{
|
|
|
|
TQDomElement orig = doc.createElement( "ORIG" );
|
|
|
|
orig.setAttribute( "x", KoUnit::parseValue( object.attributeNS( ooNS::svg, "x", TQString() ) ) );
|
|
|
|
orig.setAttribute( "y", KoUnit::parseValue( object.attributeNS( ooNS::svg, "y", TQString() ) ) + offset );
|
|
|
|
e.appendChild( orig );
|
|
|
|
|
|
|
|
TQDomElement size = doc.createElement( "SIZE" );
|
|
|
|
size.setAttribute( "width", KoUnit::parseValue( object.attributeNS( ooNS::svg, "width", TQString() ) ) );
|
|
|
|
size.setAttribute( "height", KoUnit::parseValue( object.attributeNS( ooNS::svg, "height", TQString() ) ) );
|
|
|
|
e.appendChild( size );
|
|
|
|
if( object.hasAttributeNS( ooNS::draw, "transform" ))
|
|
|
|
{
|
|
|
|
kdDebug(30518)<<" object transform \n";
|
|
|
|
//todo parse it
|
|
|
|
TQString transform = object.attributeNS( ooNS::draw, "transform", TQString() );
|
|
|
|
if( transform.contains("rotate ("))
|
|
|
|
{
|
|
|
|
//kdDebug(30518)<<" rotate object \n";
|
|
|
|
transform = transform.remove("rotate (" );
|
|
|
|
transform = transform.left(transform.find(")"));
|
|
|
|
//kdDebug(30518)<<" transform :"<<transform<<endl;
|
|
|
|
bool ok;
|
|
|
|
double radian = transform.toDouble(&ok);
|
|
|
|
if( ok )
|
|
|
|
{
|
|
|
|
TQDomElement angle = doc.createElement( "ANGLE" );
|
|
|
|
//angle is defined as a radian in oo but degree into kpresenter.
|
|
|
|
angle.setAttribute("value", (-1 * ((radian*180)/M_PI)));
|
|
|
|
|
|
|
|
e.appendChild( angle );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//return true if (x1 < x2) necessary to load correctly start-line and end-line
|
|
|
|
bool OoImpressImport::appendLineGeometry( TQDomDocument& doc, TQDomElement& e, const TQDomElement& object, int offset )
|
|
|
|
{
|
|
|
|
double x1 = KoUnit::parseValue( object.attributeNS( ooNS::svg, "x1", TQString() ) );
|
|
|
|
double y1 = KoUnit::parseValue( object.attributeNS( ooNS::svg, "y1", TQString() ) );
|
|
|
|
double x2 = KoUnit::parseValue( object.attributeNS( ooNS::svg, "x2", TQString() ) );
|
|
|
|
double y2 = KoUnit::parseValue( object.attributeNS( ooNS::svg, "y2", TQString() ) );
|
|
|
|
|
|
|
|
double x = TQMIN( x1, x2 );
|
|
|
|
double y = TQMIN( y1, y2 );
|
|
|
|
|
|
|
|
TQDomElement orig = doc.createElement( "ORIG" );
|
|
|
|
orig.setAttribute( "x", x );
|
|
|
|
orig.setAttribute( "y", y + offset );
|
|
|
|
e.appendChild( orig );
|
|
|
|
|
|
|
|
TQDomElement size = doc.createElement( "SIZE" );
|
|
|
|
size.setAttribute( "width", fabs( x1 - x2 ) );
|
|
|
|
size.setAttribute( "height", fabs( y1 - y2 ) );
|
|
|
|
e.appendChild( size );
|
|
|
|
|
|
|
|
TQDomElement linetype = doc.createElement( "LINETYPE" );
|
|
|
|
if ( ( x1 < x2 && y1 < y2 ) || ( x1 > x2 && y1 > y2 ) )
|
|
|
|
linetype.setAttribute( "value", 2 );
|
|
|
|
else
|
|
|
|
linetype.setAttribute( "value", 3 );
|
|
|
|
|
|
|
|
e.appendChild( linetype );
|
|
|
|
return (x1 < x2);
|
|
|
|
}
|
|
|
|
|
|
|
|
void OoImpressImport::appendPen( TQDomDocument& doc, TQDomElement& e )
|
|
|
|
{
|
|
|
|
if ( m_styleStack.hasAttributeNS( ooNS::draw, "stroke" ))
|
|
|
|
{
|
|
|
|
TQDomElement pen = doc.createElement( "PEN" );
|
|
|
|
if ( m_styleStack.attributeNS( ooNS::draw, "stroke" ) == "none" )
|
|
|
|
pen.setAttribute( "style", 0 );
|
|
|
|
else if ( m_styleStack.attributeNS( ooNS::draw, "stroke" ) == "solid" )
|
|
|
|
pen.setAttribute( "style", 1 );
|
|
|
|
else if ( m_styleStack.attributeNS( ooNS::draw, "stroke" ) == "dash" )
|
|
|
|
{
|
|
|
|
TQString style = m_styleStack.attributeNS( ooNS::draw, "stroke-dash" );
|
|
|
|
if ( style == "Ultrafine Dashed" || style == "Fine Dashed" ||
|
|
|
|
style == "Fine Dashed (var)" || style == "Dashed (var)" )
|
|
|
|
pen.setAttribute( "style", 2 );
|
|
|
|
else if ( style == "Fine Dotted" || style == "Ultrafine Dotted (var)" ||
|
|
|
|
style == "Line with Fine Dots" )
|
|
|
|
pen.setAttribute( "style", 3 );
|
|
|
|
else if ( style == "3 Dashes 3 Dots (var)" || style == "Ultrafine 2 Dots 3 Dashes" )
|
|
|
|
pen.setAttribute( "style", 4 );
|
|
|
|
else if ( style == "2 Dots 1 Dash" )
|
|
|
|
pen.setAttribute( "style", 5 );
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( m_styleStack.hasAttributeNS( ooNS::svg, "stroke-width" ) )
|
|
|
|
pen.setAttribute( "width", (int) KoUnit::parseValue( m_styleStack.attributeNS( ooNS::svg, "stroke-width" ) ) );
|
|
|
|
if ( m_styleStack.hasAttributeNS( ooNS::svg, "stroke-color" ) )
|
|
|
|
pen.setAttribute( "color", m_styleStack.attributeNS( ooNS::svg, "stroke-color" ) );
|
|
|
|
e.appendChild( pen );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void OoImpressImport::appendBrush( TQDomDocument& doc, TQDomElement& e )
|
|
|
|
{
|
|
|
|
if ( m_styleStack.hasAttributeNS( ooNS::draw, "fill" ) )
|
|
|
|
{
|
|
|
|
const TQString fill = m_styleStack.attributeNS( ooNS::draw, "fill" );
|
|
|
|
//kdDebug(30518)<<"void OoImpressImport::appendBrush( TQDomDocument& doc, TQDomElement& e ) :"<<fill<<endl;
|
|
|
|
if ( fill == "solid" )
|
|
|
|
{
|
|
|
|
TQDomElement brush = doc.createElement( "BRUSH" );
|
|
|
|
if ( m_styleStack.hasAttributeNS( ooNS::draw, "transparency" ) )
|
|
|
|
{
|
|
|
|
TQString transparency = m_styleStack.attributeNS( ooNS::draw, "transparency" );
|
|
|
|
transparency = transparency.remove( '%' );
|
|
|
|
int value = transparency.toInt();
|
|
|
|
if ( value >= 94 && value <= 99 )
|
|
|
|
{
|
|
|
|
brush.setAttribute( "style", 2 );
|
|
|
|
}
|
|
|
|
else if ( value>=64 && value <= 93 )
|
|
|
|
{
|
|
|
|
brush.setAttribute( "style", 3 );
|
|
|
|
}
|
|
|
|
else if ( value>=51 && value <= 63 )
|
|
|
|
{
|
|
|
|
brush.setAttribute( "style", 4 );
|
|
|
|
}
|
|
|
|
else if ( value>=38 && value <= 50 )
|
|
|
|
{
|
|
|
|
brush.setAttribute( "style", 5 );
|
|
|
|
}
|
|
|
|
else if ( value>=13 && value <= 37 )
|
|
|
|
{
|
|
|
|
brush.setAttribute( "style", 6 );
|
|
|
|
}
|
|
|
|
else if ( value>=7 && value <= 12 )
|
|
|
|
{
|
|
|
|
brush.setAttribute( "style", 7 );
|
|
|
|
}
|
|
|
|
else if ( value>=1 && value <= 6 )
|
|
|
|
{
|
|
|
|
brush.setAttribute( "style", 8 );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
brush.setAttribute( "style", 1 );
|
|
|
|
if ( m_styleStack.hasAttributeNS( ooNS::draw, "fill-color" ) )
|
|
|
|
brush.setAttribute( "color", m_styleStack.attributeNS( ooNS::draw, "fill-color" ) );
|
|
|
|
e.appendChild( brush );
|
|
|
|
}
|
|
|
|
else if ( fill == "hatch" )
|
|
|
|
{
|
|
|
|
TQDomElement brush = doc.createElement( "BRUSH" );
|
|
|
|
TQString style = m_styleStack.attributeNS( ooNS::draw, "fill-hatch-name" );
|
|
|
|
TQDomElement* draw = m_draws[style];
|
|
|
|
if ( draw )
|
|
|
|
{
|
|
|
|
if( draw->hasAttributeNS( ooNS::draw, "color" ) )
|
|
|
|
brush.setAttribute( "color", draw->attributeNS( ooNS::draw, "color", TQString() ) );
|
|
|
|
int angle = 0;
|
|
|
|
if( draw->hasAttributeNS( ooNS::draw, "rotation" ))
|
|
|
|
{
|
|
|
|
angle = (draw->attributeNS( ooNS::draw, "rotation", TQString() ).toInt())/10;
|
|
|
|
kdDebug(30518)<<"angle :"<<angle<<endl;
|
|
|
|
}
|
|
|
|
if( draw->hasAttributeNS( ooNS::draw, "style" ))
|
|
|
|
{
|
|
|
|
TQString styleHash = draw->attributeNS( ooNS::draw, "style", TQString() );
|
|
|
|
if( styleHash == "single")
|
|
|
|
{
|
|
|
|
switch( angle )
|
|
|
|
{
|
|
|
|
case 0:
|
|
|
|
case 180:
|
|
|
|
brush.setAttribute( "style", 9 );
|
|
|
|
break;
|
|
|
|
case 45:
|
|
|
|
case 225:
|
|
|
|
brush.setAttribute( "style", 12 );
|
|
|
|
break;
|
|
|
|
case 90:
|
|
|
|
case 270:
|
|
|
|
brush.setAttribute( "style", 10 );
|
|
|
|
break;
|
|
|
|
case 135:
|
|
|
|
case 315:
|
|
|
|
brush.setAttribute( "style", 13 );
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
//todo fixme when we will have a kopaint
|
|
|
|
kdDebug(30518)<<" draw:rotation 'angle' : "<<angle<<endl;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if( styleHash == "double")
|
|
|
|
{
|
|
|
|
switch( angle )
|
|
|
|
{
|
|
|
|
case 0:
|
|
|
|
case 180:
|
|
|
|
case 90:
|
|
|
|
case 270:
|
|
|
|
brush.setAttribute("style", 11 );
|
|
|
|
break;
|
|
|
|
case 45:
|
|
|
|
case 135:
|
|
|
|
case 225:
|
|
|
|
case 315:
|
|
|
|
brush.setAttribute("style",14 );
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
//todo fixme when we will have a kopaint
|
|
|
|
kdDebug(30518)<<" draw:rotation 'angle' : "<<angle<<endl;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
else if( styleHash == "triple")
|
|
|
|
{
|
|
|
|
kdDebug(30518)<<" it is not implemented :( \n";
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
e.appendChild( brush );
|
|
|
|
}
|
|
|
|
else if ( fill == "gradient" )
|
|
|
|
{
|
|
|
|
// We have to set a brush with brushstyle != no background fill
|
|
|
|
// otherwise the properties dialog for the object won't
|
|
|
|
// display the preview for the gradient.
|
|
|
|
TQDomElement brush = doc.createElement( "BRUSH" );
|
|
|
|
brush.setAttribute( "style", 1 );
|
|
|
|
e.appendChild( brush );
|
|
|
|
|
|
|
|
TQDomElement gradient = doc.createElement( "GRADIENT" );
|
|
|
|
TQString style = m_styleStack.attributeNS( ooNS::draw, "fill-gradient-name" );
|
|
|
|
|
|
|
|
TQDomElement* draw = m_draws[style];
|
|
|
|
if ( draw )
|
|
|
|
{
|
|
|
|
gradient.setAttribute( "color1", draw->attributeNS( ooNS::draw, "start-color", TQString() ) );
|
|
|
|
gradient.setAttribute( "color2", draw->attributeNS( ooNS::draw, "end-color", TQString() ) );
|
|
|
|
|
|
|
|
TQString type = draw->attributeNS( ooNS::draw, "style", TQString() );
|
|
|
|
//kdDebug(30518)<<" type !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! :"<<type<<endl;
|
|
|
|
if ( type == "linear" )
|
|
|
|
{
|
|
|
|
int angle = draw->attributeNS( ooNS::draw, "angle", TQString() ).toInt() / 10;
|
|
|
|
|
|
|
|
// make sure the angle is between 0 and 359
|
|
|
|
angle = abs( angle );
|
|
|
|
angle -= ( (int) ( angle / 360 ) ) * 360;
|
|
|
|
|
|
|
|
// What we are trying to do here is to find out if the given
|
|
|
|
// angle belongs to a horizontal, vertical or diagonal gradient.
|
|
|
|
int lower, upper, nearAngle = 0;
|
|
|
|
for ( lower = 0, upper = 45; upper < 360; lower += 45, upper += 45 )
|
|
|
|
{
|
|
|
|
if ( upper >= angle )
|
|
|
|
{
|
|
|
|
int distanceToUpper = abs( angle - upper );
|
|
|
|
int distanceToLower = abs( angle - lower );
|
|
|
|
nearAngle = distanceToUpper > distanceToLower ? lower : upper;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
kdDebug(30518)<<"nearAngle :"<<nearAngle<<endl;
|
|
|
|
// nearAngle should now be one of: 0, 45, 90, 135, 180...
|
|
|
|
if ( nearAngle == 0 || nearAngle == 180 )
|
|
|
|
gradient.setAttribute( "type", 1 ); // horizontal
|
|
|
|
else if ( nearAngle == 90 || nearAngle == 270 )
|
|
|
|
gradient.setAttribute( "type", 2 ); // vertical
|
|
|
|
else if ( nearAngle == 45 || nearAngle == 225 )
|
|
|
|
gradient.setAttribute( "type", 3 ); // diagonal 1
|
|
|
|
else if ( nearAngle == 135 || nearAngle == 315 )
|
|
|
|
gradient.setAttribute( "type", 4 ); // diagonal 2
|
|
|
|
}
|
|
|
|
else if ( type == "radial" || type == "ellipsoid" )
|
|
|
|
gradient.setAttribute( "type", 5 ); // circle
|
|
|
|
else if ( type == "square" || type == "rectangular" )
|
|
|
|
gradient.setAttribute( "type", 6 ); // rectangle
|
|
|
|
else if ( type == "axial" )
|
|
|
|
gradient.setAttribute( "type", 7 ); // pipecross
|
|
|
|
|
|
|
|
// Hard to map between x- and y-center settings of ooimpress
|
|
|
|
// and (un-)balanced settings of kpresenter. Let's try it.
|
|
|
|
int x, y;
|
|
|
|
if ( draw->hasAttributeNS( ooNS::draw, "cx" ) )
|
|
|
|
x = draw->attributeNS( ooNS::draw, "cx", TQString() ).remove( '%' ).toInt();
|
|
|
|
else
|
|
|
|
x = 50;
|
|
|
|
|
|
|
|
if ( draw->hasAttributeNS( ooNS::draw, "cy" ) )
|
|
|
|
y = draw->attributeNS( ooNS::draw, "cy", TQString() ).remove( '%' ).toInt();
|
|
|
|
else
|
|
|
|
y = 50;
|
|
|
|
|
|
|
|
if ( x == 50 && y == 50 )
|
|
|
|
{
|
|
|
|
gradient.setAttribute( "unbalanced", 0 );
|
|
|
|
gradient.setAttribute( "xfactor", 100 );
|
|
|
|
gradient.setAttribute( "yfactor", 100 );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
gradient.setAttribute( "unbalanced", 1 );
|
|
|
|
// map 0 - 100% to -200 - 200
|
|
|
|
gradient.setAttribute( "xfactor", 4 * x - 200 );
|
|
|
|
gradient.setAttribute( "yfactor", 4 * y - 200 );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
e.appendChild( gradient );
|
|
|
|
|
|
|
|
TQDomElement fillType = doc.createElement( "FILLTYPE" );
|
|
|
|
fillType.setAttribute( "value", 1 );
|
|
|
|
e.appendChild( fillType );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void OoImpressImport::appendPie( TQDomDocument& doc, TQDomElement& e, const TQDomElement& object )
|
|
|
|
{
|
|
|
|
TQDomElement angle = doc.createElement( "PIEANGLE" );
|
|
|
|
int start = (int) ( object.attributeNS( ooNS::draw, "start-angle", TQString() ).toDouble() );
|
|
|
|
angle.setAttribute( "value", start * 16 );
|
|
|
|
e.appendChild( angle );
|
|
|
|
|
|
|
|
TQDomElement length = doc.createElement( "PIELENGTH" );
|
|
|
|
int end = (int) ( object.attributeNS( ooNS::draw, "end-angle", TQString() ).toDouble() );
|
|
|
|
if ( end < start )
|
|
|
|
length.setAttribute( "value", ( 360 - start + end ) * 16 );
|
|
|
|
else
|
|
|
|
length.setAttribute( "value", ( end - start ) * 16 );
|
|
|
|
e.appendChild( length );
|
|
|
|
}
|
|
|
|
|
|
|
|
void OoImpressImport::appendImage( TQDomDocument& doc, TQDomElement& e, TQDomElement& p,
|
|
|
|
const TQDomElement& object )
|
|
|
|
{
|
|
|
|
TQString fileName = storeImage( object );
|
|
|
|
|
|
|
|
// create a key for the picture
|
|
|
|
TQTime time = TQTime::currentTime();
|
|
|
|
TQDate date = TQDate::currentDate();
|
|
|
|
|
|
|
|
TQDomElement image = doc.createElement( "KEY" );
|
|
|
|
image.setAttribute( "msec", time.msec() );
|
|
|
|
image.setAttribute( "second", time.second() );
|
|
|
|
image.setAttribute( "minute", time.minute() );
|
|
|
|
image.setAttribute( "hour", time.hour() );
|
|
|
|
image.setAttribute( "day", date.day() );
|
|
|
|
image.setAttribute( "month", date.month() );
|
|
|
|
image.setAttribute( "year", date.year() );
|
|
|
|
image.setAttribute( "filename", fileName );
|
|
|
|
e.appendChild( image );
|
|
|
|
|
|
|
|
TQDomElement settings = doc.createElement( "PICTURESETTINGS" );
|
|
|
|
if ( m_styleStack.hasAttributeNS( ooNS::draw, "color-mode" ) && ( m_styleStack.attributeNS( ooNS::draw, "color-mode" )=="greyscale" ) )
|
|
|
|
settings.setAttribute( "grayscal", 1 );
|
|
|
|
else
|
|
|
|
settings.setAttribute( "grayscal", 0 );
|
|
|
|
|
|
|
|
if ( m_styleStack.hasAttributeNS( ooNS::draw, "luminance" ) )
|
|
|
|
{
|
|
|
|
TQString str( m_styleStack.attributeNS( ooNS::draw, "luminance" ) );
|
|
|
|
str = str.remove( '%' );
|
|
|
|
settings.setAttribute( "bright", str );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
settings.setAttribute( "bright", 0 );
|
|
|
|
|
|
|
|
settings.setAttribute( "mirrorType", 0 );
|
|
|
|
settings.setAttribute( "swapRGB", 0 );
|
|
|
|
settings.setAttribute( "depth", 0 );
|
|
|
|
e.appendChild( settings );
|
|
|
|
|
|
|
|
TQDomElement effects = doc.createElement( "EFFECTS" );
|
|
|
|
bool hasEffect = false;
|
|
|
|
if ( m_styleStack.hasAttributeNS( ooNS::draw, "contrast" ) )
|
|
|
|
{
|
|
|
|
TQString str( m_styleStack.attributeNS( ooNS::draw, "contrast" ) );
|
|
|
|
str = str.remove( '%' );
|
|
|
|
int val = str.toInt();
|
|
|
|
val = ( int )( 255.0 *val/100.0 );
|
|
|
|
effects.setAttribute( "type", "5" );
|
|
|
|
effects.setAttribute( "param1", TQString::number( val ) );
|
|
|
|
hasEffect = true;
|
|
|
|
}
|
|
|
|
if ( hasEffect )
|
|
|
|
e.appendChild( effects );
|
|
|
|
|
|
|
|
TQDomElement key = image.cloneNode().toElement();
|
|
|
|
key.setAttribute( "name", "pictures/" + fileName );
|
|
|
|
p.appendChild( key );
|
|
|
|
}
|
|
|
|
|
|
|
|
void OoImpressImport::appendBackgroundImage( TQDomDocument& doc, TQDomElement& e,
|
|
|
|
TQDomElement& p, const TQDomElement& object )
|
|
|
|
{
|
|
|
|
TQString fileName = storeImage( object );
|
|
|
|
|
|
|
|
// create a key for the picture
|
|
|
|
TQTime time = TQTime::currentTime();
|
|
|
|
TQDate date = TQDate::currentDate();
|
|
|
|
|
|
|
|
TQDomElement image = doc.createElement( "BACKPICTUREKEY" );
|
|
|
|
image.setAttribute( "msec", time.msec() );
|
|
|
|
image.setAttribute( "second", time.second() );
|
|
|
|
image.setAttribute( "minute", time.minute() );
|
|
|
|
image.setAttribute( "hour", time.hour() );
|
|
|
|
image.setAttribute( "day", date.day() );
|
|
|
|
image.setAttribute( "month", date.month() );
|
|
|
|
image.setAttribute( "year", date.year() );
|
|
|
|
image.setAttribute( "filename", fileName );
|
|
|
|
e.appendChild( image );
|
|
|
|
|
|
|
|
TQDomElement key = image.cloneNode().toElement();
|
|
|
|
key.setTagName( "KEY" );
|
|
|
|
key.setAttribute( "name", "pictures/" + fileName );
|
|
|
|
p.appendChild( key );
|
|
|
|
}
|
|
|
|
|
|
|
|
void OoImpressImport::appendBackgroundGradient( TQDomDocument& doc, TQDomElement& e,
|
|
|
|
const TQDomElement& object )
|
|
|
|
{
|
|
|
|
TQDomElement backColor1 = doc.createElement( "BACKCOLOR1" );
|
|
|
|
backColor1.setAttribute( "color", object.attributeNS( ooNS::draw, "start-color", TQString() ) );
|
|
|
|
e.appendChild( backColor1 );
|
|
|
|
|
|
|
|
TQDomElement backColor2 = doc.createElement( "BACKCOLOR2" );
|
|
|
|
backColor2.setAttribute( "color", object.attributeNS( ooNS::draw, "end-color", TQString() ) );
|
|
|
|
e.appendChild( backColor2 );
|
|
|
|
|
|
|
|
TQDomElement backType = doc.createElement( "BACKTYPE" );
|
|
|
|
backType.setAttribute( "value", 0 ); // color/gradient
|
|
|
|
e.appendChild( backType );
|
|
|
|
|
|
|
|
TQDomElement bcType = doc.createElement( "BCTYPE" );
|
|
|
|
TQString type = object.attributeNS( ooNS::draw, "style", TQString() );
|
|
|
|
if ( type == "linear" )
|
|
|
|
{
|
|
|
|
int angle = object.attributeNS( ooNS::draw, "angle", TQString() ).toInt() / 10;
|
|
|
|
|
|
|
|
// make sure the angle is between 0 and 359
|
|
|
|
angle = abs( angle );
|
|
|
|
angle -= ( (int) ( angle / 360 ) ) * 360;
|
|
|
|
|
|
|
|
// What we are trying to do here is to find out if the given
|
|
|
|
// angle belongs to a horizontal, vertical or diagonal gradient.
|
|
|
|
int lower, upper, nearAngle = 0;
|
|
|
|
for ( lower = 0, upper = 45; upper < 360; lower += 45, upper += 45 )
|
|
|
|
{
|
|
|
|
if ( upper >= angle )
|
|
|
|
{
|
|
|
|
int distanceToUpper = abs( angle - upper );
|
|
|
|
int distanceToLower = abs( angle - lower );
|
|
|
|
nearAngle = distanceToUpper > distanceToLower ? lower : upper;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// nearAngle should now be one of: 0, 45, 90, 135, 180...
|
|
|
|
if ( nearAngle == 0 || nearAngle == 180 )
|
|
|
|
bcType.setAttribute( "value", 1 ); // horizontal
|
|
|
|
else if ( nearAngle == 90 || nearAngle == 270 )
|
|
|
|
bcType.setAttribute( "value", 2 ); // vertical
|
|
|
|
else if ( nearAngle == 45 || nearAngle == 225 )
|
|
|
|
bcType.setAttribute( "value", 3 ); // diagonal 1
|
|
|
|
else if ( nearAngle == 135 || nearAngle == 315 )
|
|
|
|
bcType.setAttribute( "value", 4 ); // diagonal 2
|
|
|
|
}
|
|
|
|
else if ( type == "radial" || type == "ellipsoid" )
|
|
|
|
bcType.setAttribute( "value", 5 ); // circle
|
|
|
|
else if ( type == "square" || type == "rectangular" )
|
|
|
|
bcType.setAttribute( "value", 6 ); // rectangle
|
|
|
|
else if ( type == "axial" )
|
|
|
|
bcType.setAttribute( "value", 7 ); // pipecross
|
|
|
|
|
|
|
|
e.appendChild( bcType );
|
|
|
|
|
|
|
|
TQDomElement bGradient = doc.createElement( "BGRADIENT" );
|
|
|
|
|
|
|
|
// Hard to map between x- and y-center settings of ooimpress
|
|
|
|
// and (un-)balanced settings of kpresenter. Let's try it.
|
|
|
|
int x, y;
|
|
|
|
if ( object.hasAttributeNS( ooNS::draw, "cx" ) )
|
|
|
|
x = object.attributeNS( ooNS::draw, "cx", TQString() ).remove( '%' ).toInt();
|
|
|
|
else
|
|
|
|
x = 50;
|
|
|
|
|
|
|
|
if ( object.hasAttributeNS( ooNS::draw, "cy" ) )
|
|
|
|
y = object.attributeNS( ooNS::draw, "cy", TQString() ).remove( '%' ).toInt();
|
|
|
|
else
|
|
|
|
y = 50;
|
|
|
|
|
|
|
|
if ( x == 50 && y == 50 )
|
|
|
|
{
|
|
|
|
bGradient.setAttribute( "unbalanced", 0 );
|
|
|
|
bGradient.setAttribute( "xfactor", 100 );
|
|
|
|
bGradient.setAttribute( "yfactor", 100 );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
bGradient.setAttribute( "unbalanced", 1 );
|
|
|
|
// map 0 - 100% to -200 - 200
|
|
|
|
bGradient.setAttribute( "xfactor", 4 * x - 200 );
|
|
|
|
bGradient.setAttribute( "yfactor", 4 * y - 200 );
|
|
|
|
}
|
|
|
|
|
|
|
|
e.appendChild( bGradient );
|
|
|
|
}
|
|
|
|
|
|
|
|
void OoImpressImport::appendRounding( TQDomDocument& doc, TQDomElement& e, const TQDomElement& object )
|
|
|
|
{
|
|
|
|
if ( object.hasAttributeNS( ooNS::draw, "corner-radius" ) )
|
|
|
|
{
|
|
|
|
// kpresenter uses percent, ooimpress uses cm ... hmm?
|
|
|
|
TQDomElement rounding = doc.createElement( "RNDS" );
|
|
|
|
int corner = static_cast<int>(KoUnit::parseValue(object.attributeNS( ooNS::draw, "corner-radius", TQString())));
|
|
|
|
rounding.setAttribute( "x", corner );
|
|
|
|
rounding.setAttribute( "y", corner );
|
|
|
|
e.appendChild( rounding );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void OoImpressImport::appendShadow( TQDomDocument& doc, TQDomElement& e )
|
|
|
|
{
|
|
|
|
// Note that ooimpress makes a difference between shadowed text and
|
|
|
|
// a shadowed object while kpresenter only knows the attribute 'shadow'.
|
|
|
|
// This means that a shadowed textobject in kpresenter will always show
|
|
|
|
// a shadowed text but no shadow for the object itself.
|
|
|
|
|
|
|
|
// make sure this is a textobject or textspan
|
|
|
|
if ( !e.hasAttribute( "type" ) ||
|
|
|
|
( e.hasAttribute( "type" ) && e.attribute( "type" ) == "4" ) )
|
|
|
|
{
|
|
|
|
if ( m_styleStack.hasAttributeNS( ooNS::fo, "text-shadow" ) &&
|
|
|
|
m_styleStack.attributeNS( ooNS::fo, "text-shadow" ) != "none" )
|
|
|
|
{
|
|
|
|
// use the shadow attribute to indicate a text-shadow
|
|
|
|
TQDomElement shadow = doc.createElement( "SHADOW" );
|
|
|
|
TQString distance = m_styleStack.attributeNS( ooNS::fo, "text-shadow" );
|
|
|
|
distance.truncate( distance.find( ' ' ) );
|
|
|
|
shadow.setAttribute( "distance", KoUnit::parseValue( distance ) );
|
|
|
|
shadow.setAttribute( "direction", 5 );
|
|
|
|
shadow.setAttribute( "color", "#a0a0a0" );
|
|
|
|
e.appendChild( shadow );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if ( m_styleStack.hasAttributeNS( ooNS::draw, "shadow" ) &&
|
|
|
|
m_styleStack.attributeNS( ooNS::draw, "shadow" ) == "visible" )
|
|
|
|
{
|
|
|
|
// use the shadow attribute to indicate an object-shadow
|
|
|
|
TQDomElement shadow = doc.createElement( "SHADOW" );
|
|
|
|
double x = KoUnit::parseValue( m_styleStack.attributeNS( ooNS::draw, "shadow-offset-x" ) );
|
|
|
|
double y = KoUnit::parseValue( m_styleStack.attributeNS( ooNS::draw, "shadow-offset-y" ) );
|
|
|
|
|
|
|
|
if ( x < 0 && y < 0 )
|
|
|
|
{
|
|
|
|
shadow.setAttribute( "direction", 1 );
|
|
|
|
shadow.setAttribute( "distance", (int) fabs ( x ) );
|
|
|
|
}
|
|
|
|
else if ( x == 0 && y < 0 )
|
|
|
|
{
|
|
|
|
shadow.setAttribute( "direction", 2 );
|
|
|
|
shadow.setAttribute( "distance", (int) fabs ( y ) );
|
|
|
|
}
|
|
|
|
else if ( x > 0 && y < 0 )
|
|
|
|
{
|
|
|
|
shadow.setAttribute( "direction", 3 );
|
|
|
|
shadow.setAttribute( "distance", (int) fabs ( x ) );
|
|
|
|
}
|
|
|
|
else if ( x > 0 && y == 0 )
|
|
|
|
{
|
|
|
|
shadow.setAttribute( "direction", 4 );
|
|
|
|
shadow.setAttribute( "distance", (int) fabs ( x ) );
|
|
|
|
}
|
|
|
|
else if ( x > 0 && y > 0 )
|
|
|
|
{
|
|
|
|
shadow.setAttribute( "direction", 5 );
|
|
|
|
shadow.setAttribute( "distance", (int) fabs ( x ) );
|
|
|
|
}
|
|
|
|
else if ( x == 0 && y > 0 )
|
|
|
|
{
|
|
|
|
shadow.setAttribute( "direction", 6 );
|
|
|
|
shadow.setAttribute( "distance", (int) fabs ( y ) );
|
|
|
|
}
|
|
|
|
else if ( x < 0 && y > 0 )
|
|
|
|
{
|
|
|
|
shadow.setAttribute( "direction", 7 );
|
|
|
|
shadow.setAttribute( "distance", (int) fabs ( x ) );
|
|
|
|
}
|
|
|
|
else if ( x < 0 && y == 0 )
|
|
|
|
{
|
|
|
|
shadow.setAttribute( "direction", 8 );
|
|
|
|
shadow.setAttribute( "distance", (int) fabs ( x ) );
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( m_styleStack.hasAttributeNS( ooNS::draw, "shadow-color" ) )
|
|
|
|
shadow.setAttribute( "color", m_styleStack.attributeNS( ooNS::draw, "shadow-color" ) );
|
|
|
|
|
|
|
|
e.appendChild( shadow );
|
|
|
|
}
|
|
|
|
if ( m_styleStack.hasAttributeNS( ooNS::draw, "size-protect" ) || m_styleStack.hasAttributeNS( ooNS::draw, "move-protect" ) )
|
|
|
|
{
|
|
|
|
bool b = ( m_styleStack.attributeNS( ooNS::draw, "size-protect" ) == "true" ) || ( m_styleStack.attributeNS( ooNS::draw, "move-protect" ) == "true" );
|
|
|
|
if ( b )
|
|
|
|
{
|
|
|
|
TQDomElement protect = doc.createElement( "PROTECT" );
|
|
|
|
protect.setAttribute("state" , b);
|
|
|
|
e.appendChild(protect);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void OoImpressImport::appendLineEnds( TQDomDocument& doc, TQDomElement& e, bool orderEndStartLine)
|
|
|
|
{
|
|
|
|
const char* attr = orderEndStartLine ? "marker-start" : "marker-end";
|
|
|
|
if ( m_styleStack.hasAttributeNS( ooNS::draw, attr ) )
|
|
|
|
{
|
|
|
|
TQDomElement lineBegin = doc.createElement( "LINEBEGIN" );
|
|
|
|
TQString type = m_styleStack.attributeNS( ooNS::draw, attr );
|
|
|
|
if ( type == "Arrow" || type == "Small Arrow" || type == "Rounded short Arrow" ||
|
|
|
|
type == "Symmetric Arrow" || type == "Rounded large Arrow" || type == "Arrow concave" )
|
|
|
|
lineBegin.setAttribute( "value", 1 );
|
|
|
|
else if ( type == "Square" )
|
|
|
|
lineBegin.setAttribute( "value", 2 );
|
|
|
|
else if ( type == "Circle" || type == "Square 45" )
|
|
|
|
lineBegin.setAttribute( "value", 3 );
|
|
|
|
else if ( type == "Line Arrow" )
|
|
|
|
lineBegin.setAttribute( "value", 4 );
|
|
|
|
else if ( type == "Dimension Lines" )
|
|
|
|
lineBegin.setAttribute( "value", 5 );
|
|
|
|
else if ( type == "Double Arrow" )
|
|
|
|
lineBegin.setAttribute( "value", 6 );
|
|
|
|
e.appendChild( lineBegin );
|
|
|
|
}
|
|
|
|
attr = orderEndStartLine ? "marker-end" : "marker-start";
|
|
|
|
if ( m_styleStack.hasAttributeNS( ooNS::draw, attr ) )
|
|
|
|
{
|
|
|
|
TQDomElement lineEnd = doc.createElement( "LINEEND" );
|
|
|
|
TQString type = m_styleStack.attributeNS( ooNS::draw, attr );
|
|
|
|
if ( type == "Arrow" || type == "Small Arrow" || type == "Rounded short Arrow" ||
|
|
|
|
type == "Symmetric Arrow" || type == "Rounded large Arrow" || type == "Arrow concave" )
|
|
|
|
lineEnd.setAttribute( "value", 1 );
|
|
|
|
else if ( type == "Square" )
|
|
|
|
lineEnd.setAttribute( "value", 2 );
|
|
|
|
else if ( type == "Circle" || type == "Square 45" )
|
|
|
|
lineEnd.setAttribute( "value", 3 );
|
|
|
|
else if ( type == "Line Arrow" )
|
|
|
|
lineEnd.setAttribute( "value", 4 );
|
|
|
|
else if ( type == "Dimension Lines" )
|
|
|
|
lineEnd.setAttribute( "value", 5 );
|
|
|
|
else if ( type == "Double Arrow" )
|
|
|
|
lineEnd.setAttribute( "value", 6 );
|
|
|
|
e.appendChild( lineEnd );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void OoImpressImport::appendTextObjectMargin( TQDomDocument& /*doc*/, TQDomElement& e )
|
|
|
|
{
|
|
|
|
if ( m_styleStack.hasAttributeNS( ooNS::fo, "padding" ) )
|
|
|
|
{
|
|
|
|
double tmpValue = KoUnit::parseValue(m_styleStack.attributeNS( ooNS::fo, "padding" ) );
|
|
|
|
e.setAttribute( "btoppt", tmpValue );
|
|
|
|
e.setAttribute( "bbottompt", tmpValue );
|
|
|
|
e.setAttribute( "bleftpt", tmpValue );
|
|
|
|
e.setAttribute( "brightpt", tmpValue );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if( m_styleStack.hasAttributeNS( ooNS::fo, "padding-top" ) )
|
|
|
|
e.setAttribute( "btoppt", KoUnit::parseValue( m_styleStack.attributeNS( ooNS::fo, "padding-top" ) ) );
|
|
|
|
if( m_styleStack.hasAttributeNS( ooNS::fo, "padding-bottom" ) )
|
|
|
|
e.setAttribute( "bbottompt", KoUnit::parseValue( m_styleStack.attributeNS( ooNS::fo, "padding-bottom" ) ) );
|
|
|
|
if( m_styleStack.hasAttributeNS( ooNS::fo, "padding-left" ) )
|
|
|
|
e.setAttribute( "bleftpt", KoUnit::parseValue( m_styleStack.attributeNS( ooNS::fo, "padding-left" ) ) );
|
|
|
|
if( m_styleStack.hasAttributeNS( ooNS::fo, "padding-right" ) )
|
|
|
|
e.setAttribute( "brightpt", KoUnit::parseValue( m_styleStack.attributeNS( ooNS::fo, "padding-right" ) ) );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
TQDomElement OoImpressImport::parseTextBox( TQDomDocument& doc, const TQDomElement& textBox )
|
|
|
|
{
|
|
|
|
TQDomElement textObjectElement = doc.createElement( "TEXTOBJ" );
|
|
|
|
appendTextObjectMargin( doc, textObjectElement );
|
|
|
|
|
|
|
|
// vertical alignment
|
|
|
|
if ( m_styleStack.hasAttributeNS( ooNS::draw, "textarea-vertical-align" ) )
|
|
|
|
{
|
|
|
|
TQString alignment = m_styleStack.attributeNS( ooNS::draw, "textarea-vertical-align" );
|
|
|
|
if ( alignment == "top" )
|
|
|
|
textObjectElement.setAttribute( "verticalAlign", "top" );
|
|
|
|
else if ( alignment == "middle" )
|
|
|
|
textObjectElement.setAttribute( "verticalAlign", "center" );
|
|
|
|
else if ( alignment == "bottom" )
|
|
|
|
textObjectElement.setAttribute( "verticalAlign", "bottom" );
|
|
|
|
|
|
|
|
textObjectElement.setAttribute("verticalValue", 0.0);
|
|
|
|
}
|
|
|
|
|
|
|
|
parseParagraphs( doc, textObjectElement, textBox );
|
|
|
|
|
|
|
|
return textObjectElement;
|
|
|
|
}
|
|
|
|
|
|
|
|
void OoImpressImport::parseParagraphs( TQDomDocument& doc, TQDomElement& textObjectElement, const TQDomElement& parent )
|
|
|
|
{
|
|
|
|
TQDomElement t;
|
|
|
|
forEachElement( t, parent )
|
|
|
|
{
|
|
|
|
m_styleStack.save();
|
|
|
|
const TQString localName = t.localName();
|
|
|
|
const TQString ns = t.namespaceURI();
|
|
|
|
const bool isTextNS = ns == ooNS::text;
|
|
|
|
|
|
|
|
TQDomElement e;
|
|
|
|
if ( isTextNS && localName == "p" ) // text paragraph
|
|
|
|
e = parseParagraph( doc, t );
|
|
|
|
else if ( isTextNS && localName == "h" ) // heading - can this happen in ooimpress?
|
|
|
|
{
|
|
|
|
e = parseParagraph( doc, t );
|
|
|
|
}
|
|
|
|
else if ( isTextNS && ( localName == "unordered-list" || localName == "ordered-list" ) )
|
|
|
|
{
|
|
|
|
parseList( doc, textObjectElement, t );
|
|
|
|
m_styleStack.restore();
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
// TODO text:sequence-decls
|
|
|
|
else
|
|
|
|
{
|
|
|
|
kdDebug(30518) << "Unsupported texttype '" << localName << "'" << endl;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( !e.isNull() )
|
|
|
|
textObjectElement.appendChild( e );
|
|
|
|
m_styleStack.restore(); // remove the styles added by the paragraph or list
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void OoImpressImport::applyListStyle( TQDomElement& paragraph )
|
|
|
|
{
|
|
|
|
// Spec: see 3.3.5 p137
|
|
|
|
if ( m_listStyleStack.hasListStyle() && m_nextItemIsListItem ) {
|
|
|
|
//const TQDomElement listStyle = m_listStyleStack.currentListStyle();
|
|
|
|
//bool heading = paragraph.localName() == "h";
|
|
|
|
m_nextItemIsListItem = false;
|
|
|
|
/*int level = heading ? paragraph.attributeNS( ooNS::text, "level", TQString() ).toInt()
|
|
|
|
: m_listStyleStack.level();*/
|
|
|
|
|
|
|
|
TQDomElement counter = paragraph.ownerDocument().createElement( "COUNTER" );
|
|
|
|
counter.setAttribute( "numberingtype", 0 );
|
|
|
|
counter.setAttribute( "depth", 0 );
|
|
|
|
|
|
|
|
if ( m_insideOrderedList )
|
|
|
|
counter.setAttribute( "type", 1 );
|
|
|
|
else
|
|
|
|
counter.setAttribute( "type", 10 ); // a disc bullet
|
|
|
|
paragraph.appendChild( counter );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static TQDomElement findListLevelStyle( TQDomElement& fullListStyle, int level )
|
|
|
|
{
|
|
|
|
TQDomElement listLevelItem;
|
|
|
|
forEachElement( listLevelItem, fullListStyle )
|
|
|
|
{
|
|
|
|
if ( listLevelItem.attributeNS( ooNS::text, "level", TQString() ).toInt() == level )
|
|
|
|
return listLevelItem;
|
|
|
|
}
|
|
|
|
return TQDomElement();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool OoImpressImport::pushListLevelStyle( const TQString& listStyleName, int level )
|
|
|
|
{
|
|
|
|
TQDomElement* fullListStyle = m_listStyles[listStyleName];
|
|
|
|
if ( !fullListStyle ) {
|
|
|
|
kdWarning(30518) << "List style " << listStyleName << " not found!" << endl;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return pushListLevelStyle( listStyleName, *fullListStyle, level );
|
|
|
|
}
|
|
|
|
|
|
|
|
bool OoImpressImport::pushListLevelStyle( const TQString& listStyleName, // for debug only
|
|
|
|
TQDomElement& fullListStyle, int level )
|
|
|
|
{
|
|
|
|
// Find applicable list-level-style for level
|
|
|
|
int i = level;
|
|
|
|
TQDomElement listLevelStyle;
|
|
|
|
while ( i > 0 && listLevelStyle.isNull() ) {
|
|
|
|
listLevelStyle = findListLevelStyle( fullListStyle, i );
|
|
|
|
--i;
|
|
|
|
}
|
|
|
|
if ( listLevelStyle.isNull() ) {
|
|
|
|
kdWarning(30518) << "List level style for level " << level << " in list style " << listStyleName << " not found!" << endl;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
kdDebug(30518) << "Pushing list-level-style from list-style " << listStyleName << " level " << level << endl;
|
|
|
|
m_listStyleStack.push( listLevelStyle );
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void OoImpressImport::parseList( TQDomDocument& doc, TQDomElement& textObjectElement, const TQDomElement& list )
|
|
|
|
{
|
|
|
|
//kdDebug(30518) << k_funcinfo << "parseList"<< endl;
|
|
|
|
|
|
|
|
m_insideOrderedList = ( list.localName() == "ordered-list" );
|
|
|
|
TQString oldListStyleName = m_currentListStyleName;
|
|
|
|
if ( list.hasAttributeNS( ooNS::text, "style-name" ) )
|
|
|
|
m_currentListStyleName = list.attributeNS( ooNS::text, "style-name", TQString() );
|
|
|
|
bool listOK = !m_currentListStyleName.isEmpty();
|
|
|
|
const int level = m_listStyleStack.level() + 1;
|
|
|
|
//kdDebug(30518) << k_funcinfo << " listOK=" << listOK << " level=" << level << endl;
|
|
|
|
if ( listOK )
|
|
|
|
listOK = pushListLevelStyle( m_currentListStyleName, level );
|
|
|
|
|
|
|
|
// Iterate over list items
|
|
|
|
TQDomElement listItem;
|
|
|
|
forEachElement( listItem, list )
|
|
|
|
{
|
|
|
|
// It's either list-header (normal text on top of list) or list-item
|
|
|
|
m_nextItemIsListItem = ( listItem.localName() != "list-header" );
|
|
|
|
m_restartNumbering = -1;
|
|
|
|
if ( listItem.hasAttributeNS( ooNS::text, "start-value" ) )
|
|
|
|
m_restartNumbering = listItem.attributeNS( ooNS::text, "start-value", TQString() ).toInt();
|
|
|
|
// ### Oasis: can be p h or list only.
|
|
|
|
parseParagraphs( doc, textObjectElement, listItem );
|
|
|
|
m_restartNumbering = -1;
|
|
|
|
}
|
|
|
|
if ( listOK )
|
|
|
|
m_listStyleStack.pop();
|
|
|
|
m_currentListStyleName = oldListStyleName;
|
|
|
|
}
|
|
|
|
|
|
|
|
TQDomElement OoImpressImport::parseParagraph( TQDomDocument& doc, const TQDomElement& paragraph )
|
|
|
|
{
|
|
|
|
TQDomElement p = doc.createElement( "P" );
|
|
|
|
|
|
|
|
// parse the paragraph-properties
|
|
|
|
fillStyleStack( paragraph );
|
|
|
|
|
|
|
|
// Style name
|
|
|
|
TQString styleName = m_styleStack.userStyleName("paragraph");
|
|
|
|
if ( !styleName.isEmpty() )
|
|
|
|
{
|
|
|
|
TQDomElement nameElem = doc.createElement("NAME");
|
|
|
|
nameElem.setAttribute("value", styleName);
|
|
|
|
p.appendChild(nameElem);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Paragraph alignment
|
|
|
|
if ( m_styleStack.hasAttributeNS( ooNS::fo, "text-align" ) )
|
|
|
|
{
|
|
|
|
TQString align = m_styleStack.attributeNS( ooNS::fo, "text-align" );
|
|
|
|
if ( align == "center" )
|
|
|
|
p.setAttribute( "align", 4 );
|
|
|
|
else if ( align == "justify" )
|
|
|
|
p.setAttribute( "align", 8 );
|
|
|
|
else if ( align == "start" )
|
|
|
|
p.setAttribute( "align", 0 );
|
|
|
|
else if ( align == "end" )
|
|
|
|
p.setAttribute( "align", 2 );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
p.setAttribute( "align", 0 ); // use left aligned as default
|
|
|
|
|
|
|
|
|
|
|
|
// Offset before and after paragraph
|
|
|
|
OoUtils::importTopBottomMargin( p, m_styleStack );
|
|
|
|
|
|
|
|
// Indentation (margins)
|
|
|
|
OoUtils::importIndents( p, m_styleStack );
|
|
|
|
|
|
|
|
// Line spacing
|
|
|
|
OoUtils::importLineSpacing( p, m_styleStack );
|
|
|
|
|
|
|
|
// Tabulators
|
|
|
|
OoUtils::importTabulators( p, m_styleStack );
|
|
|
|
|
|
|
|
// Borders
|
|
|
|
OoUtils::importBorders( p, m_styleStack );
|
|
|
|
|
|
|
|
applyListStyle( p );
|
|
|
|
|
|
|
|
uint pos = 0;
|
|
|
|
|
|
|
|
m_styleStack.save();
|
|
|
|
// parse every childnode of the paragraph
|
|
|
|
parseSpanOrSimilar( doc, paragraph, p, pos);
|
|
|
|
m_styleStack.restore(); // remove possible garbage (should not be needed)
|
|
|
|
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
|
|
|
void OoImpressImport::parseSpanOrSimilar( TQDomDocument& doc, const TQDomElement& parent,
|
|
|
|
TQDomElement& outputParagraph, uint& pos)
|
|
|
|
{
|
|
|
|
// Parse every child node of the parent
|
|
|
|
// Can't use forEachElement here since we also care about text nodes
|
|
|
|
for( TQDomNode node = parent.firstChild(); !node.isNull(); node = node.nextSibling() )
|
|
|
|
{
|
|
|
|
TQDomElement ts = node.toElement();
|
|
|
|
TQString textData;
|
|
|
|
const TQString localName( ts.localName() );
|
|
|
|
const TQString ns = ts.namespaceURI();
|
|
|
|
const bool isTextNS = ns == ooNS::text;
|
|
|
|
TQDomText t = node.toText();
|
|
|
|
|
|
|
|
// Try to keep the order of the tag names by probability of happening
|
|
|
|
if ( isTextNS && localName == "span" ) // text:span
|
|
|
|
{
|
|
|
|
m_styleStack.save();
|
|
|
|
fillStyleStack( ts );
|
|
|
|
parseSpanOrSimilar( doc, ts, outputParagraph, pos);
|
|
|
|
m_styleStack.restore();
|
|
|
|
}
|
|
|
|
else if ( isTextNS && localName == "s" ) // text:s
|
|
|
|
{
|
|
|
|
textData = OoUtils::expandWhitespace(ts);
|
|
|
|
}
|
|
|
|
else if ( isTextNS && localName == "tab-stop" ) // text:tab-stop
|
|
|
|
{
|
|
|
|
// KPresenter currently uses \t.
|
|
|
|
// Known bug: a line with only \t\t\t\t isn't loaded - XML (TQDom) strips out whitespace.
|
|
|
|
// One more good reason to switch to <text:tab-stop> instead...
|
|
|
|
textData = '\t';
|
|
|
|
}
|
|
|
|
else if ( isTextNS && localName == "line-break" )
|
|
|
|
{
|
|
|
|
textData = '\n';
|
|
|
|
}
|
|
|
|
else if ( localName == "image" && ns == ooNS::draw )
|
|
|
|
{
|
|
|
|
textData = '#'; // anchor placeholder
|
|
|
|
// TODO
|
|
|
|
}
|
|
|
|
else if ( isTextNS && localName == "a" )
|
|
|
|
{
|
|
|
|
m_styleStack.save();
|
|
|
|
TQString href( ts.attributeNS( ooNS::xlink, "href", TQString()) );
|
|
|
|
if ( href.startsWith("#") )
|
|
|
|
{
|
|
|
|
// We have a reference to a bookmark (### TODO)
|
|
|
|
// As we do not support it now, treat it as a <text:span> without formatting
|
|
|
|
parseSpanOrSimilar( doc, ts, outputParagraph, pos);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
#if 0 // TODO
|
|
|
|
// The problem is that KPresenter's hyperlink text is not inside the normal text, but for OOWriter it is nearly a <text:span>
|
|
|
|
// So we have to fake.
|
|
|
|
TQDomElement fakeParagraph, fakeFormats;
|
|
|
|
uint fakePos=0;
|
|
|
|
TQString text;
|
|
|
|
parseSpanOrSimilar( doc, ts, fakeParagraph, fakeFormats, text, fakePos);
|
|
|
|
textData = '#'; // hyperlink placeholder
|
|
|
|
TQDomElement linkElement (doc.createElement("LINK"));
|
|
|
|
linkElement.setAttribute("hrefName",ts.attributeNS( ooNS::xlink, "href", TQString()));
|
|
|
|
linkElement.setAttribute("linkName",text);
|
|
|
|
appendVariable(doc, ts, pos, "STRING", 9, text, linkElement);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
m_styleStack.restore();
|
|
|
|
}
|
|
|
|
else if ( isTextNS &&
|
|
|
|
(localName == "date" // fields
|
|
|
|
|| localName == "time"
|
|
|
|
|| localName == "page-number"
|
|
|
|
|| localName == "file-name"
|
|
|
|
|| localName == "author-name"
|
|
|
|
|| localName == "author-initials" ) )
|
|
|
|
{
|
|
|
|
textData = "#"; // field placeholder
|
|
|
|
appendField(doc, outputParagraph, ts, pos);
|
|
|
|
}
|
|
|
|
else if ( t.isNull() ) // no textnode, we must ignore
|
|
|
|
{
|
|
|
|
kdWarning(30518) << "Ignoring tag " << ts.tagName() << endl;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
textData = t.data();
|
|
|
|
|
|
|
|
pos += textData.length();
|
|
|
|
|
|
|
|
TQDomElement text = saveHelper(textData, doc);
|
|
|
|
|
|
|
|
kdDebug(30518) << k_funcinfo << "Para text is: " << textData << endl;
|
|
|
|
|
|
|
|
if (m_styleStack.hasAttributeNS( ooNS::fo, "language" )) {
|
|
|
|
TQString lang = m_styleStack.attributeNS( ooNS::fo, "language" );
|
|
|
|
if (lang=="en")
|
|
|
|
text.setAttribute("language", "en_US");
|
|
|
|
else
|
|
|
|
text.setAttribute("language", lang);
|
|
|
|
}
|
|
|
|
|
|
|
|
// parse the text-properties
|
|
|
|
if ( m_styleStack.hasAttributeNS( ooNS::fo, "color" ) ) {
|
|
|
|
kdDebug(30518) << "color=" << m_styleStack.attributeNS( ooNS::fo, "color" ) << endl;
|
|
|
|
text.setAttribute( "color", m_styleStack.attributeNS( ooNS::fo, "color" ) );
|
|
|
|
}
|
|
|
|
if ( m_styleStack.hasAttributeNS( ooNS::fo, "font-family" ) // 3.10.9
|
|
|
|
|| m_styleStack.hasAttributeNS( ooNS::style, "font-name") )//3.10.8
|
|
|
|
{
|
|
|
|
// 'Thorndale/Albany' are not known outside OpenOffice so we substitute them
|
|
|
|
// with 'Times New Roman/Arial' that look nearly the same.
|
|
|
|
if ( m_styleStack.attributeNS( ooNS::fo, "font-family" ) == "Thorndale" )
|
|
|
|
text.setAttribute( "family", "Times New Roman" );
|
|
|
|
else if ( m_styleStack.attributeNS( ooNS::fo, "font-family" ) == "Albany" )
|
|
|
|
text.setAttribute( "family", "Arial" );
|
|
|
|
else
|
|
|
|
text.setAttribute( "family", m_styleStack.attributeNS( ooNS::fo, "font-family" ).remove( "'" ) );
|
|
|
|
}
|
|
|
|
if ( m_styleStack.hasAttributeNS( ooNS::fo, "font-size" ) )
|
|
|
|
{
|
|
|
|
double pointSize = m_styleStack.fontSize();
|
|
|
|
text.setAttribute( "pointSize", tqRound(pointSize) ); // KPresenter uses toInt()!
|
|
|
|
}
|
|
|
|
if ( m_styleStack.hasAttributeNS( ooNS::fo, "font-weight" ) ) // 3.10.24
|
|
|
|
if ( m_styleStack.attributeNS( ooNS::fo, "font-weight" ) == "bold" )
|
|
|
|
text.setAttribute( "bold", 1 );
|
|
|
|
if ( m_styleStack.hasAttributeNS( ooNS::fo, "font-style" ) )
|
|
|
|
if ( m_styleStack.attributeNS( ooNS::fo, "font-style" ) == "italic" )
|
|
|
|
text.setAttribute( "italic", 1 );
|
|
|
|
|
|
|
|
if ( m_styleStack.hasAttributeNS( ooNS::style, "text-position" ) ) // 3.10.17
|
|
|
|
{
|
|
|
|
TQString text_position = m_styleStack.attributeNS( ooNS::style, "text-position");
|
|
|
|
TQString value;
|
|
|
|
TQString relativetextsize;
|
|
|
|
OoUtils::importTextPosition( text_position, value, relativetextsize );
|
|
|
|
text.setAttribute( "VERTALIGN", value );
|
|
|
|
if ( !relativetextsize.isEmpty() )
|
|
|
|
text.setAttribute( "relativetextsize", relativetextsize );
|
|
|
|
}
|
|
|
|
|
|
|
|
bool wordByWord = (m_styleStack.hasAttributeNS( ooNS::fo, "score-spaces"))// 3.10.25
|
|
|
|
&& (m_styleStack.attributeNS( ooNS::fo, "score-spaces") == "false");
|
|
|
|
|
|
|
|
// strikeout
|
|
|
|
if ( m_styleStack.hasAttributeNS( ooNS::style, "text-crossing-out")// 3.10.6
|
|
|
|
&& m_styleStack.attributeNS( ooNS::style, "text-crossing-out") != "none")
|
|
|
|
{
|
|
|
|
TQString strikeOutType = m_styleStack.attributeNS( ooNS::style, "text-crossing-out" );
|
|
|
|
if ( strikeOutType =="double-line" )
|
|
|
|
{
|
|
|
|
text.setAttribute( "strikeOut", "double" );
|
|
|
|
text.setAttribute( "strikeoutstyleline", "solid" );
|
|
|
|
}
|
|
|
|
else if ( strikeOutType =="thick-line" )
|
|
|
|
{
|
|
|
|
text.setAttribute( "strikeOut", "single-bold" );
|
|
|
|
text.setAttribute( "strikeoutstyleline", "solid" );
|
|
|
|
}
|
|
|
|
else //if ( strikeOutType == "single-line" ) //fall back to the default strikeout
|
|
|
|
{
|
|
|
|
text.setAttribute( "strikeOut", "single" );
|
|
|
|
text.setAttribute( "strikeoutstyleline", "solid" );
|
|
|
|
}
|
|
|
|
|
|
|
|
if (wordByWord)
|
|
|
|
text.setAttribute("wordbyword", 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
// underlining
|
|
|
|
if ( m_styleStack.hasAttributeNS( ooNS::style, "text-underline" ) ) // 3.10.22
|
|
|
|
{
|
|
|
|
TQString underline;
|
|
|
|
TQString styleline;
|
|
|
|
OoUtils::importUnderline( m_styleStack.attributeNS( ooNS::style, "text-underline" ),
|
|
|
|
underline, styleline );
|
|
|
|
TQString underLineColor = m_styleStack.attributeNS( ooNS::style, "text-underline-color" );// 3.10.23
|
|
|
|
|
|
|
|
text.setAttribute( "value", underline );
|
|
|
|
text.setAttribute( "styleline", styleline );
|
|
|
|
|
|
|
|
if ( !underLineColor.isEmpty() && underLineColor != "font-color" )
|
|
|
|
text.setAttribute("underlinecolor", underLineColor);
|
|
|
|
if ( wordByWord )
|
|
|
|
text.setAttribute("wordbyword", 1);
|
|
|
|
}
|
|
|
|
#if 0 // strange ooimpress doesn't implement it
|
|
|
|
// Small caps, lowercase, uppercase
|
|
|
|
if ( m_styleStack.hasAttributeNS( ooNS::fo, "font-variant" ) // 3.10.1
|
|
|
|
|| m_styleStack.hasAttributeNS( ooNS::fo, "text-transform" ) ) // 3.10.2
|
|
|
|
{
|
|
|
|
TQDomElement fontAttrib( doc.createElement( "FONTATTRIBUTE" ) );
|
|
|
|
bool smallCaps = m_styleStack.attributeNS( ooNS::fo, "font-variant" ) == "small-caps";
|
|
|
|
if ( smallCaps )
|
|
|
|
{
|
|
|
|
text.setAttribute( "fontattribute", "smallcaps" );
|
|
|
|
} else
|
|
|
|
{
|
|
|
|
// Both KWord/KPresenter and OO use "uppercase" and "lowercase".
|
|
|
|
// TODO in KWord: "capitalize".
|
|
|
|
text.setAttribute( "fontattribute", m_styleStack.attributeNS( ooNS::fo, "text-transform" ) );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
// background color (property of the paragraph in OOo, of the text in kword/kpresenter)
|
|
|
|
if (m_styleStack.hasAttributeNS( ooNS::fo, "background-color" ))
|
|
|
|
{
|
|
|
|
TQString bgColor = m_styleStack.attributeNS( ooNS::fo, "background-color");
|
|
|
|
if (bgColor != "transparent")
|
|
|
|
text.setAttribute("textbackcolor", bgColor);
|
|
|
|
}
|
|
|
|
|
|
|
|
appendShadow( doc, outputParagraph ); // this is necessary to take care of shadowed paragraphs
|
|
|
|
outputParagraph.appendChild( text );
|
|
|
|
} // for each text span
|
|
|
|
}
|
|
|
|
|
|
|
|
void OoImpressImport::createStyleMap( TQDomDocument &docstyles )
|
|
|
|
{
|
|
|
|
TQDomElement styles = docstyles.documentElement();
|
|
|
|
if ( styles.isNull() )
|
|
|
|
return;
|
|
|
|
|
|
|
|
TQDomNode fixedStyles = KoDom::namedItemNS( styles, ooNS::office, "styles" );
|
|
|
|
if ( !fixedStyles.isNull() )
|
|
|
|
{
|
|
|
|
insertDraws( fixedStyles.toElement() );
|
|
|
|
insertStyles( fixedStyles.toElement() );
|
|
|
|
insertStylesPresentation( fixedStyles.toElement() );
|
|
|
|
}
|
|
|
|
|
|
|
|
TQDomNode automaticStyles = KoDom::namedItemNS( styles, ooNS::office, "automatic-styles" );
|
|
|
|
if ( !automaticStyles.isNull() )
|
|
|
|
{
|
|
|
|
insertStyles( automaticStyles.toElement() );
|
|
|
|
insertStylesPresentation( automaticStyles.toElement() );
|
|
|
|
}
|
|
|
|
TQDomNode masterStyles = KoDom::namedItemNS( styles, ooNS::office, "master-styles" );
|
|
|
|
if ( !masterStyles.isNull() )
|
|
|
|
insertStyles( masterStyles.toElement() );
|
|
|
|
}
|
|
|
|
|
|
|
|
void OoImpressImport::insertDraws( const TQDomElement& styles )
|
|
|
|
{
|
|
|
|
TQDomElement e;
|
|
|
|
forEachElement( e, styles )
|
|
|
|
{
|
|
|
|
if ( !e.hasAttributeNS( ooNS::draw, "name" ) )
|
|
|
|
continue;
|
|
|
|
|
|
|
|
TQString name = e.attributeNS( ooNS::draw, "name", TQString() );
|
|
|
|
m_draws.insert( name, new TQDomElement( e ) );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void OoImpressImport::insertStyles( const TQDomElement& styles )
|
|
|
|
{
|
|
|
|
TQDomElement e;
|
|
|
|
forEachElement( e, styles )
|
|
|
|
{
|
|
|
|
const TQString localName = e.localName();
|
|
|
|
const TQString ns = e.namespaceURI();
|
|
|
|
if ( !e.hasAttributeNS( ooNS::style, "name" ) )
|
|
|
|
continue;
|
|
|
|
|
|
|
|
const TQString name = e.attributeNS( ooNS::style, "name", TQString() );
|
|
|
|
if ( localName == "list-style" && ns == ooNS::text ) {
|
|
|
|
TQDomElement* ep = new TQDomElement( e );
|
|
|
|
m_listStyles.insert( name, ep );
|
|
|
|
kdDebug(30518) << "List style: '" << name << "' loaded " << endl;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
m_styles.insert( name, new TQDomElement( e ) );
|
|
|
|
kdDebug(30518) << "Style: '" << name << "' loaded " << endl;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void OoImpressImport::insertStylesPresentation( const TQDomElement& styles )
|
|
|
|
{
|
|
|
|
TQDomElement e;
|
|
|
|
forEachElement( e, styles )
|
|
|
|
{
|
|
|
|
if ( !e.hasAttributeNS( ooNS::style, "name" ) )
|
|
|
|
continue;
|
|
|
|
|
|
|
|
TQString name = e.attributeNS( ooNS::style, "name", TQString() );
|
|
|
|
m_stylesPresentation.insert( name, new TQDomElement( e ) );
|
|
|
|
//kdDebug(30518) << "Style: '" << name << "' loaded " << endl;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void OoImpressImport::fillStyleStack( const TQDomElement& object, bool sticky )
|
|
|
|
{
|
|
|
|
// find all styles associated with an object and push them on the stack
|
|
|
|
if ( object.hasAttributeNS( ooNS::presentation, "style-name" ) )
|
|
|
|
{
|
|
|
|
kdDebug(30518)<<" presentation:style-name **************************** :"<<object.attributeNS( ooNS::presentation, "style-name", TQString() )<<endl;
|
|
|
|
if ( sticky )
|
|
|
|
addStyles( m_stylesPresentation[object.attributeNS( ooNS::presentation, "style-name", TQString() )] );
|
|
|
|
else
|
|
|
|
addStyles( m_styles[object.attributeNS( ooNS::presentation, "style-name", TQString() )] );
|
|
|
|
}
|
|
|
|
if ( object.hasAttributeNS( ooNS::draw, "style-name" ) )
|
|
|
|
addStyles( m_styles[object.attributeNS( ooNS::draw, "style-name", TQString() )] );
|
|
|
|
|
|
|
|
if ( object.hasAttributeNS( ooNS::draw, "text-style-name" ) )
|
|
|
|
addStyles( m_styles[object.attributeNS( ooNS::draw, "text-style-name", TQString() )] );
|
|
|
|
|
|
|
|
if ( object.hasAttributeNS( ooNS::text, "style-name" ) ) {
|
|
|
|
TQString styleName = object.attributeNS( ooNS::text, "style-name", TQString() );
|
|
|
|
//kdDebug(30518) << "adding style " << styleName << endl;
|
|
|
|
addStyles( m_styles[styleName] );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void OoImpressImport::addStyles( const TQDomElement* style )
|
|
|
|
{
|
|
|
|
kdDebug(30518)<<" addStyle :" << style->attributeNS( ooNS::style, "name", TQString() ) <<endl;
|
|
|
|
// this function is necessary as parent styles can have parents themself
|
|
|
|
if ( style->hasAttributeNS( ooNS::style, "parent-style-name" ) )
|
|
|
|
{
|
|
|
|
//kdDebug(30518)<<"m_styles[style->attribute( style:parent-style-name )] :"<<m_styles[style->attributeNS( ooNS::style, "parent-style-name", TQString() )]<<endl;
|
|
|
|
addStyles( m_styles[style->attributeNS( ooNS::style, "parent-style-name", TQString() )] );
|
|
|
|
}
|
|
|
|
//kdDebug(30518)<<" void OoImpressImport::addStyles( const TQDomElement* style ) :"<<style<<endl;
|
|
|
|
m_styleStack.push( *style );
|
|
|
|
}
|
|
|
|
|
|
|
|
TQString OoImpressImport::storeImage( const TQDomElement& object )
|
|
|
|
{
|
|
|
|
// store the picture
|
|
|
|
TQString url = object.attributeNS( ooNS::xlink, "href", TQString() ).remove( '#' );
|
|
|
|
KArchiveFile* file = (KArchiveFile*) m_zip->directory()->entry( url );
|
|
|
|
|
|
|
|
TQString extension = url.mid( url.find( '.' ) );
|
|
|
|
TQString fileName = TQString( "picture%1" ).arg( m_numPicture++ ) + extension;
|
|
|
|
KoStoreDevice* out = m_chain->storageFile( "pictures/" + fileName, KoStore::Write );
|
|
|
|
|
|
|
|
if ( file && out )
|
|
|
|
{
|
|
|
|
TQByteArray buffer = file->data();
|
|
|
|
out->writeBlock( buffer.data(), buffer.size() );
|
|
|
|
}
|
|
|
|
|
|
|
|
return fileName;
|
|
|
|
}
|
|
|
|
|
|
|
|
TQString OoImpressImport::storeSound(const TQDomElement & object, TQDomElement & p, TQDomDocument & doc)
|
|
|
|
{
|
|
|
|
TQFileInfo fi(m_chain->inputFile()); // handle relative URLs
|
|
|
|
TQDir::setCurrent(fi.dirPath(true));
|
|
|
|
fi.setFile(object.attributeNS( ooNS::xlink, "href", TQString()));
|
|
|
|
TQString url = fi.absFilePath();
|
|
|
|
|
|
|
|
//kdDebug(30518) << "Sound URL: " << url << endl;
|
|
|
|
|
|
|
|
TQFile file(url);
|
|
|
|
if (!file.exists())
|
|
|
|
return TQString();
|
|
|
|
|
|
|
|
TQString extension = url.mid( url.find( '.' ) );
|
|
|
|
TQString fileName = TQString( "sound%1" ).arg( m_numSound++ ) + extension;
|
|
|
|
fileName = "sounds/" + fileName;
|
|
|
|
KoStoreDevice* out = m_chain->storageFile( fileName, KoStore::Write );
|
|
|
|
|
|
|
|
if (out)
|
|
|
|
{
|
|
|
|
if (!file.open(IO_ReadOnly))
|
|
|
|
return TQString();
|
|
|
|
|
|
|
|
TQByteArray data(8*1024);
|
|
|
|
|
|
|
|
uint total = 0;
|
|
|
|
for ( int block = 0; ( block = file.readBlock(data.data(), data.size()) ) > 0;
|
|
|
|
total += block )
|
|
|
|
out->writeBlock(data.data(), data.size());
|
|
|
|
|
|
|
|
Q_ASSERT(total == fi.size());
|
|
|
|
|
|
|
|
file.close();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return TQString();
|
|
|
|
|
|
|
|
TQDomElement key = doc.createElement("FILE");
|
|
|
|
key.setAttribute("name", fileName);
|
|
|
|
key.setAttribute("filename", url);
|
|
|
|
p.appendChild(key);
|
|
|
|
|
|
|
|
return url;
|
|
|
|
}
|
|
|
|
|
|
|
|
TQDomElement OoImpressImport::saveHelper(const TQString &tmpText, TQDomDocument &doc)
|
|
|
|
{
|
|
|
|
TQDomElement element=doc.createElement("TEXT");
|
|
|
|
|
|
|
|
if(tmpText.stripWhiteSpace().isEmpty()) // ### careful, this also strips \t and \n ....
|
|
|
|
// working around a bug in TQDom
|
|
|
|
element.setAttribute("whitespace", tmpText.length());
|
|
|
|
|
|
|
|
element.appendChild(doc.createTextNode(tmpText));
|
|
|
|
return element;
|
|
|
|
}
|
|
|
|
|
|
|
|
void OoImpressImport::appendPoints(TQDomDocument& doc, TQDomElement& e, const TQDomElement& object)
|
|
|
|
{
|
|
|
|
TQDomElement ptsElem = doc.createElement("POINTS");
|
|
|
|
|
|
|
|
TQStringList ptList = TQStringList::split(' ', object.attributeNS( ooNS::draw, "points", TQString()));
|
|
|
|
|
|
|
|
TQString pt_x, pt_y;
|
|
|
|
double tmp_x, tmp_y;
|
|
|
|
for (TQStringList::Iterator it = ptList.begin(); it != ptList.end(); ++it)
|
|
|
|
{
|
|
|
|
TQDomElement point = doc.createElement("Point");
|
|
|
|
|
|
|
|
tmp_x = (*it).section(',',0,0).toInt() / 100;
|
|
|
|
tmp_y = (*it).section(',',1,1).toInt() / 100;
|
|
|
|
|
|
|
|
pt_x.setNum(tmp_x);
|
|
|
|
pt_x+="mm";
|
|
|
|
|
|
|
|
pt_y.setNum(tmp_y);
|
|
|
|
pt_y+="mm";
|
|
|
|
|
|
|
|
point.setAttribute("point_x", KoUnit::parseValue(pt_x));
|
|
|
|
point.setAttribute("point_y", KoUnit::parseValue(pt_y));
|
|
|
|
ptsElem.appendChild(point);
|
|
|
|
}
|
|
|
|
|
|
|
|
e.appendChild(ptsElem);
|
|
|
|
}
|
|
|
|
|
|
|
|
void OoImpressImport::appendField(TQDomDocument& doc, TQDomElement& e, const TQDomElement& object, uint pos)
|
|
|
|
{
|
|
|
|
const TQString tag = object.localName();
|
|
|
|
const TQString ns = object.namespaceURI();
|
|
|
|
const bool isTextNS = ns == ooNS::text;
|
|
|
|
|
|
|
|
TQDomElement custom = doc.createElement("CUSTOM");
|
|
|
|
custom.setAttribute("pos", pos);
|
|
|
|
TQDomElement variable = doc.createElement("VARIABLE");
|
|
|
|
|
|
|
|
if (isTextNS && tag == "date")
|
|
|
|
{
|
|
|
|
TQDateTime dt(TQDate::fromString(object.attributeNS( ooNS::text, "date-value", TQString()), TQt::ISODate));
|
|
|
|
|
|
|
|
bool fixed = (object.hasAttributeNS( ooNS::text, "fixed") && object.attributeNS( ooNS::text, "fixed", TQString())=="true");
|
|
|
|
|
|
|
|
if (!dt.isValid()) {
|
|
|
|
dt = TQDateTime::currentDateTime(); // OOo docs say so :)
|
|
|
|
fixed = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
TQDomElement typeElem = doc.createElement("TYPE");
|
|
|
|
typeElem.setAttribute("key", "DATE0locale"); // ### find out the correlation between KOffice and OOo date/time types
|
|
|
|
typeElem.setAttribute("type", 0); // VT_DATE
|
|
|
|
typeElem.setAttribute("text", object.text());
|
|
|
|
|
|
|
|
variable.appendChild(typeElem);
|
|
|
|
|
|
|
|
const TQDate date(dt.date());
|
|
|
|
const TQTime time(dt.time());
|
|
|
|
TQDomElement dateElement = doc.createElement("DATE");
|
|
|
|
dateElement.setAttribute("subtype", fixed ? 0 : 1); // VST_DATE_FIX, VST_DATE_CURRENT
|
|
|
|
dateElement.setAttribute("fix", fixed ? 1 : 0);
|
|
|
|
dateElement.setAttribute("day", date.day());
|
|
|
|
dateElement.setAttribute("month", date.month());
|
|
|
|
dateElement.setAttribute("year", date.year());
|
|
|
|
dateElement.setAttribute("hour", time.hour());
|
|
|
|
dateElement.setAttribute("minute", time.minute());
|
|
|
|
dateElement.setAttribute("second", time.second());
|
|
|
|
if (object.hasAttributeNS( ooNS::text, "date-adjust"))
|
|
|
|
dateElement.setAttribute("correct", object.attributeNS( ooNS::text, "date-adjust", TQString()));
|
|
|
|
|
|
|
|
variable.appendChild(dateElement);
|
|
|
|
}
|
|
|
|
else if (isTextNS && tag == "time")
|
|
|
|
{
|
|
|
|
// Use TQDateTime to work around a possible problem of TQTime::FromString in Qt 3.2.2
|
|
|
|
TQDateTime dt(TQDateTime::fromString(object.attributeNS( ooNS::text, "time-value", TQString()), TQt::ISODate));
|
|
|
|
|
|
|
|
bool fixed = (object.hasAttributeNS( ooNS::text, "fixed") && object.attributeNS( ooNS::text, "fixed", TQString())=="true");
|
|
|
|
|
|
|
|
if (!dt.isValid()) {
|
|
|
|
dt = TQDateTime::currentDateTime(); // OOo docs say so :)
|
|
|
|
fixed = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
TQDomElement typeElem = doc.createElement("TYPE");
|
|
|
|
typeElem.setAttribute("key", "TIMElocale"); // ### find out the correlation between KOffice and OOo date/time types
|
|
|
|
typeElem.setAttribute("type", 2); // VT_TIME
|
|
|
|
typeElem.setAttribute("text", object.text());
|
|
|
|
|
|
|
|
variable.appendChild(typeElem);
|
|
|
|
|
|
|
|
const TQTime time(dt.time());
|
|
|
|
TQDomElement timeElement = doc.createElement("TIME");
|
|
|
|
timeElement.setAttribute("subtype", fixed ? 0 : 1); // VST_TIME_FIX, VST_TIME_CURRENT
|
|
|
|
timeElement.setAttribute("fix", fixed ? 1 : 0);
|
|
|
|
timeElement.setAttribute("hour", time.hour());
|
|
|
|
timeElement.setAttribute("minute", time.minute());
|
|
|
|
timeElement.setAttribute("second", time.second());
|
|
|
|
/*if (object.hasAttributeNS( ooNS::text, "time-adjust"))
|
|
|
|
timeElem.setAttribute("correct", object.attributeNS( ooNS::text, "time-adjust", TQString()));*/ // ### TODO
|
|
|
|
|
|
|
|
variable.appendChild(timeElement);
|
|
|
|
}
|
|
|
|
else if (isTextNS && tag == "page-number")
|
|
|
|
{
|
|
|
|
TQDomElement typeElem = doc.createElement("TYPE");
|
|
|
|
typeElem.setAttribute("key", "NUMBER");
|
|
|
|
typeElem.setAttribute("type", 4); // VT_PGNUM
|
|
|
|
typeElem.setAttribute("text", object.text());
|
|
|
|
|
|
|
|
variable.appendChild(typeElem);
|
|
|
|
|
|
|
|
TQDomElement pgNumElem = doc.createElement("PGNUM");
|
|
|
|
|
|
|
|
int subtype = 0; // VST_PGNUM_CURRENT
|
|
|
|
|
|
|
|
if (object.hasAttributeNS( ooNS::text, "select-page"))
|
|
|
|
{
|
|
|
|
const TQString select = object.attributeNS( ooNS::text, "select-page", TQString());
|
|
|
|
|
|
|
|
if (select == "previous")
|
|
|
|
subtype = 3; // VST_PGNUM_PREVIOUS
|
|
|
|
else if (select == "next")
|
|
|
|
subtype = 4; // VST_PGNUM_NEXT
|
|
|
|
else
|
|
|
|
subtype = 0; // VST_PGNUM_CURRENT
|
|
|
|
}
|
|
|
|
|
|
|
|
pgNumElem.setAttribute("subtype", subtype);
|
|
|
|
pgNumElem.setAttribute("value", object.text());
|
|
|
|
|
|
|
|
variable.appendChild(pgNumElem);
|
|
|
|
}
|
|
|
|
else if (isTextNS && tag == "file-name")
|
|
|
|
{
|
|
|
|
TQDomElement typeElem = doc.createElement("TYPE");
|
|
|
|
typeElem.setAttribute("key", "STRING");
|
|
|
|
typeElem.setAttribute("type", 8); // VT_FIELD
|
|
|
|
typeElem.setAttribute("text", object.text());
|
|
|
|
|
|
|
|
variable.appendChild(typeElem);
|
|
|
|
|
|
|
|
int subtype = 5;
|
|
|
|
|
|
|
|
if (object.hasAttributeNS( ooNS::text, "display"))
|
|
|
|
{
|
|
|
|
const TQString display = object.attributeNS( ooNS::text, "display", TQString());
|
|
|
|
|
|
|
|
if (display == "path")
|
|
|
|
subtype = 1; // VST_DIRECTORYNAME
|
|
|
|
else if (display == "name")
|
|
|
|
subtype = 6; // VST_FILENAMEWITHOUTEXTENSION
|
|
|
|
else if (display == "name-and-extension")
|
|
|
|
subtype = 0; // VST_FILENAME
|
|
|
|
else
|
|
|
|
subtype = 5; // VST_PATHFILENAME
|
|
|
|
}
|
|
|
|
|
|
|
|
TQDomElement fileNameElem = doc.createElement("FIELD");
|
|
|
|
fileNameElem.setAttribute("subtype", subtype);
|
|
|
|
fileNameElem.setAttribute("value", object.text());
|
|
|
|
|
|
|
|
variable.appendChild(fileNameElem);
|
|
|
|
}
|
|
|
|
else if (isTextNS && tag == "author-name"
|
|
|
|
|| isTextNS && tag == "author-initials")
|
|
|
|
{
|
|
|
|
TQDomElement typeElem = doc.createElement("TYPE");
|
|
|
|
typeElem.setAttribute("key", "STRING");
|
|
|
|
typeElem.setAttribute("type", 8); // VT_FIELD
|
|
|
|
typeElem.setAttribute("text", object.text());
|
|
|
|
|
|
|
|
variable.appendChild(typeElem);
|
|
|
|
|
|
|
|
int subtype = 2; // VST_AUTHORNAME
|
|
|
|
|
|
|
|
if (isTextNS && tag == "author-initials")
|
|
|
|
subtype = 16; // VST_INITIAL
|
|
|
|
|
|
|
|
TQDomElement authorElem = doc.createElement("FIELD");
|
|
|
|
authorElem.setAttribute("subtype", subtype);
|
|
|
|
authorElem.setAttribute("value", object.text());
|
|
|
|
|
|
|
|
variable.appendChild(authorElem);
|
|
|
|
}
|
|
|
|
|
|
|
|
custom.appendChild(variable);
|
|
|
|
e.appendChild(custom);
|
|
|
|
}
|
|
|
|
|
|
|
|
void OoImpressImport::createPresentationAnimation(const TQDomElement& element)
|
|
|
|
{
|
|
|
|
int order = 0;
|
|
|
|
TQDomElement e;
|
|
|
|
forEachElement( e, element )
|
|
|
|
{
|
|
|
|
const TQString localName = e.localName();
|
|
|
|
const TQString ns = e.namespaceURI();
|
|
|
|
if ( ns == ooNS::presentation && localName == "show-shape" && e.hasAttributeNS( ooNS::draw, "shape-id" ) )
|
|
|
|
{
|
|
|
|
TQString name = e.attributeNS( ooNS::draw, "shape-id", TQString() );
|
|
|
|
//kdDebug(30518)<<" insert animation style : name :"<<name<<endl;
|
|
|
|
animationList *lst = new animationList;
|
|
|
|
TQDomElement* ep = new TQDomElement( e );
|
|
|
|
lst->element = ep;
|
|
|
|
lst->order = order;
|
|
|
|
m_animations.insert( name, lst );
|
|
|
|
++order;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
TQDomElement OoImpressImport::findAnimationByObjectID(const TQString & id, int & order)
|
|
|
|
{
|
|
|
|
kdDebug(30518)<<"TQDomElement OoImpressImport::findAnimationByObjectID(const TQString & id) :"<<id<<endl;
|
|
|
|
if (m_animations.isEmpty() )
|
|
|
|
return TQDomElement();
|
|
|
|
|
|
|
|
animationList *animation = m_animations[id];
|
|
|
|
//kdDebug(30518)<<"TQDomElement *animation = m_animations[id]; :"<<animation<<endl;
|
|
|
|
if ( !animation )
|
|
|
|
return TQDomElement();
|
|
|
|
for (TQDomNode node = *( animation->element ); !node.isNull(); node = node.nextSibling())
|
|
|
|
{
|
|
|
|
TQDomElement e = node.toElement();
|
|
|
|
order = animation->order;
|
|
|
|
kdDebug(30518)<<"e.tagName() :"<<e.tagName()<<" e.attribute(draw:shape-id) :"<<e.attributeNS( ooNS::draw, "shape-id", TQString())<<endl;
|
|
|
|
if (e.tagName()=="presentation:show-shape" && e.attributeNS( ooNS::draw, "shape-id", TQString())==id)
|
|
|
|
return e;
|
|
|
|
}
|
|
|
|
|
|
|
|
return TQDomElement();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void OoImpressImport::appendObjectEffect(TQDomDocument& doc, TQDomElement& e, const TQDomElement& object,
|
|
|
|
TQDomElement& sound)
|
|
|
|
{
|
|
|
|
int order = 0;
|
|
|
|
TQDomElement origEffect = findAnimationByObjectID(object.attributeNS( ooNS::draw, "id", TQString()), order).toElement();
|
|
|
|
|
|
|
|
if (origEffect.isNull())
|
|
|
|
return;
|
|
|
|
|
|
|
|
TQString effect = origEffect.attributeNS( ooNS::presentation, "effect", TQString());
|
|
|
|
TQString dir = origEffect.attributeNS( ooNS::presentation, "direction", TQString());
|
|
|
|
TQString speed = origEffect.attributeNS( ooNS::presentation, "speed", TQString());
|
|
|
|
kdDebug(30518)<<"speed :"<<speed<<endl;
|
|
|
|
//todo implement speed value.
|
|
|
|
|
|
|
|
int effVal=0;
|
|
|
|
//kdDebug(30518)<<" effect :"<<effect<<" dir :"<<dir<<endl;
|
|
|
|
if (effect=="fade")
|
|
|
|
{
|
|
|
|
if (dir=="from-right")
|
|
|
|
effVal=10; // EF_WIPE_RIGHT
|
|
|
|
else if (dir=="from-left")
|
|
|
|
effVal=9; // EF_WIPE_LEFT
|
|
|
|
else if (dir=="from-top")
|
|
|
|
effVal=11; // EF_WIPE_TOP
|
|
|
|
else if (dir=="from-bottom")
|
|
|
|
effVal=12; // EF_WIPE_BOTTOM
|
|
|
|
else
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
else if (effect=="move")
|
|
|
|
{
|
|
|
|
if (dir=="from-right")
|
|
|
|
effVal=1; // EF_COME_RIGHT
|
|
|
|
else if (dir=="from-left")
|
|
|
|
effVal=2; // EF_COME_LEFT
|
|
|
|
else if (dir=="from-top")
|
|
|
|
effVal=3; // EF_COME_TOP
|
|
|
|
else if (dir=="from-bottom")
|
|
|
|
effVal=4; // EF_COME_BOTTOM
|
|
|
|
else if (dir=="from-upper-right")
|
|
|
|
effVal=5; // EF_COME_RIGHT_TOP
|
|
|
|
else if (dir=="from-lower-right")
|
|
|
|
effVal=6; // EF_COME_RIGHT_BOTTOM
|
|
|
|
else if (dir=="from-upper-left")
|
|
|
|
effVal=7; // EF_COME_LEFT_TOP
|
|
|
|
else if (dir=="from-lower-left")
|
|
|
|
effVal=8; // EF_COME_LEFT_BOTTOM
|
|
|
|
else
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return; // sorry, no more supported effects :(
|
|
|
|
|
|
|
|
TQDomElement effElem = doc.createElement("EFFECTS");
|
|
|
|
effElem.setAttribute("effect", effVal);
|
|
|
|
e.appendChild(effElem);
|
|
|
|
|
|
|
|
TQDomElement presNum = doc.createElement( "PRESNUM" );
|
|
|
|
presNum.setAttribute("value", order);
|
|
|
|
e.appendChild( presNum );
|
|
|
|
|
|
|
|
// sound effect
|
|
|
|
TQDomElement origSoundEff = KoDom::namedItemNS( origEffect, ooNS::presentation, "sound");
|
|
|
|
if (!origSoundEff.isNull())
|
|
|
|
{
|
|
|
|
TQString soundUrl = storeSound(origSoundEff, sound, doc);
|
|
|
|
|
|
|
|
if (!soundUrl.isNull())
|
|
|
|
{
|
|
|
|
TQDomElement pseElem = doc.createElement("APPEARSOUNDEFFECT");
|
|
|
|
pseElem.setAttribute("appearSoundEffect", 1);
|
|
|
|
pseElem.setAttribute("appearSoundFileName", soundUrl);
|
|
|
|
|
|
|
|
e.appendChild(pseElem);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#include "ooimpressimport.moc"
|