TDE
/
koffice
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/koffice
0
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '9aec66a723'
${ noResults }
koffice/filters/kpresenter/ooimpress/ooimpressimport.cc

2433 lines
98 KiB
Raw Blame History

/* 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()), Qt::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 TQt 3.2.2
TQDateTime dt(TQDateTime::fromString(object.attributeNS( ooNS::text, "time-value", TQString()), Qt::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"
View Git Blame Copy Permalink