bool RectangleShape::loadOdf(const KoXmlElement &element, KoShapeLoadingContext &context)
{
loadOdfAttributes(element, context, OdfMandatories | OdfGeometry | OdfAdditionalAttributes | OdfCommonChildElements);
if (element.hasAttributeNS(KoXmlNS::svg, "rx") && element.hasAttributeNS(KoXmlNS::svg, "ry")) {
qreal rx = KoUnit::parseValue(element.attributeNS(KoXmlNS::svg, "rx", "0"));
qreal ry = KoUnit::parseValue(element.attributeNS(KoXmlNS::svg, "ry", "0"));
m_cornerRadiusX = rx / (0.5 * size().width()) * 100;
m_cornerRadiusY = ry / (0.5 * size().height()) * 100;
} else {
QString cornerRadius = element.attributeNS(KoXmlNS::draw, "corner-radius", "");
if (! cornerRadius.isEmpty()) {
qreal radius = KoUnit::parseValue(cornerRadius);
m_cornerRadiusX = qMin<qreal>(radius / (0.5 * size().width()) * 100, qreal(100));
m_cornerRadiusY = qMin<qreal>(radius / (0.5 * size().height()) * 100, qreal(100));
}
}
updatePath(size());
updateHandles();
loadOdfAttributes(element, context, OdfTransformation);
loadText(element, context);
return true;
}
bool KPathShape::loadOdf(const KXmlElement & element, KShapeLoadingContext &context)
{
Q_D(KPathShape);
loadOdfAttributes(element, context, OdfMandatories | OdfAdditionalAttributes | OdfCommonChildElements);
// first clear the path data from the default path
clear();
if (element.localName() == "line") {
QPointF start;
start.setX(KUnit::parseValue(element.attributeNS(KOdfXmlNS::svg, "x1", "")));
start.setY(KUnit::parseValue(element.attributeNS(KOdfXmlNS::svg, "y1", "")));
QPointF end;
end.setX(KUnit::parseValue(element.attributeNS(KOdfXmlNS::svg, "x2", "")));
end.setY(KUnit::parseValue(element.attributeNS(KOdfXmlNS::svg, "y2", "")));
moveTo(start);
lineTo(end);
} else if (element.localName() == "polyline" || element.localName() == "polygon") {
QString points = element.attributeNS(KOdfXmlNS::draw, "points").simplified();
points.replace(',', ' ');
points.remove('\r');
points.remove('\n');
bool firstPoint = true;
const QStringList coordinateList = points.split(' ');
for (QStringList::ConstIterator it = coordinateList.constBegin(); it != coordinateList.constEnd(); ++it) {
QPointF point;
point.setX((*it).toDouble());
++it;
point.setY((*it).toDouble());
if (firstPoint) {
moveTo(point);
firstPoint = false;
} else
lineTo(point);
}
if (element.localName() == "polygon")
close();
} else { // path loading
KPathShapeLoader loader(this);
loader.parseSvg(element.attributeNS(KOdfXmlNS::svg, "d"), true);
d->loadNodeTypes(element);
}
d->applyViewboxTransformation(element);
QPointF pos = normalize();
setTransformation(QTransform());
if (element.hasAttributeNS(KOdfXmlNS::svg, "x") || element.hasAttributeNS(KOdfXmlNS::svg, "y")) {
pos.setX(KUnit::parseValue(element.attributeNS(KOdfXmlNS::svg, "x", QString())));
pos.setY(KUnit::parseValue(element.attributeNS(KOdfXmlNS::svg, "y", QString())));
}
setPosition(pos);
loadOdfAttributes(element, context, OdfTransformation);
KTextOnShapeContainer::tryWrapShape(this, element, context);
return true;
}
bool KPrPlaceholderShape::loadOdf( const KoXmlElement & element, KoShapeLoadingContext &context )
{
loadOdfAttributes(element, context, OdfAdditionalAttributes);
#ifndef NWORKAROUND_ODF_BUGS
KoOdfWorkaround::fixPresentationPlaceholder(this);
#endif
delete m_strategy;
m_strategy = KPrPlaceholderStrategy::create( additionalAttribute( "presentation:class" ) );
if ( m_strategy == 0 ) {
return false;
}
// first check if we can create a placeholder before we load the attributes
loadOdfAttributes(element, context, OdfMandatories | OdfTransformation | OdfGeometry | OdfCommonChildElements);
m_strategy->loadOdf( element, context );
return true;
}
bool Rotate::loadOdf(const KoXmlElement &objectElement, KoShapeLoadingContext &context)
{
// Load style information.
loadOdfAttributes(objectElement, context, OdfObjectAttributes);
Object3D::loadOdf(objectElement, context);
QString dummy;
m_path = objectElement.attributeNS(KoXmlNS::svg, "d", "");
m_viewBox = objectElement.attributeNS(KoXmlNS::svg, "viewBox", "");
kDebug(31000) << "Rotate:" << m_path;
return true;
}
bool KPrPlaceholderShape::loadOdf( const KoXmlElement & element, KoShapeLoadingContext &context )
{
loadOdfAttributes( element, context, OdfAllAttributes );
delete m_strategy;
m_strategy = KPrPlaceholderStrategy::create( additionalAttribute( "presentation:class" ) );
if ( m_strategy == 0 ) {
return false;
}
m_strategy->loadOdf( element, context );
return true;
}
bool Sphere::loadOdf(const KoXmlElement &objectElement, KoShapeLoadingContext &context)
{
// Load style information.
loadOdfAttributes(objectElement, context, OdfObjectAttributes);
Object3D::loadOdf(objectElement, context);
// These strange default values come from the default values in OOo and LO.
QString dummy;
dummy = objectElement.attributeNS(KoXmlNS::dr3d, "center", "(0 0 0)");
m_center = odfToVector3D(dummy);
dummy = objectElement.attributeNS(KoXmlNS::dr3d, "size", "(5000.0 5000.0 5000.0)");
m_size = odfToVector3D(dummy);
kDebug(31000) << "Sphere:" << m_center << m_size;
return true;
}
bool Cube::loadOdf(const KoXmlElement &objectElement, KoShapeLoadingContext &context)
{
// Load style information.
loadOdfAttributes(objectElement, context, OdfObjectAttributes);
Object3D::loadOdf(objectElement, context);
// These strange default values come from the default values in OOo and LO.
QString dummy;
dummy = objectElement.attributeNS(KoXmlNS::dr3d, "min-edge", "(-2500.0 -2500.0 -2500.0)");
m_minEdge = odfToVector3D(dummy);
dummy = objectElement.attributeNS(KoXmlNS::dr3d, "max-edge", "(2500.0 2500.0 2500.0)");
m_maxEdge = odfToVector3D(dummy);
kDebug(31000) << "Cube:" << m_minEdge << m_maxEdge;
return true;
}
bool PictureShape::loadOdf(const KoXmlElement &element, KoShapeLoadingContext &context)
{
loadOdfAttributes(element, context, OdfAllAttributes);
if (loadOdfFrame(element, context)) {
// load contour (clip)
KoImageData *imageData = qobject_cast<KoImageData*>(userData());
QSizeF scaleFactor(size().width() / imageData->imageSize().width(),
size().height() / imageData->imageSize().height());
loadOdfClipContour(element, context, scaleFactor);
// this is needed so that the image is already normalized when calling waitUntilReady e.g. by cstester
m_clippingRect.normalize(imageData->imageSize());
return true;
}
return false;
}
bool CommentShape::loadOdf(const KoXmlElement& element, KoShapeLoadingContext& context)
{
loadOdfAttributes(element, context, OdfPosition);
KoXmlElement child;
forEachElement(child, element)
{
if(child.namespaceURI() == KoXmlNS::dc) {
if(child.localName() == "creator") {
m_creator = child.text();
QStringList creatorNames = m_creator.split(' ');
QString initials;
if(KoApplication::isLeftToRight()) {
foreach(const QString& name, creatorNames) {
initials += name.left(1);
}
}
else {
foreach(const QString& name, creatorNames) {
initials += name.right(1);
}
}
bool VideoShape::loadOdf(const KoXmlElement &element, KoShapeLoadingContext &context)
{
loadOdfAttributes(element, context, OdfAllAttributes);
return loadOdfFrame(element, context);
}
bool KoFormulaShape::loadOdf( const KoXmlElement& element, KoShapeLoadingContext &context )
{
kDebug() <<"Loading ODF in Formula";
loadOdfAttributes(element, context, OdfAllAttributes);
return loadOdfFrame(element, context);
}
bool KoConnectionShape::loadOdf(const KoXmlElement & element, KoShapeLoadingContext &context)
{
Q_D(KoConnectionShape);
loadOdfAttributes(element, context, OdfMandatories | OdfCommonChildElements | OdfAdditionalAttributes);
QString type = element.attributeNS(KoXmlNS::draw, "type", "standard");
if (type == "lines")
d->connectionType = Lines;
else if (type == "line")
d->connectionType = Straight;
else if (type == "curve")
d->connectionType = Curve;
else
d->connectionType = Standard;
// reset connection point indices
d->connectionPointId1 = -1;
d->connectionPointId2 = -1;
// reset connected shapes
d->shape1 = 0;
d->shape2 = 0;
if (element.hasAttributeNS(KoXmlNS::draw, "start-shape")) {
d->connectionPointId1 = element.attributeNS(KoXmlNS::draw, "start-glue-point", QString()).toInt();
QString shapeId1 = element.attributeNS(KoXmlNS::draw, "start-shape", QString());
kDebug(30006) << "references start-shape" << shapeId1 << "at glue-point" << d->connectionPointId1;
d->shape1 = context.shapeById(shapeId1);
if (d->shape1) {
kDebug(30006) << "start-shape was already loaded";
d->shape1->addDependee(this);
if (d->shape1->hasConnectionPoint(d->connectionPointId1)) {
kDebug(30006) << "connecting to start-shape";
d->handles[StartHandle] = d->shape1->absoluteTransformation(0).map(d->shape1->connectionPoint(d->connectionPointId1).position);
kDebug(30006) << "start handle position =" << d->handles[StartHandle];
}
} else {
kDebug(30006) << "start-shape not loaded yet, deferring connection";
context.updateShape(shapeId1, new KoConnectionShapeLoadingUpdater(this, KoConnectionShapeLoadingUpdater::First));
}
} else {
d->handles[StartHandle].setX(KoUnit::parseValue(element.attributeNS(KoXmlNS::svg, "x1", QString())));
d->handles[StartHandle].setY(KoUnit::parseValue(element.attributeNS(KoXmlNS::svg, "y1", QString())));
}
if (element.hasAttributeNS(KoXmlNS::draw, "end-shape")) {
d->connectionPointId2 = element.attributeNS(KoXmlNS::draw, "end-glue-point", "").toInt();
QString shapeId2 = element.attributeNS(KoXmlNS::draw, "end-shape", "");
kDebug(30006) << "references end-shape " << shapeId2 << "at glue-point" << d->connectionPointId2;
d->shape2 = context.shapeById(shapeId2);
if (d->shape2) {
kDebug(30006) << "end-shape was already loaded";
d->shape2->addDependee(this);
if (d->shape2->hasConnectionPoint(d->connectionPointId2)) {
kDebug(30006) << "connecting to end-shape";
d->handles[EndHandle] = d->shape2->absoluteTransformation(0).map(d->shape2->connectionPoint(d->connectionPointId2).position);
kDebug(30006) << "end handle position =" << d->handles[EndHandle];
}
} else {
kDebug(30006) << "end-shape not loaded yet, deferring connection";
context.updateShape(shapeId2, new KoConnectionShapeLoadingUpdater(this, KoConnectionShapeLoadingUpdater::Second));
}
} else {
d->handles[EndHandle].setX(KoUnit::parseValue(element.attributeNS(KoXmlNS::svg, "x2", QString())));
d->handles[EndHandle].setY(KoUnit::parseValue(element.attributeNS(KoXmlNS::svg, "y2", QString())));
}
QString skew = element.attributeNS(KoXmlNS::draw, "line-skew", QString());
QStringList skewValues = skew.simplified().split(' ', QString::SkipEmptyParts);
// TODO apply skew values once we support them
// load the path data if there is any
d->hasCustomPath = element.hasAttributeNS(KoXmlNS::svg, "d");
if (d->hasCustomPath) {
KoPathShapeLoader loader(this);
loader.parseSvg(element.attributeNS(KoXmlNS::svg, "d"), true);
if (m_subpaths.size() > 0) {
QRectF viewBox = loadOdfViewbox(element);
if (viewBox.isEmpty()) {
// there should be a viewBox to transform the path data
// if there is none, use the bounding rectangle of the parsed path
viewBox = outline().boundingRect();
}
// convert path to viewbox coordinates to have a bounding rect of (0,0 1x1)
// which can later be fitted back into the target rect once we have all
// the required information
QTransform viewMatrix;
viewMatrix.scale(viewBox.width() ? static_cast<qreal>(1.0) / viewBox.width() : 1.0,
viewBox.height() ? static_cast<qreal>(1.0) / viewBox.height() : 1.0);
viewMatrix.translate(-viewBox.left(), -viewBox.top());
d->map(viewMatrix);
// trigger finishing the connections in case we have all data
// otherwise it gets called again once the shapes we are
// connected to are loaded
}
else {
d->hasCustomPath = false;
}
finishLoadingConnection();
} else {
d->forceUpdate = true;
updateConnections();
}
loadText(element, context);
return true;
}
bool EnhancedPathShape::loadOdf(const KXmlElement & element, KShapeLoadingContext &context)
{
reset();
loadOdfAttributes(element, context, OdfAdditionalAttributes | OdfCommonChildElements);
const KXmlElement enhancedGeometry(KoXml::namedItemNS(element, KOdfXmlNS::draw, "enhanced-geometry" ) );
if (!enhancedGeometry.isNull()) {
// load the modifiers
QString modifiers = enhancedGeometry.attributeNS(KOdfXmlNS::draw, "modifiers");
if (!modifiers.isEmpty()) {
addModifiers(modifiers);
}
KXmlElement grandChild;
forEachElement(grandChild, enhancedGeometry) {
if (grandChild.namespaceURI() != KOdfXmlNS::draw)
continue;
if (grandChild.localName() == "equation") {
QString name = grandChild.attributeNS(KOdfXmlNS::draw, "name");
QString formula = grandChild.attributeNS(KOdfXmlNS::draw, "formula");
addFormula(name, formula);
} else if (grandChild.localName() == "handle") {
EnhancedPathHandle * handle = new EnhancedPathHandle(this);
if (handle->loadOdf(grandChild, context)) {
m_enhancedHandles.append(handle);
evaluateHandles();
} else {
delete handle;
}
}
}
setMirrorHorizontally(enhancedGeometry.attributeNS(KOdfXmlNS::draw, "mirror-horizontal") == "true");
setMirrorVertically(enhancedGeometry.attributeNS(KOdfXmlNS::draw, "mirror-vertical") == "true");
// load the enhanced path data
QString path = enhancedGeometry.attributeNS(KOdfXmlNS::draw, "enhanced-path");
#ifndef NWORKAROUND_ODF_BUGS
KOdfWorkaround::fixEnhancedPath(path, enhancedGeometry, context);
#endif
if (!path.isEmpty()) {
parsePathData(path);
}
// load the viewbox
QRectF viewBox = loadOdfViewbox(enhancedGeometry);
if (! viewBox.isEmpty()) {
m_viewBox = viewBox;
} else {
// if there is no view box defined make it is big as the path.
m_viewBox = m_viewBound;
}
QString gluePoints(enhancedGeometry.attributeNS(KOdfXmlNS::draw, "glue-points"));
if (!gluePoints.isEmpty()) {
qreal x = -1;
foreach (const QString &token, gluePoints.split(' ')) {
if (x == -1) { // processing 'x'
x = token.toInt();
} else {
addConnectionPoint(QPointF(x, token.toInt()));
x = -1;
}
}
}