xmloff/source/draw/ximpshap.cxx

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