xmloff/source/draw/ximpstyl.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: ximpstyl.cxx,v $
  10  * $Revision: 1.53 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_xmloff.hxx"
  33
  34
  35 #include "ximpstyl.hxx"
  36 #include <xmloff/XMLShapeStyleContext.hxx>
  37 #include "xmlnmspe.hxx"
  38 #include <xmloff/xmltoken.hxx>
  39 #include <xmloff/xmluconv.hxx>
  40 #include "ximpnote.hxx"
  41 #include <tools/debug.hxx>
  42
  43 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  44 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
  45 #include <com/sun/star/presentation/XPresentationPage.hpp>
  46 #include <com/sun/star/drawing/XDrawPages.hpp>
  47 #include <com/sun/star/container/XNamed.hpp>
  48 #include <com/sun/star/beans/XPropertySet.hpp>
  49 #include <com/sun/star/beans/XPropertyState.hpp>
  50 #include <com/sun/star/presentation/XHandoutMasterSupplier.hpp>
  51 #include <comphelper/namecontainer.hxx>
  52 #include <xmloff/xmlprcon.hxx>
  53 #include <xmloff/families.hxx>
  54 #include <com/sun/star/container/XNameContainer.hpp>
  55 #include <svtools/zforlist.hxx>
  56 #include "PropertySetMerger.hxx"
  57 #include "sdpropls.hxx"
  58 #include "layerimp.hxx"
  59 #include <xmloff/XMLGraphicsDefaultStyle.hxx>
  60 #include "XMLNumberStylesImport.hxx"
  61 #include "xmlerror.hxx"
  62
  63 using ::rtl::OUString;
  64 using ::rtl::OUStringBuffer;
  65
  66 using namespace ::com::sun::star;
  67 using namespace ::com::sun::star::uno;
  68 using namespace ::com::sun::star::xml::sax;
  69 using namespace ::xmloff::token;
  70
  71 //////////////////////////////////////////////////////////////////////////////
  72
  73 class SdXMLDrawingPagePropertySetContext : public SvXMLPropertySetContext
  74 {
  75 public:
  76
  77     TYPEINFO();
  78
  79     SdXMLDrawingPagePropertySetContext( SvXMLImport& rImport, sal_uInt16 nPrfx,
  80                 const ::rtl::OUString& rLName,
  81                  const ::com::sun::star::uno::Reference<
  82                          ::com::sun::star::xml::sax::XAttributeList >& xAttrList,
  83                  ::std::vector< XMLPropertyState > &rProps,
  84                  const UniReference < SvXMLImportPropertyMapper > &rMap );
  85
  86     virtual ~SdXMLDrawingPagePropertySetContext();
  87
  88     using SvXMLPropertySetContext::CreateChildContext;
  89     virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
  90                                    const ::rtl::OUString& rLocalName,
  91                                    const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList >& xAttrList,
  92                                    ::std::vector< XMLPropertyState > &rProperties,
  93                                    const XMLPropertyState& rProp);
  94 };
  95
  96 TYPEINIT1( SdXMLDrawingPagePropertySetContext, SvXMLPropertySetContext );
  97
  98 SdXMLDrawingPagePropertySetContext::SdXMLDrawingPagePropertySetContext(
  99                  SvXMLImport& rImport, sal_uInt16 nPrfx,
 100                  const OUString& rLName,
 101                  const uno::Reference< xml::sax::XAttributeList > & xAttrList,
 102                  ::std::vector< XMLPropertyState > &rProps,
 103                  const UniReference < SvXMLImportPropertyMapper > &rMap ) :
 104     SvXMLPropertySetContext( rImport, nPrfx, rLName, xAttrList,
 105                              XML_TYPE_PROP_DRAWING_PAGE, rProps, rMap )
 106 {
 107 }
 108
 109 SdXMLDrawingPagePropertySetContext::~SdXMLDrawingPagePropertySetContext()
 110 {
 111 }
 112
 113 SvXMLImportContext *SdXMLDrawingPagePropertySetContext::CreateChildContext(
 114                    sal_uInt16 p_nPrefix,
 115                    const OUString& rLocalName,
 116                    const uno::Reference< xml::sax::XAttributeList > & xAttrList,
 117                    ::std::vector< XMLPropertyState > &rProperties,
 118                    const XMLPropertyState& rProp )
 119 {
 120     SvXMLImportContext *pContext = 0;
 121
 122     switch( mxMapper->getPropertySetMapper()->GetEntryContextId( rProp.mnIndex ) )
 123     {
 124     case CTF_PAGE_SOUND_URL:
 125     {
 126         const sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
 127         for(sal_Int16 i=0; i < nAttrCount; i++)
 128         {
 129             OUString aLocalName;
 130             sal_uInt16 nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName(xAttrList->getNameByIndex(i), &aLocalName);
 131
 132             if( (nPrefix == XML_NAMESPACE_XLINK) && IsXMLToken( aLocalName, XML_HREF ) )
 133             {
 134                 uno::Any aAny( GetImport().GetAbsoluteReference( xAttrList->getValueByIndex(i) ) );
 135                 XMLPropertyState aPropState( rProp.mnIndex, aAny );
 136                 rProperties.push_back( aPropState );
 137             }
 138         }
 139         break;
 140     }
 141     }
 142
 143     if( !pContext )
 144         pContext = SvXMLPropertySetContext::CreateChildContext( p_nPrefix, rLocalName,
 145                                                             xAttrList,
 146                                                             rProperties, rProp );
 147
 148     return pContext;
 149 }
 150
 151 //////////////////////////////////////////////////////////////////////////////
 152
 153 class SdXMLDrawingPageStyleContext : public XMLPropStyleContext
 154 {
 155 public:
 156     TYPEINFO();
 157
 158     SdXMLDrawingPageStyleContext(
 159         SvXMLImport& rImport,
 160         sal_uInt16 nPrfx,
 161         const rtl::OUString& rLName,
 162         const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList >& xAttrList,
 163         SvXMLStylesContext& rStyles,
 164         sal_uInt16 nFamily = XML_STYLE_FAMILY_SD_DRAWINGPAGE_ID);
 165     virtual ~SdXMLDrawingPageStyleContext();
 166
 167     SvXMLImportContext * CreateChildContext(
 168         sal_uInt16 nPrefix,
 169         const ::rtl::OUString& rLocalName,
 170         const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList > & xAttrList );
 171
 172     virtual void Finish( sal_Bool bOverwrite );
 173
 174     // #i35918#
 175     virtual void FillPropertySet(
 176             const ::com::sun::star::uno::Reference<
 177                 ::com::sun::star::beans::XPropertySet > & rPropSet );
 178 };
 179
 180 TYPEINIT1( SdXMLDrawingPageStyleContext, XMLPropStyleContext );
 181
 182 SdXMLDrawingPageStyleContext::SdXMLDrawingPageStyleContext(
 183     SvXMLImport& rImport,
 184     sal_uInt16 nPrfx,
 185     const OUString& rLName,
 186     const uno::Reference< xml::sax::XAttributeList >& xAttrList,
 187     SvXMLStylesContext& rStyles,
 188     sal_uInt16 nFamily)
 189 :       XMLPropStyleContext(rImport, nPrfx, rLName, xAttrList, rStyles, nFamily )
 190 {
 191 }
 192
 193 SdXMLDrawingPageStyleContext::~SdXMLDrawingPageStyleContext()
 194 {
 195 }
 196
 197 SvXMLImportContext *SdXMLDrawingPageStyleContext::CreateChildContext(
 198         sal_uInt16 nPrefix,
 199         const OUString& rLocalName,
 200         const uno::Reference< xml::sax::XAttributeList > & xAttrList )
 201 {
 202     SvXMLImportContext *pContext = 0;
 203
 204     if( XML_NAMESPACE_STYLE == nPrefix &&
 205         IsXMLToken( rLocalName, XML_DRAWING_PAGE_PROPERTIES ) )
 206     {
 207         UniReference < SvXMLImportPropertyMapper > xImpPrMap =
 208             GetStyles()->GetImportPropertyMapper( GetFamily() );
 209         if( xImpPrMap.is() )
 210             pContext = new SdXMLDrawingPagePropertySetContext( GetImport(), nPrefix,
 211                                                     rLocalName, xAttrList,
 212                                                     GetProperties(),
 213                                                     xImpPrMap );
 214     }
 215
 216     if( !pContext )
 217         pContext = XMLPropStyleContext::CreateChildContext( nPrefix, rLocalName,
 218                                                           xAttrList );
 219
 220     return pContext;
 221 }
 222
 223 void SdXMLDrawingPageStyleContext::Finish( sal_Bool bOverwrite )
 224 {
 225     XMLPropStyleContext::Finish( bOverwrite );
 226
 227     ::std::vector< XMLPropertyState > &rProperties = GetProperties();
 228
 229     const UniReference< XMLPropertySetMapper >& rImpPrMap = GetStyles()->GetImportPropertyMapper( GetFamily() )->getPropertySetMapper();
 230
 231     ::std::vector< XMLPropertyState >::iterator property = rProperties.begin();
 232     for(; property != rProperties.end(); property++)
 233     {
 234         if( property->mnIndex == -1 )
 235             continue;
 236
 237         sal_Int16 nContextID = rImpPrMap->GetEntryContextId(property->mnIndex);
 238         switch( nContextID )
 239         {
 240             case CTF_DATE_TIME_FORMAT:
 241             {
 242                 OUString sStyleName;
 243                 (*property).maValue >>= sStyleName;
 244
 245                 sal_Int32 nStyle = 0;
 246
 247                 SdXMLNumberFormatImportContext* pSdNumStyle =
 248                     PTR_CAST( SdXMLNumberFormatImportContext,
 249                         GetStyles()->FindStyleChildContext( XML_STYLE_FAMILY_DATA_STYLE, sStyleName, sal_True ) );
 250
 251                 if( pSdNumStyle )
 252                     nStyle = pSdNumStyle->GetDrawKey();
 253
 254                 (*property).maValue <<= nStyle;
 255             }
 256             break;
 257         }
 258     }
 259
 260 }
 261
 262 // #i35918#
 263 void SdXMLDrawingPageStyleContext::FillPropertySet(
 264     const Reference< beans::XPropertySet > & rPropSet )
 265 {
 266     const sal_uInt16 MAX_SPECIAL_DRAW_STYLES = 7;
 267     struct _ContextID_Index_Pair aContextIDs[MAX_SPECIAL_DRAW_STYLES+1] =
 268     {
 269         { CTF_DASHNAME , -1 },
 270         { CTF_LINESTARTNAME , -1 },
 271         { CTF_LINEENDNAME , -1 },
 272         { CTF_FILLGRADIENTNAME, -1 },
 273         { CTF_FILLTRANSNAME , -1 },
 274         { CTF_FILLHATCHNAME , -1 },
 275         { CTF_FILLBITMAPNAME , -1 },
 276         { -1, -1 }
 277     };
 278     static sal_uInt16 aFamilies[MAX_SPECIAL_DRAW_STYLES] =
 279     {
 280         XML_STYLE_FAMILY_SD_STROKE_DASH_ID,
 281         XML_STYLE_FAMILY_SD_MARKER_ID,
 282         XML_STYLE_FAMILY_SD_MARKER_ID,
 283         XML_STYLE_FAMILY_SD_GRADIENT_ID,
 284         XML_STYLE_FAMILY_SD_GRADIENT_ID,
 285         XML_STYLE_FAMILY_SD_HATCH_ID,
 286         XML_STYLE_FAMILY_SD_FILL_IMAGE_ID
 287     };
 288
 289     UniReference < SvXMLImportPropertyMapper > xImpPrMap =
 290         GetStyles()->GetImportPropertyMapper( GetFamily() );
 291     DBG_ASSERT( xImpPrMap.is(), "There is the import prop mapper" );
 292     if( xImpPrMap.is() )
 293         xImpPrMap->FillPropertySet( GetProperties(), rPropSet, aContextIDs );
 294
 295     Reference< beans::XPropertySetInfo > xInfo;
 296     for( sal_uInt16 i=0; i<MAX_SPECIAL_DRAW_STYLES; i++ )
 297     {
 298         sal_Int32 nIndex = aContextIDs[i].nIndex;
 299         if( nIndex != -1 )
 300         {
 301             struct XMLPropertyState& rState = GetProperties()[nIndex];
 302             OUString sStyleName;
 303             rState.maValue >>= sStyleName;
 304             sStyleName = GetImport().GetStyleDisplayName( aFamilies[i],
 305                                                           sStyleName );
 306             // get property set mapper
 307             UniReference<XMLPropertySetMapper> rPropMapper =
 308                                         xImpPrMap->getPropertySetMapper();
 309
 310             // set property
 311             const OUString& rPropertyName =
 312                     rPropMapper->GetEntryAPIName(rState.mnIndex);
 313             if( !xInfo.is() )
 314                 xInfo = rPropSet->getPropertySetInfo();
 315             if ( xInfo->hasPropertyByName( rPropertyName ) )
 316             {
 317                 rPropSet->setPropertyValue( rPropertyName, Any( sStyleName ) );
 318             }
 319         }
 320     }
 321 }
 322
 323 //////////////////////////////////////////////////////////////////////////////
 324
 325 TYPEINIT1( SdXMLPageMasterStyleContext, SvXMLStyleContext );
 326
 327 SdXMLPageMasterStyleContext::SdXMLPageMasterStyleContext(
 328     SdXMLImport& rImport,
 329     sal_uInt16 nPrfx,
 330     const OUString& rLName,
 331     const uno::Reference< xml::sax::XAttributeList>& xAttrList)
 332 :       SvXMLStyleContext(rImport, nPrfx, rLName, xAttrList, XML_STYLE_FAMILY_SD_PAGEMASTERSTYLECONEXT_ID),
 333     mnBorderBottom( 0L ),
 334     mnBorderLeft( 0L ),
 335     mnBorderRight( 0L ),
 336     mnBorderTop( 0L ),
 337     mnWidth( 0L ),
 338     mnHeight( 0L ),
 339     meOrientation(GetSdImport().IsDraw() ? view::PaperOrientation_PORTRAIT : view::PaperOrientation_LANDSCAPE)
 340 {
 341     // set family to something special at SvXMLStyleContext
 342     // for differences in search-methods
 343
 344     sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
 345     for(sal_Int16 i=0; i < nAttrCount; i++)
 346     {
 347         OUString sAttrName = xAttrList->getNameByIndex(i);
 348         OUString aLocalName;
 349         sal_uInt16 nPrefix = GetSdImport().GetNamespaceMap().GetKeyByAttrName(sAttrName, &aLocalName);
 350         OUString sValue = xAttrList->getValueByIndex(i);
 351         const SvXMLTokenMap& rAttrTokenMap = GetSdImport().GetPageMasterStyleAttrTokenMap();
 352
 353         switch(rAttrTokenMap.Get(nPrefix, aLocalName))
 354         {
 355             case XML_TOK_PAGEMASTERSTYLE_MARGIN_TOP:
 356             {
 357                 GetSdImport().GetMM100UnitConverter().convertMeasure(mnBorderTop, sValue);
 358                 break;
 359             }
 360             case XML_TOK_PAGEMASTERSTYLE_MARGIN_BOTTOM:
 361             {
 362                 GetSdImport().GetMM100UnitConverter().convertMeasure(mnBorderBottom, sValue);
 363                 break;
 364             }
 365             case XML_TOK_PAGEMASTERSTYLE_MARGIN_LEFT:
 366             {
 367                 GetSdImport().GetMM100UnitConverter().convertMeasure(mnBorderLeft, sValue);
 368                 break;
 369             }
 370             case XML_TOK_PAGEMASTERSTYLE_MARGIN_RIGHT:
 371             {
 372                 GetSdImport().GetMM100UnitConverter().convertMeasure(mnBorderRight, sValue);
 373                 break;
 374             }
 375             case XML_TOK_PAGEMASTERSTYLE_PAGE_WIDTH:
 376             {
 377                 GetSdImport().GetMM100UnitConverter().convertMeasure(mnWidth, sValue);
 378                 break;
 379             }
 380             case XML_TOK_PAGEMASTERSTYLE_PAGE_HEIGHT:
 381             {
 382                 GetSdImport().GetMM100UnitConverter().convertMeasure(mnHeight, sValue);
 383                 break;
 384             }
 385             case XML_TOK_PAGEMASTERSTYLE_PAGE_ORIENTATION:
 386             {
 387                 if( IsXMLToken( sValue, XML_PORTRAIT ) )
 388                     meOrientation = view::PaperOrientation_PORTRAIT;
 389                 else
 390                     meOrientation = view::PaperOrientation_LANDSCAPE;
 391                 break;
 392             }
 393         }
 394     }
 395 }
 396
 397 //////////////////////////////////////////////////////////////////////////////
 398
 399 SdXMLPageMasterStyleContext::~SdXMLPageMasterStyleContext()
 400 {
 401 }
 402
 403 //////////////////////////////////////////////////////////////////////////////
 404 //////////////////////////////////////////////////////////////////////////////
 405
 406 TYPEINIT1( SdXMLPageMasterContext, SvXMLStyleContext );
 407
 408 SdXMLPageMasterContext::SdXMLPageMasterContext(
 409     SdXMLImport& rImport,
 410     sal_uInt16 nPrfx,
 411     const OUString& rLName,
 412     const uno::Reference< xml::sax::XAttributeList>& xAttrList)
 413 :       SvXMLStyleContext(rImport, nPrfx, rLName, xAttrList, XML_STYLE_FAMILY_SD_PAGEMASTERCONEXT_ID),
 414     mpPageMasterStyle( 0L )
 415 {
 416     // set family to something special at SvXMLStyleContext
 417     // for differences in search-methods
 418
 419     sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
 420     for(sal_Int16 i=0; i < nAttrCount; i++)
 421     {
 422         OUString sAttrName = xAttrList->getNameByIndex(i);
 423         OUString aLocalName;
 424         sal_uInt16 nPrefix = GetSdImport().GetNamespaceMap().GetKeyByAttrName(sAttrName, &aLocalName);
 425         OUString sValue = xAttrList->getValueByIndex(i);
 426         const SvXMLTokenMap& rAttrTokenMap = GetSdImport().GetPageMasterAttrTokenMap();
 427
 428         switch(rAttrTokenMap.Get(nPrefix, aLocalName))
 429         {
 430             case XML_TOK_PAGEMASTER_NAME:
 431             {
 432                 msName = sValue;
 433                 break;
 434             }
 435         }
 436     }
 437 }
 438
 439 //////////////////////////////////////////////////////////////////////////////
 440
 441 SdXMLPageMasterContext::~SdXMLPageMasterContext()
 442 {
 443     // release remembered contexts, they are no longer needed
 444     if(mpPageMasterStyle)
 445     {
 446         mpPageMasterStyle->ReleaseRef();
 447         mpPageMasterStyle = 0L;
 448     }
 449 }
 450
 451 //////////////////////////////////////////////////////////////////////////////
 452
 453 SvXMLImportContext *SdXMLPageMasterContext::CreateChildContext(
 454     sal_uInt16 nPrefix,
 455     const OUString& rLocalName,
 456     const uno::Reference< xml::sax::XAttributeList >& xAttrList )
 457 {
 458     SvXMLImportContext* pContext = 0;
 459
 460     if(nPrefix == XML_NAMESPACE_STYLE && IsXMLToken( rLocalName, XML_PAGE_LAYOUT_PROPERTIES) )
 461     {
 462         pContext = new SdXMLPageMasterStyleContext(GetSdImport(), nPrefix, rLocalName, xAttrList);
 463
 464         // remember SdXMLPresentationPlaceholderContext for later evaluation
 465         if(pContext)
 466         {
 467             pContext->AddRef();
 468             DBG_ASSERT(!mpPageMasterStyle, "PageMasterStyle is set, there seem to be two of them (!)");
 469             mpPageMasterStyle = (SdXMLPageMasterStyleContext*)pContext;
 470         }
 471     }
 472
 473     // call base class
 474     if(!pContext)
 475         pContext = SvXMLStyleContext::CreateChildContext(nPrefix, rLocalName, xAttrList);
 476
 477     return pContext;
 478 }
 479
 480 //////////////////////////////////////////////////////////////////////////////
 481 //////////////////////////////////////////////////////////////////////////////
 482
 483 TYPEINIT1( SdXMLPresentationPageLayoutContext, SvXMLStyleContext );
 484
 485 SdXMLPresentationPageLayoutContext::SdXMLPresentationPageLayoutContext(
 486     SdXMLImport& rImport,
 487     sal_uInt16 nPrfx,
 488     const OUString& rLName,
 489     const uno::Reference< xml::sax::XAttributeList >& xAttrList)
 490 :       SvXMLStyleContext(rImport, nPrfx, rLName, xAttrList, XML_STYLE_FAMILY_SD_PRESENTATIONPAGELAYOUT_ID),
 491     mnTypeId( 20 ) // AUTOLAYOUT_NONE
 492 {
 493     // set family to somethiong special at SvXMLStyleContext
 494     // for differences in search-methods
 495
 496     sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
 497     for( sal_Int16 i=0; i < nAttrCount; i++ )
 498     {
 499         const OUString& rAttrName = xAttrList->getNameByIndex( i );
 500         OUString aLocalName;
 501         sal_uInt16 nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName( rAttrName, &aLocalName );
 502
 503         if(nPrefix == XML_NAMESPACE_STYLE && IsXMLToken( aLocalName, XML_NAME ) )
 504         {
 505             msName = xAttrList->getValueByIndex( i );
 506         }
 507     }
 508 }
 509
 510 SdXMLPresentationPageLayoutContext::~SdXMLPresentationPageLayoutContext()
 511 {
 512 }
 513
 514 SvXMLImportContext *SdXMLPresentationPageLayoutContext::CreateChildContext(
 515     sal_uInt16 nPrefix,
 516     const OUString& rLocalName,
 517     const uno::Reference< xml::sax::XAttributeList >& xAttrList )
 518 {
 519     SvXMLImportContext* pContext = 0;
 520
 521     if(nPrefix == XML_NAMESPACE_PRESENTATION && IsXMLToken( rLocalName, XML_PLACEHOLDER ) )
 522     {
 523         // presentation:placeholder inside style:presentation-page-layout context
 524         pContext = new SdXMLPresentationPlaceholderContext(
 525             GetSdImport(), nPrefix, rLocalName, xAttrList);
 526
 527         // remember SdXMLPresentationPlaceholderContext for later evaluation
 528         if(pContext)
 529         {
 530             pContext->AddRef();
 531             maList.Insert((SdXMLPresentationPlaceholderContext*)pContext, LIST_APPEND);
 532         }
 533     }
 534
 535     // call base class
 536     if(!pContext)
 537         pContext = SvXMLStyleContext::CreateChildContext(nPrefix, rLocalName, xAttrList);
 538
 539     return pContext;
 540 }
 541
 542 void SdXMLPresentationPageLayoutContext::EndElement()
 543 {
 544     // build presentation page layout type here
 545     // calc mnTpeId due to content of maList
 546     // at the moment only use number of types used there
 547     if(maList.Count())
 548     {
 549         SdXMLPresentationPlaceholderContext* pObj0 = maList.GetObject(0);
 550         if(pObj0->GetName().equals(OUString(RTL_CONSTASCII_USTRINGPARAM("handout"))))
 551         {
 552             switch( maList.Count() )
 553             {
 554             case 1:
 555                 mnTypeId = 22; // AUTOLAYOUT_HANDOUT1
 556                 break;
 557             case 2:
 558                 mnTypeId = 23; // AUTOLAYOUT_HANDOUT2
 559                 break;
 560             case 3:
 561                 mnTypeId = 24; // AUTOLAYOUT_HANDOUT3
 562                 break;
 563             case 4:
 564                 mnTypeId = 25; // AUTOLAYOUT_HANDOUT4
 565                 break;
 566             case 9:
 567                 mnTypeId = 31; // AUTOLAYOUT_HANDOUT9
 568                 break;
 569             default:
 570                 mnTypeId = 26; // AUTOLAYOUT_HANDOUT6
 571             }
 572         }
 573         else
 574         {
 575             switch(maList.Count())
 576             {
 577                 case 1:
 578                 {
 579                     if(pObj0->GetName().equals(OUString(RTL_CONSTASCII_USTRINGPARAM("title"))))
 580                     {
 581                         mnTypeId = 19; // AUTOLAYOUT_ONLY_TITLE
 582                     }
 583                     else
 584                     {
 585                         mnTypeId = 32; // AUTOLAYOUT_ONLY_TEXT
 586                     }
 587                     break;
 588                 }
 589                 case 2:
 590                 {
 591                     SdXMLPresentationPlaceholderContext* pObj1 = maList.GetObject(1);
 592
 593                     if(pObj1->GetName().equals(
 594                         OUString(RTL_CONSTASCII_USTRINGPARAM("subtitle"))))
 595                     {
 596                         mnTypeId = 0; // AUTOLAYOUT_TITLE
 597                     }
 598                     else if(pObj1->GetName().equals(
 599                         OUString(RTL_CONSTASCII_USTRINGPARAM("outline"))))
 600                     {
 601                         mnTypeId = 1; // AUTOLAYOUT_ENUM
 602                     }
 603                     else if(pObj1->GetName().equals(
 604                         OUString(RTL_CONSTASCII_USTRINGPARAM("chart"))))
 605                     {
 606                         mnTypeId = 2; // AUTOLAYOUT_CHART
 607                     }
 608                     else if(pObj1->GetName().equals(
 609                         OUString(RTL_CONSTASCII_USTRINGPARAM("table"))))
 610                     {
 611                         mnTypeId = 8; // AUTOLAYOUT_TAB
 612                     }
 613                     else if(pObj1->GetName().equals(
 614                         OUString(RTL_CONSTASCII_USTRINGPARAM("object"))))
 615                     {
 616                         mnTypeId = 11; // AUTOLAYOUT_OBJ
 617                     }
 618                     else if(pObj1->GetName().equals(
 619                         OUString(RTL_CONSTASCII_USTRINGPARAM("vertical_outline"))))
 620                     {
 621                         if(pObj0->GetName().equals(OUString(RTL_CONSTASCII_USTRINGPARAM("vertical_title"))))
 622                         {
 623                             // AUTOLAYOUT_VERTICAL_TITLE_VERTICAL_OUTLINE
 624                             mnTypeId = 28;
 625                         }
 626                         else
 627                         {
 628                             // AUTOLAYOUT_TITLE_VERTICAL_OUTLINE
 629                             mnTypeId = 29;
 630                         }
 631                     }
 632                     else
 633                     {
 634                         mnTypeId = 21; // AUTOLAYOUT_NOTES
 635                     }
 636                     break;
 637                 }
 638                 case 3:
 639                 {
 640                     SdXMLPresentationPlaceholderContext* pObj1 = maList.GetObject(1);
 641                     SdXMLPresentationPlaceholderContext* pObj2 = maList.GetObject(2);
 642
 643                     if(pObj1->GetName().equals(
 644                         OUString(RTL_CONSTASCII_USTRINGPARAM("outline"))))
 645                     {
 646                         if(pObj2->GetName().equals(
 647                             OUString(RTL_CONSTASCII_USTRINGPARAM("outline"))))
 648                         {
 649                             mnTypeId = 3; // AUTOLAYOUT_2TEXT
 650                         }
 651                         else if(pObj2->GetName().equals(
 652                             OUString(RTL_CONSTASCII_USTRINGPARAM("chart"))))
 653                         {
 654                             mnTypeId = 4; // AUTOLAYOUT_TEXTCHART
 655                         }
 656                         else if(pObj2->GetName().equals(
 657                             OUString(RTL_CONSTASCII_USTRINGPARAM("graphic"))))
 658                         {
 659                             mnTypeId = 6; // AUTOLAYOUT_TEXTCLIP
 660                         }
 661                         else
 662                         {
 663                             if(pObj1->GetX() < pObj2->GetX())
 664                             {
 665                                 mnTypeId = 10; // AUTOLAYOUT_TEXTOBJ -> outline left, object right
 666                             }
 667                             else
 668                             {
 669                                 mnTypeId = 17; // AUTOLAYOUT_TEXTOVEROBJ -> outline top, object right
 670                             }
 671                         }
 672                     }
 673                     else if(pObj1->GetName().equals(
 674                         OUString(RTL_CONSTASCII_USTRINGPARAM("chart"))))
 675                     {
 676                         mnTypeId = 7; // AUTOLAYOUT_CHARTTEXT
 677                     }
 678                     else if(pObj1->GetName().equals(
 679                         OUString(RTL_CONSTASCII_USTRINGPARAM("graphic"))))
 680                     {
 681                         if(pObj2->GetName().equals(OUString(RTL_CONSTASCII_USTRINGPARAM("vertical_outline"))))
 682                         {
 683                             // AUTOLAYOUT_TITLE_VERTICAL_OUTLINE_CLIPART
 684                             mnTypeId = 30;
 685                         }
 686                         else
 687                         {
 688                             mnTypeId = 9; // AUTOLAYOUT_CLIPTEXT
 689                         }
 690                     }
 691                     else if(pObj1->GetName().equals(
 692                         OUString(RTL_CONSTASCII_USTRINGPARAM("vertical_outline"))))
 693                     {
 694                         // AUTOLAYOUT_VERTICAL_TITLE_TEXT_CHART
 695                         mnTypeId = 27;
 696                     }
 697                     else
 698                     {
 699                         if(pObj1->GetX() < pObj2->GetX())
 700                         {
 701                             mnTypeId = 13; // AUTOLAYOUT_OBJTEXT -> left, right
 702                         }
 703                         else
 704                         {
 705                             mnTypeId = 14; // AUTOLAYOUT_OBJOVERTEXT -> top, bottom
 706                         }
 707                     }
 708                     break;
 709                 }
 710                 case 4:
 711                 {
 712                     SdXMLPresentationPlaceholderContext* pObj1 = maList.GetObject(1);
 713                     SdXMLPresentationPlaceholderContext* pObj2 = maList.GetObject(2);
 714
 715                     if(pObj1->GetName().equals(
 716                         OUString(RTL_CONSTASCII_USTRINGPARAM("object"))))
 717                     {
 718                         if(pObj1->GetX() < pObj2->GetX())
 719                         {
 720                             mnTypeId = 16; // AUTOLAYOUT_2OBJOVERTEXT
 721                         }
 722                         else
 723                         {
 724                             mnTypeId = 15; // AUTOLAYOUT_2OBJTEXT
 725                         }
 726                     }
 727                     else
 728                     {
 729                         mnTypeId = 12; // AUTOLAYOUT_TEXT2OBJ
 730                     }
 731                     break;
 732                 }
 733                 case 5:
 734                 {
 735                     SdXMLPresentationPlaceholderContext* pObj1 = maList.GetObject(1);
 736
 737                     if(pObj1->GetName().equals(
 738                         OUString(RTL_CONSTASCII_USTRINGPARAM("object"))))
 739                     {
 740                         mnTypeId = 18; // AUTOLAYOUT_4OBJ
 741                     }
 742                     else
 743                     {
 744                         mnTypeId = 33; // AUTOLAYOUT_4CLIPART
 745                     }
 746                      break;
 747
 748                 }
 749                 case 7:
 750                 {
 751                     mnTypeId = 33; // AUTOLAYOUT_6CLIPART
 752                     break;
 753                 }
 754                 default:
 755                 {
 756                     mnTypeId = 20; // AUTOLAYOUT_NONE
 757                     break;
 758                 }
 759             }
 760         }
 761
 762         // release remembered contexts, they are no longer needed
 763         while(maList.Count())
 764             maList.Remove(maList.Count() - 1)->ReleaseRef();
 765     }
 766 }
 767
 768 //////////////////////////////////////////////////////////////////////////////
 769 //////////////////////////////////////////////////////////////////////////////
 770
 771 SdXMLPresentationPlaceholderContext::SdXMLPresentationPlaceholderContext(
 772     SdXMLImport& rImport,
 773     sal_uInt16 nPrfx, const
 774     OUString& rLName,
 775     const uno::Reference< xml::sax::XAttributeList>& xAttrList)
 776 :       SvXMLImportContext( rImport, nPrfx, rLName),
 777     mnX(0L),
 778     mnY(0L),
 779     mnWidth(1L),
 780     mnHeight(1L)
 781 {
 782     sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
 783     for(sal_Int16 i=0; i < nAttrCount; i++)
 784     {
 785         OUString sAttrName = xAttrList->getNameByIndex(i);
 786         OUString aLocalName;
 787         sal_uInt16 nPrefix = GetSdImport().GetNamespaceMap().GetKeyByAttrName(sAttrName, &aLocalName);
 788         OUString sValue = xAttrList->getValueByIndex(i);
 789         const SvXMLTokenMap& rAttrTokenMap = GetSdImport().GetPresentationPlaceholderAttrTokenMap();
 790
 791         switch(rAttrTokenMap.Get(nPrefix, aLocalName))
 792         {
 793             case XML_TOK_PRESENTATIONPLACEHOLDER_OBJECTNAME:
 794             {
 795                 msName = sValue;
 796                 break;
 797             }
 798             case XML_TOK_PRESENTATIONPLACEHOLDER_X:
 799             {
 800                 GetSdImport().GetMM100UnitConverter().convertMeasure(mnX, sValue);
 801                 break;
 802             }
 803             case XML_TOK_PRESENTATIONPLACEHOLDER_Y:
 804             {
 805                 GetSdImport().GetMM100UnitConverter().convertMeasure(mnY, sValue);
 806                 break;
 807             }
 808             case XML_TOK_PRESENTATIONPLACEHOLDER_WIDTH:
 809             {
 810                 GetSdImport().GetMM100UnitConverter().convertMeasure(mnWidth, sValue);
 811                 break;
 812             }
 813             case XML_TOK_PRESENTATIONPLACEHOLDER_HEIGHT:
 814             {
 815                 GetSdImport().GetMM100UnitConverter().convertMeasure(mnHeight, sValue);
 816                 break;
 817             }
 818         }
 819     }
 820 }
 821
 822 //////////////////////////////////////////////////////////////////////////////
 823
 824 SdXMLPresentationPlaceholderContext::~SdXMLPresentationPlaceholderContext()
 825 {
 826 }
 827
 828 //////////////////////////////////////////////////////////////////////////////
 829 //////////////////////////////////////////////////////////////////////////////
 830
 831 TYPEINIT1( SdXMLMasterPageContext, SdXMLGenericPageContext );
 832
 833 SdXMLMasterPageContext::SdXMLMasterPageContext(
 834     SdXMLImport& rImport,
 835     sal_uInt16 nPrfx,
 836     const OUString& rLName,
 837     const uno::Reference< xml::sax::XAttributeList>& xAttrList,
 838     uno::Reference< drawing::XShapes >& rShapes)
 839 :       SdXMLGenericPageContext( rImport, nPrfx, rLName, xAttrList, rShapes )
 840 {
 841     const sal_Bool bHandoutMaster = IsXMLToken( rLName, XML_HANDOUT_MASTER );
 842
 843     const sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
 844     for(sal_Int16 i=0; i < nAttrCount; i++)
 845     {
 846         OUString sAttrName = xAttrList->getNameByIndex( i );
 847         OUString aLocalName;
 848         sal_uInt16 nPrefix = GetSdImport().GetNamespaceMap().GetKeyByAttrName( sAttrName, &aLocalName );
 849         OUString sValue = xAttrList->getValueByIndex( i );
 850         const SvXMLTokenMap& rAttrTokenMap = GetSdImport().GetMasterPageAttrTokenMap();
 851
 852         switch(rAttrTokenMap.Get(nPrefix, aLocalName))
 853         {
 854             case XML_TOK_MASTERPAGE_NAME:
 855             {
 856                 msName = sValue;
 857                 break;
 858             }
 859             case XML_TOK_MASTERPAGE_DISPLAY_NAME:
 860             {
 861                 msDisplayName = sValue;
 862                 break;
 863             }
 864             case XML_TOK_MASTERPAGE_PAGE_MASTER_NAME:
 865             {
 866                 msPageMasterName = sValue;
 867                 break;
 868             }
 869             case XML_TOK_MASTERPAGE_STYLE_NAME:
 870             {
 871                 msStyleName = sValue;
 872                 break;
 873             }
 874             case XML_TOK_MASTERPAGE_PAGE_LAYOUT_NAME:
 875             {
 876                 maPageLayoutName = sValue;
 877                 break;
 878             }
 879             case XML_TOK_MASTERPAGE_USE_HEADER_NAME:
 880             {
 881                 maUseHeaderDeclName =  sValue;
 882                 break;
 883             }
 884             case XML_TOK_MASTERPAGE_USE_FOOTER_NAME:
 885             {
 886                 maUseFooterDeclName =  sValue;
 887                 break;
 888             }
 889             case XML_TOK_MASTERPAGE_USE_DATE_TIME_NAME:
 890             {
 891                 maUseDateTimeDeclName =  sValue;
 892                 break;
 893             }
 894         }
 895     }
 896
 897     if( !msDisplayName.getLength() )
 898         msDisplayName = msName;
 899     else if( msDisplayName != msName )
 900         GetImport().AddStyleDisplayName( XML_STYLE_FAMILY_MASTER_PAGE, msName, msDisplayName );
 901
 902     GetImport().GetShapeImport()->startPage( GetLocalShapesContext() );
 903
 904     // set page name?
 905     if(!bHandoutMaster && msDisplayName.getLength() && GetLocalShapesContext().is())
 906     {
 907         uno::Reference < container::XNamed > xNamed(GetLocalShapesContext(), uno::UNO_QUERY);
 908         if(xNamed.is())
 909             xNamed->setName(msDisplayName);
 910     }
 911
 912     // set page-master?
 913     if(msPageMasterName.getLength())
 914     {
 915         SetPageMaster( msPageMasterName );
 916     }
 917
 918     SetStyle( msStyleName );
 919
 920     SetLayout();
 921
 922     DeleteAllShapes();
 923 }
 924
 925 //////////////////////////////////////////////////////////////////////////////
 926
 927 SdXMLMasterPageContext::~SdXMLMasterPageContext()
 928 {
 929 }
 930
 931 //////////////////////////////////////////////////////////////////////////////
 932
 933 void SdXMLMasterPageContext::EndElement()
 934 {
 935     // set styles on master-page
 936     if(msName.getLength() && GetSdImport().GetShapeImport()->GetStylesContext())
 937     {
 938         SvXMLImportContext* pContext = GetSdImport().GetShapeImport()->GetStylesContext();
 939         if( pContext && pContext->ISA( SvXMLStyleContext ) )
 940             ((SdXMLStylesContext*)pContext)->SetMasterPageStyles(*this);
 941     }
 942
 943     SdXMLGenericPageContext::EndElement();
 944     GetImport().GetShapeImport()->endPage(GetLocalShapesContext());
 945 }
 946
 947 //////////////////////////////////////////////////////////////////////////////
 948
 949 SvXMLImportContext* SdXMLMasterPageContext::CreateChildContext(
 950     sal_uInt16 nPrefix,
 951     const OUString& rLocalName,
 952     const uno::Reference< xml::sax::XAttributeList>& xAttrList )
 953 {
 954     SvXMLImportContext* pContext = 0;
 955     const SvXMLTokenMap& rTokenMap = GetSdImport().GetMasterPageElemTokenMap();
 956
 957     // some special objects inside style:masterpage context
 958     switch(rTokenMap.Get(nPrefix, rLocalName))
 959     {
 960         case XML_TOK_MASTERPAGE_STYLE:
 961         {
 962             if(GetSdImport().GetShapeImport()->GetStylesContext())
 963             {
 964                 // style:style inside master-page context -> presentation style
 965                 XMLShapeStyleContext* pNew = new XMLShapeStyleContext(
 966                     GetSdImport(), nPrefix, rLocalName, xAttrList,
 967                     *GetSdImport().GetShapeImport()->GetStylesContext(),
 968                     XML_STYLE_FAMILY_SD_PRESENTATION_ID);
 969
 970                 // add this style to the outer StylesContext class for later processing
 971                 if(pNew)
 972                 {
 973                     pContext = pNew;
 974                     GetSdImport().GetShapeImport()->GetStylesContext()->AddStyle(*pNew);
 975                 }
 976             }
 977             break;
 978         }
 979         case XML_TOK_MASTERPAGE_NOTES:
 980         {
 981             if( GetSdImport().IsImpress() )
 982             {
 983                 // get notes page
 984                 uno::Reference< presentation::XPresentationPage > xPresPage(GetLocalShapesContext(), uno::UNO_QUERY);
 985                 if(xPresPage.is())
 986                 {
 987                     uno::Reference< drawing::XDrawPage > xNotesDrawPage(xPresPage->getNotesPage(), uno::UNO_QUERY);
 988                     if(xNotesDrawPage.is())
 989                     {
 990                         uno::Reference< drawing::XShapes > xNewShapes(xNotesDrawPage, uno::UNO_QUERY);
 991                         if(xNewShapes.is())
 992                         {
 993                             // presentation:notes inside master-page context
 994                             pContext = new SdXMLNotesContext( GetSdImport(), nPrefix, rLocalName, xAttrList, xNewShapes);
 995                         }
 996                     }
 997                 }
 998             }
 999         }
1000     }
1001
1002     // call base class
1003     if(!pContext)
1004         pContext = SdXMLGenericPageContext::CreateChildContext(nPrefix, rLocalName, xAttrList);
1005
1006     return pContext;
1007 }
1008
1009 //////////////////////////////////////////////////////////////////////////////
1010 //////////////////////////////////////////////////////////////////////////////
1011
1012 TYPEINIT1( SdXMLStylesContext, SvXMLStyleContext );
1013
1014 SdXMLStylesContext::SdXMLStylesContext(
1015     SdXMLImport& rImport,
1016     sal_uInt16 nPrfx,
1017     const OUString& rLName,
1018     const uno::Reference< xml::sax::XAttributeList >& xAttrList,
1019     sal_Bool bIsAutoStyle)
1020 :       SvXMLStylesContext(rImport, nPrfx, rLName, xAttrList),
1021     mbIsAutoStyle(bIsAutoStyle)
1022 {
1023     // #110680#
1024     // Reference< lang::XMultiServiceFactory > xMSF = ::comphelper::getProcessServiceFactory();
1025     Reference< lang::XMultiServiceFactory > xMSF = rImport.getServiceFactory();
1026
1027     mpNumFormatter = new SvNumberFormatter( xMSF, LANGUAGE_SYSTEM );
1028
1029     // #110680#
1030     // mpNumFmtHelper = new SvXMLNumFmtHelper( mpNumFormatter );
1031     mpNumFmtHelper = new SvXMLNumFmtHelper( mpNumFormatter, xMSF );
1032 }
1033
1034 //////////////////////////////////////////////////////////////////////////////
1035
1036 SdXMLStylesContext::~SdXMLStylesContext()
1037 {
1038     delete mpNumFmtHelper;
1039     delete mpNumFormatter;
1040 }
1041
1042 //////////////////////////////////////////////////////////////////////////////
1043
1044 SvXMLStyleContext* SdXMLStylesContext::CreateStyleChildContext(
1045     sal_uInt16 nPrefix,
1046     const OUString& rLocalName,
1047     const uno::Reference< xml::sax::XAttributeList >& xAttrList)
1048 {
1049     SvXMLStyleContext* pContext = 0;
1050     const SvXMLTokenMap& rStyleTokenMap = GetSdImport().GetStylesElemTokenMap();
1051
1052     switch(rStyleTokenMap.Get(nPrefix, rLocalName))
1053     {
1054         case XML_TOK_STYLES_PAGE_MASTER:
1055         {
1056             // style:page-master inside office:styles context
1057             pContext = new SdXMLPageMasterContext(GetSdImport(), nPrefix, rLocalName, xAttrList);
1058             break;
1059         }
1060         case XML_TOK_STYLES_PRESENTATION_PAGE_LAYOUT:
1061         {
1062             // style:presentation-page-layout inside office:styles context
1063             pContext = new SdXMLPresentationPageLayoutContext(GetSdImport(), nPrefix, rLocalName, xAttrList);
1064             break;
1065         }
1066     }
1067
1068     if(!pContext)
1069     {
1070         const SvXMLTokenMap& rTokenMap = mpNumFmtHelper->GetStylesElemTokenMap();
1071         sal_uInt16 nToken = rTokenMap.Get( nPrefix, rLocalName );
1072         switch (nToken)
1073         {
1074             case XML_TOK_STYLES_DATE_STYLE:
1075             case XML_TOK_STYLES_TIME_STYLE:
1076                 // number:date-style or number:time-style
1077                 pContext = new SdXMLNumberFormatImportContext( GetSdImport(), nPrefix, rLocalName, mpNumFmtHelper->getData(), nToken, xAttrList, *this );
1078                 break;
1079
1080             case XML_TOK_STYLES_NUMBER_STYLE:
1081             case XML_TOK_STYLES_CURRENCY_STYLE:
1082             case XML_TOK_STYLES_PERCENTAGE_STYLE:
1083             case XML_TOK_STYLES_BOOLEAN_STYLE:
1084             case XML_TOK_STYLES_TEXT_STYLE:
1085                 pContext = new SvXMLNumFormatContext( GetSdImport(), nPrefix, rLocalName,
1086                                                         mpNumFmtHelper->getData(), nToken, xAttrList, *this );
1087                 break;
1088         }
1089     }
1090
1091     if(!pContext && nPrefix == XML_NAMESPACE_PRESENTATION )
1092     {
1093         if( IsXMLToken( rLocalName, XML_HEADER_DECL ) ||
1094             IsXMLToken( rLocalName, XML_FOOTER_DECL ) ||
1095             IsXMLToken( rLocalName, XML_DATE_TIME_DECL ) )
1096         {
1097             pContext = new SdXMLHeaderFooterDeclContext( GetImport(), nPrefix, rLocalName, xAttrList );
1098         }
1099     }
1100
1101     if(!pContext && (nPrefix == XML_NAMESPACE_TABLE) && IsXMLToken( rLocalName, XML_TABLE_TEMPLATE ) )
1102     {
1103         pContext = GetImport().GetShapeImport()->GetShapeTableImport()->CreateTableTemplateContext(nPrefix, rLocalName, xAttrList );
1104     }
1105
1106     // call base class
1107     if(!pContext)
1108         pContext = SvXMLStylesContext::CreateStyleChildContext(nPrefix, rLocalName, xAttrList);
1109
1110     return pContext;
1111 }
1112
1113 //////////////////////////////////////////////////////////////////////////////
1114
1115 SvXMLStyleContext* SdXMLStylesContext::CreateStyleStyleChildContext(
1116     sal_uInt16 nFamily,
1117     sal_uInt16 nPrefix,
1118     const OUString& rLocalName,
1119     const uno::Reference< com::sun::star::xml::sax::XAttributeList >& xAttrList)
1120 {
1121     SvXMLStyleContext* pContext = 0;
1122
1123     switch( nFamily )
1124     {
1125     case XML_STYLE_FAMILY_SD_DRAWINGPAGE_ID:
1126         pContext = new SdXMLDrawingPageStyleContext(GetSdImport(), nPrefix, rLocalName, xAttrList, *this );
1127         break;
1128     case XML_STYLE_FAMILY_TABLE_CELL:
1129     case XML_STYLE_FAMILY_TABLE_COLUMN:
1130     case XML_STYLE_FAMILY_TABLE_ROW:
1131         pContext = new XMLShapeStyleContext( GetSdImport(), nPrefix, rLocalName, xAttrList, *this, nFamily );
1132         break;
1133     }
1134
1135     // call base class
1136     if(!pContext)
1137         pContext = SvXMLStylesContext::CreateStyleStyleChildContext(nFamily, nPrefix, rLocalName, xAttrList);
1138
1139     return pContext;
1140 }
1141
1142 //////////////////////////////////////////////////////////////////////////////
1143
1144 SvXMLStyleContext* SdXMLStylesContext::CreateDefaultStyleStyleChildContext(
1145     sal_uInt16 nFamily,
1146     sal_uInt16 nPrefix,
1147     const OUString& rLocalName,
1148     const Reference< XAttributeList > & xAttrList )
1149 {
1150     SvXMLStyleContext* pContext = 0;
1151
1152     switch( nFamily )
1153     {
1154     case XML_STYLE_FAMILY_SD_GRAPHICS_ID:
1155         pContext = new XMLGraphicsDefaultStyle(GetSdImport(), nPrefix, rLocalName, xAttrList, *this );
1156         break;
1157     }
1158
1159     // call base class
1160     if(!pContext)
1161         pContext = SvXMLStylesContext::CreateDefaultStyleStyleChildContext(nFamily, nPrefix, rLocalName, xAttrList);
1162
1163     return pContext;
1164 }
1165
1166 //////////////////////////////////////////////////////////////////////////////
1167
1168 sal_uInt16 SdXMLStylesContext::GetFamily( const OUString& rFamily ) const
1169 {
1170 //      if(rFamily.getLength())
1171 //      {
1172 //              if(rFamily.equals(OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_SD_GRAPHICS_NAME))))
1173 //                      return XML_STYLE_FAMILY_SD_GRAPHICS_ID;
1174 //
1175 //              if(rFamily.equals(OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_SD_PRESENTATION_NAME))))
1176 //                      return XML_STYLE_FAMILY_SD_PRESENTATION_ID;
1177 //
1178 //              if(rFamily.equals(OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_SD_POOL_NAME))))
1179 //                      return XML_STYLE_FAMILY_SD_POOL_ID;
1180 //
1181 //              if(rFamily.equals(OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_SD_DRAWINGPAGE_NAME))))
1182 //                      return XML_STYLE_FAMILY_SD_DRAWINGPAGE_ID;
1183 //      }
1184
1185     // call base class
1186     return SvXMLStylesContext::GetFamily(rFamily);
1187 }
1188
1189 //////////////////////////////////////////////////////////////////////////////
1190
1191 UniReference< SvXMLImportPropertyMapper > SdXMLStylesContext::GetImportPropertyMapper(
1192     sal_uInt16 nFamily) const
1193 {
1194     UniReference < SvXMLImportPropertyMapper > xMapper;
1195
1196 //      if(XML_STYLE_FAMILY_SD_GRAPHICS_ID == nFamily
1197 //              || XML_STYLE_FAMILY_SD_PRESENTATION_ID == nFamily
1198 //              || XML_STYLE_FAMILY_SD_POOL_ID == nFamily)
1199 //      {
1200 //              if(!xPropImpPropMapper.is())
1201 //              {
1202 //                      UniReference< XMLShapeImportHelper > aImpHelper = ((SvXMLImport&)GetImport()).GetShapeImport();
1203 //                      ((SdXMLStylesContext*)this)->xPropImpPropMapper =
1204 //                              new SvXMLImportPropertyMapper(aImpHelper->GetPropertySetMapper());
1205 //              }
1206 //              xMapper = xPropImpPropMapper;
1207 //              return xMapper;
1208 //      }
1209
1210     switch( nFamily )
1211     {
1212     case XML_STYLE_FAMILY_SD_DRAWINGPAGE_ID:
1213     {
1214         if(!xPresImpPropMapper.is())
1215         {
1216             UniReference< XMLShapeImportHelper > aImpHelper = ((SvXMLImport&)GetImport()).GetShapeImport();
1217             ((SdXMLStylesContext*)this)->xPresImpPropMapper =
1218                 aImpHelper->GetPresPagePropsMapper();
1219         }
1220         xMapper = xPresImpPropMapper;
1221         break;
1222     }
1223
1224     case XML_STYLE_FAMILY_TABLE_COLUMN:
1225     case XML_STYLE_FAMILY_TABLE_ROW:
1226     case XML_STYLE_FAMILY_TABLE_CELL:
1227     {
1228         const rtl::Reference< XMLTableImport >& xTableImport( const_cast< SvXMLImport& >( GetImport() ).GetShapeImport()->GetShapeTableImport() );
1229
1230         switch( nFamily )
1231         {
1232         case XML_STYLE_FAMILY_TABLE_COLUMN: xMapper = xTableImport->GetColumnImportPropertySetMapper().get(); break;
1233         case XML_STYLE_FAMILY_TABLE_ROW: xMapper = xTableImport->GetRowImportPropertySetMapper().get(); break;
1234         case XML_STYLE_FAMILY_TABLE_CELL: xMapper = xTableImport->GetCellImportPropertySetMapper().get(); break;
1235         }
1236         break;
1237     }
1238     }
1239
1240     // call base class
1241     if( !xMapper.is() )
1242         xMapper = SvXMLStylesContext::GetImportPropertyMapper(nFamily);
1243     return xMapper;
1244 }
1245
1246 //////////////////////////////////////////////////////////////////////////////
1247 // Process all style and object info
1248 //
1249 void SdXMLStylesContext::EndElement()
1250 {
1251     if(mbIsAutoStyle)
1252     {
1253         // AutoStyles for text import
1254         GetImport().GetTextImport()->SetAutoStyles( this );
1255
1256         // AutoStyles for chart
1257         GetImport().GetChartImport()->SetAutoStylesContext( this );
1258
1259         // AutoStyles for forms
1260         GetImport().GetFormImport()->setAutoStyleContext( this );
1261
1262         // associate AutoStyles with styles in preparation to setting Styles on shapes
1263         for(sal_uInt32 a(0L); a < GetStyleCount(); a++)
1264         {
1265             const SvXMLStyleContext* pStyle = GetStyle(a);
1266             if(pStyle && pStyle->ISA(XMLShapeStyleContext))
1267             {
1268                 XMLShapeStyleContext* pDocStyle = (XMLShapeStyleContext*)pStyle;
1269 //                              pDocStyle->Filter();
1270
1271                 SvXMLStylesContext* pStylesContext = GetSdImport().GetShapeImport()->GetStylesContext();
1272                 if( pStylesContext )
1273                 {
1274                     pStyle = pStylesContext->FindStyleChildContext(pStyle->GetFamily(), pStyle->GetParentName());
1275
1276                     if(pStyle && pStyle->ISA(XMLShapeStyleContext))
1277                     {
1278                         XMLShapeStyleContext* pParentStyle = (XMLShapeStyleContext*)pStyle;
1279                         if(pParentStyle->GetStyle().is())
1280                         {
1281                             pDocStyle->SetStyle(pParentStyle->GetStyle());
1282                         }
1283                     }
1284                 }
1285             }
1286         }
1287
1288         FinishStyles( false );
1289     }
1290     else
1291     {
1292         // Process styles list
1293         ImpSetGraphicStyles();
1294         ImpSetCellStyles();
1295         GetImport().GetShapeImport()->GetShapeTableImport()->finishStyles();
1296
1297         // put style infos in the info set for other components ( content import f.e. )
1298         uno::Reference< beans::XPropertySet > xInfoSet( GetImport().getImportInfo() );
1299         if( xInfoSet.is() )
1300         {
1301             uno::Reference< beans::XPropertySetInfo > xInfoSetInfo( xInfoSet->getPropertySetInfo() );
1302
1303             if( xInfoSetInfo->hasPropertyByName( OUString( RTL_CONSTASCII_USTRINGPARAM( "PageLayouts" ) ) ) )
1304                 xInfoSet->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "PageLayouts" ) ), uno::makeAny( getPageLayouts() ) );
1305         }
1306
1307     }
1308 }
1309
1310 //////////////////////////////////////////////////////////////////////////////
1311 // set master-page styles (all with family="presentation" and a special
1312 // prefix) on given master-page.
1313 //
1314 void SdXMLStylesContext::SetMasterPageStyles(SdXMLMasterPageContext& rMaster) const
1315 {
1316     UniString sPrefix(rMaster.GetDisplayName(), (sal_uInt16)rMaster.GetDisplayName().getLength());
1317     sPrefix += sal_Unicode('-');
1318
1319     if(GetSdImport().GetLocalDocStyleFamilies().is() && GetSdImport().GetLocalDocStyleFamilies()->hasByName(rMaster.GetDisplayName())) try
1320     {
1321         uno::Reference< container::XNameAccess > xMasterPageStyles( GetSdImport().GetLocalDocStyleFamilies()->getByName(rMaster.GetDisplayName()), UNO_QUERY_THROW );
1322         ImpSetGraphicStyles(xMasterPageStyles, XML_STYLE_FAMILY_SD_PRESENTATION_ID, sPrefix);
1323     }
1324     catch( uno::Exception& )
1325     {
1326         DBG_ERROR( "xmloff::SdXMLStylesContext::SetMasterPageStyles(), exception caught!" );
1327     }
1328 }
1329
1330 //////////////////////////////////////////////////////////////////////////////
1331 // Process styles list:
1332 // set graphic styles (all with family="graphics"). Remember xStyle at list element.
1333 //
1334 void SdXMLStylesContext::ImpSetGraphicStyles() const
1335 {
1336     if(GetSdImport().GetLocalDocStyleFamilies().is()) try
1337     {
1338         const OUString sGraphicStyleName(OUString(RTL_CONSTASCII_USTRINGPARAM("graphics")));
1339         uno::Reference< container::XNameAccess > xGraphicPageStyles( GetSdImport().GetLocalDocStyleFamilies()->getByName(sGraphicStyleName), uno::UNO_QUERY_THROW );
1340
1341         UniString aPrefix;
1342         ImpSetGraphicStyles(xGraphicPageStyles, XML_STYLE_FAMILY_SD_GRAPHICS_ID, aPrefix);
1343     }
1344     catch( uno::Exception& )
1345     {
1346         DBG_ERROR( "xmloff::SdXMLStylesContext::ImpSetGraphicStyles(), exception caught!" );
1347     }
1348 }
1349
1350 void SdXMLStylesContext::ImpSetCellStyles() const
1351 {
1352     if(GetSdImport().GetLocalDocStyleFamilies().is()) try
1353     {
1354         const OUString sCellStyleName(OUString(RTL_CONSTASCII_USTRINGPARAM("cell")));
1355         uno::Reference< container::XNameAccess > xGraphicPageStyles( GetSdImport().GetLocalDocStyleFamilies()->getByName(sCellStyleName), uno::UNO_QUERY_THROW );
1356
1357         UniString aPrefix;
1358         ImpSetGraphicStyles(xGraphicPageStyles, XML_STYLE_FAMILY_TABLE_CELL, aPrefix);
1359     }
1360     catch( uno::Exception& )
1361     {
1362         DBG_ERROR( "xmloff::SdXMLStylesContext::ImpSetCellStyles(), exception caught!" );
1363     }
1364 }
1365
1366 //////////////////////////////////////////////////////////////////////////////
1367 // help function used by ImpSetGraphicStyles() and ImpSetMasterPageStyles()
1368 //
1369 void SdXMLStylesContext::ImpSetGraphicStyles( uno::Reference< container::XNameAccess >& xPageStyles,  sal_uInt16 nFamily,  const UniString& rPrefix) const
1370 {
1371     xub_StrLen nPrefLen(rPrefix.Len());
1372
1373     sal_uInt32 a;
1374
1375     // set defaults
1376     for( a = 0; a < GetStyleCount(); a++)
1377     {
1378         const SvXMLStyleContext* pStyle = GetStyle(a);
1379
1380         if(nFamily == pStyle->GetFamily() && pStyle->IsDefaultStyle())
1381         {
1382             ((SvXMLStyleContext*)pStyle)->SetDefaults();
1383         }
1384     }
1385
1386     // create all styles and set properties
1387     for( a = 0; a < GetStyleCount(); a++)
1388     {
1389         try
1390         {
1391             const SvXMLStyleContext* pStyle = GetStyle(a);
1392             if(nFamily == pStyle->GetFamily() && !pStyle->IsDefaultStyle())
1393             {
1394                 OUString aStyleName(pStyle->GetDisplayName());
1395                 if( nPrefLen )
1396                 {
1397                     sal_Int32 nStylePrefLen = aStyleName.lastIndexOf( sal_Unicode('-') ) + 1;
1398                     if( (nPrefLen != nStylePrefLen) ||  (aStyleName.compareTo( rPrefix, nPrefLen ) != 0) )
1399                         continue;
1400
1401                     aStyleName = aStyleName.copy( nPrefLen );
1402                 }
1403
1404                 uno::Reference< style::XStyle > xStyle;
1405                 if(xPageStyles->hasByName(aStyleName))
1406                 {
1407                     xPageStyles->getByName(aStyleName) >>= xStyle;
1408
1409                     // set properties of existing styles to default
1410                     uno::Reference< beans::XPropertySet > xPropSet( xStyle, uno::UNO_QUERY );
1411                     uno::Reference< beans::XPropertySetInfo > xPropSetInfo;
1412                     if( xPropSet.is() )
1413                         xPropSetInfo = xPropSet->getPropertySetInfo();
1414
1415                     uno::Reference< beans::XPropertyState > xPropState( xStyle, uno::UNO_QUERY );
1416
1417                     if( xPropState.is() )
1418                     {
1419                         UniReference < XMLPropertySetMapper > xPrMap;
1420                         UniReference < SvXMLImportPropertyMapper > xImpPrMap = GetImportPropertyMapper( nFamily );
1421                         DBG_ASSERT( xImpPrMap.is(), "There is the import prop mapper" );
1422                         if( xImpPrMap.is() )
1423                             xPrMap = xImpPrMap->getPropertySetMapper();
1424                         if( xPrMap.is() )
1425                         {
1426                             const sal_Int32 nCount = xPrMap->GetEntryCount();
1427                             for( sal_Int32 i = 0; i < nCount; i++ )
1428                             {
1429                                 const OUString& rName = xPrMap->GetEntryAPIName( i );
1430                                 if( xPropSetInfo->hasPropertyByName( rName ) && beans::PropertyState_DIRECT_VALUE == xPropState->getPropertyState( rName ) )
1431                                 {
1432                                     xPropState->setPropertyToDefault( rName );
1433                                 }
1434                             }
1435                         }
1436                     }
1437                 }
1438                 else
1439                 {
1440                     // graphics style does not exist, create and add it
1441                     uno::Reference< lang::XSingleServiceFactory > xServiceFact(xPageStyles, uno::UNO_QUERY);
1442                     if(xServiceFact.is())
1443                     {
1444                         uno::Reference< style::XStyle > xNewStyle( xServiceFact->createInstance(), uno::UNO_QUERY);
1445
1446                         if(xNewStyle.is())
1447                         {
1448                             // remember style
1449                             xStyle = xNewStyle;
1450
1451                             // add new style to graphics style pool
1452                             uno::Reference< container::XNameContainer > xInsertContainer(xPageStyles, uno::UNO_QUERY);
1453                             if(xInsertContainer.is())
1454                                 xInsertContainer->insertByName(aStyleName, uno::Any( xStyle ) );
1455                         }
1456                     }
1457                 }
1458
1459                 if(xStyle.is())
1460                 {
1461                     // set properties at style
1462                     XMLPropStyleContext* pPropStyle = dynamic_cast< XMLPropStyleContext* >( const_cast< SvXMLStyleContext* >( pStyle ) );
1463                     uno::Reference< beans::XPropertySet > xPropSet(xStyle, uno::UNO_QUERY);
1464
1465                     if(xPropSet.is() && pPropStyle)
1466                     {
1467                         pPropStyle->FillPropertySet(xPropSet);
1468                         pPropStyle->SetStyle(xStyle);
1469                     }
1470                 }
1471             }
1472         }
1473         catch( Exception& e)
1474         {
1475             uno::Sequence<OUString> aSeq(0);
1476             const_cast<SdXMLImport*>(&GetSdImport())->SetError( XMLERROR_FLAG_WARNING | XMLERROR_API, aSeq, e.Message, NULL );
1477         }
1478     }
1479
1480     // now set parents for all styles (when necessary)
1481     for(a = 0L; a < GetStyleCount(); a++)
1482     {
1483         const SvXMLStyleContext* pStyle = GetStyle(a);
1484
1485         if(pStyle && pStyle->GetName().getLength() && (nFamily == pStyle->GetFamily())) try
1486         {
1487             OUString aStyleName(pStyle->GetDisplayName());
1488             if( nPrefLen )
1489             {
1490                 sal_Int32 nStylePrefLen = aStyleName.lastIndexOf( sal_Unicode('-') ) + 1;
1491                 if( (nPrefLen != nStylePrefLen) ||  (aStyleName.compareTo( rPrefix, nPrefLen ) != 0) )
1492                     continue;
1493
1494                 aStyleName = aStyleName.copy( nPrefLen );
1495             }
1496
1497             uno::Reference< style::XStyle > xStyle( xPageStyles->getByName(aStyleName), UNO_QUERY );
1498             if(xStyle.is())
1499             {
1500                 // set parent style name
1501                 ::rtl::OUString sParentStyleDisplayName( const_cast< SvXMLImport& >( GetImport() ).GetStyleDisplayName( pStyle->GetFamily(), pStyle->GetParentName() ) );
1502                 if( nPrefLen )
1503                 {
1504                     sal_Int32 nStylePrefLen = sParentStyleDisplayName.lastIndexOf( sal_Unicode('-') ) + 1;
1505                     if( (nPrefLen != nStylePrefLen) || (sParentStyleDisplayName.compareTo( rPrefix, nPrefLen ) != 0) )
1506                         continue;
1507
1508                     sParentStyleDisplayName = sParentStyleDisplayName.copy( nPrefLen );
1509                 }
1510                 xStyle->setParentStyle( sParentStyleDisplayName );
1511             }
1512         }
1513         catch( Exception& e )
1514         {
1515             uno::Sequence<OUString> aSeq(0);
1516             const_cast<SdXMLImport*>(&GetSdImport())->SetError( XMLERROR_FLAG_WARNING | XMLERROR_API, aSeq, e.Message, NULL );
1517         }
1518     }
1519 }
1520
1521 ////////////////////////////////////////////////////////////////////////////////
1522 // helper function to create the uno component that hold the mappings from
1523 // xml auto layout name to internal autolayout id
1524
1525 uno::Reference< container::XNameAccess > SdXMLStylesContext::getPageLayouts() const
1526 {
1527     uno::Reference< container::XNameContainer > xLayouts( comphelper::NameContainer_createInstance( ::getCppuType((const sal_Int32*)0)) );
1528
1529     for(sal_uInt32 a(0L); a < GetStyleCount(); a++)
1530     {
1531         const SvXMLStyleContext* pStyle = GetStyle(a);
1532         if(pStyle && pStyle->ISA(SdXMLPresentationPageLayoutContext))
1533         {
1534             xLayouts->insertByName( pStyle->GetName(), uno::makeAny(
1535             (sal_Int32)((SdXMLPresentationPageLayoutContext*)pStyle)->GetTypeId() ) );
1536         }
1537     }
1538
1539     return uno::Reference< container::XNameAccess >::query( xLayouts );
1540 }
1541
1542 ////////////////////////////////////////////////////////////////////////////////
1543 ////////////////////////////////////////////////////////////////////////////////
1544 //
1545 TYPEINIT1( SdXMLMasterStylesContext, SvXMLImportContext );
1546
1547 SdXMLMasterStylesContext::SdXMLMasterStylesContext(
1548     SdXMLImport& rImport,
1549     sal_uInt16 nPrfx,
1550     const rtl::OUString& rLName)
1551 :       SvXMLImportContext( rImport, nPrfx, rLName)
1552 {
1553 }
1554
1555 SdXMLMasterStylesContext::~SdXMLMasterStylesContext()
1556 {
1557     while(maMasterPageList.Count())
1558         maMasterPageList.Remove(maMasterPageList.Count() - 1)->ReleaseRef();
1559 }
1560
1561 SvXMLImportContext* SdXMLMasterStylesContext::CreateChildContext(
1562     sal_uInt16 nPrefix,
1563     const rtl::OUString& rLocalName,
1564     const uno::Reference< xml::sax::XAttributeList >& xAttrList)
1565 {
1566     SvXMLImportContext* pContext = 0;
1567
1568     if(nPrefix == XML_NAMESPACE_STYLE
1569        && IsXMLToken( rLocalName, XML_MASTER_PAGE ) )
1570     {
1571         // style:masterpage inside office:styles context
1572         uno::Reference< drawing::XDrawPage > xNewMasterPage;
1573         uno::Reference< drawing::XDrawPages > xMasterPages(GetSdImport().GetLocalMasterPages(), uno::UNO_QUERY);
1574
1575         if( xMasterPages.is() )
1576         {
1577             if(GetSdImport().GetNewMasterPageCount() + 1 > xMasterPages->getCount())
1578             {
1579                 // new page, create and insert
1580                 xNewMasterPage = xMasterPages->insertNewByIndex(xMasterPages->getCount());
1581             }
1582             else
1583             {
1584                 // existing page, use it
1585                 xMasterPages->getByIndex(GetSdImport().GetNewMasterPageCount()) >>= xNewMasterPage;
1586             }
1587
1588             // increment global import page counter
1589             GetSdImport().IncrementNewMasterPageCount();
1590
1591             if(xNewMasterPage.is())
1592             {
1593                 uno::Reference< drawing::XShapes > xNewShapes(xNewMasterPage, uno::UNO_QUERY);
1594                 if(xNewShapes.is() && GetSdImport().GetShapeImport()->GetStylesContext())
1595                 {
1596                     pContext = new SdXMLMasterPageContext(GetSdImport(),
1597                         nPrefix, rLocalName, xAttrList, xNewShapes);
1598
1599                     if(pContext)
1600                     {
1601                         pContext->AddRef();
1602                         maMasterPageList.Insert((SdXMLMasterPageContext*)pContext, LIST_APPEND);
1603                     }
1604                 }
1605             }
1606         }
1607     }
1608     else        if(nPrefix == XML_NAMESPACE_STYLE
1609         && IsXMLToken( rLocalName, XML_HANDOUT_MASTER ) )
1610     {
1611         uno::Reference< presentation::XHandoutMasterSupplier > xHandoutSupp( GetSdImport().GetModel(), uno::UNO_QUERY );
1612         if( xHandoutSupp.is() )
1613         {
1614             uno::Reference< drawing::XShapes > xHandoutPage( xHandoutSupp->getHandoutMasterPage(), uno::UNO_QUERY );
1615             if(xHandoutPage.is() && GetSdImport().GetShapeImport()->GetStylesContext())
1616             {
1617                 pContext = new SdXMLMasterPageContext(GetSdImport(),
1618                     nPrefix, rLocalName, xAttrList, xHandoutPage);
1619             }
1620         }
1621     }
1622     else if( (nPrefix == XML_NAMESPACE_DRAW )&& IsXMLToken( rLocalName, XML_LAYER_SET ) )
1623     {
1624         pContext = new SdXMLLayerSetContext( GetImport(), nPrefix, rLocalName, xAttrList );
1625     }
1626
1627     // call base class
1628     if(!pContext)
1629         pContext = SvXMLImportContext::CreateChildContext(nPrefix, rLocalName, xAttrList);
1630
1631     return pContext;
1632 }
1633
1634 ///////////////////////////////////////////////////////////////////////
1635
1636 SdXMLHeaderFooterDeclContext::SdXMLHeaderFooterDeclContext( SvXMLImport& rImport, sal_uInt16 nPrfx,
1637         const ::rtl::OUString& rLName,
1638         const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList >& xAttrList )
1639 : SvXMLStyleContext( rImport, nPrfx, rLName, xAttrList )
1640 {
1641     const sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
1642     for(sal_Int16 i=0; i < nAttrCount; i++)
1643     {
1644         OUString aLocalName;
1645         const OUString aValue( xAttrList->getValueByIndex(i) );
1646         sal_uInt16 nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName(xAttrList->getNameByIndex(i), &aLocalName);
1647
1648         if( nPrefix == XML_NAMESPACE_PRESENTATION )
1649         {
1650             if( IsXMLToken( aLocalName, XML_NAME ) )
1651             {
1652                 maStrName = aValue;
1653             }
1654             else if( IsXMLToken( aLocalName, XML_SOURCE ) )
1655             {
1656                 mbFixed = IsXMLToken( aValue, XML_FIXED );
1657             }
1658         }
1659         else if( nPrefix == XML_NAMESPACE_STYLE )
1660         {
1661             if( IsXMLToken( aLocalName, XML_DATA_STYLE_NAME ) )
1662             {
1663                 maStrDateTimeFormat = aValue;
1664             }
1665         }
1666     }
1667 }
1668
1669 BOOL SdXMLHeaderFooterDeclContext::IsTransient() const
1670 {
1671     return TRUE;
1672 }
1673
1674 void SdXMLHeaderFooterDeclContext::EndElement()
1675 {
1676     SdXMLImport& rImport = *dynamic_cast< SdXMLImport* >( &GetImport() );
1677     if( IsXMLToken( GetLocalName(), XML_HEADER_DECL ) )
1678     {
1679         rImport.AddHeaderDecl( maStrName, maStrText );
1680     }
1681     else if( IsXMLToken( GetLocalName(), XML_FOOTER_DECL ) )
1682     {
1683         rImport.AddFooterDecl( maStrName, maStrText );
1684     }
1685     else if( IsXMLToken( GetLocalName(), XML_DATE_TIME_DECL ) )
1686     {
1687         rImport.AddDateTimeDecl( maStrName, maStrText, mbFixed, maStrDateTimeFormat );
1688     }
1689 }
1690
1691 void SdXMLHeaderFooterDeclContext::Characters( const ::rtl::OUString& rChars )
1692 {
1693     maStrText += rChars;
1694 }
1695