Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <tools/debug.hxx>
21 : #include <com/sun/star/document/XEventsSupplier.hpp>
22 : #include <com/sun/star/container/XNameReplace.hpp>
23 : #include <com/sun/star/presentation/ClickAction.hpp>
24 : #include <com/sun/star/drawing/FillStyle.hpp>
25 : #include <com/sun/star/drawing/LineStyle.hpp>
26 : #include <xmloff/unointerfacetouniqueidentifiermapper.hxx>
27 : #include <com/sun/star/drawing/XGluePointsSupplier.hpp>
28 : #include <com/sun/star/container/XIdentifierAccess.hpp>
29 : #include <com/sun/star/drawing/GluePoint2.hpp>
30 : #include <com/sun/star/drawing/Alignment.hpp>
31 : #include <com/sun/star/drawing/EscapeDirection.hpp>
32 : #include <com/sun/star/media/ZoomLevel.hpp>
33 : #include <com/sun/star/awt/Rectangle.hpp>
34 :
35 : #include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
36 : #include <com/sun/star/container/XNameAccess.hpp>
37 : #include <comphelper/extract.hxx>
38 : #include "ximpshap.hxx"
39 : #include <xmloff/XMLBase64ImportContext.hxx>
40 : #include <xmloff/XMLShapeStyleContext.hxx>
41 : #include <xmloff/xmluconv.hxx>
42 : #include <com/sun/star/container/XNamed.hpp>
43 : #include <com/sun/star/drawing/CircleKind.hpp>
44 : #include <com/sun/star/beans/XPropertySet.hpp>
45 : #include <com/sun/star/awt/XControlModel.hpp>
46 : #include <com/sun/star/drawing/XControlShape.hpp>
47 : #include <com/sun/star/drawing/PointSequenceSequence.hpp>
48 : #include <com/sun/star/drawing/PointSequence.hpp>
49 : #include <com/sun/star/lang/XServiceInfo.hpp>
50 : #include <com/sun/star/util/XCloneable.hpp>
51 : #include <com/sun/star/beans/XMultiPropertyStates.hpp>
52 : #include "xexptran.hxx"
53 : #include <com/sun/star/drawing/PolyPolygonBezierCoords.hpp>
54 : #include <com/sun/star/beans/XPropertySetInfo.hpp>
55 : #include <com/sun/star/drawing/ConnectorType.hpp>
56 : #include <com/sun/star/drawing/HomogenMatrix3.hpp>
57 :
58 : #include <sax/tools/converter.hxx>
59 :
60 : #include "PropertySetMerger.hxx"
61 : #include <xmloff/families.hxx>
62 : #include "ximpstyl.hxx"
63 : #include"xmloff/xmlnmspe.hxx"
64 : #include <xmloff/xmltoken.hxx>
65 : #include "EnhancedCustomShapeToken.hxx"
66 : #include "XMLReplacementImageContext.hxx"
67 : #include "XMLImageMapContext.hxx"
68 : #include "sdpropls.hxx"
69 : #include "eventimp.hxx"
70 :
71 : #include "descriptionimp.hxx"
72 : #include "ximpcustomshape.hxx"
73 : #include "XMLEmbeddedObjectImportContext.hxx"
74 : #include "xmloff/xmlerror.hxx"
75 : #include <basegfx/matrix/b2dhommatrix.hxx>
76 : #include <com/sun/star/drawing/XEnhancedCustomShapeDefaulter.hpp>
77 : #include <com/sun/star/container/XChild.hpp>
78 : #include <com/sun/star/text/XTextDocument.hpp>
79 :
80 : using ::rtl::OUString;
81 : using ::rtl::OUStringBuffer;
82 :
83 : using namespace ::com::sun::star;
84 : using namespace ::com::sun::star::uno;
85 : using namespace ::com::sun::star::drawing;
86 : using namespace ::com::sun::star::style;
87 : using namespace ::com::sun::star::container;
88 : using namespace ::com::sun::star::document;
89 : using namespace ::xmloff::token;
90 : using namespace ::xmloff::EnhancedCustomShapeToken;
91 :
92 : SvXMLEnumMapEntry aXML_GlueAlignment_EnumMap[] =
93 : {
94 : { XML_TOP_LEFT, drawing::Alignment_TOP_LEFT },
95 : { XML_TOP, drawing::Alignment_TOP },
96 : { XML_TOP_RIGHT, drawing::Alignment_TOP_RIGHT },
97 : { XML_LEFT, drawing::Alignment_LEFT },
98 : { XML_CENTER, drawing::Alignment_CENTER },
99 : { XML_RIGHT, drawing::Alignment_RIGHT },
100 : { XML_BOTTOM_LEFT, drawing::Alignment_BOTTOM_LEFT },
101 : { XML_BOTTOM, drawing::Alignment_BOTTOM },
102 : { XML_BOTTOM_RIGHT, drawing::Alignment_BOTTOM_RIGHT },
103 : { XML_TOKEN_INVALID, 0 }
104 : };
105 :
106 : SvXMLEnumMapEntry aXML_GlueEscapeDirection_EnumMap[] =
107 : {
108 : { XML_AUTO, drawing::EscapeDirection_SMART },
109 : { XML_LEFT, drawing::EscapeDirection_LEFT },
110 : { XML_RIGHT, drawing::EscapeDirection_RIGHT },
111 : { XML_UP, drawing::EscapeDirection_UP },
112 : { XML_DOWN, drawing::EscapeDirection_DOWN },
113 : { XML_HORIZONTAL, drawing::EscapeDirection_HORIZONTAL },
114 : { XML_VERTICAL, drawing::EscapeDirection_VERTICAL },
115 : { XML_TOKEN_INVALID, 0 }
116 : };
117 :
118 : ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
119 :
120 4 : static bool ImpIsEmptyURL( const ::rtl::OUString& rURL )
121 : {
122 4 : if( rURL.isEmpty() )
123 0 : return true;
124 :
125 : // #i13140# Also compare against 'toplevel' URLs. which also
126 : // result in empty filename strings.
127 4 : if( 0 == rURL.compareToAscii( "#./" ) )
128 0 : return true;
129 :
130 4 : return false;
131 : }
132 :
133 : ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
134 :
135 0 : TYPEINIT1( SvXMLShapeContext, SvXMLImportContext );
136 12 : TYPEINIT1( SdXMLShapeContext, SvXMLShapeContext );
137 :
138 170 : SdXMLShapeContext::SdXMLShapeContext(
139 : SvXMLImport& rImport,
140 : sal_uInt16 nPrfx,
141 : const OUString& rLocalName,
142 : const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList,
143 : uno::Reference< drawing::XShapes >& rShapes,
144 : sal_Bool bTemporaryShape)
145 : : SvXMLShapeContext( rImport, nPrfx, rLocalName, bTemporaryShape )
146 : , mxShapes( rShapes )
147 : , mxAttrList(xAttrList)
148 : , mbListContextPushed( false )
149 : , mnStyleFamily(XML_STYLE_FAMILY_SD_GRAPHICS_ID)
150 : , mbIsPlaceholder(sal_False)
151 : , mbClearDefaultAttributes( true )
152 : , mbIsUserTransformed(sal_False)
153 : , mnZOrder(-1)
154 : , maSize(1, 1)
155 : , maPosition(0, 0)
156 : , mbVisible(true)
157 170 : , mbPrintable(true)
158 : {
159 170 : }
160 :
161 : //////////////////////////////////////////////////////////////////////////////
162 :
163 170 : SdXMLShapeContext::~SdXMLShapeContext()
164 : {
165 170 : }
166 :
167 : //////////////////////////////////////////////////////////////////////////////
168 :
169 115 : SvXMLImportContext *SdXMLShapeContext::CreateChildContext( sal_uInt16 p_nPrefix,
170 : const OUString& rLocalName,
171 : const uno::Reference< xml::sax::XAttributeList>& xAttrList )
172 : {
173 115 : SvXMLImportContext * pContext = NULL;
174 :
175 : // #i68101#
176 115 : if( p_nPrefix == XML_NAMESPACE_SVG &&
177 0 : (IsXMLToken( rLocalName, XML_TITLE ) || IsXMLToken( rLocalName, XML_DESC ) ) )
178 : {
179 0 : pContext = new SdXMLDescriptionContext( GetImport(), p_nPrefix, rLocalName, xAttrList, mxShape );
180 : }
181 115 : else if( p_nPrefix == XML_NAMESPACE_OFFICE && IsXMLToken( rLocalName, XML_EVENT_LISTENERS ) )
182 : {
183 0 : pContext = new SdXMLEventsContext( GetImport(), p_nPrefix, rLocalName, xAttrList, mxShape );
184 : }
185 115 : else if( p_nPrefix == XML_NAMESPACE_DRAW && IsXMLToken( rLocalName, XML_GLUE_POINT ) )
186 : {
187 0 : addGluePoint( xAttrList );
188 : }
189 115 : else if( p_nPrefix == XML_NAMESPACE_DRAW && IsXMLToken( rLocalName, XML_THUMBNAIL ) )
190 : {
191 : // search attributes for xlink:href
192 0 : sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
193 0 : for(sal_Int16 i=0; i < nAttrCount; i++)
194 : {
195 0 : OUString sAttrName = xAttrList->getNameByIndex( i );
196 0 : OUString aLocalName;
197 0 : sal_uInt16 nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName( sAttrName, &aLocalName );
198 :
199 0 : if( nPrefix == XML_NAMESPACE_XLINK )
200 : {
201 0 : if( IsXMLToken( aLocalName, XML_HREF ) )
202 : {
203 0 : maThumbnailURL = xAttrList->getValueByIndex( i );
204 : break;
205 : }
206 : }
207 0 : }
208 : }
209 : else
210 : {
211 : // create text cursor on demand
212 115 : if( !mxCursor.is() )
213 : {
214 97 : uno::Reference< text::XText > xText( mxShape, uno::UNO_QUERY );
215 97 : if( xText.is() )
216 : {
217 : UniReference < XMLTextImportHelper > xTxtImport =
218 97 : GetImport().GetTextImport();
219 97 : mxOldCursor = xTxtImport->GetCursor();
220 97 : mxCursor = xText->createTextCursor();
221 97 : if( mxCursor.is() )
222 : {
223 97 : xTxtImport->SetCursor( mxCursor );
224 : }
225 :
226 : // remember old list item and block (#91964#) and reset them
227 : // for the text frame
228 97 : xTxtImport->PushListContext();
229 97 : mbListContextPushed = true;
230 97 : }
231 : }
232 :
233 : // if we have a text cursor, lets try to import some text
234 115 : if( mxCursor.is() )
235 : {
236 115 : pContext = GetImport().GetTextImport()->CreateTextChildContext(
237 230 : GetImport(), p_nPrefix, rLocalName, xAttrList );
238 : }
239 : }
240 :
241 : // call parent for content
242 115 : if(!pContext)
243 0 : pContext = SvXMLImportContext::CreateChildContext( p_nPrefix, rLocalName, xAttrList );
244 :
245 115 : return pContext;
246 : }
247 :
248 0 : void SdXMLShapeContext::addGluePoint( const uno::Reference< xml::sax::XAttributeList>& xAttrList )
249 : {
250 : // get the glue points container for this shape if its not already there
251 0 : if( !mxGluePoints.is() )
252 : {
253 0 : uno::Reference< drawing::XGluePointsSupplier > xSupplier( mxShape, uno::UNO_QUERY );
254 0 : if( !xSupplier.is() )
255 : return;
256 :
257 0 : mxGluePoints = uno::Reference< container::XIdentifierContainer >::query( xSupplier->getGluePoints() );
258 :
259 0 : if( !mxGluePoints.is() )
260 0 : return;
261 : }
262 :
263 0 : drawing::GluePoint2 aGluePoint;
264 0 : aGluePoint.IsUserDefined = sal_True;
265 0 : aGluePoint.Position.X = 0;
266 0 : aGluePoint.Position.Y = 0;
267 0 : aGluePoint.Escape = drawing::EscapeDirection_SMART;
268 0 : aGluePoint.PositionAlignment = drawing::Alignment_CENTER;
269 0 : aGluePoint.IsRelative = sal_True;
270 :
271 0 : sal_Int32 nId = -1;
272 :
273 : // read attributes for the 3DScene
274 0 : sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
275 0 : for(sal_Int16 i=0; i < nAttrCount; i++)
276 : {
277 0 : OUString sAttrName = xAttrList->getNameByIndex( i );
278 0 : OUString aLocalName;
279 0 : sal_uInt16 nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName( sAttrName, &aLocalName );
280 0 : const OUString sValue( xAttrList->getValueByIndex( i ) );
281 :
282 0 : if( nPrefix == XML_NAMESPACE_SVG )
283 : {
284 0 : if( IsXMLToken( aLocalName, XML_X ) )
285 : {
286 0 : GetImport().GetMM100UnitConverter().convertMeasureToCore(
287 0 : aGluePoint.Position.X, sValue);
288 : }
289 0 : else if( IsXMLToken( aLocalName, XML_Y ) )
290 : {
291 0 : GetImport().GetMM100UnitConverter().convertMeasureToCore(
292 0 : aGluePoint.Position.Y, sValue);
293 : }
294 : }
295 0 : else if( nPrefix == XML_NAMESPACE_DRAW )
296 : {
297 0 : if( IsXMLToken( aLocalName, XML_ID ) )
298 : {
299 0 : nId = sValue.toInt32();
300 : }
301 0 : else if( IsXMLToken( aLocalName, XML_ALIGN ) )
302 : {
303 : sal_uInt16 eKind;
304 0 : if( SvXMLUnitConverter::convertEnum( eKind, sValue, aXML_GlueAlignment_EnumMap ) )
305 : {
306 0 : aGluePoint.PositionAlignment = (drawing::Alignment)eKind;
307 0 : aGluePoint.IsRelative = sal_False;
308 : }
309 : }
310 0 : else if( IsXMLToken( aLocalName, XML_ESCAPE_DIRECTION ) )
311 : {
312 : sal_uInt16 eKind;
313 0 : if( SvXMLUnitConverter::convertEnum( eKind, sValue, aXML_GlueEscapeDirection_EnumMap ) )
314 : {
315 0 : aGluePoint.Escape = (drawing::EscapeDirection)eKind;
316 : }
317 : }
318 : }
319 0 : }
320 :
321 0 : if( nId != -1 )
322 : {
323 : try
324 : {
325 0 : sal_Int32 nInternalId = mxGluePoints->insert( uno::makeAny( aGluePoint ) );
326 0 : GetImport().GetShapeImport()->addGluePointMapping( mxShape, nId, nInternalId );
327 : }
328 0 : catch(const uno::Exception&)
329 : {
330 : OSL_FAIL( "exception during setting of glue points!");
331 : }
332 : }
333 : }
334 : //////////////////////////////////////////////////////////////////////////////
335 :
336 123 : void SdXMLShapeContext::StartElement(const uno::Reference< xml::sax::XAttributeList>&)
337 : {
338 123 : GetImport().GetShapeImport()->finishShape( mxShape, mxAttrList, mxShapes );
339 123 : }
340 :
341 170 : void SdXMLShapeContext::EndElement()
342 : {
343 170 : if(mxCursor.is())
344 : {
345 : // delete addition newline
346 97 : const OUString aEmpty;
347 97 : mxCursor->gotoEnd( sal_False );
348 97 : mxCursor->goLeft( 1, sal_True );
349 97 : mxCursor->setString( aEmpty );
350 :
351 : // reset cursor
352 97 : GetImport().GetTextImport()->ResetCursor();
353 : }
354 :
355 170 : if(mxOldCursor.is())
356 1 : GetImport().GetTextImport()->SetCursor( mxOldCursor );
357 :
358 : // reinstall old list item (if necessary) #91964#
359 170 : if (mbListContextPushed) {
360 97 : GetImport().GetTextImport()->PopListContext();
361 : }
362 :
363 170 : if( !msHyperlink.isEmpty() ) try
364 : {
365 0 : uno::Reference< beans::XPropertySet > xProp( mxShape, uno::UNO_QUERY );
366 :
367 0 : rtl::OUString sLink( "Hyperlink" );
368 0 : if ( xProp.is() && xProp->getPropertySetInfo()->hasPropertyByName( sLink ) )
369 0 : xProp->setPropertyValue( sLink, uno::Any( msHyperlink ) );
370 0 : Reference< XEventsSupplier > xEventsSupplier( mxShape, UNO_QUERY_THROW );
371 0 : const OUString sBookmark( "Bookmark" );
372 :
373 0 : if( xEventsSupplier.is() )
374 : {
375 0 : const OUString sEventType( "EventType" );
376 0 : const OUString sClickAction( "ClickAction" );
377 :
378 0 : Reference< XNameReplace > xEvents( xEventsSupplier->getEvents(), UNO_QUERY_THROW );
379 :
380 0 : uno::Sequence< beans::PropertyValue > aProperties( 3 );
381 0 : aProperties[0].Name = sEventType;
382 0 : aProperties[0].Handle = -1;
383 0 : aProperties[0].Value <<= OUString( "Presentation" );
384 0 : aProperties[0].State = beans::PropertyState_DIRECT_VALUE;
385 :
386 0 : aProperties[1].Name = sClickAction;
387 0 : aProperties[1].Handle = -1;
388 0 : aProperties[1].Value <<= ::com::sun::star::presentation::ClickAction_DOCUMENT;
389 0 : aProperties[1].State = beans::PropertyState_DIRECT_VALUE;
390 :
391 0 : aProperties[2].Name = sBookmark;
392 0 : aProperties[2].Handle = -1;
393 0 : aProperties[2].Value <<= msHyperlink;
394 0 : aProperties[2].State = beans::PropertyState_DIRECT_VALUE;
395 :
396 0 : const OUString sAPIEventName( "OnClick" );
397 0 : xEvents->replaceByName( sAPIEventName, Any( aProperties ) );
398 : }
399 : else
400 : {
401 : // in draw use the Bookmark property
402 0 : Reference< beans::XPropertySet > xSet( mxShape, UNO_QUERY_THROW );
403 0 : xSet->setPropertyValue( sBookmark, Any( msHyperlink ) );
404 0 : xSet->setPropertyValue( OUString( "OnClick" ), Any( ::com::sun::star::presentation::ClickAction_DOCUMENT ) );
405 0 : }
406 : }
407 0 : catch(const Exception&)
408 : {
409 : OSL_FAIL("xmloff::SdXMLShapeContext::EndElement(), exception caught while setting hyperlink!");
410 : }
411 :
412 170 : if( mxLockable.is() )
413 134 : mxLockable->removeActionLock();
414 170 : }
415 :
416 : //////////////////////////////////////////////////////////////////////////////
417 :
418 134 : void SdXMLShapeContext::AddShape(uno::Reference< drawing::XShape >& xShape)
419 : {
420 134 : if(xShape.is())
421 : {
422 : // set shape local
423 134 : mxShape = xShape;
424 :
425 134 : if(!maShapeName.isEmpty())
426 : {
427 0 : uno::Reference< container::XNamed > xNamed( mxShape, uno::UNO_QUERY );
428 0 : if( xNamed.is() )
429 0 : xNamed->setName( maShapeName );
430 : }
431 :
432 134 : UniReference< XMLShapeImportHelper > xImp( GetImport().GetShapeImport() );
433 134 : xImp->addShape( xShape, mxAttrList, mxShapes );
434 :
435 134 : if( mbClearDefaultAttributes )
436 : {
437 108 : uno::Reference<beans::XMultiPropertyStates> xMultiPropertyStates(xShape, uno::UNO_QUERY );
438 108 : if (xMultiPropertyStates.is())
439 108 : xMultiPropertyStates->setAllPropertiesToDefault();
440 : }
441 :
442 134 : if( !mbVisible || !mbPrintable ) try
443 : {
444 0 : uno::Reference< beans::XPropertySet > xSet( xShape, uno::UNO_QUERY_THROW );
445 0 : if( !mbVisible )
446 0 : xSet->setPropertyValue( rtl::OUString( "Visible" ), uno::Any( sal_False ) );
447 :
448 0 : if( !mbPrintable )
449 0 : xSet->setPropertyValue( rtl::OUString( "Printable" ), uno::Any( sal_False ) );
450 : }
451 0 : catch(const Exception&)
452 : {
453 : OSL_FAIL( "SdXMLShapeContext::AddShape(), exception caught!" );
454 : }
455 :
456 : // #107848#
457 534 : if(!mbTemporaryShape && (!GetImport().HasTextImport()
458 400 : || !GetImport().GetTextImport()->IsInsideDeleteContext()))
459 : {
460 133 : xImp->shapeWithZIndexAdded( xShape, mnZOrder );
461 : }
462 :
463 134 : if( !maShapeId.isEmpty() )
464 : {
465 0 : uno::Reference< uno::XInterface > xRef( static_cast<uno::XInterface *>(xShape.get()) );
466 0 : GetImport().getInterfaceToIdentifierMapper().registerReference( maShapeId, xRef );
467 : }
468 :
469 : // #91065# count only if counting for shape import is enabled
470 134 : if(GetImport().GetShapeImport()->IsHandleProgressBarEnabled())
471 : {
472 : // #80365# increment progress bar at load once for each draw object
473 130 : GetImport().GetProgressBarHelper()->Increment();
474 134 : }
475 : }
476 :
477 134 : mxLockable = uno::Reference< document::XActionLockable >::query( xShape );
478 :
479 134 : if( mxLockable.is() )
480 134 : mxLockable->addActionLock();
481 :
482 134 : }
483 :
484 : //////////////////////////////////////////////////////////////////////////////
485 :
486 134 : void SdXMLShapeContext::AddShape(const char* pServiceName )
487 : {
488 134 : uno::Reference< lang::XMultiServiceFactory > xServiceFact(GetImport().GetModel(), uno::UNO_QUERY);
489 134 : if(xServiceFact.is())
490 : {
491 : try
492 : {
493 : /* Since fix for issue i33294 the Writer model doesn't support
494 : com.sun.star.drawing.OLE2Shape anymore.
495 : To handle Draw OLE objects it's decided to import these
496 : objects as com.sun.star.drawing.OLE2Shape and convert these
497 : objects after the import into com.sun.star.drawing.GraphicObjectShape.
498 : */
499 134 : uno::Reference< drawing::XShape > xShape;
500 276 : if ( OUString::createFromAscii(pServiceName).compareToAscii( "com.sun.star.drawing.OLE2Shape" ) == 0 &&
501 142 : uno::Reference< text::XTextDocument >(GetImport().GetModel(), uno::UNO_QUERY).is() )
502 : {
503 0 : xShape = uno::Reference< drawing::XShape >(xServiceFact->createInstance(OUString("com.sun.star.drawing.temporaryForXMLImportOLE2Shape")), uno::UNO_QUERY);
504 : }
505 : else
506 : {
507 134 : xShape = uno::Reference< drawing::XShape >(xServiceFact->createInstance(OUString::createFromAscii(pServiceName)), uno::UNO_QUERY);
508 : }
509 134 : if( xShape.is() )
510 134 : AddShape( xShape );
511 : }
512 0 : catch(const uno::Exception& e)
513 : {
514 0 : uno::Sequence<rtl::OUString> aSeq( 1 );
515 0 : aSeq[0] = OUString::createFromAscii(pServiceName);
516 0 : GetImport().SetError( XMLERROR_FLAG_ERROR | XMLERROR_API,
517 0 : aSeq, e.Message, NULL );
518 : }
519 134 : }
520 134 : }
521 :
522 : //////////////////////////////////////////////////////////////////////////////
523 :
524 129 : void SdXMLShapeContext::SetTransformation()
525 : {
526 129 : if(mxShape.is())
527 : {
528 129 : uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY);
529 129 : if(xPropSet.is())
530 : {
531 129 : ::basegfx::B2DHomMatrix aTransformation;
532 :
533 129 : if(maSize.Width != 1 || maSize.Height != 1)
534 : {
535 : // take care there are no zeros used by error
536 129 : if(0 == maSize.Width)
537 0 : maSize.Width = 1;
538 129 : if(0 == maSize.Height)
539 0 : maSize.Height = 1;
540 :
541 : // set global size. This should always be used.
542 129 : aTransformation.scale(maSize.Width, maSize.Height);
543 : }
544 :
545 129 : if(maPosition.X != 0 || maPosition.Y != 0)
546 : {
547 : // if global position is used, add it to transformation
548 118 : aTransformation.translate(maPosition.X, maPosition.Y);
549 : }
550 :
551 129 : if(mnTransform.NeedsAction())
552 : {
553 : // transformation is used, apply to object.
554 : // NOTICE: The transformation is applied AFTER evtl. used
555 : // global positioning and scaling is used, so any shear or
556 : // rotate used herein is applied around the (0,0) position
557 : // of the PAGE object !!!
558 9 : ::basegfx::B2DHomMatrix aMat;
559 9 : mnTransform.GetFullTransform(aMat);
560 :
561 : // now add to transformation
562 9 : aTransformation *= aMat;
563 : }
564 :
565 : // now set transformation for this object
566 129 : uno::Any aAny;
567 129 : drawing::HomogenMatrix3 aMatrix;
568 :
569 129 : aMatrix.Line1.Column1 = aTransformation.get(0, 0);
570 129 : aMatrix.Line1.Column2 = aTransformation.get(0, 1);
571 129 : aMatrix.Line1.Column3 = aTransformation.get(0, 2);
572 :
573 129 : aMatrix.Line2.Column1 = aTransformation.get(1, 0);
574 129 : aMatrix.Line2.Column2 = aTransformation.get(1, 1);
575 129 : aMatrix.Line2.Column3 = aTransformation.get(1, 2);
576 :
577 129 : aMatrix.Line3.Column1 = aTransformation.get(2, 0);
578 129 : aMatrix.Line3.Column2 = aTransformation.get(2, 1);
579 129 : aMatrix.Line3.Column3 = aTransformation.get(2, 2);
580 :
581 129 : aAny <<= aMatrix;
582 :
583 129 : xPropSet->setPropertyValue(
584 129 : OUString("Transformation"), aAny);
585 129 : }
586 : }
587 129 : }
588 :
589 : //////////////////////////////////////////////////////////////////////////////
590 :
591 134 : void SdXMLShapeContext::SetStyle( bool bSupportsStyle /* = true */)
592 : {
593 : try
594 : {
595 134 : uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY);
596 134 : if( !xPropSet.is() )
597 134 : return;
598 :
599 : do
600 : {
601 134 : XMLPropStyleContext* pDocStyle = NULL;
602 :
603 : // set style on shape
604 134 : if(maDrawStyleName.isEmpty())
605 : break;
606 :
607 123 : const SvXMLStyleContext* pStyle = 0L;
608 123 : sal_Bool bAutoStyle(sal_False);
609 :
610 123 : if(GetImport().GetShapeImport()->GetAutoStylesContext())
611 123 : pStyle = GetImport().GetShapeImport()->GetAutoStylesContext()->FindStyleChildContext(mnStyleFamily, maDrawStyleName);
612 :
613 123 : if(pStyle)
614 117 : bAutoStyle = sal_True;
615 :
616 123 : if(!pStyle && GetImport().GetShapeImport()->GetStylesContext())
617 4 : pStyle = GetImport().GetShapeImport()->GetStylesContext()->FindStyleChildContext(mnStyleFamily, maDrawStyleName);
618 :
619 123 : OUString aStyleName = maDrawStyleName;
620 123 : uno::Reference< style::XStyle > xStyle;
621 :
622 123 : if( pStyle && pStyle->ISA(XMLShapeStyleContext) )
623 : {
624 121 : pDocStyle = PTR_CAST( XMLShapeStyleContext, pStyle );
625 :
626 121 : if( pDocStyle->GetStyle().is() )
627 : {
628 4 : xStyle = pDocStyle->GetStyle();
629 : }
630 : else
631 : {
632 117 : aStyleName = pDocStyle->GetParentName();
633 : }
634 : }
635 :
636 123 : if( !xStyle.is() && !aStyleName.isEmpty() )
637 : {
638 : try
639 : {
640 :
641 103 : uno::Reference< style::XStyleFamiliesSupplier > xFamiliesSupplier( GetImport().GetModel(), uno::UNO_QUERY );
642 :
643 103 : if( xFamiliesSupplier.is() )
644 : {
645 103 : uno::Reference< container::XNameAccess > xFamilies( xFamiliesSupplier->getStyleFamilies() );
646 103 : if( xFamilies.is() )
647 : {
648 :
649 103 : uno::Reference< container::XNameAccess > xFamily;
650 :
651 103 : if( XML_STYLE_FAMILY_SD_PRESENTATION_ID == mnStyleFamily )
652 : {
653 15 : aStyleName = GetImport().GetStyleDisplayName(
654 : XML_STYLE_FAMILY_SD_PRESENTATION_ID,
655 15 : aStyleName );
656 15 : sal_Int32 nPos = aStyleName.lastIndexOf( sal_Unicode('-') );
657 15 : if( -1 != nPos )
658 : {
659 15 : OUString aFamily( aStyleName.copy( 0, nPos ) );
660 :
661 15 : xFamilies->getByName( aFamily ) >>= xFamily;
662 15 : aStyleName = aStyleName.copy( nPos + 1 );
663 : }
664 : }
665 : else
666 : {
667 : // get graphics familie
668 88 : xFamilies->getByName( OUString( "graphics" ) ) >>= xFamily;
669 88 : aStyleName = GetImport().GetStyleDisplayName(
670 : XML_STYLE_FAMILY_SD_GRAPHICS_ID,
671 88 : aStyleName );
672 : }
673 :
674 103 : if( xFamily.is() )
675 103 : xFamily->getByName( aStyleName ) >>= xStyle;
676 103 : }
677 103 : }
678 : }
679 0 : catch(const uno::Exception&)
680 : {
681 : OSL_FAIL( "could not find style for shape!" );
682 : }
683 : }
684 :
685 123 : if( bSupportsStyle && xStyle.is() )
686 : {
687 : try
688 : {
689 : // set style on object
690 107 : uno::Any aAny;
691 107 : aAny <<= xStyle;
692 107 : xPropSet->setPropertyValue(OUString("Style"), aAny);
693 : }
694 0 : catch(const uno::Exception&)
695 : {
696 : OSL_FAIL( "could not find style for shape!" );
697 : }
698 : }
699 :
700 : // if this is an auto style, set its properties
701 123 : if(bAutoStyle && pDocStyle)
702 : {
703 : // set PropertySet on object
704 117 : pDocStyle->FillPropertySet(xPropSet);
705 123 : }
706 :
707 : } while(0);
708 :
709 : // try to set text auto style
710 : do
711 : {
712 : // set style on shape
713 134 : if( maTextStyleName.isEmpty() )
714 39 : break;
715 :
716 95 : if( NULL == GetImport().GetShapeImport()->GetAutoStylesContext())
717 0 : break;
718 :
719 95 : const SvXMLStyleContext* pTempStyle = GetImport().GetShapeImport()->GetAutoStylesContext()->FindStyleChildContext(XML_STYLE_FAMILY_TEXT_PARAGRAPH, maTextStyleName);
720 95 : XMLPropStyleContext* pStyle = PTR_CAST( XMLPropStyleContext, pTempStyle ); // use temp var, PTR_CAST is a bad macro, FindStyleChildContext will be called twice
721 95 : if( pStyle == NULL )
722 0 : break;
723 :
724 : // set PropertySet on object
725 95 : pStyle->FillPropertySet(xPropSet);
726 :
727 134 : } while(0);
728 : }
729 0 : catch(const uno::Exception&)
730 : {
731 : }
732 : }
733 :
734 129 : void SdXMLShapeContext::SetLayer()
735 : {
736 129 : if( !maLayerName.isEmpty() )
737 : {
738 : try
739 : {
740 125 : uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY);
741 125 : if(xPropSet.is() )
742 : {
743 125 : uno::Any aAny;
744 125 : aAny <<= maLayerName;
745 :
746 125 : xPropSet->setPropertyValue(OUString("LayerName"), aAny);
747 254 : return;
748 125 : }
749 : }
750 0 : catch(const uno::Exception&)
751 : {
752 : }
753 : }
754 : }
755 :
756 0 : void SdXMLShapeContext::SetThumbnail()
757 : {
758 0 : if( maThumbnailURL.isEmpty() )
759 0 : return;
760 :
761 : try
762 : {
763 0 : uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY);
764 0 : if( !xPropSet.is() )
765 : return;
766 :
767 0 : const OUString sProperty("ThumbnailGraphicURL");
768 :
769 0 : uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() );
770 0 : if( xPropSetInfo.is() && xPropSetInfo->hasPropertyByName( sProperty ) )
771 : {
772 : // load the thumbnail graphic and export it to a wmf stream so we can set
773 : // it at the api
774 :
775 0 : const OUString aInternalURL( GetImport().ResolveGraphicObjectURL( maThumbnailURL, sal_False ) );
776 0 : xPropSet->setPropertyValue( sProperty, uno::makeAny( aInternalURL ) );
777 0 : }
778 : }
779 0 : catch(const uno::Exception&)
780 : {
781 : }
782 : }
783 :
784 : // this is called from the parent group for each unparsed attribute in the attribute list
785 919 : void SdXMLShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue )
786 : {
787 919 : bool bHaveXmlId( false );
788 919 : if( (XML_NAMESPACE_DRAW == nPrefix) || (XML_NAMESPACE_DRAW_EXT == nPrefix) )
789 : {
790 672 : if( IsXMLToken( rLocalName, XML_ZINDEX ) )
791 : {
792 3 : mnZOrder = rValue.toInt32();
793 : }
794 333 : else if( IsXMLToken( rLocalName, XML_ID ) )
795 : {
796 0 : if (!bHaveXmlId) { maShapeId = rValue; };
797 : }
798 333 : else if( IsXMLToken( rLocalName, XML_NAME ) )
799 : {
800 0 : maShapeName = rValue;
801 : }
802 333 : else if( IsXMLToken( rLocalName, XML_STYLE_NAME ) )
803 : {
804 104 : maDrawStyleName = rValue;
805 : }
806 229 : else if( IsXMLToken( rLocalName, XML_TEXT_STYLE_NAME ) )
807 : {
808 95 : maTextStyleName = rValue;
809 : }
810 134 : else if( IsXMLToken( rLocalName, XML_LAYER ) )
811 : {
812 125 : maLayerName = rValue;
813 : }
814 9 : else if( IsXMLToken( rLocalName, XML_TRANSFORM ) )
815 : {
816 9 : mnTransform.SetString(rValue, GetImport().GetMM100UnitConverter());
817 : }
818 0 : else if( IsXMLToken( rLocalName, XML_DISPLAY ) )
819 : {
820 0 : mbVisible = IsXMLToken( rValue, XML_ALWAYS ) || IsXMLToken( rValue, XML_SCREEN );
821 0 : mbPrintable = IsXMLToken( rValue, XML_ALWAYS ) || IsXMLToken( rValue, XML_PRINTER );
822 : }
823 : }
824 583 : else if( XML_NAMESPACE_PRESENTATION == nPrefix )
825 : {
826 63 : if( IsXMLToken( rLocalName, XML_USER_TRANSFORMED ) )
827 : {
828 1 : mbIsUserTransformed = IsXMLToken( rValue, XML_TRUE );
829 : }
830 62 : else if( IsXMLToken( rLocalName, XML_PLACEHOLDER ) )
831 : {
832 11 : mbIsPlaceholder = IsXMLToken( rValue, XML_TRUE );
833 11 : if( mbIsPlaceholder )
834 11 : mbClearDefaultAttributes = false;
835 : }
836 51 : else if( IsXMLToken( rLocalName, XML_CLASS ) )
837 : {
838 32 : maPresentationClass = rValue;
839 : }
840 19 : else if( IsXMLToken( rLocalName, XML_STYLE_NAME ) )
841 : {
842 19 : maDrawStyleName = rValue;
843 19 : mnStyleFamily = XML_STYLE_FAMILY_SD_PRESENTATION_ID;
844 : }
845 : }
846 520 : else if( XML_NAMESPACE_SVG == nPrefix )
847 : {
848 486 : if( IsXMLToken( rLocalName, XML_X ) )
849 : {
850 117 : GetImport().GetMM100UnitConverter().convertMeasureToCore(
851 234 : maPosition.X, rValue);
852 : }
853 369 : else if( IsXMLToken( rLocalName, XML_Y ) )
854 : {
855 117 : GetImport().GetMM100UnitConverter().convertMeasureToCore(
856 234 : maPosition.Y, rValue);
857 : }
858 252 : else if( IsXMLToken( rLocalName, XML_WIDTH ) )
859 : {
860 126 : GetImport().GetMM100UnitConverter().convertMeasureToCore(
861 252 : maSize.Width, rValue);
862 126 : if( maSize.Width > 0 )
863 126 : maSize.Width += 1;
864 0 : else if( maSize.Width < 0 )
865 0 : maSize.Width -= 1;
866 : }
867 126 : else if( IsXMLToken( rLocalName, XML_HEIGHT ) )
868 : {
869 126 : GetImport().GetMM100UnitConverter().convertMeasureToCore(
870 252 : maSize.Height, rValue);
871 126 : if( maSize.Height > 0 )
872 126 : maSize.Height += 1;
873 0 : else if( maSize.Height < 0 )
874 0 : maSize.Height -= 1;
875 : }
876 0 : else if( IsXMLToken( rLocalName, XML_TRANSFORM ) )
877 : {
878 : // because of #85127# take svg:transform into account and hanle like
879 : // draw:transform for compatibility
880 0 : mnTransform.SetString(rValue, GetImport().GetMM100UnitConverter());
881 : }
882 :
883 : // #i68101#
884 0 : else if( IsXMLToken( rLocalName, XML_TITLE ) )
885 : {
886 0 : maShapeTitle = rValue;
887 : }
888 0 : else if( IsXMLToken( rLocalName, XML_DESC ) )
889 : {
890 0 : maShapeDescription = rValue;
891 : }
892 : }
893 34 : else if( (XML_NAMESPACE_NONE == nPrefix) || (XML_NAMESPACE_XML == nPrefix) )
894 : {
895 0 : if( IsXMLToken( rLocalName, XML_ID ) )
896 : {
897 0 : maShapeId = rValue;
898 0 : bHaveXmlId = true;
899 : }
900 : }
901 919 : }
902 :
903 27 : sal_Bool SdXMLShapeContext::isPresentationShape() const
904 : {
905 27 : if( !maPresentationClass.isEmpty() && (const_cast<SdXMLShapeContext*>(this))->GetImport().GetShapeImport()->IsPresentationShapesSupported() )
906 : {
907 22 : if(XML_STYLE_FAMILY_SD_PRESENTATION_ID == mnStyleFamily)
908 : {
909 18 : return sal_True;
910 : }
911 :
912 7 : if( IsXMLToken( maPresentationClass, XML_HEADER ) || IsXMLToken( maPresentationClass, XML_FOOTER ) ||
913 3 : IsXMLToken( maPresentationClass, XML_PAGE_NUMBER ) || IsXMLToken( maPresentationClass, XML_DATE_TIME ) )
914 : {
915 4 : return sal_True;
916 : }
917 : }
918 :
919 5 : return sal_False;
920 : }
921 :
922 : ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
923 : ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
924 :
925 0 : TYPEINIT1( SdXMLRectShapeContext, SdXMLShapeContext );
926 :
927 0 : SdXMLRectShapeContext::SdXMLRectShapeContext(
928 : SvXMLImport& rImport,
929 : sal_uInt16 nPrfx,
930 : const OUString& rLocalName,
931 : const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList,
932 : uno::Reference< drawing::XShapes >& rShapes,
933 : sal_Bool bTemporaryShape)
934 : : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape ),
935 0 : mnRadius( 0L )
936 : {
937 0 : }
938 :
939 : //////////////////////////////////////////////////////////////////////////////
940 :
941 0 : SdXMLRectShapeContext::~SdXMLRectShapeContext()
942 : {
943 0 : }
944 :
945 : //////////////////////////////////////////////////////////////////////////////
946 :
947 : // this is called from the parent group for each unparsed attribute in the attribute list
948 0 : void SdXMLRectShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue )
949 : {
950 0 : if( XML_NAMESPACE_DRAW == nPrefix )
951 : {
952 0 : if( IsXMLToken( rLocalName, XML_CORNER_RADIUS ) )
953 : {
954 0 : GetImport().GetMM100UnitConverter().convertMeasureToCore(
955 0 : mnRadius, rValue);
956 0 : return;
957 : }
958 : }
959 :
960 0 : SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue );
961 : }
962 :
963 : //////////////////////////////////////////////////////////////////////////////
964 :
965 0 : void SdXMLRectShapeContext::StartElement(const uno::Reference< xml::sax::XAttributeList>& xAttrList)
966 : {
967 : // create rectangle shape
968 0 : AddShape("com.sun.star.drawing.RectangleShape");
969 0 : if(mxShape.is())
970 : {
971 : // Add, set Style and properties from base shape
972 0 : SetStyle();
973 0 : SetLayer();
974 :
975 : // set pos, size, shear and rotate
976 0 : SetTransformation();
977 :
978 0 : if(mnRadius)
979 : {
980 0 : uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY);
981 0 : if(xPropSet.is())
982 : {
983 : try
984 : {
985 0 : xPropSet->setPropertyValue(OUString("CornerRadius"), uno::makeAny( mnRadius ) );
986 : }
987 0 : catch(const uno::Exception&)
988 : {
989 : OSL_FAIL( "exception during setting of corner radius!");
990 : }
991 0 : }
992 : }
993 0 : SdXMLShapeContext::StartElement(xAttrList);
994 : }
995 0 : }
996 :
997 : ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
998 : ////////////////////////////////////////3////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
999 :
1000 0 : TYPEINIT1( SdXMLLineShapeContext, SdXMLShapeContext );
1001 :
1002 3 : SdXMLLineShapeContext::SdXMLLineShapeContext(
1003 : SvXMLImport& rImport,
1004 : sal_uInt16 nPrfx,
1005 : const OUString& rLocalName,
1006 : const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList,
1007 : uno::Reference< drawing::XShapes >& rShapes,
1008 : sal_Bool bTemporaryShape)
1009 : : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape ),
1010 : mnX1( 0L ),
1011 : mnY1( 0L ),
1012 : mnX2( 1L ),
1013 3 : mnY2( 1L )
1014 : {
1015 3 : }
1016 :
1017 : //////////////////////////////////////////////////////////////////////////////
1018 :
1019 6 : SdXMLLineShapeContext::~SdXMLLineShapeContext()
1020 : {
1021 6 : }
1022 :
1023 : //////////////////////////////////////////////////////////////////////////////
1024 :
1025 : // this is called from the parent group for each unparsed attribute in the attribute list
1026 21 : void SdXMLLineShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue )
1027 : {
1028 21 : if( XML_NAMESPACE_SVG == nPrefix )
1029 : {
1030 12 : if( IsXMLToken( rLocalName, XML_X1 ) )
1031 : {
1032 3 : GetImport().GetMM100UnitConverter().convertMeasureToCore(
1033 6 : mnX1, rValue);
1034 3 : return;
1035 : }
1036 9 : if( IsXMLToken( rLocalName, XML_Y1 ) )
1037 : {
1038 3 : GetImport().GetMM100UnitConverter().convertMeasureToCore(
1039 6 : mnY1, rValue);
1040 3 : return;
1041 : }
1042 6 : if( IsXMLToken( rLocalName, XML_X2 ) )
1043 : {
1044 3 : GetImport().GetMM100UnitConverter().convertMeasureToCore(
1045 6 : mnX2, rValue);
1046 3 : return;
1047 : }
1048 3 : if( IsXMLToken( rLocalName, XML_Y2 ) )
1049 : {
1050 3 : GetImport().GetMM100UnitConverter().convertMeasureToCore(
1051 6 : mnY2, rValue);
1052 3 : return;
1053 : }
1054 : }
1055 :
1056 9 : SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue );
1057 : }
1058 :
1059 : //////////////////////////////////////////////////////////////////////////////
1060 :
1061 3 : void SdXMLLineShapeContext::StartElement(const uno::Reference< xml::sax::XAttributeList>& xAttrList)
1062 : {
1063 : // #85920# use SetTransformation() to handle import of simple lines.
1064 : // This is necessary to kake into account all anchor positions and
1065 : // other things. All shape imports use the same import schemata now.
1066 : // create necessary shape (Line Shape)
1067 3 : AddShape("com.sun.star.drawing.PolyLineShape");
1068 :
1069 3 : if(mxShape.is())
1070 : {
1071 : // Add, set Style and properties from base shape
1072 3 : SetStyle();
1073 3 : SetLayer();
1074 :
1075 : // get sizes and offsets
1076 3 : awt::Point aTopLeft(mnX1, mnY1);
1077 3 : awt::Point aBottomRight(mnX2, mnY2);
1078 :
1079 3 : if(mnX1 > mnX2)
1080 : {
1081 1 : aTopLeft.X = mnX2;
1082 1 : aBottomRight.X = mnX1;
1083 : }
1084 :
1085 3 : if(mnY1 > mnY2)
1086 : {
1087 1 : aTopLeft.Y = mnY2;
1088 1 : aBottomRight.Y = mnY1;
1089 : }
1090 :
1091 : // set local parameters on shape
1092 3 : uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY);
1093 3 : if(xPropSet.is())
1094 : {
1095 3 : drawing::PointSequenceSequence aPolyPoly(1L);
1096 3 : drawing::PointSequence* pOuterSequence = aPolyPoly.getArray();
1097 3 : pOuterSequence->realloc(2L);
1098 3 : awt::Point* pInnerSequence = pOuterSequence->getArray();
1099 3 : uno::Any aAny;
1100 :
1101 3 : *pInnerSequence = awt::Point( mnX1 - aTopLeft.X, mnY1 - aTopLeft.Y);
1102 3 : pInnerSequence++;
1103 3 : *pInnerSequence = awt::Point( mnX2 - aTopLeft.X, mnY2 - aTopLeft.Y);
1104 :
1105 3 : aAny <<= aPolyPoly;
1106 3 : xPropSet->setPropertyValue(
1107 3 : OUString("Geometry"), aAny);
1108 : }
1109 :
1110 : // set sizes for transformation
1111 3 : maSize.Width = aBottomRight.X - aTopLeft.X;
1112 3 : maSize.Height = aBottomRight.Y - aTopLeft.Y;
1113 3 : maPosition.X = aTopLeft.X;
1114 3 : maPosition.Y = aTopLeft.Y;
1115 :
1116 : // set pos, size, shear and rotate and get copy of matrix
1117 3 : SetTransformation();
1118 :
1119 3 : SdXMLShapeContext::StartElement(xAttrList);
1120 : }
1121 3 : }
1122 :
1123 : ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1124 : ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1125 :
1126 0 : TYPEINIT1( SdXMLEllipseShapeContext, SdXMLShapeContext );
1127 :
1128 3 : SdXMLEllipseShapeContext::SdXMLEllipseShapeContext(
1129 : SvXMLImport& rImport,
1130 : sal_uInt16 nPrfx,
1131 : const OUString& rLocalName,
1132 : const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList,
1133 : uno::Reference< drawing::XShapes >& rShapes,
1134 : sal_Bool bTemporaryShape)
1135 : : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape ),
1136 : mnCX( 0L ),
1137 : mnCY( 0L ),
1138 : mnRX( 1L ),
1139 : mnRY( 1L ),
1140 : meKind( drawing::CircleKind_FULL ),
1141 : mnStartAngle( 0 ),
1142 3 : mnEndAngle( 0 )
1143 : {
1144 3 : }
1145 :
1146 : //////////////////////////////////////////////////////////////////////////////
1147 :
1148 6 : SdXMLEllipseShapeContext::~SdXMLEllipseShapeContext()
1149 : {
1150 6 : }
1151 :
1152 : //////////////////////////////////////////////////////////////////////////////
1153 :
1154 : // this is called from the parent group for each unparsed attribute in the attribute list
1155 25 : void SdXMLEllipseShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue )
1156 : {
1157 25 : if( XML_NAMESPACE_SVG == nPrefix )
1158 : {
1159 10 : if( IsXMLToken( rLocalName, XML_RX ) )
1160 : {
1161 0 : GetImport().GetMM100UnitConverter().convertMeasureToCore(
1162 0 : mnRX, rValue);
1163 0 : return;
1164 : }
1165 10 : if( IsXMLToken( rLocalName, XML_RY ) )
1166 : {
1167 0 : GetImport().GetMM100UnitConverter().convertMeasureToCore(
1168 0 : mnRY, rValue);
1169 0 : return;
1170 : }
1171 10 : if( IsXMLToken( rLocalName, XML_CX ) )
1172 : {
1173 0 : GetImport().GetMM100UnitConverter().convertMeasureToCore(
1174 0 : mnCX, rValue);
1175 0 : return;
1176 : }
1177 10 : if( IsXMLToken( rLocalName, XML_CY ) )
1178 : {
1179 0 : GetImport().GetMM100UnitConverter().convertMeasureToCore(
1180 0 : mnCY, rValue);
1181 0 : return;
1182 : }
1183 10 : if( IsXMLToken( rLocalName, XML_R ) )
1184 : {
1185 : // single radius, it's a circle and both radii are the same
1186 0 : GetImport().GetMM100UnitConverter().convertMeasureToCore(
1187 0 : mnRX, rValue);
1188 0 : mnRY = mnRX;
1189 0 : return;
1190 : }
1191 : }
1192 15 : else if( XML_NAMESPACE_DRAW == nPrefix )
1193 : {
1194 9 : if( IsXMLToken( rLocalName, XML_KIND ) )
1195 : {
1196 : sal_uInt16 eKind;
1197 0 : if( SvXMLUnitConverter::convertEnum( eKind, rValue, aXML_CircleKind_EnumMap ) )
1198 : {
1199 0 : meKind = eKind;
1200 : }
1201 : return;
1202 : }
1203 9 : if( IsXMLToken( rLocalName, XML_START_ANGLE ) )
1204 : {
1205 : double dStartAngle;
1206 0 : if (::sax::Converter::convertDouble( dStartAngle, rValue ))
1207 0 : mnStartAngle = (sal_Int32)(dStartAngle * 100.0);
1208 : return;
1209 : }
1210 9 : if( IsXMLToken( rLocalName, XML_END_ANGLE ) )
1211 : {
1212 : double dEndAngle;
1213 0 : if (::sax::Converter::convertDouble( dEndAngle, rValue ))
1214 0 : mnEndAngle = (sal_Int32)(dEndAngle * 100.0);
1215 : return;
1216 : }
1217 : }
1218 :
1219 25 : SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue );
1220 : }
1221 :
1222 : //////////////////////////////////////////////////////////////////////////////
1223 :
1224 3 : void SdXMLEllipseShapeContext::StartElement(const uno::Reference< xml::sax::XAttributeList>& xAttrList)
1225 : {
1226 : // create rectangle shape
1227 3 : AddShape("com.sun.star.drawing.EllipseShape");
1228 3 : if(mxShape.is())
1229 : {
1230 : // Add, set Style and properties from base shape
1231 3 : SetStyle();
1232 3 : SetLayer();
1233 :
1234 : // set pos, size, shear and rotate
1235 3 : SetTransformation();
1236 :
1237 3 : if( meKind != drawing::CircleKind_FULL )
1238 : {
1239 0 : uno::Reference< beans::XPropertySet > xPropSet( mxShape, uno::UNO_QUERY );
1240 0 : if( xPropSet.is() )
1241 : {
1242 0 : uno::Any aAny;
1243 0 : aAny <<= (drawing::CircleKind)meKind;
1244 0 : xPropSet->setPropertyValue( OUString("CircleKind"), aAny );
1245 :
1246 0 : aAny <<= mnStartAngle;
1247 0 : xPropSet->setPropertyValue( OUString("CircleStartAngle"), aAny );
1248 :
1249 0 : aAny <<= mnEndAngle;
1250 0 : xPropSet->setPropertyValue( OUString("CircleEndAngle"), aAny );
1251 0 : }
1252 : }
1253 :
1254 3 : SdXMLShapeContext::StartElement(xAttrList);
1255 : }
1256 3 : }
1257 :
1258 : ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1259 : ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1260 :
1261 0 : TYPEINIT1( SdXMLPolygonShapeContext, SdXMLShapeContext );
1262 :
1263 5 : SdXMLPolygonShapeContext::SdXMLPolygonShapeContext(
1264 : SvXMLImport& rImport,
1265 : sal_uInt16 nPrfx,
1266 : const OUString& rLocalName,
1267 : const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList,
1268 : uno::Reference< drawing::XShapes >& rShapes, sal_Bool bClosed, sal_Bool bTemporaryShape)
1269 : : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape ),
1270 5 : mbClosed( bClosed )
1271 : {
1272 5 : }
1273 :
1274 : //////////////////////////////////////////////////////////////////////////////
1275 :
1276 : // this is called from the parent group for each unparsed attribute in the attribute list
1277 42 : void SdXMLPolygonShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue )
1278 : {
1279 42 : if( XML_NAMESPACE_SVG == nPrefix )
1280 : {
1281 21 : if( IsXMLToken( rLocalName, XML_VIEWBOX ) )
1282 : {
1283 5 : maViewBox = rValue;
1284 5 : return;
1285 : }
1286 : }
1287 21 : else if( XML_NAMESPACE_DRAW == nPrefix )
1288 : {
1289 21 : if( IsXMLToken( rLocalName, XML_POINTS ) )
1290 : {
1291 5 : maPoints = rValue;
1292 5 : return;
1293 : }
1294 : }
1295 :
1296 32 : SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue );
1297 : }
1298 :
1299 : //////////////////////////////////////////////////////////////////////////////
1300 :
1301 10 : SdXMLPolygonShapeContext::~SdXMLPolygonShapeContext()
1302 : {
1303 10 : }
1304 :
1305 : //////////////////////////////////////////////////////////////////////////////
1306 :
1307 5 : void SdXMLPolygonShapeContext::StartElement(const uno::Reference< xml::sax::XAttributeList>& xAttrList)
1308 : {
1309 : // Add, set Style and properties from base shape
1310 5 : if(mbClosed)
1311 4 : AddShape("com.sun.star.drawing.PolyPolygonShape");
1312 : else
1313 1 : AddShape("com.sun.star.drawing.PolyLineShape");
1314 :
1315 5 : if( mxShape.is() )
1316 : {
1317 5 : SetStyle();
1318 5 : SetLayer();
1319 :
1320 : // set local parameters on shape
1321 5 : uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY);
1322 5 : if(xPropSet.is())
1323 : {
1324 : // set polygon
1325 5 : if(!maPoints.isEmpty() && !maViewBox.isEmpty())
1326 : {
1327 5 : SdXMLImExViewBox aViewBox(maViewBox, GetImport().GetMM100UnitConverter());
1328 5 : awt::Size aSize(aViewBox.GetWidth(), aViewBox.GetHeight());
1329 5 : if (maSize.Width != 0 && maSize.Height !=0)
1330 : {
1331 5 : aSize = maSize;
1332 : }
1333 5 : awt::Point aPosition(aViewBox.GetX(), aViewBox.GetY());
1334 : SdXMLImExPointsElement aPoints(maPoints, aViewBox,
1335 5 : aPosition, aSize, GetImport().GetMM100UnitConverter());
1336 :
1337 5 : uno::Any aAny;
1338 5 : aAny <<= aPoints.GetPointSequenceSequence();
1339 5 : xPropSet->setPropertyValue(
1340 5 : OUString("Geometry"), aAny);
1341 : }
1342 : }
1343 :
1344 : // set pos, size, shear and rotate and get copy of matrix
1345 5 : SetTransformation();
1346 :
1347 5 : SdXMLShapeContext::StartElement(xAttrList);
1348 : }
1349 5 : }
1350 :
1351 : ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1352 : ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1353 :
1354 0 : TYPEINIT1( SdXMLPathShapeContext, SdXMLShapeContext );
1355 :
1356 4 : SdXMLPathShapeContext::SdXMLPathShapeContext(
1357 : SvXMLImport& rImport,
1358 : sal_uInt16 nPrfx,
1359 : const OUString& rLocalName,
1360 : const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList,
1361 : uno::Reference< drawing::XShapes >& rShapes,
1362 : sal_Bool bTemporaryShape)
1363 4 : : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape )
1364 : {
1365 4 : }
1366 :
1367 : //////////////////////////////////////////////////////////////////////////////
1368 :
1369 8 : SdXMLPathShapeContext::~SdXMLPathShapeContext()
1370 : {
1371 8 : }
1372 :
1373 : //////////////////////////////////////////////////////////////////////////////
1374 :
1375 : // this is called from the parent group for each unparsed attribute in the attribute list
1376 34 : void SdXMLPathShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue )
1377 : {
1378 34 : if( XML_NAMESPACE_SVG == nPrefix )
1379 : {
1380 20 : if( IsXMLToken( rLocalName, XML_VIEWBOX ) )
1381 : {
1382 4 : maViewBox = rValue;
1383 4 : return;
1384 : }
1385 16 : else if( IsXMLToken( rLocalName, XML_D ) )
1386 : {
1387 4 : maD = rValue;
1388 4 : return;
1389 : }
1390 : }
1391 :
1392 26 : SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue );
1393 : }
1394 :
1395 : //////////////////////////////////////////////////////////////////////////////
1396 :
1397 4 : void SdXMLPathShapeContext::StartElement(const uno::Reference< xml::sax::XAttributeList>& xAttrList)
1398 : {
1399 : // create polygon shape
1400 4 : if(!maD.isEmpty())
1401 : {
1402 : // prepare some of the parameters
1403 4 : SdXMLImExViewBox aViewBox(maViewBox, GetImport().GetMM100UnitConverter());
1404 4 : awt::Size aSize(aViewBox.GetWidth(), aViewBox.GetHeight());
1405 4 : awt::Point aPosition(aViewBox.GetX(), aViewBox.GetY());
1406 4 : if (maSize.Width != 0 && maSize.Height !=0)
1407 : {
1408 4 : aSize = maSize;
1409 : }
1410 4 : SdXMLImExSvgDElement aPoints(maD, aViewBox, aPosition, aSize, GetImport());
1411 :
1412 : const char* pService;
1413 : // now create shape
1414 4 : if(aPoints.IsCurve())
1415 : {
1416 4 : if(aPoints.IsClosed())
1417 : {
1418 2 : pService = "com.sun.star.drawing.ClosedBezierShape";
1419 : }
1420 : else
1421 : {
1422 2 : pService = "com.sun.star.drawing.OpenBezierShape";
1423 : }
1424 : }
1425 : else
1426 : {
1427 0 : if(aPoints.IsClosed())
1428 : {
1429 0 : pService = "com.sun.star.drawing.PolyPolygonShape";
1430 : }
1431 : else
1432 : {
1433 0 : pService = "com.sun.star.drawing.PolyLineShape";
1434 : }
1435 : }
1436 :
1437 : // Add, set Style and properties from base shape
1438 4 : AddShape(pService);
1439 :
1440 : // #89344# test for mxShape.is() and not for mxShapes.is() to support
1441 : // shape import helper classes WITHOUT XShapes (member mxShapes). This
1442 : // is used by the writer.
1443 4 : if( mxShape.is() )
1444 : {
1445 4 : SetStyle();
1446 4 : SetLayer();
1447 :
1448 : // set local parameters on shape
1449 4 : uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY);
1450 4 : if(xPropSet.is())
1451 : {
1452 4 : uno::Any aAny;
1453 :
1454 : // set svg:d
1455 4 : if(!maD.isEmpty())
1456 : {
1457 4 : if(aPoints.IsCurve())
1458 : {
1459 : drawing::PolyPolygonBezierCoords aSourcePolyPolygon(
1460 4 : aPoints.GetPointSequenceSequence(),
1461 8 : aPoints.GetFlagSequenceSequence());
1462 :
1463 4 : aAny <<= aSourcePolyPolygon;
1464 4 : xPropSet->setPropertyValue(
1465 4 : OUString("Geometry"), aAny);
1466 : }
1467 : else
1468 : {
1469 0 : aAny <<= aPoints.GetPointSequenceSequence();
1470 0 : xPropSet->setPropertyValue(
1471 0 : OUString("Geometry"), aAny);
1472 : }
1473 4 : }
1474 : }
1475 :
1476 : // set pos, size, shear and rotate
1477 4 : SetTransformation();
1478 :
1479 4 : SdXMLShapeContext::StartElement(xAttrList);
1480 4 : }
1481 : }
1482 4 : }
1483 :
1484 : ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1485 : ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1486 :
1487 0 : TYPEINIT1( SdXMLTextBoxShapeContext, SdXMLShapeContext );
1488 :
1489 27 : SdXMLTextBoxShapeContext::SdXMLTextBoxShapeContext(
1490 : SvXMLImport& rImport,
1491 : sal_uInt16 nPrfx,
1492 : const OUString& rLocalName,
1493 : const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList,
1494 : uno::Reference< drawing::XShapes >& rShapes,
1495 : sal_Bool bTemporaryShape)
1496 : : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape ),
1497 27 : mnRadius(0)
1498 : {
1499 27 : }
1500 :
1501 : //////////////////////////////////////////////////////////////////////////////
1502 :
1503 54 : SdXMLTextBoxShapeContext::~SdXMLTextBoxShapeContext()
1504 : {
1505 54 : }
1506 :
1507 : //////////////////////////////////////////////////////////////////////////////
1508 :
1509 : // this is called from the parent group for each unparsed attribute in the attribute list
1510 211 : void SdXMLTextBoxShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue )
1511 : {
1512 211 : if( XML_NAMESPACE_DRAW == nPrefix )
1513 : {
1514 58 : if( IsXMLToken( rLocalName, XML_CORNER_RADIUS ) )
1515 : {
1516 0 : GetImport().GetMM100UnitConverter().convertMeasureToCore(
1517 0 : mnRadius, rValue);
1518 211 : return;
1519 : }
1520 : }
1521 :
1522 211 : SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue );
1523 : }
1524 :
1525 : //////////////////////////////////////////////////////////////////////////////
1526 :
1527 27 : void SdXMLTextBoxShapeContext::StartElement(const uno::Reference< xml::sax::XAttributeList>&)
1528 : {
1529 : // create textbox shape
1530 27 : sal_Bool bIsPresShape = sal_False;
1531 27 : bool bClearText = false;
1532 :
1533 27 : const char *pService = NULL;
1534 :
1535 27 : if( isPresentationShape() )
1536 : {
1537 : // check if the current document supports presentation shapes
1538 22 : if( GetImport().GetShapeImport()->IsPresentationShapesSupported() )
1539 : {
1540 22 : if( IsXMLToken( maPresentationClass, XML_PRESENTATION_SUBTITLE ))
1541 : {
1542 : // XmlShapeTypePresSubtitleShape
1543 0 : pService = "com.sun.star.presentation.SubtitleShape";
1544 : }
1545 22 : else if( IsXMLToken( maPresentationClass, XML_PRESENTATION_OUTLINE ) )
1546 : {
1547 : // XmlShapeTypePresOutlinerShape
1548 1 : pService = "com.sun.star.presentation.OutlinerShape";
1549 : }
1550 21 : else if( IsXMLToken( maPresentationClass, XML_PRESENTATION_NOTES ) )
1551 : {
1552 : // XmlShapeTypePresNotesShape
1553 9 : pService = "com.sun.star.presentation.NotesShape";
1554 : }
1555 12 : else if( IsXMLToken( maPresentationClass, XML_HEADER ) )
1556 : {
1557 : // XmlShapeTypePresHeaderShape
1558 2 : pService = "com.sun.star.presentation.HeaderShape";
1559 2 : bClearText = true;
1560 : }
1561 10 : else if( IsXMLToken( maPresentationClass, XML_FOOTER ) )
1562 : {
1563 : // XmlShapeTypePresFooterShape
1564 3 : pService = "com.sun.star.presentation.FooterShape";
1565 3 : bClearText = true;
1566 : }
1567 7 : else if( IsXMLToken( maPresentationClass, XML_PAGE_NUMBER ) )
1568 : {
1569 : // XmlShapeTypePresSlideNumberShape
1570 3 : pService = "com.sun.star.presentation.SlideNumberShape";
1571 3 : bClearText = true;
1572 : }
1573 4 : else if( IsXMLToken( maPresentationClass, XML_DATE_TIME ) )
1574 : {
1575 : // XmlShapeTypePresDateTimeShape
1576 3 : pService = "com.sun.star.presentation.DateTimeShape";
1577 3 : bClearText = true;
1578 : }
1579 : else // IsXMLToken( maPresentationClass, XML_PRESENTATION_TITLE ) )
1580 : {
1581 : // XmlShapeTypePresTitleTextShape
1582 1 : pService = "com.sun.star.presentation.TitleTextShape";
1583 : }
1584 22 : bIsPresShape = sal_True;
1585 : }
1586 : }
1587 :
1588 27 : if( NULL == pService )
1589 : {
1590 : // normal text shape
1591 5 : pService = "com.sun.star.drawing.TextShape";
1592 : }
1593 :
1594 : // Add, set Style and properties from base shape
1595 27 : AddShape(pService);
1596 :
1597 27 : if( mxShape.is() )
1598 : {
1599 27 : SetStyle();
1600 27 : SetLayer();
1601 :
1602 27 : if(bIsPresShape)
1603 : {
1604 22 : uno::Reference< beans::XPropertySet > xProps(mxShape, uno::UNO_QUERY);
1605 22 : if(xProps.is())
1606 : {
1607 22 : uno::Reference< beans::XPropertySetInfo > xPropsInfo( xProps->getPropertySetInfo() );
1608 22 : if( xPropsInfo.is() )
1609 : {
1610 22 : if( !mbIsPlaceholder && xPropsInfo->hasPropertyByName(OUString("IsEmptyPresentationObject" )))
1611 11 : xProps->setPropertyValue( OUString("IsEmptyPresentationObject" ), ::cppu::bool2any( sal_False ) );
1612 :
1613 22 : if( mbIsUserTransformed && xPropsInfo->hasPropertyByName(OUString("IsPlaceholderDependent" )))
1614 0 : xProps->setPropertyValue( OUString("IsPlaceholderDependent" ), ::cppu::bool2any( sal_False ) );
1615 22 : }
1616 22 : }
1617 : }
1618 :
1619 27 : if( bClearText )
1620 : {
1621 11 : uno::Reference< text::XText > xText( mxShape, uno::UNO_QUERY );
1622 11 : OUString aEmpty;
1623 11 : xText->setString( aEmpty );
1624 : }
1625 :
1626 : // set parameters on shape
1627 : //A AW->CL: Eventually You need to strip scale and translate from the transformation
1628 : //A to reach the same goal again.
1629 : //A if(!bIsPresShape || mbIsUserTransformed)
1630 : //A {
1631 : //A // set pos and size on shape, this should remove binding
1632 : //A // to pres object on masterpage
1633 : //A SetSizeAndPosition();
1634 : //A }
1635 :
1636 : // set pos, size, shear and rotate
1637 27 : SetTransformation();
1638 :
1639 27 : if(mnRadius)
1640 : {
1641 0 : uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY);
1642 0 : if(xPropSet.is())
1643 : {
1644 : try
1645 : {
1646 0 : xPropSet->setPropertyValue(OUString("CornerRadius"), uno::makeAny( mnRadius ) );
1647 : }
1648 0 : catch(const uno::Exception&)
1649 : {
1650 : OSL_FAIL( "exception during setting of corner radius!");
1651 : }
1652 0 : }
1653 : }
1654 :
1655 27 : SdXMLShapeContext::StartElement(mxAttrList);
1656 : }
1657 27 : }
1658 :
1659 : ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1660 : ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1661 :
1662 0 : TYPEINIT1( SdXMLControlShapeContext, SdXMLShapeContext );
1663 :
1664 0 : SdXMLControlShapeContext::SdXMLControlShapeContext(
1665 : SvXMLImport& rImport,
1666 : sal_uInt16 nPrfx,
1667 : const OUString& rLocalName,
1668 : const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList,
1669 : uno::Reference< drawing::XShapes >& rShapes,
1670 : sal_Bool bTemporaryShape)
1671 0 : : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape )
1672 : {
1673 0 : }
1674 :
1675 : //////////////////////////////////////////////////////////////////////////////
1676 :
1677 0 : SdXMLControlShapeContext::~SdXMLControlShapeContext()
1678 : {
1679 0 : }
1680 :
1681 : //////////////////////////////////////////////////////////////////////////////
1682 :
1683 : // this is called from the parent group for each unparsed attribute in the attribute list
1684 0 : void SdXMLControlShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue )
1685 : {
1686 0 : if( XML_NAMESPACE_DRAW == nPrefix )
1687 : {
1688 0 : if( IsXMLToken( rLocalName, XML_CONTROL ) )
1689 : {
1690 0 : maFormId = rValue;
1691 0 : return;
1692 : }
1693 : }
1694 :
1695 0 : SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue );
1696 : }
1697 :
1698 0 : void SdXMLControlShapeContext::StartElement(const uno::Reference< xml::sax::XAttributeList>& xAttrList)
1699 : {
1700 : // create Control shape
1701 : // add, set style and properties from base shape
1702 0 : AddShape("com.sun.star.drawing.ControlShape");
1703 0 : if( mxShape.is() )
1704 : {
1705 : DBG_ASSERT( !maFormId.isEmpty(), "draw:control without a form:id attribute!" );
1706 0 : if( !maFormId.isEmpty() )
1707 : {
1708 0 : if( GetImport().IsFormsSupported() )
1709 : {
1710 0 : uno::Reference< awt::XControlModel > xControlModel( GetImport().GetFormImport()->lookupControl( maFormId ), uno::UNO_QUERY );
1711 0 : if( xControlModel.is() )
1712 : {
1713 0 : uno::Reference< drawing::XControlShape > xControl( mxShape, uno::UNO_QUERY );
1714 0 : if( xControl.is() )
1715 0 : xControl->setControl( xControlModel );
1716 :
1717 0 : }
1718 : }
1719 : }
1720 :
1721 0 : SetStyle();
1722 0 : SetLayer();
1723 :
1724 : // set pos, size, shear and rotate
1725 0 : SetTransformation();
1726 :
1727 0 : SdXMLShapeContext::StartElement(xAttrList);
1728 : }
1729 0 : }
1730 :
1731 : ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1732 : ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1733 :
1734 0 : TYPEINIT1( SdXMLConnectorShapeContext, SdXMLShapeContext );
1735 :
1736 0 : SdXMLConnectorShapeContext::SdXMLConnectorShapeContext(
1737 : SvXMLImport& rImport,
1738 : sal_uInt16 nPrfx,
1739 : const OUString& rLocalName,
1740 : const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList,
1741 : uno::Reference< drawing::XShapes >& rShapes,
1742 : sal_Bool bTemporaryShape)
1743 : : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape ),
1744 : maStart(0,0),
1745 : maEnd(1,1),
1746 : mnType( (sal_uInt16)drawing::ConnectorType_STANDARD ),
1747 : mnStartGlueId(-1),
1748 : mnEndGlueId(-1),
1749 : mnDelta1(0),
1750 : mnDelta2(0),
1751 0 : mnDelta3(0)
1752 : {
1753 0 : }
1754 :
1755 : //////////////////////////////////////////////////////////////////////////////
1756 :
1757 0 : SdXMLConnectorShapeContext::~SdXMLConnectorShapeContext()
1758 : {
1759 0 : }
1760 :
1761 : //////////////////////////////////////////////////////////////////////////////
1762 :
1763 : // this is called from the parent group for each unparsed attribute in the attribute list
1764 0 : void SdXMLConnectorShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue )
1765 : {
1766 0 : switch( nPrefix )
1767 : {
1768 : case XML_NAMESPACE_DRAW:
1769 : {
1770 0 : if( IsXMLToken( rLocalName, XML_START_SHAPE ) )
1771 : {
1772 0 : maStartShapeId = rValue;
1773 0 : return;
1774 : }
1775 0 : if( IsXMLToken( rLocalName, XML_START_GLUE_POINT ) )
1776 : {
1777 0 : mnStartGlueId = rValue.toInt32();
1778 0 : return;
1779 : }
1780 0 : if( IsXMLToken( rLocalName, XML_END_SHAPE ) )
1781 : {
1782 0 : maEndShapeId = rValue;
1783 0 : return;
1784 : }
1785 0 : if( IsXMLToken( rLocalName, XML_END_GLUE_POINT ) )
1786 : {
1787 0 : mnEndGlueId = rValue.toInt32();
1788 0 : return;
1789 : }
1790 0 : if( IsXMLToken( rLocalName, XML_LINE_SKEW ) )
1791 : {
1792 0 : SvXMLTokenEnumerator aTokenEnum( rValue );
1793 0 : OUString aToken;
1794 0 : if( aTokenEnum.getNextToken( aToken ) )
1795 : {
1796 0 : GetImport().GetMM100UnitConverter().convertMeasureToCore(
1797 0 : mnDelta1, aToken);
1798 0 : if( aTokenEnum.getNextToken( aToken ) )
1799 : {
1800 0 : GetImport().GetMM100UnitConverter().convertMeasureToCore(
1801 0 : mnDelta2, aToken);
1802 0 : if( aTokenEnum.getNextToken( aToken ) )
1803 : {
1804 0 : GetImport().GetMM100UnitConverter().convertMeasureToCore(
1805 0 : mnDelta3, aToken);
1806 : }
1807 : }
1808 : }
1809 0 : return;
1810 : }
1811 0 : if( IsXMLToken( rLocalName, XML_TYPE ) )
1812 : {
1813 0 : SvXMLUnitConverter::convertEnum( mnType, rValue, aXML_ConnectionKind_EnumMap );
1814 0 : return;
1815 : }
1816 : }
1817 : case XML_NAMESPACE_SVG:
1818 : {
1819 0 : if( IsXMLToken( rLocalName, XML_X1 ) )
1820 : {
1821 0 : GetImport().GetMM100UnitConverter().convertMeasureToCore(
1822 0 : maStart.X, rValue);
1823 0 : return;
1824 : }
1825 0 : if( IsXMLToken( rLocalName, XML_Y1 ) )
1826 : {
1827 0 : GetImport().GetMM100UnitConverter().convertMeasureToCore(
1828 0 : maStart.Y, rValue);
1829 0 : return;
1830 : }
1831 0 : if( IsXMLToken( rLocalName, XML_X2 ) )
1832 : {
1833 0 : GetImport().GetMM100UnitConverter().convertMeasureToCore(
1834 0 : maEnd.X, rValue);
1835 0 : return;
1836 : }
1837 0 : if( IsXMLToken( rLocalName, XML_Y2 ) )
1838 : {
1839 0 : GetImport().GetMM100UnitConverter().convertMeasureToCore(
1840 0 : maEnd.Y, rValue);
1841 0 : return;
1842 : }
1843 0 : if( IsXMLToken( rLocalName, XML_D ) )
1844 : {
1845 0 : SdXMLImExViewBox aViewBox( 0, 0, 1, 1 );
1846 0 : awt::Point aPoint( 0, 0 );
1847 0 : awt::Size aSize( 1, 1 );
1848 :
1849 0 : SdXMLImExSvgDElement aPoints( rValue, aViewBox, aPoint, aSize, GetImport() );
1850 :
1851 0 : if ( aPoints.IsCurve() )
1852 : {
1853 : drawing::PolyPolygonBezierCoords aSourcePolyPolygon(
1854 0 : aPoints.GetPointSequenceSequence(),
1855 0 : aPoints.GetFlagSequenceSequence());
1856 0 : maPath <<= aSourcePolyPolygon;
1857 : }
1858 : else
1859 : {
1860 0 : const drawing::PointSequenceSequence& rOuterSeq = aPoints.GetPointSequenceSequence();
1861 0 : drawing::FlagSequenceSequence aFlagSeqSeq( rOuterSeq.getLength() );
1862 0 : for ( int a = 0; a < rOuterSeq.getLength(); a++ )
1863 0 : aFlagSeqSeq[ a ] = drawing::FlagSequence( rOuterSeq[ a ].getLength() );
1864 :
1865 : drawing::PolyPolygonBezierCoords aSourcePolyPolygon(
1866 0 : aPoints.GetPointSequenceSequence(),
1867 0 : aFlagSeqSeq );
1868 0 : maPath <<= aSourcePolyPolygon;
1869 0 : }
1870 : }
1871 : }
1872 : }
1873 :
1874 0 : SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue );
1875 : }
1876 :
1877 : //////////////////////////////////////////////////////////////////////////////
1878 :
1879 0 : void SdXMLConnectorShapeContext::StartElement(const uno::Reference< xml::sax::XAttributeList>& xAttrList)
1880 : {
1881 : // #107928#
1882 : // For security reasons, do not add empty connectors. There may have been an error in EA2
1883 : // that created empty, far set off connectors (e.g. 63 meters below top of document). This
1884 : // is not guaranteed, but it's definitely safe to not add empty connectors.
1885 0 : sal_Bool bDoAdd(sal_True);
1886 :
1887 0 : if( maStartShapeId.isEmpty()
1888 0 : && maEndShapeId.isEmpty()
1889 : && maStart.X == maEnd.X
1890 : && maStart.Y == maEnd.Y
1891 : && 0 == mnDelta1
1892 : && 0 == mnDelta2
1893 : && 0 == mnDelta3
1894 : )
1895 : {
1896 0 : bDoAdd = sal_False;
1897 : }
1898 :
1899 0 : if(bDoAdd)
1900 : {
1901 : // create Connector shape
1902 : // add, set style and properties from base shape
1903 0 : AddShape("com.sun.star.drawing.ConnectorShape");
1904 0 : if(mxShape.is())
1905 : {
1906 : // add connection ids
1907 0 : if( !maStartShapeId.isEmpty() )
1908 0 : GetImport().GetShapeImport()->addShapeConnection( mxShape, sal_True, maStartShapeId, mnStartGlueId );
1909 0 : if( !maEndShapeId.isEmpty() )
1910 0 : GetImport().GetShapeImport()->addShapeConnection( mxShape, sal_False, maEndShapeId, mnEndGlueId );
1911 :
1912 0 : uno::Reference< beans::XPropertySet > xProps( mxShape, uno::UNO_QUERY );
1913 0 : if( xProps.is() )
1914 : {
1915 0 : uno::Any aAny;
1916 0 : aAny <<= maStart;
1917 0 : xProps->setPropertyValue(OUString("StartPosition"), aAny);
1918 :
1919 0 : aAny <<= maEnd;
1920 0 : xProps->setPropertyValue(OUString("EndPosition"), aAny );
1921 :
1922 0 : aAny <<= (drawing::ConnectorType)mnType;
1923 0 : xProps->setPropertyValue(OUString("EdgeKind"), aAny );
1924 :
1925 0 : aAny <<= mnDelta1;
1926 0 : xProps->setPropertyValue(OUString("EdgeLine1Delta"), aAny );
1927 :
1928 0 : aAny <<= mnDelta2;
1929 0 : xProps->setPropertyValue(OUString("EdgeLine2Delta"), aAny );
1930 :
1931 0 : aAny <<= mnDelta3;
1932 0 : xProps->setPropertyValue(OUString("EdgeLine3Delta"), aAny );
1933 : }
1934 0 : SetStyle();
1935 0 : SetLayer();
1936 :
1937 0 : if ( maPath.hasValue() )
1938 : {
1939 : // #i115492#
1940 : // Ignore svg:d attribute for text documents created by OpenOffice.org
1941 : // versions before OOo 3.3, because these OOo versions are storing
1942 : // svg:d values not using the correct unit.
1943 0 : bool bApplySVGD( true );
1944 0 : if ( uno::Reference< text::XTextDocument >(GetImport().GetModel(), uno::UNO_QUERY).is() )
1945 : {
1946 0 : sal_Int32 nUPD( 0 );
1947 0 : sal_Int32 nBuild( 0 );
1948 0 : const bool bBuildIdFound = GetImport().getBuildIds( nUPD, nBuild );
1949 0 : if ( GetImport().IsTextDocInOOoFileFormat() ||
1950 : ( bBuildIdFound &&
1951 : ( ( nUPD == 641 ) || ( nUPD == 645 ) || // prior OOo 2.0
1952 : ( nUPD == 680 ) || // OOo 2.x
1953 : ( nUPD == 300 ) || // OOo 3.0 - OOo 3.0.1
1954 : ( nUPD == 310 ) || // OOo 3.1 - OOo 3.1.1
1955 : ( nUPD == 320 ) ) ) ) // OOo 3.2 - OOo 3.2.1
1956 : {
1957 0 : bApplySVGD = false;
1958 : }
1959 : }
1960 :
1961 0 : if ( bApplySVGD )
1962 : {
1963 0 : xProps->setPropertyValue( OUString("PolyPolygonBezier" ), maPath );
1964 : }
1965 : }
1966 :
1967 0 : SdXMLShapeContext::StartElement(xAttrList);
1968 : }
1969 : }
1970 0 : }
1971 :
1972 : ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1973 : ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1974 :
1975 0 : TYPEINIT1( SdXMLMeasureShapeContext, SdXMLShapeContext );
1976 :
1977 0 : SdXMLMeasureShapeContext::SdXMLMeasureShapeContext(
1978 : SvXMLImport& rImport,
1979 : sal_uInt16 nPrfx,
1980 : const OUString& rLocalName,
1981 : const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList,
1982 : uno::Reference< drawing::XShapes >& rShapes,
1983 : sal_Bool bTemporaryShape)
1984 : : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape ),
1985 : maStart(0,0),
1986 0 : maEnd(1,1)
1987 : {
1988 0 : }
1989 :
1990 : //////////////////////////////////////////////////////////////////////////////
1991 :
1992 0 : SdXMLMeasureShapeContext::~SdXMLMeasureShapeContext()
1993 : {
1994 0 : }
1995 :
1996 : // this is called from the parent group for each unparsed attribute in the attribute list
1997 0 : void SdXMLMeasureShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue )
1998 : {
1999 0 : switch( nPrefix )
2000 : {
2001 : case XML_NAMESPACE_SVG:
2002 : {
2003 0 : if( IsXMLToken( rLocalName, XML_X1 ) )
2004 : {
2005 0 : GetImport().GetMM100UnitConverter().convertMeasureToCore(
2006 0 : maStart.X, rValue);
2007 0 : return;
2008 : }
2009 0 : if( IsXMLToken( rLocalName, XML_Y1 ) )
2010 : {
2011 0 : GetImport().GetMM100UnitConverter().convertMeasureToCore(
2012 0 : maStart.Y, rValue);
2013 0 : return;
2014 : }
2015 0 : if( IsXMLToken( rLocalName, XML_X2 ) )
2016 : {
2017 0 : GetImport().GetMM100UnitConverter().convertMeasureToCore(
2018 0 : maEnd.X, rValue);
2019 0 : return;
2020 : }
2021 0 : if( IsXMLToken( rLocalName, XML_Y2 ) )
2022 : {
2023 0 : GetImport().GetMM100UnitConverter().convertMeasureToCore(
2024 0 : maEnd.Y, rValue);
2025 0 : return;
2026 : }
2027 : }
2028 : }
2029 :
2030 0 : SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue );
2031 : }
2032 :
2033 : //////////////////////////////////////////////////////////////////////////////
2034 :
2035 0 : void SdXMLMeasureShapeContext::StartElement(const uno::Reference< xml::sax::XAttributeList>& xAttrList)
2036 : {
2037 : // create Measure shape
2038 : // add, set style and properties from base shape
2039 0 : AddShape("com.sun.star.drawing.MeasureShape");
2040 0 : if(mxShape.is())
2041 : {
2042 0 : SetStyle();
2043 0 : SetLayer();
2044 :
2045 0 : uno::Reference< beans::XPropertySet > xProps( mxShape, uno::UNO_QUERY );
2046 0 : if( xProps.is() )
2047 : {
2048 0 : uno::Any aAny;
2049 0 : aAny <<= maStart;
2050 0 : xProps->setPropertyValue(OUString("StartPosition"), aAny);
2051 :
2052 0 : aAny <<= maEnd;
2053 0 : xProps->setPropertyValue(OUString("EndPosition"), aAny );
2054 : }
2055 :
2056 : // delete pre created fields
2057 0 : uno::Reference< text::XText > xText( mxShape, uno::UNO_QUERY );
2058 0 : if( xText.is() )
2059 : {
2060 0 : const OUString aEmpty( " " );
2061 0 : xText->setString( aEmpty );
2062 : }
2063 :
2064 0 : SdXMLShapeContext::StartElement(xAttrList);
2065 : }
2066 0 : }
2067 :
2068 0 : void SdXMLMeasureShapeContext::EndElement()
2069 : {
2070 : do
2071 : {
2072 : // delete pre created fields
2073 0 : uno::Reference< text::XText > xText( mxShape, uno::UNO_QUERY );
2074 0 : if( !xText.is() )
2075 : break;
2076 :
2077 0 : uno::Reference< text::XTextCursor > xCursor( xText->createTextCursor() );
2078 0 : if( !xCursor.is() )
2079 : break;
2080 :
2081 0 : const OUString aEmpty;
2082 0 : xCursor->collapseToStart();
2083 0 : xCursor->goRight( 1, sal_True );
2084 0 : xCursor->setString( aEmpty );
2085 : }
2086 : while(0);
2087 :
2088 0 : SdXMLShapeContext::EndElement();
2089 0 : }
2090 :
2091 : ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2092 : ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2093 :
2094 0 : TYPEINIT1( SdXMLPageShapeContext, SdXMLShapeContext );
2095 :
2096 15 : SdXMLPageShapeContext::SdXMLPageShapeContext(
2097 : SvXMLImport& rImport,
2098 : sal_uInt16 nPrfx,
2099 : const OUString& rLocalName,
2100 : const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList,
2101 : uno::Reference< drawing::XShapes >& rShapes,
2102 : sal_Bool bTemporaryShape)
2103 15 : : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape ), mnPageNumber(0)
2104 : {
2105 15 : mbClearDefaultAttributes = false;
2106 15 : }
2107 :
2108 : //////////////////////////////////////////////////////////////////////////////
2109 :
2110 30 : SdXMLPageShapeContext::~SdXMLPageShapeContext()
2111 : {
2112 30 : }
2113 :
2114 : //////////////////////////////////////////////////////////////////////////////
2115 :
2116 : // this is called from the parent group for each unparsed attribute in the attribute list
2117 101 : void SdXMLPageShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue )
2118 : {
2119 101 : if( XML_NAMESPACE_DRAW == nPrefix )
2120 : {
2121 31 : if( IsXMLToken( rLocalName, XML_PAGE_NUMBER ) )
2122 : {
2123 8 : mnPageNumber = rValue.toInt32();
2124 109 : return;
2125 : }
2126 : }
2127 :
2128 93 : SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue );
2129 : }
2130 :
2131 : //////////////////////////////////////////////////////////////////////////////
2132 :
2133 15 : void SdXMLPageShapeContext::StartElement(const uno::Reference< xml::sax::XAttributeList>& xAttrList)
2134 : {
2135 : // create Page shape
2136 : // add, set style and properties from base shape
2137 :
2138 : // #86163# take into account which type of PageShape needs to
2139 : // be constructed. It's an pres shape if presentation:XML_CLASS == XML_PRESENTATION_PAGE.
2140 15 : sal_Bool bIsPresentation = !maPresentationClass.isEmpty() &&
2141 30 : GetImport().GetShapeImport()->IsPresentationShapesSupported();
2142 :
2143 15 : uno::Reference< lang::XServiceInfo > xInfo( mxShapes, uno::UNO_QUERY );
2144 15 : const sal_Bool bIsOnHandoutPage = xInfo.is() && xInfo->supportsService( OUString( "com.sun.star.presentation.HandoutMasterPage") );
2145 :
2146 15 : if( bIsOnHandoutPage )
2147 : {
2148 6 : AddShape("com.sun.star.presentation.HandoutShape");
2149 : }
2150 : else
2151 : {
2152 9 : if(bIsPresentation && !IsXMLToken( maPresentationClass, XML_PRESENTATION_PAGE ) )
2153 : {
2154 0 : bIsPresentation = sal_False;
2155 : }
2156 :
2157 9 : if(bIsPresentation)
2158 : {
2159 9 : AddShape("com.sun.star.presentation.PageShape");
2160 : }
2161 : else
2162 : {
2163 0 : AddShape("com.sun.star.drawing.PageShape");
2164 : }
2165 : }
2166 :
2167 15 : if(mxShape.is())
2168 : {
2169 15 : SetStyle();
2170 15 : SetLayer();
2171 :
2172 : // set pos, size, shear and rotate
2173 15 : SetTransformation();
2174 :
2175 15 : uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY);
2176 15 : if(xPropSet.is())
2177 : {
2178 15 : uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() );
2179 15 : const OUString aPageNumberStr("PageNumber");
2180 15 : if( xPropSetInfo.is() && xPropSetInfo->hasPropertyByName(aPageNumberStr))
2181 15 : xPropSet->setPropertyValue(aPageNumberStr, uno::makeAny( mnPageNumber ));
2182 : }
2183 :
2184 15 : SdXMLShapeContext::StartElement(xAttrList);
2185 15 : }
2186 15 : }
2187 :
2188 : ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2189 : ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2190 :
2191 0 : TYPEINIT1( SdXMLCaptionShapeContext, SdXMLShapeContext );
2192 :
2193 1 : SdXMLCaptionShapeContext::SdXMLCaptionShapeContext(
2194 : SvXMLImport& rImport,
2195 : sal_uInt16 nPrfx,
2196 : const OUString& rLocalName,
2197 : const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList,
2198 : uno::Reference< drawing::XShapes >& rShapes,
2199 : sal_Bool bTemporaryShape)
2200 : : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape ),
2201 : // #86616# for correct edge rounding import mnRadius needs to be initialized
2202 1 : mnRadius( 0L )
2203 : {
2204 1 : }
2205 :
2206 : //////////////////////////////////////////////////////////////////////////////
2207 :
2208 2 : SdXMLCaptionShapeContext::~SdXMLCaptionShapeContext()
2209 : {
2210 2 : }
2211 :
2212 : //////////////////////////////////////////////////////////////////////////////
2213 :
2214 1 : void SdXMLCaptionShapeContext::StartElement(const uno::Reference< xml::sax::XAttributeList>& xAttrList)
2215 : {
2216 : // create Caption shape
2217 : // add, set style and properties from base shape
2218 1 : AddShape("com.sun.star.drawing.CaptionShape");
2219 1 : if( mxShape.is() )
2220 : {
2221 1 : SetStyle();
2222 1 : SetLayer();
2223 :
2224 1 : uno::Reference< beans::XPropertySet > xProps( mxShape, uno::UNO_QUERY );
2225 :
2226 : // SJ: If AutoGrowWidthItem is set, SetTransformation will lead to the wrong SnapRect
2227 : // because NbcAdjustTextFrameWidthAndHeight() is called (text is set later and center alignment
2228 : // is the default setting, so the top left reference point that is used by the caption point is
2229 : // no longer correct) There are two ways to solve this problem, temporarily disabling the
2230 : // autogrowwith as we are doing here or to apply the CaptionPoint after setting text
2231 1 : sal_Bool bIsAutoGrowWidth = sal_False;
2232 1 : if ( xProps.is() )
2233 : {
2234 1 : uno::Any aAny( xProps->getPropertyValue( OUString("TextAutoGrowWidth" ) ) );
2235 1 : aAny >>= bIsAutoGrowWidth;
2236 :
2237 1 : if ( bIsAutoGrowWidth )
2238 0 : xProps->setPropertyValue( OUString("TextAutoGrowWidth"), uno::makeAny( sal_False ) );
2239 : }
2240 :
2241 : // set pos, size, shear and rotate
2242 1 : SetTransformation();
2243 1 : if( xProps.is() )
2244 1 : xProps->setPropertyValue(OUString("CaptionPoint"), uno::makeAny( maCaptionPoint ) );
2245 :
2246 1 : if ( bIsAutoGrowWidth )
2247 0 : xProps->setPropertyValue( OUString("TextAutoGrowWidth"), uno::makeAny( sal_True ) );
2248 :
2249 1 : if(mnRadius)
2250 : {
2251 0 : uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY);
2252 0 : if(xPropSet.is())
2253 : {
2254 : try
2255 : {
2256 0 : xPropSet->setPropertyValue(OUString("CornerRadius"), uno::makeAny( mnRadius ) );
2257 : }
2258 0 : catch(const uno::Exception&)
2259 : {
2260 : OSL_FAIL( "exception during setting of corner radius!");
2261 : }
2262 0 : }
2263 : }
2264 :
2265 1 : SdXMLShapeContext::StartElement(xAttrList);
2266 : }
2267 1 : }
2268 :
2269 : // this is called from the parent group for each unparsed attribute in the attribute list
2270 8 : void SdXMLCaptionShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue )
2271 : {
2272 8 : if( XML_NAMESPACE_DRAW == nPrefix )
2273 : {
2274 4 : if( IsXMLToken( rLocalName, XML_CAPTION_POINT_X ) )
2275 : {
2276 1 : GetImport().GetMM100UnitConverter().convertMeasureToCore(
2277 2 : maCaptionPoint.X, rValue);
2278 1 : return;
2279 : }
2280 3 : if( IsXMLToken( rLocalName, XML_CAPTION_POINT_Y ) )
2281 : {
2282 1 : GetImport().GetMM100UnitConverter().convertMeasureToCore(
2283 2 : maCaptionPoint.Y, rValue);
2284 1 : return;
2285 : }
2286 2 : if( IsXMLToken( rLocalName, XML_CORNER_RADIUS ) )
2287 : {
2288 0 : GetImport().GetMM100UnitConverter().convertMeasureToCore(
2289 0 : mnRadius, rValue);
2290 0 : return;
2291 : }
2292 : }
2293 6 : SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue );
2294 : }
2295 :
2296 : ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2297 : ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2298 :
2299 0 : TYPEINIT1( SdXMLGraphicObjectShapeContext, SdXMLShapeContext );
2300 :
2301 3 : SdXMLGraphicObjectShapeContext::SdXMLGraphicObjectShapeContext(
2302 : SvXMLImport& rImport,
2303 : sal_uInt16 nPrfx,
2304 : const OUString& rLocalName,
2305 : const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList,
2306 : uno::Reference< drawing::XShapes >& rShapes,
2307 : sal_Bool bTemporaryShape)
2308 : : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape ),
2309 3 : maURL()
2310 : {
2311 3 : }
2312 :
2313 : //////////////////////////////////////////////////////////////////////////////
2314 :
2315 : // this is called from the parent group for each unparsed attribute in the attribute list
2316 34 : void SdXMLGraphicObjectShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue )
2317 : {
2318 34 : if( XML_NAMESPACE_XLINK == nPrefix )
2319 : {
2320 12 : if( IsXMLToken( rLocalName, XML_HREF ) )
2321 : {
2322 3 : maURL = rValue;
2323 37 : return;
2324 : }
2325 : }
2326 :
2327 31 : SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue );
2328 : }
2329 :
2330 : //////////////////////////////////////////////////////////////////////////////
2331 :
2332 3 : void SdXMLGraphicObjectShapeContext::StartElement( const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList >& )
2333 : {
2334 : // create graphic object shape
2335 : const char *pService;
2336 :
2337 3 : if( IsXMLToken( maPresentationClass, XML_GRAPHIC ) && GetImport().GetShapeImport()->IsPresentationShapesSupported() )
2338 : {
2339 1 : pService = "com.sun.star.presentation.GraphicObjectShape";
2340 : }
2341 : else
2342 : {
2343 2 : pService = "com.sun.star.drawing.GraphicObjectShape";
2344 : }
2345 :
2346 3 : AddShape( pService );
2347 :
2348 3 : if(mxShape.is())
2349 : {
2350 3 : SetStyle();
2351 3 : SetLayer();
2352 :
2353 3 : uno::Reference< beans::XPropertySet > xPropset(mxShape, uno::UNO_QUERY);
2354 3 : if(xPropset.is())
2355 : {
2356 : // since OOo 1.x had no line or fill style for graphics, but may create
2357 : // documents with them, we have to override them here
2358 : sal_Int32 nUPD, nBuildId;
2359 3 : if( GetImport().getBuildIds( nUPD, nBuildId ) && (nUPD == 645) ) try
2360 : {
2361 0 : xPropset->setPropertyValue( OUString("FillStyle"), Any( FillStyle_NONE ) );
2362 0 : xPropset->setPropertyValue( OUString("LineStyle"), Any( LineStyle_NONE ) );
2363 : }
2364 0 : catch(const Exception&)
2365 : {
2366 : }
2367 :
2368 3 : uno::Reference< beans::XPropertySetInfo > xPropsInfo( xPropset->getPropertySetInfo() );
2369 3 : if( xPropsInfo.is() && xPropsInfo->hasPropertyByName(OUString("IsEmptyPresentationObject" )))
2370 3 : xPropset->setPropertyValue( OUString("IsEmptyPresentationObject" ), ::cppu::bool2any( mbIsPlaceholder ) );
2371 :
2372 3 : if( !mbIsPlaceholder )
2373 : {
2374 3 : if( !maURL.isEmpty() )
2375 : {
2376 3 : uno::Any aAny;
2377 3 : aAny <<= GetImport().ResolveGraphicObjectURL( maURL, GetImport().isGraphicLoadOnDemandSupported() );
2378 : try
2379 : {
2380 3 : xPropset->setPropertyValue( OUString("GraphicURL" ), aAny );
2381 3 : xPropset->setPropertyValue( OUString("GraphicStreamURL" ), aAny );
2382 : }
2383 0 : catch (const lang::IllegalArgumentException&)
2384 : {
2385 3 : }
2386 : }
2387 3 : }
2388 : }
2389 :
2390 3 : if(mbIsUserTransformed)
2391 : {
2392 1 : uno::Reference< beans::XPropertySet > xProps(mxShape, uno::UNO_QUERY);
2393 1 : if(xProps.is())
2394 : {
2395 1 : uno::Reference< beans::XPropertySetInfo > xPropsInfo( xProps->getPropertySetInfo() );
2396 1 : if( xPropsInfo.is() )
2397 : {
2398 1 : if( xPropsInfo->hasPropertyByName(OUString("IsPlaceholderDependent" )))
2399 1 : xProps->setPropertyValue( OUString("IsPlaceholderDependent" ), ::cppu::bool2any( sal_False ) );
2400 1 : }
2401 1 : }
2402 : }
2403 :
2404 : // set pos, size, shear and rotate
2405 3 : SetTransformation();
2406 :
2407 3 : SdXMLShapeContext::StartElement(mxAttrList);
2408 : }
2409 3 : }
2410 :
2411 3 : void SdXMLGraphicObjectShapeContext::EndElement()
2412 : {
2413 3 : if( mxBase64Stream.is() )
2414 : {
2415 0 : OUString sURL( GetImport().ResolveGraphicObjectURLFromBase64( mxBase64Stream ) );
2416 0 : if( !sURL.isEmpty() )
2417 : {
2418 : try
2419 : {
2420 0 : uno::Reference< beans::XPropertySet > xProps(mxShape, uno::UNO_QUERY);
2421 0 : if(xProps.is())
2422 : {
2423 0 : const uno::Any aAny( uno::makeAny( sURL ) );
2424 0 : xProps->setPropertyValue( OUString("GraphicURL" ), aAny );
2425 0 : xProps->setPropertyValue( OUString("GraphicStreamURL" ), aAny );
2426 0 : }
2427 : }
2428 0 : catch (const lang::IllegalArgumentException&)
2429 : {
2430 : }
2431 0 : }
2432 : }
2433 :
2434 3 : SdXMLShapeContext::EndElement();
2435 3 : }
2436 :
2437 :
2438 : //////////////////////////////////////////////////////////////////////////////
2439 :
2440 3 : SvXMLImportContext* SdXMLGraphicObjectShapeContext::CreateChildContext(
2441 : sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName,
2442 : const uno::Reference<xml::sax::XAttributeList>& xAttrList )
2443 : {
2444 3 : SvXMLImportContext* pContext = NULL;
2445 :
2446 3 : if( (XML_NAMESPACE_OFFICE == nPrefix) &&
2447 0 : xmloff::token::IsXMLToken( rLocalName, xmloff::token::XML_BINARY_DATA ) )
2448 : {
2449 0 : if( maURL.isEmpty() && !mxBase64Stream.is() )
2450 : {
2451 0 : mxBase64Stream = GetImport().GetStreamForGraphicObjectURLFromBase64();
2452 0 : if( mxBase64Stream.is() )
2453 0 : pContext = new XMLBase64ImportContext( GetImport(), nPrefix,
2454 : rLocalName, xAttrList,
2455 0 : mxBase64Stream );
2456 : }
2457 : }
2458 :
2459 : // delegate to parent class if no context could be created
2460 3 : if ( NULL == pContext )
2461 : pContext = SdXMLShapeContext::CreateChildContext(nPrefix, rLocalName,
2462 3 : xAttrList);
2463 :
2464 3 : return pContext;
2465 : }
2466 :
2467 : //////////////////////////////////////////////////////////////////////////////
2468 :
2469 6 : SdXMLGraphicObjectShapeContext::~SdXMLGraphicObjectShapeContext()
2470 : {
2471 :
2472 6 : }
2473 :
2474 : ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2475 : ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2476 :
2477 0 : TYPEINIT1( SdXMLChartShapeContext, SdXMLShapeContext );
2478 :
2479 0 : SdXMLChartShapeContext::SdXMLChartShapeContext(
2480 : SvXMLImport& rImport,
2481 : sal_uInt16 nPrfx,
2482 : const OUString& rLocalName,
2483 : const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList,
2484 : uno::Reference< drawing::XShapes >& rShapes,
2485 : sal_Bool bTemporaryShape)
2486 : : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape ),
2487 0 : mpChartContext( NULL )
2488 : {
2489 0 : }
2490 :
2491 : //////////////////////////////////////////////////////////////////////////////
2492 :
2493 0 : SdXMLChartShapeContext::~SdXMLChartShapeContext()
2494 : {
2495 0 : if( mpChartContext )
2496 0 : delete mpChartContext;
2497 0 : }
2498 :
2499 : //////////////////////////////////////////////////////////////////////////////
2500 :
2501 0 : void SdXMLChartShapeContext::StartElement(const uno::Reference< xml::sax::XAttributeList>& xAttrList)
2502 : {
2503 0 : const sal_Bool bIsPresentation = isPresentationShape();
2504 :
2505 0 : AddShape( bIsPresentation ? "com.sun.star.presentation.ChartShape" : "com.sun.star.drawing.OLE2Shape" );
2506 :
2507 0 : if(mxShape.is())
2508 : {
2509 0 : SetStyle();
2510 0 : SetLayer();
2511 :
2512 0 : if( !mbIsPlaceholder )
2513 : {
2514 0 : uno::Reference< beans::XPropertySet > xProps(mxShape, uno::UNO_QUERY);
2515 0 : if(xProps.is())
2516 : {
2517 0 : uno::Reference< beans::XPropertySetInfo > xPropsInfo( xProps->getPropertySetInfo() );
2518 0 : if( xPropsInfo.is() && xPropsInfo->hasPropertyByName(OUString("IsEmptyPresentationObject" )))
2519 0 : xProps->setPropertyValue( OUString("IsEmptyPresentationObject" ), ::cppu::bool2any( sal_False ) );
2520 :
2521 0 : uno::Any aAny;
2522 :
2523 0 : const OUString aCLSID( "12DCAE26-281F-416F-a234-c3086127382e");
2524 :
2525 0 : aAny <<= aCLSID;
2526 0 : xProps->setPropertyValue( OUString("CLSID" ), aAny );
2527 :
2528 0 : aAny = xProps->getPropertyValue( OUString("Model" ) );
2529 0 : uno::Reference< frame::XModel > xChartModel;
2530 0 : if( aAny >>= xChartModel )
2531 : {
2532 0 : mpChartContext = GetImport().GetChartImport()->CreateChartContext( GetImport(), XML_NAMESPACE_SVG, GetXMLToken(XML_CHART), xChartModel, xAttrList );
2533 0 : }
2534 0 : }
2535 : }
2536 :
2537 0 : if(mbIsUserTransformed)
2538 : {
2539 0 : uno::Reference< beans::XPropertySet > xProps(mxShape, uno::UNO_QUERY);
2540 0 : if(xProps.is())
2541 : {
2542 0 : uno::Reference< beans::XPropertySetInfo > xPropsInfo( xProps->getPropertySetInfo() );
2543 0 : if( xPropsInfo.is() )
2544 : {
2545 0 : if( xPropsInfo->hasPropertyByName(OUString("IsPlaceholderDependent" )))
2546 0 : xProps->setPropertyValue( OUString("IsPlaceholderDependent" ), ::cppu::bool2any( sal_False ) );
2547 0 : }
2548 0 : }
2549 : }
2550 :
2551 :
2552 : // set pos, size, shear and rotate
2553 0 : SetTransformation();
2554 :
2555 0 : SdXMLShapeContext::StartElement(xAttrList);
2556 :
2557 0 : if( mpChartContext )
2558 0 : mpChartContext->StartElement( xAttrList );
2559 : }
2560 0 : }
2561 :
2562 0 : void SdXMLChartShapeContext::EndElement()
2563 : {
2564 0 : if( mpChartContext )
2565 0 : mpChartContext->EndElement();
2566 :
2567 0 : SdXMLShapeContext::EndElement();
2568 0 : }
2569 :
2570 0 : void SdXMLChartShapeContext::Characters( const ::rtl::OUString& rChars )
2571 : {
2572 0 : if( mpChartContext )
2573 0 : mpChartContext->Characters( rChars );
2574 0 : }
2575 :
2576 0 : SvXMLImportContext * SdXMLChartShapeContext::CreateChildContext( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName,
2577 : const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList )
2578 : {
2579 0 : if( mpChartContext )
2580 0 : return mpChartContext->CreateChildContext( nPrefix, rLocalName, xAttrList );
2581 :
2582 0 : return NULL;
2583 : }
2584 :
2585 : //////////////////////////////////////////////////////////////////////////////
2586 :
2587 12 : TYPEINIT1( SdXMLObjectShapeContext, SdXMLShapeContext );
2588 :
2589 4 : SdXMLObjectShapeContext::SdXMLObjectShapeContext( SvXMLImport& rImport, sal_uInt16 nPrfx,
2590 : const rtl::OUString& rLocalName,
2591 : const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList,
2592 : com::sun::star::uno::Reference< com::sun::star::drawing::XShapes >& rShapes,
2593 : sal_Bool bTemporaryShape)
2594 4 : : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape )
2595 : {
2596 4 : }
2597 :
2598 8 : SdXMLObjectShapeContext::~SdXMLObjectShapeContext()
2599 : {
2600 8 : }
2601 :
2602 4 : void SdXMLObjectShapeContext::StartElement( const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList >& )
2603 : {
2604 : // #96717# in theorie, if we don't have a url we shouldn't even
2605 : // export this ole shape. But practical its to risky right now
2606 : // to change this so we better dispose this on load
2607 : //if( !mbIsPlaceholder && ImpIsEmptyURL(maHref) )
2608 : // return;
2609 :
2610 : // #100592# this BugFix prevents that a shape is created. CL
2611 : // is thinking about an alternative.
2612 : // #i13140# Check for more than empty string in maHref, there are
2613 : // other possibilities that maHref results in empty container
2614 : // storage names
2615 4 : if( !(GetImport().getImportFlags() & IMPORT_EMBEDDED) && !mbIsPlaceholder && ImpIsEmptyURL(maHref) )
2616 4 : return;
2617 :
2618 4 : const char* pService = "com.sun.star.drawing.OLE2Shape";
2619 :
2620 4 : sal_Bool bIsPresShape = !maPresentationClass.isEmpty() && GetImport().GetShapeImport()->IsPresentationShapesSupported();
2621 :
2622 4 : if( bIsPresShape )
2623 : {
2624 0 : if( IsXMLToken( maPresentationClass, XML_PRESENTATION_CHART ) )
2625 : {
2626 0 : pService = "com.sun.star.presentation.ChartShape";
2627 : }
2628 0 : else if( IsXMLToken( maPresentationClass, XML_PRESENTATION_TABLE ) )
2629 : {
2630 0 : pService = "com.sun.star.presentation.CalcShape";
2631 : }
2632 0 : else if( IsXMLToken( maPresentationClass, XML_PRESENTATION_OBJECT ) )
2633 : {
2634 0 : pService = "com.sun.star.presentation.OLE2Shape";
2635 : }
2636 : }
2637 :
2638 4 : AddShape( pService );
2639 :
2640 4 : if( mxShape.is() )
2641 : {
2642 4 : SetLayer();
2643 :
2644 4 : if(bIsPresShape)
2645 : {
2646 0 : uno::Reference< beans::XPropertySet > xProps(mxShape, uno::UNO_QUERY);
2647 0 : if(xProps.is())
2648 : {
2649 0 : uno::Reference< beans::XPropertySetInfo > xPropsInfo( xProps->getPropertySetInfo() );
2650 0 : if( xPropsInfo.is() )
2651 : {
2652 0 : if( !mbIsPlaceholder && xPropsInfo->hasPropertyByName(OUString("IsEmptyPresentationObject" )))
2653 0 : xProps->setPropertyValue( OUString("IsEmptyPresentationObject" ), ::cppu::bool2any( sal_False ) );
2654 :
2655 0 : if( mbIsUserTransformed && xPropsInfo->hasPropertyByName(OUString("IsPlaceholderDependent" )))
2656 0 : xProps->setPropertyValue( OUString("IsPlaceholderDependent" ), ::cppu::bool2any( sal_False ) );
2657 0 : }
2658 0 : }
2659 : }
2660 :
2661 4 : if( !mbIsPlaceholder && !maHref.isEmpty() )
2662 : {
2663 4 : uno::Reference< beans::XPropertySet > xProps( mxShape, uno::UNO_QUERY );
2664 :
2665 4 : if( xProps.is() )
2666 : {
2667 4 : OUString aPersistName = GetImport().ResolveEmbeddedObjectURL( maHref, maCLSID );
2668 :
2669 4 : if ( GetImport().IsPackageURL( maHref ) )
2670 : {
2671 4 : const OUString sURL( "vnd.sun.star.EmbeddedObject:" );
2672 :
2673 4 : if ( aPersistName.compareTo( sURL, sURL.getLength() ) == 0 )
2674 4 : aPersistName = aPersistName.copy( sURL.getLength() );
2675 :
2676 4 : xProps->setPropertyValue( OUString( "PersistName" ),
2677 4 : uno::makeAny( aPersistName ) );
2678 : }
2679 : else
2680 : {
2681 : // this is OOo link object
2682 0 : xProps->setPropertyValue( OUString( "LinkURL" ),
2683 0 : uno::makeAny( aPersistName ) );
2684 4 : }
2685 4 : }
2686 : }
2687 :
2688 : // set pos, size, shear and rotate
2689 4 : SetTransformation();
2690 :
2691 4 : SetStyle();
2692 :
2693 4 : GetImport().GetShapeImport()->finishShape( mxShape, mxAttrList, mxShapes );
2694 : }
2695 : }
2696 :
2697 4 : void SdXMLObjectShapeContext::EndElement()
2698 : {
2699 : // #i67705#
2700 4 : const sal_uInt16 nGeneratorVersion(GetImport().getGeneratorVersion());
2701 :
2702 4 : if(nGeneratorVersion < SvXMLImport::OOo_34x)
2703 : {
2704 : // #i118485#
2705 : // If it's an old file from us written before OOo3.4, we need to correct
2706 : // FillStyle and LineStyle for OLE2 objects. The error was that the old paint
2707 : // implementations just ignored added fill/linestyles completely, thus
2708 : // those objects need to be corrected to not show blue and hairline which
2709 : // always was the default, but would be shown now
2710 4 : uno::Reference< beans::XPropertySet > xProps(mxShape, uno::UNO_QUERY);
2711 :
2712 4 : if( xProps.is() )
2713 : {
2714 4 : xProps->setPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("FillStyle")), uno::makeAny(drawing::FillStyle_NONE));
2715 4 : xProps->setPropertyValue(::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("LineStyle")), uno::makeAny(drawing::LineStyle_NONE));
2716 4 : }
2717 : }
2718 :
2719 : // #100592#
2720 4 : if( mxBase64Stream.is() )
2721 : {
2722 0 : OUString aPersistName( GetImport().ResolveEmbeddedObjectURLFromBase64() );
2723 0 : const OUString sURL( "vnd.sun.star.EmbeddedObject:" );
2724 :
2725 0 : aPersistName = aPersistName.copy( sURL.getLength() );
2726 :
2727 0 : uno::Reference< beans::XPropertySet > xProps(mxShape, uno::UNO_QUERY);
2728 0 : if( xProps.is() )
2729 0 : xProps->setPropertyValue( OUString( "PersistName" ), uno::makeAny( aPersistName ) );
2730 : }
2731 :
2732 4 : SdXMLShapeContext::EndElement();
2733 4 : }
2734 :
2735 : // this is called from the parent group for each unparsed attribute in the attribute list
2736 40 : void SdXMLObjectShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue )
2737 : {
2738 40 : switch( nPrefix )
2739 : {
2740 : case XML_NAMESPACE_DRAW:
2741 8 : if( IsXMLToken( rLocalName, XML_CLASS_ID ) )
2742 : {
2743 0 : maCLSID = rValue;
2744 0 : return;
2745 : }
2746 8 : break;
2747 : case XML_NAMESPACE_XLINK:
2748 16 : if( IsXMLToken( rLocalName, XML_HREF ) )
2749 : {
2750 4 : maHref = rValue;
2751 4 : return;
2752 : }
2753 12 : break;
2754 : }
2755 :
2756 36 : SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue );
2757 : }
2758 :
2759 0 : SvXMLImportContext* SdXMLObjectShapeContext::CreateChildContext(
2760 : sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName,
2761 : const uno::Reference<xml::sax::XAttributeList>& xAttrList )
2762 : {
2763 : // #100592#
2764 0 : SvXMLImportContext* pContext = NULL;
2765 :
2766 0 : if((XML_NAMESPACE_OFFICE == nPrefix) && IsXMLToken(rLocalName, XML_BINARY_DATA))
2767 : {
2768 0 : mxBase64Stream = GetImport().GetStreamForEmbeddedObjectURLFromBase64();
2769 0 : if( mxBase64Stream.is() )
2770 0 : pContext = new XMLBase64ImportContext( GetImport(), nPrefix,
2771 : rLocalName, xAttrList,
2772 0 : mxBase64Stream );
2773 : }
2774 0 : else if( ((XML_NAMESPACE_OFFICE == nPrefix) && IsXMLToken(rLocalName, XML_DOCUMENT)) ||
2775 0 : ((XML_NAMESPACE_MATH == nPrefix) && IsXMLToken(rLocalName, XML_MATH)) )
2776 : {
2777 : XMLEmbeddedObjectImportContext *pEContext =
2778 0 : new XMLEmbeddedObjectImportContext( GetImport(), nPrefix,
2779 0 : rLocalName, xAttrList );
2780 0 : maCLSID = pEContext->GetFilterCLSID();
2781 0 : if( !maCLSID.isEmpty() )
2782 : {
2783 0 : uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY);
2784 0 : if( xPropSet.is() )
2785 : {
2786 0 : xPropSet->setPropertyValue( OUString("CLSID" ), uno::makeAny( maCLSID ) );
2787 :
2788 0 : uno::Reference< lang::XComponent > xComp;
2789 0 : xPropSet->getPropertyValue( OUString("Model" ) ) >>= xComp;
2790 : DBG_ASSERT( xComp.is(), "no xModel for own OLE format" );
2791 0 : pEContext->SetComponent( xComp );
2792 0 : }
2793 : }
2794 0 : pContext = pEContext;
2795 : }
2796 :
2797 : // delegate to parent class if no context could be created
2798 0 : if(!pContext)
2799 0 : pContext = SdXMLShapeContext::CreateChildContext(nPrefix, rLocalName, xAttrList);
2800 :
2801 0 : return pContext;
2802 : }
2803 :
2804 : //////////////////////////////////////////////////////////////////////////////
2805 :
2806 0 : TYPEINIT1( SdXMLAppletShapeContext, SdXMLShapeContext );
2807 :
2808 0 : SdXMLAppletShapeContext::SdXMLAppletShapeContext( SvXMLImport& rImport, sal_uInt16 nPrfx,
2809 : const rtl::OUString& rLocalName,
2810 : const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList,
2811 : com::sun::star::uno::Reference< com::sun::star::drawing::XShapes >& rShapes,
2812 : sal_Bool bTemporaryShape)
2813 : : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape ),
2814 0 : mbIsScript( sal_False )
2815 : {
2816 0 : }
2817 :
2818 0 : SdXMLAppletShapeContext::~SdXMLAppletShapeContext()
2819 : {
2820 0 : }
2821 :
2822 0 : void SdXMLAppletShapeContext::StartElement( const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList >& )
2823 : {
2824 0 : const char* pService = "com.sun.star.drawing.AppletShape";
2825 0 : AddShape( pService );
2826 :
2827 0 : if( mxShape.is() )
2828 : {
2829 0 : SetLayer();
2830 :
2831 : // set pos, size, shear and rotate
2832 0 : SetTransformation();
2833 0 : GetImport().GetShapeImport()->finishShape( mxShape, mxAttrList, mxShapes );
2834 : }
2835 0 : }
2836 :
2837 : // this is called from the parent group for each unparsed attribute in the attribute list
2838 0 : void SdXMLAppletShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue )
2839 : {
2840 0 : switch( nPrefix )
2841 : {
2842 : case XML_NAMESPACE_DRAW:
2843 0 : if( IsXMLToken( rLocalName, XML_APPLET_NAME ) )
2844 : {
2845 0 : maAppletName = rValue;
2846 0 : return;
2847 : }
2848 0 : if( IsXMLToken( rLocalName, XML_CODE ) )
2849 : {
2850 0 : maAppletCode = rValue;
2851 0 : return;
2852 : }
2853 0 : if( IsXMLToken( rLocalName, XML_MAY_SCRIPT ) )
2854 : {
2855 0 : mbIsScript = IsXMLToken( rValue, XML_TRUE );
2856 0 : return;
2857 : }
2858 0 : break;
2859 : case XML_NAMESPACE_XLINK:
2860 0 : if( IsXMLToken( rLocalName, XML_HREF ) )
2861 : {
2862 0 : maHref = GetImport().GetAbsoluteReference(rValue);
2863 0 : return;
2864 : }
2865 0 : break;
2866 : }
2867 :
2868 0 : SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue );
2869 : }
2870 :
2871 0 : void SdXMLAppletShapeContext::EndElement()
2872 : {
2873 0 : uno::Reference< beans::XPropertySet > xProps( mxShape, uno::UNO_QUERY );
2874 0 : if( xProps.is() )
2875 : {
2876 0 : uno::Any aAny;
2877 :
2878 0 : if ( maSize.Width && maSize.Height )
2879 : {
2880 : // the visual area for applet must be set on loading
2881 0 : awt::Rectangle aRect( 0, 0, maSize.Width, maSize.Height );
2882 0 : aAny <<= aRect;
2883 0 : xProps->setPropertyValue( OUString( "VisibleArea" ), aAny );
2884 : }
2885 :
2886 0 : if( maParams.getLength() )
2887 : {
2888 0 : aAny <<= maParams;
2889 0 : xProps->setPropertyValue( OUString( "AppletCommands" ), aAny );
2890 : }
2891 :
2892 0 : if( !maHref.isEmpty() )
2893 : {
2894 0 : aAny <<= maHref;
2895 0 : xProps->setPropertyValue( OUString( "AppletCodeBase" ), aAny );
2896 : }
2897 :
2898 0 : if( !maAppletName.isEmpty() )
2899 : {
2900 0 : aAny <<= maAppletName;
2901 0 : xProps->setPropertyValue( OUString( "AppletName" ), aAny );
2902 : }
2903 :
2904 0 : if( mbIsScript )
2905 : {
2906 0 : aAny <<= mbIsScript;
2907 0 : xProps->setPropertyValue( OUString( "AppletIsScript" ), aAny );
2908 :
2909 : }
2910 :
2911 0 : if( !maAppletCode.isEmpty() )
2912 : {
2913 0 : aAny <<= maAppletCode;
2914 0 : xProps->setPropertyValue( OUString( "AppletCode" ), aAny );
2915 : }
2916 :
2917 0 : aAny <<= ::rtl::OUString( GetImport().GetDocumentBase() );
2918 0 : xProps->setPropertyValue( OUString( "AppletDocBase" ), aAny );
2919 :
2920 0 : SetThumbnail();
2921 : }
2922 :
2923 0 : SdXMLShapeContext::EndElement();
2924 0 : }
2925 :
2926 0 : SvXMLImportContext * SdXMLAppletShapeContext::CreateChildContext( sal_uInt16 p_nPrefix, const ::rtl::OUString& rLocalName, const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList )
2927 : {
2928 0 : if( p_nPrefix == XML_NAMESPACE_DRAW && IsXMLToken( rLocalName, XML_PARAM ) )
2929 : {
2930 0 : OUString aParamName, aParamValue;
2931 0 : const sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
2932 : // now parse the attribute list and look for draw:name and draw:value
2933 0 : for(sal_Int16 a(0); a < nAttrCount; a++)
2934 : {
2935 0 : const OUString& rAttrName = xAttrList->getNameByIndex(a);
2936 0 : OUString aLocalName;
2937 0 : sal_uInt16 nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName(rAttrName, &aLocalName);
2938 0 : const OUString aValue( xAttrList->getValueByIndex(a) );
2939 :
2940 0 : if( nPrefix == XML_NAMESPACE_DRAW )
2941 : {
2942 0 : if( IsXMLToken( aLocalName, XML_NAME ) )
2943 : {
2944 0 : aParamName = aValue;
2945 : }
2946 0 : else if( IsXMLToken( aLocalName, XML_VALUE ) )
2947 : {
2948 0 : aParamValue = aValue;
2949 : }
2950 : }
2951 0 : }
2952 :
2953 0 : if( !aParamName.isEmpty() )
2954 : {
2955 0 : sal_Int32 nIndex = maParams.getLength();
2956 0 : maParams.realloc( nIndex + 1 );
2957 0 : maParams[nIndex].Name = aParamName;
2958 0 : maParams[nIndex].Handle = -1;
2959 0 : maParams[nIndex].Value <<= aParamValue;
2960 0 : maParams[nIndex].State = beans::PropertyState_DIRECT_VALUE;
2961 : }
2962 :
2963 0 : return new SvXMLImportContext( GetImport(), p_nPrefix, rLocalName );
2964 : }
2965 :
2966 0 : return SdXMLShapeContext::CreateChildContext( p_nPrefix, rLocalName, xAttrList );
2967 : }
2968 :
2969 : //////////////////////////////////////////////////////////////////////////////
2970 :
2971 0 : TYPEINIT1( SdXMLPluginShapeContext, SdXMLShapeContext );
2972 :
2973 0 : SdXMLPluginShapeContext::SdXMLPluginShapeContext( SvXMLImport& rImport, sal_uInt16 nPrfx,
2974 : const rtl::OUString& rLocalName,
2975 : const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList,
2976 : com::sun::star::uno::Reference< com::sun::star::drawing::XShapes >& rShapes,
2977 : sal_Bool bTemporaryShape) :
2978 : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape ),
2979 0 : mbMedia( false )
2980 : {
2981 0 : }
2982 :
2983 0 : SdXMLPluginShapeContext::~SdXMLPluginShapeContext()
2984 : {
2985 0 : }
2986 :
2987 0 : void SdXMLPluginShapeContext::StartElement( const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList >& xAttrList)
2988 : {
2989 : // watch for MimeType attribute to see if we have a media object
2990 0 : for( sal_Int16 n = 0, nAttrCount = ( xAttrList.is() ? xAttrList->getLength() : 0 ); n < nAttrCount; ++n )
2991 : {
2992 0 : OUString aLocalName;
2993 0 : sal_uInt16 nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName( xAttrList->getNameByIndex( n ), &aLocalName );
2994 :
2995 0 : if( nPrefix == XML_NAMESPACE_DRAW && IsXMLToken( aLocalName, XML_MIME_TYPE ) )
2996 : {
2997 0 : if( 0 == xAttrList->getValueByIndex( n ).compareToAscii( "application/vnd.sun.star.media" ) )
2998 0 : mbMedia = true;
2999 :
3000 : // leave this loop
3001 0 : n = nAttrCount - 1;
3002 : }
3003 0 : }
3004 :
3005 : const char* pService;
3006 :
3007 0 : sal_Bool bIsPresShape = sal_False;
3008 :
3009 0 : if( mbMedia )
3010 : {
3011 0 : pService = "com.sun.star.drawing.MediaShape";
3012 :
3013 0 : bIsPresShape = !maPresentationClass.isEmpty() && GetImport().GetShapeImport()->IsPresentationShapesSupported();
3014 0 : if( bIsPresShape )
3015 : {
3016 0 : if( IsXMLToken( maPresentationClass, XML_PRESENTATION_OBJECT ) )
3017 : {
3018 0 : pService = "com.sun.star.presentation.MediaShape";
3019 : }
3020 : }
3021 : }
3022 : else
3023 0 : pService = "com.sun.star.drawing.PluginShape";
3024 :
3025 0 : AddShape( pService );
3026 :
3027 0 : if( mxShape.is() )
3028 : {
3029 0 : SetLayer();
3030 :
3031 0 : if(bIsPresShape)
3032 : {
3033 0 : uno::Reference< beans::XPropertySet > xProps( mxShape, uno::UNO_QUERY );
3034 0 : if(xProps.is())
3035 : {
3036 0 : uno::Reference< beans::XPropertySetInfo > xPropsInfo( xProps->getPropertySetInfo() );
3037 0 : if( xPropsInfo.is() )
3038 : {
3039 0 : if( !mbIsPlaceholder && xPropsInfo->hasPropertyByName(OUString("IsEmptyPresentationObject" )))
3040 0 : xProps->setPropertyValue( OUString("IsEmptyPresentationObject" ), ::cppu::bool2any( sal_False ) );
3041 :
3042 0 : if( mbIsUserTransformed && xPropsInfo->hasPropertyByName(OUString("IsPlaceholderDependent" )))
3043 0 : xProps->setPropertyValue( OUString("IsPlaceholderDependent" ), ::cppu::bool2any( sal_False ) );
3044 0 : }
3045 0 : }
3046 : }
3047 :
3048 : // set pos, size, shear and rotate
3049 0 : SetTransformation();
3050 0 : GetImport().GetShapeImport()->finishShape( mxShape, mxAttrList, mxShapes );
3051 : }
3052 0 : }
3053 :
3054 : static ::rtl::OUString
3055 0 : lcl_GetMediaReference(SvXMLImport const& rImport, ::rtl::OUString const& rURL)
3056 : {
3057 0 : if (rImport.IsPackageURL(rURL))
3058 : {
3059 0 : return ::rtl::OUString( "vnd.sun.star.Package:") + rURL;
3060 : }
3061 : else
3062 : {
3063 0 : return rImport.GetAbsoluteReference(rURL);
3064 : }
3065 : }
3066 :
3067 : // this is called from the parent group for each unparsed attribute in the attribute list
3068 0 : void SdXMLPluginShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue )
3069 : {
3070 0 : switch( nPrefix )
3071 : {
3072 : case XML_NAMESPACE_DRAW:
3073 0 : if( IsXMLToken( rLocalName, XML_MIME_TYPE ) )
3074 : {
3075 0 : maMimeType = rValue;
3076 0 : return;
3077 : }
3078 0 : break;
3079 : case XML_NAMESPACE_XLINK:
3080 0 : if( IsXMLToken( rLocalName, XML_HREF ) )
3081 : {
3082 0 : maHref = lcl_GetMediaReference(GetImport(), rValue);
3083 0 : return;
3084 : }
3085 0 : break;
3086 : }
3087 :
3088 0 : SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue );
3089 : }
3090 :
3091 0 : void SdXMLPluginShapeContext::EndElement()
3092 : {
3093 0 : uno::Reference< beans::XPropertySet > xProps( mxShape, uno::UNO_QUERY );
3094 :
3095 0 : if( xProps.is() )
3096 : {
3097 0 : uno::Any aAny;
3098 :
3099 0 : if ( maSize.Width && maSize.Height )
3100 : {
3101 0 : const rtl::OUString sVisibleArea( "VisibleArea" );
3102 0 : uno::Reference< beans::XPropertySetInfo > aXPropSetInfo( xProps->getPropertySetInfo() );
3103 0 : if ( !aXPropSetInfo.is() || aXPropSetInfo->hasPropertyByName( sVisibleArea ) )
3104 : {
3105 : // the visual area for a plugin must be set on loading
3106 0 : awt::Rectangle aRect( 0, 0, maSize.Width, maSize.Height );
3107 0 : aAny <<= aRect;
3108 0 : xProps->setPropertyValue( sVisibleArea, aAny );
3109 0 : }
3110 : }
3111 :
3112 0 : if( !mbMedia )
3113 : {
3114 : // in case we have a plugin object
3115 0 : if( maParams.getLength() )
3116 : {
3117 0 : aAny <<= maParams;
3118 0 : xProps->setPropertyValue( OUString( "PluginCommands" ), aAny );
3119 : }
3120 :
3121 0 : if( !maMimeType.isEmpty() )
3122 : {
3123 0 : aAny <<= maMimeType;
3124 0 : xProps->setPropertyValue( OUString( "PluginMimeType" ), aAny );
3125 : }
3126 :
3127 0 : if( !maHref.isEmpty() )
3128 : {
3129 0 : aAny <<= maHref;
3130 0 : xProps->setPropertyValue( OUString( "PluginURL" ), aAny );
3131 : }
3132 : }
3133 : else
3134 : {
3135 : // in case we have a media object
3136 0 : xProps->setPropertyValue(
3137 : OUString("MediaURL"),
3138 0 : uno::makeAny(maHref));
3139 :
3140 0 : for( sal_Int32 nParam = 0; nParam < maParams.getLength(); ++nParam )
3141 : {
3142 0 : const OUString& rName = maParams[ nParam ].Name;
3143 :
3144 0 : if( 0 == rName.compareToAscii( "Loop" ) )
3145 : {
3146 0 : OUString aValueStr;
3147 0 : maParams[ nParam ].Value >>= aValueStr;
3148 0 : xProps->setPropertyValue( OUString( "Loop" ),
3149 0 : uno::makeAny( static_cast< sal_Bool >( 0 == aValueStr.compareToAscii( "true" ) ) ) );
3150 : }
3151 0 : else if( 0 == rName.compareToAscii( "Mute" ) )
3152 : {
3153 0 : OUString aValueStr;
3154 0 : maParams[ nParam ].Value >>= aValueStr;
3155 0 : xProps->setPropertyValue( OUString( "Mute" ),
3156 0 : uno::makeAny( static_cast< sal_Bool >( 0 == aValueStr.compareToAscii( "true" ) ) ) );
3157 : }
3158 0 : else if( 0 == rName.compareToAscii( "VolumeDB" ) )
3159 : {
3160 0 : OUString aValueStr;
3161 0 : maParams[ nParam ].Value >>= aValueStr;
3162 0 : xProps->setPropertyValue( OUString( "VolumeDB" ),
3163 0 : uno::makeAny( static_cast< sal_Int16 >( aValueStr.toInt32() ) ) );
3164 : }
3165 0 : else if( 0 == rName.compareToAscii( "Zoom" ) )
3166 : {
3167 0 : OUString aZoomStr;
3168 : media::ZoomLevel eZoomLevel;
3169 :
3170 0 : maParams[ nParam ].Value >>= aZoomStr;
3171 :
3172 0 : if( 0 == aZoomStr.compareToAscii( "25%" ) )
3173 0 : eZoomLevel = media::ZoomLevel_ZOOM_1_TO_4;
3174 0 : else if( 0 == aZoomStr.compareToAscii( "50%" ) )
3175 0 : eZoomLevel = media::ZoomLevel_ZOOM_1_TO_2;
3176 0 : else if( 0 == aZoomStr.compareToAscii( "100%" ) )
3177 0 : eZoomLevel = media::ZoomLevel_ORIGINAL;
3178 0 : else if( 0 == aZoomStr.compareToAscii( "200%" ) )
3179 0 : eZoomLevel = media::ZoomLevel_ZOOM_2_TO_1;
3180 0 : else if( 0 == aZoomStr.compareToAscii( "400%" ) )
3181 0 : eZoomLevel = media::ZoomLevel_ZOOM_4_TO_1;
3182 0 : else if( 0 == aZoomStr.compareToAscii( "fit" ) )
3183 0 : eZoomLevel = media::ZoomLevel_FIT_TO_WINDOW;
3184 0 : else if( 0 == aZoomStr.compareToAscii( "fixedfit" ) )
3185 0 : eZoomLevel = media::ZoomLevel_FIT_TO_WINDOW_FIXED_ASPECT;
3186 0 : else if( 0 == aZoomStr.compareToAscii( "fullscreen" ) )
3187 0 : eZoomLevel = media::ZoomLevel_FULLSCREEN;
3188 : else
3189 0 : eZoomLevel = media::ZoomLevel_NOT_AVAILABLE;
3190 :
3191 0 : xProps->setPropertyValue( OUString( "Zoom" ), uno::makeAny( eZoomLevel ) );
3192 : }
3193 : }
3194 : }
3195 :
3196 0 : SetThumbnail();
3197 : }
3198 :
3199 0 : SdXMLShapeContext::EndElement();
3200 0 : }
3201 :
3202 0 : SvXMLImportContext * SdXMLPluginShapeContext::CreateChildContext( sal_uInt16 p_nPrefix, const ::rtl::OUString& rLocalName, const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList )
3203 : {
3204 0 : if( p_nPrefix == XML_NAMESPACE_DRAW && IsXMLToken( rLocalName, XML_PARAM ) )
3205 : {
3206 0 : OUString aParamName, aParamValue;
3207 0 : const sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
3208 : // now parse the attribute list and look for draw:name and draw:value
3209 0 : for(sal_Int16 a(0); a < nAttrCount; a++)
3210 : {
3211 0 : const OUString& rAttrName = xAttrList->getNameByIndex(a);
3212 0 : OUString aLocalName;
3213 0 : sal_uInt16 nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName(rAttrName, &aLocalName);
3214 0 : const OUString aValue( xAttrList->getValueByIndex(a) );
3215 :
3216 0 : if( nPrefix == XML_NAMESPACE_DRAW )
3217 : {
3218 0 : if( IsXMLToken( aLocalName, XML_NAME ) )
3219 : {
3220 0 : aParamName = aValue;
3221 : }
3222 0 : else if( IsXMLToken( aLocalName, XML_VALUE ) )
3223 : {
3224 0 : aParamValue = aValue;
3225 : }
3226 : }
3227 :
3228 0 : if( !aParamName.isEmpty() )
3229 : {
3230 0 : sal_Int32 nIndex = maParams.getLength();
3231 0 : maParams.realloc( nIndex + 1 );
3232 0 : maParams[nIndex].Name = aParamName;
3233 0 : maParams[nIndex].Handle = -1;
3234 0 : maParams[nIndex].Value <<= aParamValue;
3235 0 : maParams[nIndex].State = beans::PropertyState_DIRECT_VALUE;
3236 : }
3237 0 : }
3238 :
3239 0 : return new SvXMLImportContext( GetImport(), p_nPrefix, rLocalName );
3240 : }
3241 :
3242 0 : return SdXMLShapeContext::CreateChildContext( p_nPrefix, rLocalName, xAttrList );
3243 : }
3244 :
3245 : //////////////////////////////////////////////////////////////////////////////
3246 :
3247 0 : TYPEINIT1( SdXMLFloatingFrameShapeContext, SdXMLShapeContext );
3248 :
3249 0 : SdXMLFloatingFrameShapeContext::SdXMLFloatingFrameShapeContext( SvXMLImport& rImport, sal_uInt16 nPrfx,
3250 : const rtl::OUString& rLocalName,
3251 : const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList,
3252 : com::sun::star::uno::Reference< com::sun::star::drawing::XShapes >& rShapes,
3253 : sal_Bool bTemporaryShape)
3254 0 : : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape )
3255 : {
3256 0 : }
3257 :
3258 0 : SdXMLFloatingFrameShapeContext::~SdXMLFloatingFrameShapeContext()
3259 : {
3260 0 : }
3261 :
3262 0 : void SdXMLFloatingFrameShapeContext::StartElement( const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList >& )
3263 : {
3264 0 : const char* pService = "com.sun.star.drawing.FrameShape";
3265 0 : AddShape( pService );
3266 :
3267 0 : if( mxShape.is() )
3268 : {
3269 0 : SetLayer();
3270 :
3271 : // set pos, size, shear and rotate
3272 0 : SetTransformation();
3273 :
3274 0 : uno::Reference< beans::XPropertySet > xProps( mxShape, uno::UNO_QUERY );
3275 0 : if( xProps.is() )
3276 : {
3277 0 : uno::Any aAny;
3278 :
3279 0 : if( !maFrameName.isEmpty() )
3280 : {
3281 0 : aAny <<= maFrameName;
3282 0 : xProps->setPropertyValue( OUString( "FrameName" ), aAny );
3283 : }
3284 :
3285 0 : if( !maHref.isEmpty() )
3286 : {
3287 0 : aAny <<= maHref;
3288 0 : xProps->setPropertyValue( OUString( "FrameURL" ), aAny );
3289 0 : }
3290 : }
3291 :
3292 0 : SetStyle();
3293 :
3294 0 : GetImport().GetShapeImport()->finishShape( mxShape, mxAttrList, mxShapes );
3295 : }
3296 0 : }
3297 :
3298 : // this is called from the parent group for each unparsed attribute in the attribute list
3299 0 : void SdXMLFloatingFrameShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue )
3300 : {
3301 0 : switch( nPrefix )
3302 : {
3303 : case XML_NAMESPACE_DRAW:
3304 0 : if( IsXMLToken( rLocalName, XML_FRAME_NAME ) )
3305 : {
3306 0 : maFrameName = rValue;
3307 0 : return;
3308 : }
3309 0 : break;
3310 : case XML_NAMESPACE_XLINK:
3311 0 : if( IsXMLToken( rLocalName, XML_HREF ) )
3312 : {
3313 0 : maHref = GetImport().GetAbsoluteReference(rValue);
3314 0 : return;
3315 : }
3316 0 : break;
3317 : }
3318 :
3319 0 : SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue );
3320 : }
3321 :
3322 0 : void SdXMLFloatingFrameShapeContext::EndElement()
3323 : {
3324 0 : uno::Reference< beans::XPropertySet > xProps( mxShape, uno::UNO_QUERY );
3325 :
3326 0 : if( xProps.is() )
3327 : {
3328 0 : if ( maSize.Width && maSize.Height )
3329 : {
3330 : // the visual area for a floating frame must be set on loading
3331 0 : awt::Rectangle aRect( 0, 0, maSize.Width, maSize.Height );
3332 0 : uno::Any aAny;
3333 0 : aAny <<= aRect;
3334 0 : xProps->setPropertyValue( OUString( "VisibleArea" ), aAny );
3335 : }
3336 : }
3337 :
3338 0 : SetThumbnail();
3339 0 : SdXMLShapeContext::EndElement();
3340 0 : }
3341 :
3342 : //////////////////////////////////////////////////////////////////////////////
3343 :
3344 0 : TYPEINIT1( SdXMLFrameShapeContext, SdXMLShapeContext );
3345 :
3346 36 : SdXMLFrameShapeContext::SdXMLFrameShapeContext( SvXMLImport& rImport, sal_uInt16 nPrfx,
3347 : const rtl::OUString& rLocalName,
3348 : const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList,
3349 : com::sun::star::uno::Reference< com::sun::star::drawing::XShapes >& rShapes,
3350 : sal_Bool bTemporaryShape)
3351 : : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape ),
3352 : multiImageImportHelper(),
3353 : mbSupportsReplacement( sal_False ),
3354 : mxImplContext(),
3355 36 : mxReplImplContext()
3356 : {
3357 36 : uno::Reference < util::XCloneable > xClone( xAttrList, uno::UNO_QUERY );
3358 36 : if( xClone.is() )
3359 36 : mxAttrList.set( xClone->createClone(), uno::UNO_QUERY );
3360 : else
3361 0 : mxAttrList = new SvXMLAttributeList( xAttrList );
3362 :
3363 36 : }
3364 :
3365 72 : SdXMLFrameShapeContext::~SdXMLFrameShapeContext()
3366 : {
3367 72 : }
3368 :
3369 0 : void SdXMLFrameShapeContext::removeGraphicFromImportContext(const SvXMLImportContext& rContext) const
3370 : {
3371 0 : const SdXMLGraphicObjectShapeContext* pSdXMLGraphicObjectShapeContext = dynamic_cast< const SdXMLGraphicObjectShapeContext* >(&rContext);
3372 :
3373 0 : if(pSdXMLGraphicObjectShapeContext)
3374 : {
3375 : try
3376 : {
3377 0 : uno::Reference< container::XChild > xChild(pSdXMLGraphicObjectShapeContext->getShape(), uno::UNO_QUERY_THROW);
3378 :
3379 0 : if(xChild.is())
3380 : {
3381 0 : uno::Reference< drawing::XShapes > xParent(xChild->getParent(), uno::UNO_QUERY_THROW);
3382 :
3383 0 : if(xParent.is())
3384 : {
3385 : // remove from parent
3386 0 : xParent->remove(pSdXMLGraphicObjectShapeContext->getShape());
3387 :
3388 : // dispose
3389 0 : uno::Reference< lang::XComponent > xComp(pSdXMLGraphicObjectShapeContext->getShape(), UNO_QUERY);
3390 :
3391 0 : if(xComp.is())
3392 : {
3393 0 : xComp->dispose();
3394 0 : }
3395 0 : }
3396 0 : }
3397 : }
3398 0 : catch( uno::Exception& )
3399 : {
3400 : OSL_FAIL( "Error in cleanup of multiple graphic object import (!)" );
3401 : }
3402 : }
3403 0 : }
3404 :
3405 0 : rtl::OUString SdXMLFrameShapeContext::getGraphicURLFromImportContext(const SvXMLImportContext& rContext) const
3406 : {
3407 0 : rtl::OUString aRetval;
3408 0 : const SdXMLGraphicObjectShapeContext* pSdXMLGraphicObjectShapeContext = dynamic_cast< const SdXMLGraphicObjectShapeContext* >(&rContext);
3409 :
3410 0 : if(pSdXMLGraphicObjectShapeContext)
3411 : {
3412 : try
3413 : {
3414 0 : const uno::Reference< beans::XPropertySet > xPropSet(pSdXMLGraphicObjectShapeContext->getShape(), uno::UNO_QUERY_THROW);
3415 :
3416 0 : if(xPropSet.is())
3417 : {
3418 0 : xPropSet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("GraphicStreamURL"))) >>= aRetval;
3419 :
3420 0 : if(!aRetval.getLength())
3421 : {
3422 : // it maybe a link, try GraphicURL
3423 0 : xPropSet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("GraphicURL"))) >>= aRetval;
3424 : }
3425 0 : }
3426 : }
3427 0 : catch( uno::Exception& )
3428 : {
3429 : OSL_FAIL( "Error in cleanup of multiple graphic object import (!)" );
3430 : }
3431 : }
3432 :
3433 0 : return aRetval;
3434 : }
3435 :
3436 42 : SvXMLImportContext *SdXMLFrameShapeContext::CreateChildContext( sal_uInt16 nPrefix,
3437 : const OUString& rLocalName,
3438 : const uno::Reference< xml::sax::XAttributeList>& xAttrList )
3439 : {
3440 42 : SvXMLImportContext * pContext = 0;
3441 :
3442 42 : if( !mxImplContext.Is() )
3443 : {
3444 :
3445 36 : SvXMLShapeContext* pShapeContext= GetImport().GetShapeImport()->CreateFrameChildContext(
3446 72 : GetImport(), nPrefix, rLocalName, xAttrList, mxShapes, mxAttrList );
3447 :
3448 36 : pContext = pShapeContext;
3449 :
3450 : // propagate the hyperlink to child context
3451 36 : if ( !msHyperlink.isEmpty() )
3452 0 : pShapeContext->setHyperlink( msHyperlink );
3453 :
3454 36 : mxImplContext = pContext;
3455 36 : mbSupportsReplacement = IsXMLToken(rLocalName, XML_OBJECT ) || IsXMLToken(rLocalName, XML_OBJECT_OLE);
3456 36 : setSupportsMultipleContents(IsXMLToken(rLocalName, XML_IMAGE));
3457 :
3458 36 : if(getSupportsMultipleContents() && dynamic_cast< SdXMLGraphicObjectShapeContext* >(pContext))
3459 : {
3460 3 : addContent(*mxImplContext);
3461 : }
3462 : }
3463 6 : else if(getSupportsMultipleContents() && XML_NAMESPACE_DRAW == nPrefix && IsXMLToken(rLocalName, XML_IMAGE))
3464 : {
3465 : // read another image
3466 0 : pContext = GetImport().GetShapeImport()->CreateFrameChildContext(
3467 0 : GetImport(), nPrefix, rLocalName, xAttrList, mxShapes, mxAttrList);
3468 0 : mxImplContext = pContext;
3469 :
3470 0 : if(dynamic_cast< SdXMLGraphicObjectShapeContext* >(pContext))
3471 : {
3472 0 : addContent(*mxImplContext);
3473 : }
3474 : }
3475 10 : else if( mbSupportsReplacement && !mxReplImplContext &&
3476 : XML_NAMESPACE_DRAW == nPrefix &&
3477 4 : IsXMLToken( rLocalName, XML_IMAGE ) )
3478 : {
3479 : // read replacement image
3480 4 : SvXMLImportContext *pImplContext = &mxImplContext;
3481 : SdXMLShapeContext *pSContext =
3482 4 : PTR_CAST( SdXMLShapeContext, pImplContext );
3483 4 : if( pSContext )
3484 : {
3485 : uno::Reference < beans::XPropertySet > xPropSet(
3486 4 : pSContext->getShape(), uno::UNO_QUERY );
3487 4 : if( xPropSet.is() )
3488 : {
3489 4 : pContext = new XMLReplacementImageContext( GetImport(),
3490 4 : nPrefix, rLocalName, xAttrList, xPropSet );
3491 4 : mxReplImplContext = pContext;
3492 4 : }
3493 : }
3494 : }
3495 6 : else if(
3496 : ( nPrefix == XML_NAMESPACE_SVG && // #i68101#
3497 0 : (IsXMLToken( rLocalName, XML_TITLE ) || IsXMLToken( rLocalName, XML_DESC ) ) ) ||
3498 0 : (nPrefix == XML_NAMESPACE_OFFICE && IsXMLToken( rLocalName, XML_EVENT_LISTENERS ) ) ||
3499 2 : (nPrefix == XML_NAMESPACE_DRAW && (IsXMLToken( rLocalName, XML_GLUE_POINT ) ||
3500 2 : IsXMLToken( rLocalName, XML_THUMBNAIL ) ) ) )
3501 : {
3502 0 : SvXMLImportContext *pImplContext = &mxImplContext;
3503 0 : pContext = PTR_CAST( SdXMLShapeContext, pImplContext )->CreateChildContext( nPrefix,
3504 0 : rLocalName, xAttrList );
3505 : }
3506 2 : else if ( (XML_NAMESPACE_DRAW == nPrefix) && IsXMLToken( rLocalName, XML_IMAGE_MAP ) )
3507 : {
3508 0 : SdXMLShapeContext *pSContext = dynamic_cast< SdXMLShapeContext* >( &mxImplContext );
3509 0 : if( pSContext )
3510 : {
3511 0 : uno::Reference < beans::XPropertySet > xPropSet( pSContext->getShape(), uno::UNO_QUERY );
3512 0 : if (xPropSet.is())
3513 : {
3514 0 : pContext = new XMLImageMapContext(GetImport(), nPrefix, rLocalName, xPropSet);
3515 0 : }
3516 : }
3517 : }
3518 :
3519 : // call parent for content
3520 42 : if(!pContext)
3521 2 : pContext = SvXMLImportContext::CreateChildContext( nPrefix, rLocalName, xAttrList );
3522 :
3523 42 : return pContext;
3524 : }
3525 :
3526 36 : void SdXMLFrameShapeContext::StartElement(const uno::Reference< xml::sax::XAttributeList>&)
3527 : {
3528 : // ignore
3529 36 : }
3530 :
3531 36 : void SdXMLFrameShapeContext::EndElement()
3532 : {
3533 : /// solve if multiple image child contexts were imported
3534 36 : solveMultipleImages();
3535 :
3536 36 : if( !mxImplContext.Is() )
3537 : {
3538 : // now check if this is an empty presentation object
3539 0 : sal_Int16 nAttrCount = mxAttrList.is() ? mxAttrList->getLength() : 0;
3540 0 : for(sal_Int16 a(0); a < nAttrCount; a++)
3541 : {
3542 0 : OUString aLocalName;
3543 0 : sal_uInt16 nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName(mxAttrList->getNameByIndex(a), &aLocalName);
3544 :
3545 0 : if( nPrefix == XML_NAMESPACE_PRESENTATION )
3546 : {
3547 0 : if( IsXMLToken( aLocalName, XML_PLACEHOLDER ) )
3548 : {
3549 0 : mbIsPlaceholder = IsXMLToken( mxAttrList->getValueByIndex(a), XML_TRUE );
3550 : }
3551 0 : else if( IsXMLToken( aLocalName, XML_CLASS ) )
3552 : {
3553 0 : maPresentationClass = mxAttrList->getValueByIndex(a);
3554 : }
3555 : }
3556 0 : }
3557 :
3558 0 : if( (!maPresentationClass.isEmpty()) && mbIsPlaceholder )
3559 : {
3560 0 : uno::Reference< xml::sax::XAttributeList> xEmpty;
3561 :
3562 0 : enum XMLTokenEnum eToken = XML_TEXT_BOX;
3563 :
3564 0 : if( IsXMLToken( maPresentationClass, XML_GRAPHIC ) )
3565 : {
3566 0 : eToken = XML_IMAGE;
3567 :
3568 : }
3569 0 : else if( IsXMLToken( maPresentationClass, XML_PRESENTATION_PAGE ) )
3570 : {
3571 0 : eToken = XML_PAGE_THUMBNAIL;
3572 : }
3573 0 : else if( IsXMLToken( maPresentationClass, XML_PRESENTATION_CHART ) ||
3574 0 : IsXMLToken( maPresentationClass, XML_PRESENTATION_TABLE ) ||
3575 0 : IsXMLToken( maPresentationClass, XML_PRESENTATION_OBJECT ) )
3576 : {
3577 0 : eToken = XML_OBJECT;
3578 : }
3579 :
3580 0 : mxImplContext = GetImport().GetShapeImport()->CreateFrameChildContext(
3581 0 : GetImport(), XML_NAMESPACE_DRAW, GetXMLToken( eToken ), mxAttrList, mxShapes, xEmpty );
3582 :
3583 0 : if( mxImplContext.Is() )
3584 : {
3585 0 : mxImplContext->StartElement( mxAttrList );
3586 0 : mxImplContext->EndElement();
3587 0 : }
3588 : }
3589 : }
3590 :
3591 36 : mxImplContext = 0;
3592 36 : SdXMLShapeContext::EndElement();
3593 36 : }
3594 :
3595 269 : void SdXMLFrameShapeContext::processAttribute( sal_uInt16,
3596 : const ::rtl::OUString&, const ::rtl::OUString& )
3597 : {
3598 : // ignore
3599 269 : }
3600 :
3601 0 : TYPEINIT1( SdXMLCustomShapeContext, SdXMLShapeContext );
3602 :
3603 62 : SdXMLCustomShapeContext::SdXMLCustomShapeContext(
3604 : SvXMLImport& rImport,
3605 : sal_uInt16 nPrfx,
3606 : const OUString& rLocalName,
3607 : const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList,
3608 : uno::Reference< drawing::XShapes >& rShapes,
3609 : sal_Bool bTemporaryShape)
3610 62 : : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape )
3611 : {
3612 62 : }
3613 :
3614 : //////////////////////////////////////////////////////////////////////////////
3615 :
3616 124 : SdXMLCustomShapeContext::~SdXMLCustomShapeContext()
3617 : {
3618 124 : }
3619 :
3620 : //////////////////////////////////////////////////////////////////////////////
3621 :
3622 : // this is called from the parent group for each unparsed attribute in the attribute list
3623 432 : void SdXMLCustomShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue )
3624 : {
3625 432 : if( XML_NAMESPACE_DRAW == nPrefix )
3626 : {
3627 183 : if( IsXMLToken( rLocalName, XML_ENGINE ) )
3628 : {
3629 0 : maCustomShapeEngine = rValue;
3630 0 : return;
3631 : }
3632 183 : if ( IsXMLToken( rLocalName, XML_DATA ) )
3633 : {
3634 0 : maCustomShapeData = rValue;
3635 0 : return;
3636 : }
3637 : }
3638 432 : SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue );
3639 : }
3640 :
3641 : //////////////////////////////////////////////////////////////////////////////
3642 :
3643 62 : void SdXMLCustomShapeContext::StartElement( const uno::Reference< xml::sax::XAttributeList >& xAttrList )
3644 : {
3645 : // create rectangle shape
3646 62 : AddShape("com.sun.star.drawing.CustomShape");
3647 62 : if ( mxShape.is() )
3648 : {
3649 : // Add, set Style and properties from base shape
3650 62 : SetStyle();
3651 62 : SetLayer();
3652 :
3653 : // set pos, size, shear and rotate
3654 62 : SetTransformation();
3655 :
3656 : try
3657 : {
3658 62 : uno::Reference< beans::XPropertySet > xPropSet( mxShape, uno::UNO_QUERY );
3659 62 : if( xPropSet.is() )
3660 : {
3661 62 : if ( !maCustomShapeEngine.isEmpty() )
3662 : {
3663 0 : uno::Any aAny;
3664 0 : aAny <<= maCustomShapeEngine;
3665 0 : xPropSet->setPropertyValue( EASGet( EAS_CustomShapeEngine ), aAny );
3666 : }
3667 62 : if ( !maCustomShapeData.isEmpty() )
3668 : {
3669 0 : uno::Any aAny;
3670 0 : aAny <<= maCustomShapeData;
3671 0 : xPropSet->setPropertyValue( EASGet( EAS_CustomShapeData ), aAny );
3672 : }
3673 62 : }
3674 : }
3675 0 : catch(const uno::Exception&)
3676 : {
3677 : OSL_FAIL( "could not set enhanced customshape geometry" );
3678 : }
3679 62 : SdXMLShapeContext::StartElement(xAttrList);
3680 : }
3681 62 : }
3682 :
3683 62 : void SdXMLCustomShapeContext::EndElement()
3684 : {
3685 62 : if ( !maCustomShapeGeometry.empty() )
3686 : {
3687 62 : const rtl::OUString sCustomShapeGeometry ( "CustomShapeGeometry" );
3688 :
3689 : // converting the vector to a sequence
3690 62 : uno::Sequence< beans::PropertyValue > aSeq( maCustomShapeGeometry.size() );
3691 62 : beans::PropertyValue* pValues = aSeq.getArray();
3692 62 : std::vector< beans::PropertyValue >::const_iterator aIter( maCustomShapeGeometry.begin() );
3693 62 : std::vector< beans::PropertyValue >::const_iterator aEnd( maCustomShapeGeometry.end() );
3694 444 : while ( aIter != aEnd )
3695 320 : *pValues++ = *aIter++;
3696 :
3697 : try
3698 : {
3699 62 : uno::Reference< beans::XPropertySet > xPropSet( mxShape, uno::UNO_QUERY );
3700 62 : if( xPropSet.is() )
3701 : {
3702 62 : uno::Any aAny;
3703 62 : aAny <<= aSeq;
3704 62 : xPropSet->setPropertyValue( sCustomShapeGeometry, aAny );
3705 62 : }
3706 : }
3707 0 : catch(const uno::Exception&)
3708 : {
3709 : OSL_FAIL( "could not set enhanced customshape geometry" );
3710 : }
3711 :
3712 62 : sal_Int32 nUPD( 0 );
3713 62 : sal_Int32 nBuild( 0 );
3714 62 : GetImport().getBuildIds( nUPD, nBuild );
3715 62 : if( ((nUPD >= 640 && nUPD <= 645) || (nUPD == 680)) && (nBuild <= 9221) )
3716 : {
3717 0 : Reference< drawing::XEnhancedCustomShapeDefaulter > xDefaulter( mxShape, UNO_QUERY );
3718 0 : if( xDefaulter.is() )
3719 : {
3720 0 : rtl::OUString aEmptyType;
3721 0 : xDefaulter->createCustomShapeDefaults( aEmptyType );
3722 0 : }
3723 62 : }
3724 : }
3725 :
3726 62 : SdXMLShapeContext::EndElement();
3727 62 : }
3728 :
3729 : //////////////////////////////////////////////////////////////////////////////
3730 :
3731 124 : SvXMLImportContext* SdXMLCustomShapeContext::CreateChildContext(
3732 : sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName,
3733 : const uno::Reference<xml::sax::XAttributeList>& xAttrList )
3734 : {
3735 124 : SvXMLImportContext* pContext = NULL;
3736 124 : if ( XML_NAMESPACE_DRAW == nPrefix )
3737 : {
3738 62 : if ( IsXMLToken( rLocalName, XML_ENHANCED_GEOMETRY ) )
3739 : {
3740 62 : uno::Reference< beans::XPropertySet > xPropSet( mxShape,uno::UNO_QUERY );
3741 62 : if ( xPropSet.is() )
3742 62 : pContext = new XMLEnhancedCustomShapeContext( GetImport(), mxShape, nPrefix, rLocalName, maCustomShapeGeometry );
3743 : }
3744 : }
3745 : // delegate to parent class if no context could be created
3746 124 : if ( NULL == pContext )
3747 : pContext = SdXMLShapeContext::CreateChildContext( nPrefix, rLocalName,
3748 62 : xAttrList);
3749 124 : return pContext;
3750 : }
3751 :
3752 : ///////////////////////////////////////////////////////////////////////
3753 :
3754 : //////////////////////////////////////////////////////////////////////////////
3755 :
3756 0 : TYPEINIT1( SdXMLTableShapeContext, SdXMLShapeContext );
3757 :
3758 2 : SdXMLTableShapeContext::SdXMLTableShapeContext( SvXMLImport& rImport, sal_uInt16 nPrfx, const rtl::OUString& rLocalName, const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList, com::sun::star::uno::Reference< com::sun::star::drawing::XShapes >& rShapes )
3759 2 : : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, sal_False )
3760 : {
3761 2 : memset( &maTemplateStylesUsed, 0, sizeof( maTemplateStylesUsed ) );
3762 2 : }
3763 :
3764 4 : SdXMLTableShapeContext::~SdXMLTableShapeContext()
3765 : {
3766 4 : }
3767 :
3768 2 : void SdXMLTableShapeContext::StartElement( const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList >& xAttrList )
3769 : {
3770 2 : const char* pService = "com.sun.star.drawing.TableShape";
3771 :
3772 2 : sal_Bool bIsPresShape = !maPresentationClass.isEmpty() && GetImport().GetShapeImport()->IsPresentationShapesSupported();
3773 2 : if( bIsPresShape )
3774 : {
3775 0 : if( IsXMLToken( maPresentationClass, XML_PRESENTATION_TABLE ) )
3776 : {
3777 0 : pService = "com.sun.star.presentation.TableShape";
3778 : }
3779 : }
3780 :
3781 2 : AddShape( pService );
3782 :
3783 2 : if( mxShape.is() )
3784 : {
3785 2 : SetLayer();
3786 :
3787 2 : uno::Reference< beans::XPropertySet > xProps(mxShape, uno::UNO_QUERY);
3788 :
3789 2 : if(bIsPresShape)
3790 : {
3791 0 : if(xProps.is())
3792 : {
3793 0 : uno::Reference< beans::XPropertySetInfo > xPropsInfo( xProps->getPropertySetInfo() );
3794 0 : if( xPropsInfo.is() )
3795 : {
3796 0 : if( !mbIsPlaceholder && xPropsInfo->hasPropertyByName(OUString("IsEmptyPresentationObject" )))
3797 0 : xProps->setPropertyValue( OUString("IsEmptyPresentationObject" ), ::cppu::bool2any( sal_False ) );
3798 :
3799 0 : if( mbIsUserTransformed && xPropsInfo->hasPropertyByName(OUString("IsPlaceholderDependent" )))
3800 0 : xProps->setPropertyValue( OUString("IsPlaceholderDependent" ), ::cppu::bool2any( sal_False ) );
3801 0 : }
3802 : }
3803 : }
3804 :
3805 2 : SetStyle();
3806 :
3807 2 : if( xProps.is() )
3808 : {
3809 2 : if( !msTemplateStyleName.isEmpty() ) try
3810 : {
3811 2 : Reference< XStyleFamiliesSupplier > xFamiliesSupp( GetImport().GetModel(), UNO_QUERY_THROW );
3812 2 : Reference< XNameAccess > xFamilies( xFamiliesSupp->getStyleFamilies() );
3813 2 : const OUString sFamilyName( "table" );
3814 2 : Reference< XNameAccess > xTableFamily( xFamilies->getByName( sFamilyName ), UNO_QUERY_THROW );
3815 2 : Reference< XStyle > xTableStyle( xTableFamily->getByName( msTemplateStyleName ), UNO_QUERY_THROW );
3816 2 : xProps->setPropertyValue( OUString( "TableTemplate" ), Any( xTableStyle ) );
3817 : }
3818 0 : catch(const Exception&)
3819 : {
3820 : OSL_FAIL("SdXMLTableShapeContext::StartElement(), exception caught!");
3821 : }
3822 :
3823 2 : const XMLPropertyMapEntry* pEntry = &aXMLTableShapeAttributes[0];
3824 14 : for( int i = 0; pEntry->msApiName && (i < 6); i++, pEntry++ )
3825 : {
3826 : try
3827 : {
3828 12 : const OUString sAPIPropertyName( OUString(pEntry->msApiName, pEntry->nApiNameLength, RTL_TEXTENCODING_ASCII_US ) );
3829 12 : xProps->setPropertyValue( sAPIPropertyName, Any( maTemplateStylesUsed[i] ) );
3830 : }
3831 0 : catch(const Exception&)
3832 : {
3833 : OSL_FAIL("SdXMLTableShapeContext::StartElement(), exception caught!");
3834 : }
3835 : }
3836 : }
3837 :
3838 2 : GetImport().GetShapeImport()->finishShape( mxShape, mxAttrList, mxShapes );
3839 :
3840 2 : const rtl::Reference< XMLTableImport >& xTableImport( GetImport().GetShapeImport()->GetShapeTableImport() );
3841 2 : if( xTableImport.is() && xProps.is() )
3842 : {
3843 : uno::Reference< table::XColumnRowRange > xColumnRowRange(
3844 2 : xProps->getPropertyValue( OUString("Model" ) ), uno::UNO_QUERY );
3845 :
3846 2 : if( xColumnRowRange.is() )
3847 2 : mxTableImportContext = xTableImport->CreateTableContext( GetPrefix(), GetLocalName(), xColumnRowRange );
3848 :
3849 2 : if( mxTableImportContext.Is() )
3850 2 : mxTableImportContext->StartElement( xAttrList );
3851 2 : }
3852 : }
3853 2 : }
3854 :
3855 2 : void SdXMLTableShapeContext::EndElement()
3856 : {
3857 2 : if( mxTableImportContext.Is() )
3858 2 : mxTableImportContext->EndElement();
3859 :
3860 2 : SdXMLShapeContext::EndElement();
3861 :
3862 2 : if( mxShape.is() )
3863 : {
3864 : // set pos, size, shear and rotate
3865 2 : SetTransformation();
3866 : }
3867 2 : }
3868 :
3869 : // this is called from the parent group for each unparsed attribute in the attribute list
3870 18 : void SdXMLTableShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue )
3871 : {
3872 18 : if( nPrefix == XML_NAMESPACE_TABLE )
3873 : {
3874 6 : if( IsXMLToken( rLocalName, XML_TEMPLATE_NAME ) )
3875 : {
3876 2 : msTemplateStyleName = rValue;
3877 : }
3878 : else
3879 : {
3880 4 : int i = 0;
3881 4 : const XMLPropertyMapEntry* pEntry = &aXMLTableShapeAttributes[0];
3882 16 : while( pEntry->msApiName && (i < 6) )
3883 : {
3884 12 : if( IsXMLToken( rLocalName, pEntry->meXMLName ) )
3885 : {
3886 4 : if( IsXMLToken( rValue, XML_TRUE ) )
3887 4 : maTemplateStylesUsed[i] = sal_True;
3888 4 : break;
3889 : }
3890 8 : pEntry++;
3891 8 : i++;
3892 : }
3893 : }
3894 : }
3895 18 : SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue );
3896 18 : }
3897 :
3898 18 : SvXMLImportContext* SdXMLTableShapeContext::CreateChildContext( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const uno::Reference<xml::sax::XAttributeList>& xAttrList )
3899 : {
3900 18 : if( mxTableImportContext.Is() && (nPrefix == XML_NAMESPACE_TABLE) )
3901 18 : return mxTableImportContext->CreateChildContext(nPrefix, rLocalName, xAttrList);
3902 : else
3903 0 : return SdXMLShapeContext::CreateChildContext(nPrefix, rLocalName, xAttrList);
3904 : }
3905 :
3906 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
