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