oox/source/ppt/presentationfragmenthandler.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "comphelper/anytostring.hxx"
  21 #include <comphelper/sequenceashashmap.hxx>
  22 #include "cppuhelper/exc_hlp.hxx"
  23 #include <osl/diagnose.h>
  24 #include <tools/multisel.hxx>
  25
  26 #include <com/sun/star/drawing/XMasterPagesSupplier.hpp>
  27 #include <com/sun/star/drawing/XDrawPages.hpp>
  28 #include <com/sun/star/drawing/XDrawPagesSupplier.hpp>
  29 #include <com/sun/star/drawing/XMasterPageTarget.hpp>
  30 #include <com/sun/star/xml/dom/XDocument.hpp>
  31 #include <com/sun/star/xml/sax/XFastSAXSerializable.hpp>
  32 #include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
  33 #include <com/sun/star/style/XStyle.hpp>
  34 #include <com/sun/star/presentation/XPresentationPage.hpp>
  35 #include <com/sun/star/task/XStatusIndicator.hpp>
  36
  37 #include "oox/drawingml/theme.hxx"
  38 #include "oox/drawingml/drawingmltypes.hxx"
  39 #include "oox/drawingml/themefragmenthandler.hxx"
  40 #include "drawingml/textliststylecontext.hxx"
  41 #include <oox/helper/attributelist.hxx>
  42 #include "oox/ppt/pptshape.hxx"
  43 #include "oox/ppt/presentationfragmenthandler.hxx"
  44 #include "oox/ppt/slidefragmenthandler.hxx"
  45 #include "oox/ppt/layoutfragmenthandler.hxx"
  46 #include "oox/ppt/pptimport.hxx"
  47 #include <oox/token/namespaces.hxx>
  48 #include <oox/token/tokens.hxx>
  49
  50 #include <com/sun/star/office/XAnnotation.hpp>
  51 #include <com/sun/star/office/XAnnotationAccess.hpp>
  52
  53 using namespace ::com::sun::star;
  54 using namespace ::oox::core;
  55 using namespace ::oox::drawingml;
  56 using namespace ::com::sun::star::uno;
  57 using namespace ::com::sun::star::beans;
  58 using namespace ::com::sun::star::drawing;
  59 using namespace ::com::sun::star::presentation;
  60 using namespace ::com::sun::star::xml::sax;
  61
  62 namespace oox { namespace ppt {
  63
  64 PresentationFragmentHandler::PresentationFragmentHandler( XmlFilterBase& rFilter, const OUString& rFragmentPath ) throw()
  65 : FragmentHandler2( rFilter, rFragmentPath )
  66 , mpTextListStyle( new TextListStyle )
  67 , mbCommentAuthorsRead(false)
  68 {
  69     TextParagraphPropertiesVector& rParagraphDefaulsVector( mpTextListStyle->getListStyle() );
  70     TextParagraphPropertiesVector::iterator aParagraphDefaultIter( rParagraphDefaulsVector.begin() );
  71     while( aParagraphDefaultIter != rParagraphDefaulsVector.end() )
  72     {
  73         // ppt is having zero bottom margin per default, whereas OOo is 0,5cm,
  74         // so this attribute needs to be set always
  75         (*aParagraphDefaultIter++)->getParaBottomMargin() = TextSpacing( 0 );
  76     }
  77 }
  78
  79 PresentationFragmentHandler::~PresentationFragmentHandler() throw()
  80 {
  81 }
  82
  83 void ResolveTextFields( XmlFilterBase& rFilter )
  84 {
  85     const oox::core::TextFieldStack& rTextFields = rFilter.getTextFieldStack();
  86     if ( !rTextFields.empty() )
  87     {
  88         Reference< frame::XModel > xModel( rFilter.getModel() );
  89         oox::core::TextFieldStack::const_iterator aIter( rTextFields.begin() );
  90         while( aIter != rTextFields.end() )
  91         {
  92             const OUString sURL = "URL";
  93             Reference< drawing::XDrawPagesSupplier > xDPS( xModel, uno::UNO_QUERY_THROW );
  94             Reference< drawing::XDrawPages > xDrawPages( xDPS->getDrawPages(), uno::UNO_QUERY_THROW );
  95
  96             const oox::core::TextField& rTextField( *aIter++ );
  97             Reference< XPropertySet > xPropSet( rTextField.xTextField, UNO_QUERY );
  98             Reference< XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() );
  99             if ( xPropSetInfo->hasPropertyByName( sURL ) )
 100             {
 101                 OUString aURL;
 102                 if ( xPropSet->getPropertyValue( sURL ) >>= aURL )
 103                 {
 104                     const OUString sSlide = "#Slide ";
 105                     const OUString sNotes = "#Notes ";
 106                     bool bNotes = false;
 107                     sal_Int32 nPageNumber = 0;
 108                     if ( aURL.match( sSlide ) )
 109                         nPageNumber = aURL.copy( sSlide.getLength() ).toInt32();
 110                     else if ( aURL.match( sNotes ) )
 111                     {
 112                         nPageNumber = aURL.copy( sNotes.getLength() ).toInt32();
 113                         bNotes = true;
 114                     }
 115                     if ( nPageNumber )
 116                     {
 117                         try
 118                         {
 119                             Reference< XDrawPage > xDrawPage;
 120                             xDrawPages->getByIndex( nPageNumber - 1 ) >>= xDrawPage;
 121                             if ( bNotes )
 122                             {
 123                                 Reference< css::presentation::XPresentationPage > xPresentationPage( xDrawPage, UNO_QUERY_THROW );
 124                                 xDrawPage = xPresentationPage->getNotesPage();
 125                             }
 126                             Reference< container::XNamed > xNamed( xDrawPage, UNO_QUERY_THROW );
 127                             aURL = "#" + xNamed->getName();
 128                             xPropSet->setPropertyValue( sURL, Any( aURL ) );
 129                             Reference< text::XTextContent > xContent( rTextField.xTextField, UNO_QUERY);
 130                             Reference< text::XTextRange > xTextRange( rTextField.xTextCursor, UNO_QUERY );
 131                             rTextField.xText->insertTextContent( xTextRange, xContent, true );
 132                         }
 133                         catch( uno::Exception& )
 134                         {
 135                         }
 136                     }
 137                 }
 138             }
 139         }
 140     }
 141 }
 142
 143 void PresentationFragmentHandler::importSlide(sal_uInt32 nSlide, bool bFirstPage, bool bImportNotesPage)
 144 {
 145     PowerPointImport& rFilter = dynamic_cast< PowerPointImport& >( getFilter() );
 146
 147     Reference< frame::XModel > xModel( rFilter.getModel() );
 148     Reference< drawing::XDrawPage > xSlide;
 149
 150     // importing slide pages and its corresponding notes page
 151     Reference< drawing::XDrawPagesSupplier > xDPS( xModel, uno::UNO_QUERY_THROW );
 152     Reference< drawing::XDrawPages > xDrawPages( xDPS->getDrawPages(), uno::UNO_QUERY_THROW );
 153
 154     try {
 155
 156         if( bFirstPage )
 157             xDrawPages->getByIndex( 0 ) >>= xSlide;
 158         else
 159             xSlide = xDrawPages->insertNewByIndex( xDrawPages->getCount() );
 160
 161         OUString aSlideFragmentPath = getFragmentPathFromRelId( maSlidesVector[ nSlide ] );
 162         if( !aSlideFragmentPath.isEmpty() )
 163         {
 164             SlidePersistPtr pMasterPersistPtr;
 165             SlidePersistPtr pSlidePersistPtr( new SlidePersist( rFilter, false, false, xSlide,
 166                                 ShapePtr( new PPTShape( Slide, "com.sun.star.drawing.GroupShape" ) ), mpTextListStyle ) );
 167
 168             FragmentHandlerRef xSlideFragmentHandler( new SlideFragmentHandler( rFilter, aSlideFragmentPath, pSlidePersistPtr, Slide ) );
 169
 170             // importing the corresponding masterpage/layout
 171             OUString aLayoutFragmentPath = xSlideFragmentHandler->getFragmentPathFromFirstTypeFromOfficeDoc( "slideLayout" );
 172             OUString aCommentFragmentPath = xSlideFragmentHandler->getFragmentPathFromFirstTypeFromOfficeDoc( "comments" );
 173             if ( !aLayoutFragmentPath.isEmpty() )
 174             {
 175                 // importing layout
 176                 RelationsRef xLayoutRelations = rFilter.importRelations( aLayoutFragmentPath );
 177                 OUString aMasterFragmentPath = xLayoutRelations->getFragmentPathFromFirstTypeFromOfficeDoc( "slideMaster" );
 178                 if( !aMasterFragmentPath.isEmpty() )
 179                 {
 180                     // check if the corresponding masterpage+layout has already been imported
 181                     std::vector< SlidePersistPtr >& rMasterPages( rFilter.getMasterPages() );
 182                     std::vector< SlidePersistPtr >::iterator aIter( rMasterPages.begin() );
 183                     while( aIter != rMasterPages.end() )
 184                     {
 185                         if ( ( (*aIter)->getPath() == aMasterFragmentPath ) && ( (*aIter)->getLayoutPath() == aLayoutFragmentPath ) )
 186                         {
 187                             pMasterPersistPtr = *aIter;
 188                             break;
 189                         }
 190                         ++aIter;
 191                     }
 192
 193                     if ( !pMasterPersistPtr.get() )
 194                     {   // masterpersist not found, we have to load it
 195                         Reference< drawing::XDrawPage > xMasterPage;
 196                         Reference< drawing::XMasterPagesSupplier > xMPS( xModel, uno::UNO_QUERY_THROW );
 197                         Reference< drawing::XDrawPages > xMasterPages( xMPS->getMasterPages(), uno::UNO_QUERY_THROW );
 198
 199                         if( rFilter.getMasterPages().empty() )
 200                             xMasterPages->getByIndex( 0 ) >>= xMasterPage;
 201                         else
 202                             xMasterPage = xMasterPages->insertNewByIndex( xMasterPages->getCount() );
 203
 204                         pMasterPersistPtr = std::make_shared<SlidePersist>( rFilter, true, false, xMasterPage,
 205                             ShapePtr( new PPTShape( Master, "com.sun.star.drawing.GroupShape" ) ), mpTextListStyle );
 206                         pMasterPersistPtr->setLayoutPath( aLayoutFragmentPath );
 207                         rFilter.getMasterPages().push_back( pMasterPersistPtr );
 208                         rFilter.setActualSlidePersist( pMasterPersistPtr );
 209                         FragmentHandlerRef xMasterFragmentHandler( new SlideFragmentHandler( rFilter, aMasterFragmentPath, pMasterPersistPtr, Master ) );
 210
 211                         // set the correct theme
 212                         OUString aThemeFragmentPath = xMasterFragmentHandler->getFragmentPathFromFirstTypeFromOfficeDoc( "theme" );
 213                         if( !aThemeFragmentPath.isEmpty() )
 214                         {
 215                             std::map< OUString, oox::drawingml::ThemePtr >& rThemes( rFilter.getThemes() );
 216                             std::map< OUString, oox::drawingml::ThemePtr >::iterator aIter2( rThemes.find( aThemeFragmentPath ) );
 217                             if( aIter2 == rThemes.end() )
 218                             {
 219                                 oox::drawingml::ThemePtr pThemePtr( new oox::drawingml::Theme() );
 220                                 pMasterPersistPtr->setTheme( pThemePtr );
 221                                 Reference<xml::dom::XDocument> xDoc=
 222                                     rFilter.importFragment(aThemeFragmentPath);
 223
 224                                 rFilter.importFragment(
 225                                     new ThemeFragmentHandler(
 226                                         rFilter, aThemeFragmentPath, *pThemePtr ),
 227                                     Reference<xml::sax::XFastSAXSerializable>(
 228                                         xDoc,
 229                                         UNO_QUERY_THROW));
 230                                 rThemes[ aThemeFragmentPath ] = pThemePtr;
 231                                 pThemePtr->setFragment(xDoc);
 232                             }
 233                             else
 234                             {
 235                                 pMasterPersistPtr->setTheme( (*aIter2).second );
 236                             }
 237                         }
 238                         importSlide( xMasterFragmentHandler, pMasterPersistPtr );
 239                         rFilter.importFragment( new LayoutFragmentHandler( rFilter, aLayoutFragmentPath, pMasterPersistPtr ) );
 240                         pMasterPersistPtr->createBackground( rFilter );
 241                         pMasterPersistPtr->createXShapes( rFilter );
 242                     }
 243                 }
 244             }
 245
 246             // importing slide page
 247             if (pMasterPersistPtr.get()) {
 248                 pSlidePersistPtr->setMasterPersist( pMasterPersistPtr );
 249                 pSlidePersistPtr->setTheme( pMasterPersistPtr->getTheme() );
 250                 Reference< drawing::XMasterPageTarget > xMasterPageTarget( pSlidePersistPtr->getPage(), UNO_QUERY );
 251                 if( xMasterPageTarget.is() )
 252                     xMasterPageTarget->setMasterPage( pMasterPersistPtr->getPage() );
 253             }
 254             rFilter.getDrawPages().push_back( pSlidePersistPtr );
 255             rFilter.setActualSlidePersist( pSlidePersistPtr );
 256             importSlide( xSlideFragmentHandler, pSlidePersistPtr );
 257             pSlidePersistPtr->createBackground( rFilter );
 258             pSlidePersistPtr->createXShapes( rFilter );
 259
 260             if(bImportNotesPage) {
 261
 262                 // now importing the notes page
 263                 OUString aNotesFragmentPath = xSlideFragmentHandler->getFragmentPathFromFirstTypeFromOfficeDoc( "notesSlide" );
 264                 if( !aNotesFragmentPath.isEmpty() )
 265                 {
 266                     Reference< XPresentationPage > xPresentationPage( xSlide, UNO_QUERY );
 267                     if ( xPresentationPage.is() )
 268                     {
 269                         Reference< XDrawPage > xNotesPage( xPresentationPage->getNotesPage() );
 270                         if ( xNotesPage.is() )
 271                         {
 272                             SlidePersistPtr pNotesPersistPtr( new SlidePersist( rFilter, false, true, xNotesPage,
 273                                 ShapePtr( new PPTShape( Slide, "com.sun.star.drawing.GroupShape" ) ), mpTextListStyle ) );
 274                             FragmentHandlerRef xNotesFragmentHandler( new SlideFragmentHandler( getFilter(), aNotesFragmentPath, pNotesPersistPtr, Slide ) );
 275                             rFilter.getNotesPages().push_back( pNotesPersistPtr );
 276                             rFilter.setActualSlidePersist( pNotesPersistPtr );
 277                             importSlide( xNotesFragmentHandler, pNotesPersistPtr );
 278                             pNotesPersistPtr->createBackground( rFilter );
 279                             pNotesPersistPtr->createXShapes( rFilter );
 280                         }
 281                     }
 282                 }
 283             }
 284
 285             if( !mbCommentAuthorsRead && !aCommentFragmentPath.isEmpty() )
 286             {
 287                 // Comments are present and commentAuthors.xml has still not been read
 288                 mbCommentAuthorsRead = true;
 289                 OUString aCommentAuthorsFragmentPath = "ppt/commentAuthors.xml";
 290                 Reference< XPresentationPage > xPresentationPage( xSlide, UNO_QUERY );
 291                 Reference< XDrawPage > xCommentAuthorsPage( xPresentationPage->getNotesPage() );
 292                 SlidePersistPtr pCommentAuthorsPersistPtr(
 293                     new SlidePersist( rFilter, false, true, xCommentAuthorsPage,
 294                                       ShapePtr(
 295                                           new PPTShape(
 296                                               Slide, "com.sun.star.drawing.GroupShape" ) ),
 297                                       mpTextListStyle ) );
 298                 FragmentHandlerRef xCommentAuthorsFragmentHandler(
 299                     new SlideFragmentHandler( getFilter(),
 300                                               aCommentAuthorsFragmentPath,
 301                                               pCommentAuthorsPersistPtr,
 302                                               Slide ) );
 303
 304                 getFilter().importFragment( xCommentAuthorsFragmentHandler );
 305                 maAuthorList.setValues( pCommentAuthorsPersistPtr->getCommentAuthors() );
 306             }
 307             if( !aCommentFragmentPath.isEmpty() )
 308             {
 309                 Reference< XPresentationPage > xPresentationPage( xSlide, UNO_QUERY );
 310                 Reference< XDrawPage > xCommentsPage( xPresentationPage->getNotesPage() );
 311                 SlidePersistPtr pCommentsPersistPtr(
 312                     new SlidePersist(
 313                         rFilter, false, true, xCommentsPage,
 314                         ShapePtr(
 315                             new PPTShape(
 316                                 Slide, "com.sun.star.drawing.GroupShape" ) ),
 317                         mpTextListStyle ) );
 318
 319                 FragmentHandlerRef xCommentsFragmentHandler(
 320                     new SlideFragmentHandler(
 321                         getFilter(),
 322                         aCommentFragmentPath,
 323                         pCommentsPersistPtr,
 324                         Slide ) );
 325                 pCommentsPersistPtr->getCommentsList().cmLst.clear();
 326                 getFilter().importFragment( xCommentsFragmentHandler );
 327
 328                 if (!pCommentsPersistPtr->getCommentsList().cmLst.empty())
 329                 {
 330                     //set comment chars for last comment on slide
 331                     SlideFragmentHandler* comment_handler =
 332                         dynamic_cast<SlideFragmentHandler*>(xCommentsFragmentHandler.get());
 333                     // some comments have no text -> set empty string as text to avoid
 334                     // crash (back() on empty vector is undefined) and losing other
 335                     // comment data that might be there (author, position, timestamp etc.)
 336                     pCommentsPersistPtr->getCommentsList().cmLst.back().setText(
 337                             comment_handler->getCharVector().empty() ? "" :
 338                             comment_handler->getCharVector().back() );
 339                 }
 340                 pCommentsPersistPtr->getCommentAuthors().setValues(maAuthorList);
 341
 342                 //insert all comments from commentsList
 343                 for(int i=0; i<pCommentsPersistPtr->getCommentsList().getSize(); i++)
 344                 {
 345                     try {
 346                         Comment aComment = pCommentsPersistPtr->getCommentsList().getCommentAtIndex(i);
 347                         uno::Reference< office::XAnnotationAccess > xAnnotationAccess( xSlide, UNO_QUERY_THROW );
 348                         uno::Reference< office::XAnnotation > xAnnotation( xAnnotationAccess->createAndInsertAnnotation() );
 349                         int nPosX = aComment.getIntX();
 350                         int nPosY = aComment.getIntY();
 351                         xAnnotation->setPosition(
 352                             geometry::RealPoint2D(
 353                                 ::oox::drawingml::convertEmuToHmm( nPosX ) * 15.87,
 354                                 ::oox::drawingml::convertEmuToHmm( nPosY ) * 15.87 ) );
 355                         xAnnotation->setAuthor( aComment.getAuthor(maAuthorList) );
 356                         xAnnotation->setDateTime( aComment.getDateTime() );
 357                         uno::Reference< text::XText > xText( xAnnotation->getTextRange() );
 358                         xText->setString( aComment.get_text());
 359                     } catch( css::lang::IllegalArgumentException& ) {}
 360                 }
 361             }
 362         }
 363     }
 364     catch( uno::Exception& )
 365     {
 366         OSL_FAIL( OString("oox::ppt::PresentationFragmentHandler::EndDocument(), "
 367                     "exception caught: " +
 368             OUStringToOString(
 369                 comphelper::anyToString( cppu::getCaughtException() ),
 370                 RTL_TEXTENCODING_UTF8 )).getStr() );
 371
 372     }
 373 }
 374
 375 void PresentationFragmentHandler::finalizeImport()
 376 {
 377     PowerPointImport& rFilter = dynamic_cast< PowerPointImport& >( getFilter() );
 378
 379     sal_Int32 nPageCount = maSlidesVector.size();
 380
 381     // we will take the FilterData property "PageRange" if available, otherwise full range is used
 382     comphelper::SequenceAsHashMap& rFilterData = rFilter.getFilterData();
 383
 384     // writing back the original PageCount of this document, it can be accessed from the XModel
 385     // via getArgs after the import.
 386     rFilterData["OriginalPageCount"] <<= nPageCount;
 387     bool bImportNotesPages = rFilterData.getUnpackedValueOrDefault("ImportNotesPages", true);
 388     OUString aPageRange = rFilterData.getUnpackedValueOrDefault("PageRange", OUString());
 389
 390     if( !aPageRange.getLength() )
 391     {
 392         aPageRange = OUStringBuffer()
 393             .append( static_cast< sal_Int32 >( 1 ) )
 394             .append( '-' )
 395             .append( nPageCount ).makeStringAndClear();
 396     }
 397
 398     StringRangeEnumerator aRangeEnumerator( aPageRange, 0, nPageCount - 1 );
 399     StringRangeEnumerator::Iterator aIter = aRangeEnumerator.begin();
 400     StringRangeEnumerator::Iterator aEnd  = aRangeEnumerator.end();
 401     if(aIter!=aEnd) {
 402
 403         // todo: localized progress bar text
 404         const Reference< task::XStatusIndicator >& rxStatusIndicator( getFilter().getStatusIndicator() );
 405         if ( rxStatusIndicator.is() )
 406             rxStatusIndicator->start( OUString(), 10000 );
 407
 408         try
 409         {
 410             int nPagesImported = 0;
 411             while (aIter!=aEnd)
 412             {
 413                 if ( rxStatusIndicator.is() )
 414                     rxStatusIndicator->setValue((nPagesImported * 10000) / aRangeEnumerator.size());
 415
 416                 importSlide(*aIter, !nPagesImported, bImportNotesPages);
 417                 nPagesImported++;
 418                 ++aIter;
 419             }
 420             ResolveTextFields( rFilter );
 421         }
 422         catch( uno::Exception& )
 423         {
 424             OSL_FAIL( OString("oox::ppt::PresentationFragmentHandler::finalizeImport(), "
 425                         "exception caught: " +
 426                 OUStringToOString(
 427                     comphelper::anyToString( cppu::getCaughtException() ),
 428                     RTL_TEXTENCODING_UTF8 )).getStr() );
 429         }
 430         // todo error handling;
 431         if ( rxStatusIndicator.is() )
 432             rxStatusIndicator->end();
 433     }
 434 }
 435
 436 // CT_Presentation
 437 ::oox::core::ContextHandlerRef PresentationFragmentHandler::onCreateContext( sal_Int32 aElementToken, const AttributeList& rAttribs )
 438 {
 439     switch( aElementToken )
 440     {
 441     case PPT_TOKEN( presentation ):
 442     case PPT_TOKEN( sldMasterIdLst ):
 443     case PPT_TOKEN( notesMasterIdLst ):
 444     case PPT_TOKEN( sldIdLst ):
 445         return this;
 446     case PPT_TOKEN( sldMasterId ):
 447         maSlideMasterVector.push_back( rAttribs.getString( R_TOKEN( id ), OUString() ) );
 448         return this;
 449     case PPT_TOKEN( sldId ):
 450         maSlidesVector.push_back( rAttribs.getString( R_TOKEN( id ), OUString() ) );
 451         return this;
 452     case PPT_TOKEN( notesMasterId ):
 453         maNotesMasterVector.push_back( rAttribs.getString( R_TOKEN( id ), OUString() ) );
 454         return this;
 455     case PPT_TOKEN( sldSz ):
 456         maSlideSize = GetSize2D( rAttribs.getFastAttributeList() );
 457         return this;
 458     case PPT_TOKEN( notesSz ):
 459         maNotesSize = GetSize2D( rAttribs.getFastAttributeList() );
 460         return this;
 461     case PPT_TOKEN( custShowLst ):
 462         return new CustomShowListContext( *this, maCustomShowList );
 463     case PPT_TOKEN( defaultTextStyle ):
 464         return new TextListStyleContext( *this, *mpTextListStyle );
 465     }
 466     return this;
 467 }
 468
 469 void PresentationFragmentHandler::importSlide( const FragmentHandlerRef& rxSlideFragmentHandler,
 470         const SlidePersistPtr& rSlidePersistPtr )
 471 {
 472     Reference< drawing::XDrawPage > xSlide( rSlidePersistPtr->getPage() );
 473     SlidePersistPtr pMasterPersistPtr( rSlidePersistPtr->getMasterPersist() );
 474     if ( pMasterPersistPtr.get() )
 475     {
 476         // Setting "Layout" property adds extra title and outliner preset shapes to the master slide
 477         Reference< drawing::XDrawPage > xMasterSlide(pMasterPersistPtr->getPage());
 478         const int nCount = xMasterSlide->getCount();
 479
 480         const OUString sLayout = "Layout";
 481         uno::Reference< beans::XPropertySet > xSet( xSlide, uno::UNO_QUERY_THROW );
 482         xSet->setPropertyValue( sLayout, Any( pMasterPersistPtr->getLayoutFromValueToken() ) );
 483
 484         while( nCount < xMasterSlide->getCount())
 485         {
 486             Reference< drawing::XShape > xShape;
 487             xMasterSlide->getByIndex(xMasterSlide->getCount()-1) >>= xShape;
 488             xMasterSlide->remove(xShape);
 489         }
 490     }
 491     while( xSlide->getCount() )
 492     {
 493         Reference< drawing::XShape > xShape;
 494         xSlide->getByIndex(0) >>= xShape;
 495         xSlide->remove( xShape );
 496     }
 497
 498     Reference< XPropertySet > xPropertySet( xSlide, UNO_QUERY );
 499     if ( xPropertySet.is() )
 500     {
 501         awt::Size& rPageSize( rSlidePersistPtr->isNotesPage() ? maNotesSize : maSlideSize );
 502         xPropertySet->setPropertyValue( "Width", Any( rPageSize.Width ) );
 503         xPropertySet->setPropertyValue( "Height", Any( rPageSize.Height ) );
 504
 505         oox::ppt::HeaderFooter aHeaderFooter( rSlidePersistPtr->getHeaderFooter() );
 506         if ( !rSlidePersistPtr->isMasterPage() )
 507             aHeaderFooter.mbSlideNumber = aHeaderFooter.mbHeader = aHeaderFooter.mbFooter = aHeaderFooter.mbDateTime = false;
 508         try
 509         {
 510             if ( rSlidePersistPtr->isNotesPage() )
 511                 xPropertySet->setPropertyValue( "IsHeaderVisible", Any( aHeaderFooter.mbHeader ) );
 512             xPropertySet->setPropertyValue( "IsFooterVisible", Any( aHeaderFooter.mbFooter ) );
 513             xPropertySet->setPropertyValue( "IsDateTimeVisible", Any( aHeaderFooter.mbDateTime ) );
 514             xPropertySet->setPropertyValue( "IsPageNumberVisible", Any( aHeaderFooter.mbSlideNumber ) );
 515         }
 516         catch( uno::Exception& )
 517         {
 518         }
 519     }
 520     rSlidePersistPtr->setPath( rxSlideFragmentHandler->getFragmentPath() );
 521     getFilter().importFragment( rxSlideFragmentHandler );
 522 }
 523
 524 } }
 525
 526 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */