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/io/XInputStream.hpp>
  31 #include <com/sun/star/xml/dom/XDocument.hpp>
  32 #include <com/sun/star/xml/sax/XFastSAXSerializable.hpp>
  33 #include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
  34 #include <com/sun/star/style/XStyle.hpp>
  35 #include <com/sun/star/presentation/XPresentationPage.hpp>
  36 #include <com/sun/star/task/XStatusIndicator.hpp>
  37
  38 #include <oox/drawingml/theme.hxx>
  39 #include <oox/drawingml/drawingmltypes.hxx>
  40 #include <oox/drawingml/themefragmenthandler.hxx>
  41 #include <drawingml/textliststylecontext.hxx>
  42 #include <oox/helper/attributelist.hxx>
  43 #include <oox/ole/olestorage.hxx>
  44 #include <oox/ole/vbaproject.hxx>
  45 #include <oox/ppt/pptshape.hxx>
  46 #include <oox/ppt/presentationfragmenthandler.hxx>
  47 #include <oox/ppt/slidefragmenthandler.hxx>
  48 #include <oox/ppt/layoutfragmenthandler.hxx>
  49 #include <oox/ppt/pptimport.hxx>
  50 #include <oox/token/namespaces.hxx>
  51 #include <oox/token/tokens.hxx>
  52
  53 #include <com/sun/star/office/XAnnotation.hpp>
  54 #include <com/sun/star/office/XAnnotationAccess.hpp>
  55
  56 using namespace ::com::sun::star;
  57 using namespace ::oox::core;
  58 using namespace ::oox::drawingml;
  59 using namespace ::com::sun::star::uno;
  60 using namespace ::com::sun::star::beans;
  61 using namespace ::com::sun::star::drawing;
  62 using namespace ::com::sun::star::presentation;
  63 using namespace ::com::sun::star::xml::sax;
  64
  65 namespace oox { namespace ppt {
  66
  67 static std::map<PredefinedClrSchemeId, sal_Int32> PredefinedClrTokens =
  68 {
  69     //{ dk1, XML_dk1 },
  70     //{ lt1, XML_lt1 },
  71     { dk2, XML_dk2 },
  72     { lt2, XML_lt2 },
  73     { accent1, XML_accent1 },
  74     { accent2, XML_accent2 },
  75     { accent3, XML_accent3 },
  76     { accent4, XML_accent4 },
  77     { accent5, XML_accent5 },
  78     { accent6, XML_accent6 },
  79     { hlink, XML_hlink },
  80     { folHlink, XML_folHlink }
  81 };
  82
  83 PresentationFragmentHandler::PresentationFragmentHandler(XmlFilterBase& rFilter, const OUString& rFragmentPath)
  84     : FragmentHandler2( rFilter, rFragmentPath )
  85     , mpTextListStyle( new TextListStyle )
  86     , mbCommentAuthorsRead(false)
  87 {
  88     // TODO JNA Typo
  89     TextParagraphPropertiesVector& rParagraphDefaulsVector( mpTextListStyle->getListStyle() );
  90     for (auto const& elem : rParagraphDefaulsVector)
  91     {
  92         // ppt is having zero bottom margin per default, whereas OOo is 0,5cm,
  93         // so this attribute needs to be set always
  94         elem->getParaBottomMargin() = TextSpacing( 0 );
  95     }
  96 }
  97
  98 PresentationFragmentHandler::~PresentationFragmentHandler() throw()
  99 {
 100 }
 101
 102 void ResolveTextFields( XmlFilterBase const & rFilter )
 103 {
 104     const oox::core::TextFieldStack& rTextFields = rFilter.getTextFieldStack();
 105     if ( !rTextFields.empty() )
 106     {
 107         Reference< frame::XModel > xModel( rFilter.getModel() );
 108         for (auto const& textField : rTextFields)
 109         {
 110             const OUString sURL = "URL";
 111             Reference< drawing::XDrawPagesSupplier > xDPS( xModel, uno::UNO_QUERY_THROW );
 112             Reference< drawing::XDrawPages > xDrawPages( xDPS->getDrawPages(), uno::UNO_QUERY_THROW );
 113
 114             const oox::core::TextField& rTextField( textField );
 115             Reference< XPropertySet > xPropSet( rTextField.xTextField, UNO_QUERY );
 116             Reference< XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() );
 117             if ( xPropSetInfo->hasPropertyByName( sURL ) )
 118             {
 119                 OUString aURL;
 120                 if ( xPropSet->getPropertyValue( sURL ) >>= aURL )
 121                 {
 122                     const OUString sSlide = "#Slide ";
 123                     const OUString sNotes = "#Notes ";
 124                     bool bNotes = false;
 125                     sal_Int32 nPageNumber = 0;
 126                     if ( aURL.match( sSlide ) )
 127                         nPageNumber = aURL.copy( sSlide.getLength() ).toInt32();
 128                     else if ( aURL.match( sNotes ) )
 129                     {
 130                         nPageNumber = aURL.copy( sNotes.getLength() ).toInt32();
 131                         bNotes = true;
 132                     }
 133                     if ( nPageNumber )
 134                     {
 135                         try
 136                         {
 137                             Reference< XDrawPage > xDrawPage;
 138                             xDrawPages->getByIndex( nPageNumber - 1 ) >>= xDrawPage;
 139                             if ( bNotes )
 140                             {
 141                                 Reference< css::presentation::XPresentationPage > xPresentationPage( xDrawPage, UNO_QUERY_THROW );
 142                                 xDrawPage = xPresentationPage->getNotesPage();
 143                             }
 144                             Reference< container::XNamed > xNamed( xDrawPage, UNO_QUERY_THROW );
 145                             aURL = "#" + xNamed->getName();
 146                             xPropSet->setPropertyValue( sURL, Any( aURL ) );
 147                             Reference< text::XTextContent > xContent( rTextField.xTextField, UNO_QUERY);
 148                             Reference< text::XTextRange > xTextRange( rTextField.xTextCursor, UNO_QUERY );
 149                             rTextField.xText->insertTextContent( xTextRange, xContent, true );
 150                         }
 151                         catch( uno::Exception& )
 152                         {
 153                         }
 154                     }
 155                 }
 156             }
 157         }
 158     }
 159 }
 160
 161 void PresentationFragmentHandler::saveThemeToGrabBag(oox::drawingml::ThemePtr pThemePtr, const OUString& sTheme)
 162 {
 163     if (!pThemePtr)
 164         return;
 165
 166     try
 167     {
 168         uno::Reference<beans::XPropertySet> xDocProps(getFilter().getModel(), uno::UNO_QUERY);
 169         if (xDocProps.is())
 170         {
 171             uno::Reference<beans::XPropertySetInfo> xPropsInfo = xDocProps->getPropertySetInfo();
 172
 173             const OUString aGrabBagPropName = "InteropGrabBag";
 174             if (xPropsInfo.is() && xPropsInfo->hasPropertyByName(aGrabBagPropName))
 175             {
 176                 // get existing grab bag
 177                 comphelper::SequenceAsHashMap aGrabBag(xDocProps->getPropertyValue(aGrabBagPropName));
 178
 179                 uno::Sequence<beans::PropertyValue> aTheme(1);
 180                 comphelper::SequenceAsHashMap aThemesHashMap;
 181
 182                 // create current theme
 183                 uno::Sequence<beans::PropertyValue> aCurrentTheme(PredefinedClrSchemeId::Count);
 184
 185                 ClrScheme rClrScheme = pThemePtr->getClrScheme();
 186                 for (int nId = PredefinedClrSchemeId::dk2; nId != PredefinedClrSchemeId::Count; nId++)
 187                 {
 188                     sal_uInt32 nToken = PredefinedClrTokens[static_cast<PredefinedClrSchemeId>(nId)];
 189                     const OUString& sName = PredefinedClrNames[static_cast<PredefinedClrSchemeId>(nId)];
 190                     ::Color nColor;
 191
 192                     rClrScheme.getColor(nToken, nColor);
 193                     const uno::Any& rColor = uno::makeAny(nColor);
 194
 195                     aCurrentTheme[nId].Name = sName;
 196                     aCurrentTheme[nId].Value = rColor;
 197                 }
 198
 199                 // add new theme to the sequence
 200                 aTheme[0].Name = sTheme;
 201                 const uno::Any& rCurrentTheme = makeAny(aCurrentTheme);
 202                 aTheme[0].Value = rCurrentTheme;
 203
 204                 aThemesHashMap << aTheme;
 205
 206                 // put the new items
 207                 aGrabBag.update(aThemesHashMap);
 208
 209                 // put it back to the document
 210                 xDocProps->setPropertyValue(aGrabBagPropName, uno::Any(aGrabBag.getAsConstPropertyValueList()));
 211             }
 212         }
 213     }
 214     catch (const uno::Exception&)
 215     {
 216         SAL_WARN("oox", "oox::ppt::PresentationFragmentHandler::saveThemeToGrabBag, Failed to save grab bag");
 217     }
 218 }
 219
 220 void PresentationFragmentHandler::importSlide(sal_uInt32 nSlide, bool bFirstPage, bool bImportNotesPage)
 221 {
 222     PowerPointImport& rFilter = dynamic_cast< PowerPointImport& >( getFilter() );
 223
 224     Reference< frame::XModel > xModel( rFilter.getModel() );
 225     Reference< drawing::XDrawPage > xSlide;
 226
 227     // importing slide pages and its corresponding notes page
 228     Reference< drawing::XDrawPagesSupplier > xDPS( xModel, uno::UNO_QUERY_THROW );
 229     Reference< drawing::XDrawPages > xDrawPages( xDPS->getDrawPages(), uno::UNO_QUERY_THROW );
 230
 231     try {
 232
 233         if( bFirstPage )
 234             xDrawPages->getByIndex( 0 ) >>= xSlide;
 235         else
 236             xSlide = xDrawPages->insertNewByIndex( xDrawPages->getCount() );
 237
 238         OUString aSlideFragmentPath = getFragmentPathFromRelId( maSlidesVector[ nSlide ] );
 239         if( !aSlideFragmentPath.isEmpty() )
 240         {
 241             SlidePersistPtr pMasterPersistPtr;
 242             SlidePersistPtr pSlidePersistPtr( new SlidePersist( rFilter, false, false, xSlide,
 243                                 ShapePtr( new PPTShape( Slide, "com.sun.star.drawing.GroupShape" ) ), mpTextListStyle ) );
 244
 245             FragmentHandlerRef xSlideFragmentHandler( new SlideFragmentHandler( rFilter, aSlideFragmentPath, pSlidePersistPtr, Slide ) );
 246
 247             // importing the corresponding masterpage/layout
 248             OUString aLayoutFragmentPath = xSlideFragmentHandler->getFragmentPathFromFirstTypeFromOfficeDoc( "slideLayout" );
 249             OUString aCommentFragmentPath = xSlideFragmentHandler->getFragmentPathFromFirstTypeFromOfficeDoc( "comments" );
 250             if ( !aLayoutFragmentPath.isEmpty() )
 251             {
 252                 // importing layout
 253                 RelationsRef xLayoutRelations = rFilter.importRelations( aLayoutFragmentPath );
 254                 OUString aMasterFragmentPath = xLayoutRelations->getFragmentPathFromFirstTypeFromOfficeDoc( "slideMaster" );
 255                 if( !aMasterFragmentPath.isEmpty() )
 256                 {
 257                     // check if the corresponding masterpage+layout has already been imported
 258                     std::vector< SlidePersistPtr >& rMasterPages( rFilter.getMasterPages() );
 259                     for (auto const& masterPage : rMasterPages)
 260                     {
 261                         if ( ( masterPage->getPath() == aMasterFragmentPath ) && ( masterPage->getLayoutPath() == aLayoutFragmentPath ) )
 262                         {
 263                             pMasterPersistPtr = masterPage;
 264                             break;
 265                         }
 266                     }
 267
 268                     if ( !pMasterPersistPtr.get() )
 269                     {   // masterpersist not found, we have to load it
 270                         Reference< drawing::XDrawPage > xMasterPage;
 271                         Reference< drawing::XMasterPagesSupplier > xMPS( xModel, uno::UNO_QUERY_THROW );
 272                         Reference< drawing::XDrawPages > xMasterPages( xMPS->getMasterPages(), uno::UNO_QUERY_THROW );
 273
 274                         if( rFilter.getMasterPages().empty() )
 275                             xMasterPages->getByIndex( 0 ) >>= xMasterPage;
 276                         else
 277                             xMasterPage = xMasterPages->insertNewByIndex( xMasterPages->getCount() );
 278
 279                         pMasterPersistPtr = std::make_shared<SlidePersist>( rFilter, true, false, xMasterPage,
 280                             ShapePtr( new PPTShape( Master, "com.sun.star.drawing.GroupShape" ) ), mpTextListStyle );
 281                         pMasterPersistPtr->setLayoutPath( aLayoutFragmentPath );
 282                         rFilter.getMasterPages().push_back( pMasterPersistPtr );
 283                         rFilter.setActualSlidePersist( pMasterPersistPtr );
 284                         FragmentHandlerRef xMasterFragmentHandler( new SlideFragmentHandler( rFilter, aMasterFragmentPath, pMasterPersistPtr, Master ) );
 285
 286                         // set the correct theme
 287                         OUString aThemeFragmentPath = xMasterFragmentHandler->getFragmentPathFromFirstTypeFromOfficeDoc( "theme" );
 288                         if( !aThemeFragmentPath.isEmpty() )
 289                         {
 290                             std::map< OUString, oox::drawingml::ThemePtr >& rThemes( rFilter.getThemes() );
 291                             std::map< OUString, oox::drawingml::ThemePtr >::iterator aIter2( rThemes.find( aThemeFragmentPath ) );
 292                             if( aIter2 == rThemes.end() )
 293                             {
 294                                 oox::drawingml::ThemePtr pThemePtr( new oox::drawingml::Theme() );
 295                                 pMasterPersistPtr->setTheme( pThemePtr );
 296                                 Reference<xml::dom::XDocument> xDoc=
 297                                     rFilter.importFragment(aThemeFragmentPath);
 298
 299                                 rFilter.importFragment(
 300                                     new ThemeFragmentHandler(
 301                                         rFilter, aThemeFragmentPath, *pThemePtr ),
 302                                     Reference<xml::sax::XFastSAXSerializable>(
 303                                         xDoc,
 304                                         UNO_QUERY_THROW));
 305                                 rThemes[ aThemeFragmentPath ] = pThemePtr;
 306                                 pThemePtr->setFragment(xDoc);
 307                                 saveThemeToGrabBag(pThemePtr, aThemeFragmentPath);
 308                             }
 309                             else
 310                             {
 311                                 pMasterPersistPtr->setTheme( (*aIter2).second );
 312                             }
 313                         }
 314                         importSlide( xMasterFragmentHandler, pMasterPersistPtr );
 315                         rFilter.importFragment( new LayoutFragmentHandler( rFilter, aLayoutFragmentPath, pMasterPersistPtr ) );
 316                         pMasterPersistPtr->createBackground( rFilter );
 317                         pMasterPersistPtr->createXShapes( rFilter );
 318                     }
 319                 }
 320             }
 321
 322             // importing slide page
 323             if (pMasterPersistPtr.get()) {
 324                 pSlidePersistPtr->setMasterPersist( pMasterPersistPtr );
 325                 pSlidePersistPtr->setTheme( pMasterPersistPtr->getTheme() );
 326                 Reference< drawing::XMasterPageTarget > xMasterPageTarget( pSlidePersistPtr->getPage(), UNO_QUERY );
 327                 if( xMasterPageTarget.is() )
 328                     xMasterPageTarget->setMasterPage( pMasterPersistPtr->getPage() );
 329             }
 330             rFilter.getDrawPages().push_back( pSlidePersistPtr );
 331             rFilter.setActualSlidePersist( pSlidePersistPtr );
 332             importSlide( xSlideFragmentHandler, pSlidePersistPtr );
 333             pSlidePersistPtr->createBackground( rFilter );
 334             pSlidePersistPtr->createXShapes( rFilter );
 335
 336             if(bImportNotesPage) {
 337
 338                 // now importing the notes page
 339                 OUString aNotesFragmentPath = xSlideFragmentHandler->getFragmentPathFromFirstTypeFromOfficeDoc( "notesSlide" );
 340                 if( !aNotesFragmentPath.isEmpty() )
 341                 {
 342                     Reference< XPresentationPage > xPresentationPage( xSlide, UNO_QUERY );
 343                     if ( xPresentationPage.is() )
 344                     {
 345                         Reference< XDrawPage > xNotesPage( xPresentationPage->getNotesPage() );
 346                         if ( xNotesPage.is() )
 347                         {
 348                             SlidePersistPtr pNotesPersistPtr( new SlidePersist( rFilter, false, true, xNotesPage,
 349                                 ShapePtr( new PPTShape( Slide, "com.sun.star.drawing.GroupShape" ) ), mpTextListStyle ) );
 350                             FragmentHandlerRef xNotesFragmentHandler( new SlideFragmentHandler( getFilter(), aNotesFragmentPath, pNotesPersistPtr, Slide ) );
 351                             rFilter.getNotesPages().push_back( pNotesPersistPtr );
 352                             rFilter.setActualSlidePersist( pNotesPersistPtr );
 353                             importSlide( xNotesFragmentHandler, pNotesPersistPtr );
 354                             pNotesPersistPtr->createBackground( rFilter );
 355                             pNotesPersistPtr->createXShapes( rFilter );
 356                         }
 357                     }
 358                 }
 359             }
 360
 361             if( !mbCommentAuthorsRead && !aCommentFragmentPath.isEmpty() )
 362             {
 363                 // Comments are present and commentAuthors.xml has still not been read
 364                 mbCommentAuthorsRead = true;
 365                 OUString aCommentAuthorsFragmentPath = "ppt/commentAuthors.xml";
 366                 Reference< XPresentationPage > xPresentationPage( xSlide, UNO_QUERY );
 367                 Reference< XDrawPage > xCommentAuthorsPage( xPresentationPage->getNotesPage() );
 368                 SlidePersistPtr pCommentAuthorsPersistPtr(
 369                     new SlidePersist( rFilter, false, true, xCommentAuthorsPage,
 370                                       ShapePtr(
 371                                           new PPTShape(
 372                                               Slide, "com.sun.star.drawing.GroupShape" ) ),
 373                                       mpTextListStyle ) );
 374                 FragmentHandlerRef xCommentAuthorsFragmentHandler(
 375                     new SlideFragmentHandler( getFilter(),
 376                                               aCommentAuthorsFragmentPath,
 377                                               pCommentAuthorsPersistPtr,
 378                                               Slide ) );
 379
 380                 getFilter().importFragment( xCommentAuthorsFragmentHandler );
 381                 maAuthorList.setValues( pCommentAuthorsPersistPtr->getCommentAuthors() );
 382             }
 383             if( !aCommentFragmentPath.isEmpty() )
 384             {
 385                 Reference< XPresentationPage > xPresentationPage( xSlide, UNO_QUERY );
 386                 Reference< XDrawPage > xCommentsPage( xPresentationPage->getNotesPage() );
 387                 SlidePersistPtr pCommentsPersistPtr(
 388                     new SlidePersist(
 389                         rFilter, false, true, xCommentsPage,
 390                         ShapePtr(
 391                             new PPTShape(
 392                                 Slide, "com.sun.star.drawing.GroupShape" ) ),
 393                         mpTextListStyle ) );
 394
 395                 FragmentHandlerRef xCommentsFragmentHandler(
 396                     new SlideFragmentHandler(
 397                         getFilter(),
 398                         aCommentFragmentPath,
 399                         pCommentsPersistPtr,
 400                         Slide ) );
 401                 pCommentsPersistPtr->getCommentsList().cmLst.clear();
 402                 getFilter().importFragment( xCommentsFragmentHandler );
 403
 404                 if (!pCommentsPersistPtr->getCommentsList().cmLst.empty())
 405                 {
 406                     //set comment chars for last comment on slide
 407                     SlideFragmentHandler* comment_handler =
 408                         dynamic_cast<SlideFragmentHandler*>(xCommentsFragmentHandler.get());
 409                     // some comments have no text -> set empty string as text to avoid
 410                     // crash (back() on empty vector is undefined) and losing other
 411                     // comment data that might be there (author, position, timestamp etc.)
 412                     pCommentsPersistPtr->getCommentsList().cmLst.back().setText(
 413                             comment_handler->getCharVector().empty() ? "" :
 414                             comment_handler->getCharVector().back() );
 415                 }
 416                 pCommentsPersistPtr->getCommentAuthors().setValues(maAuthorList);
 417
 418                 //insert all comments from commentsList
 419                 for(int i=0; i<pCommentsPersistPtr->getCommentsList().getSize(); i++)
 420                 {
 421                     try {
 422                         Comment aComment = pCommentsPersistPtr->getCommentsList().getCommentAtIndex(i);
 423                         uno::Reference< office::XAnnotationAccess > xAnnotationAccess( xSlide, UNO_QUERY_THROW );
 424                         uno::Reference< office::XAnnotation > xAnnotation( xAnnotationAccess->createAndInsertAnnotation() );
 425                         int nPosX = aComment.getIntX();
 426                         int nPosY = aComment.getIntY();
 427                         xAnnotation->setPosition(
 428                             geometry::RealPoint2D(
 429                                 ::oox::drawingml::convertEmuToHmm( nPosX ) * 15.87,
 430                                 ::oox::drawingml::convertEmuToHmm( nPosY ) * 15.87 ) );
 431                         xAnnotation->setAuthor( aComment.getAuthor(maAuthorList) );
 432                         xAnnotation->setDateTime( aComment.getDateTime() );
 433                         uno::Reference< text::XText > xText( xAnnotation->getTextRange() );
 434                         xText->setString( aComment.get_text());
 435                     } catch( css::lang::IllegalArgumentException& ) {}
 436                 }
 437             }
 438         }
 439     }
 440     catch( uno::Exception& )
 441     {
 442         SAL_WARN( "oox", "oox::ppt::PresentationFragmentHandler::EndDocument(), "
 443                   "exception caught: " << comphelper::anyToString( cppu::getCaughtException() ) );
 444     }
 445 }
 446
 447 void PresentationFragmentHandler::finalizeImport()
 448 {
 449     PowerPointImport& rFilter = dynamic_cast< PowerPointImport& >( getFilter() );
 450
 451     sal_Int32 nPageCount = maSlidesVector.size();
 452
 453     // we will take the FilterData property "PageRange" if available, otherwise full range is used
 454     comphelper::SequenceAsHashMap& rFilterData = rFilter.getFilterData();
 455
 456     // writing back the original PageCount of this document, it can be accessed from the XModel
 457     // via getArgs after the import.
 458     rFilterData["OriginalPageCount"] <<= nPageCount;
 459     bool bImportNotesPages = rFilterData.getUnpackedValueOrDefault("ImportNotesPages", true);
 460     OUString aPageRange = rFilterData.getUnpackedValueOrDefault("PageRange", OUString());
 461
 462     if( !aPageRange.getLength() )
 463     {
 464         aPageRange = OUStringBuffer()
 465             .append( static_cast< sal_Int32 >( 1 ) )
 466             .append( '-' )
 467             .append( nPageCount ).makeStringAndClear();
 468     }
 469
 470     StringRangeEnumerator aRangeEnumerator( aPageRange, 0, nPageCount - 1 );
 471     if (aRangeEnumerator.size())
 472     {
 473         // todo: localized progress bar text
 474         const Reference< task::XStatusIndicator >& rxStatusIndicator( getFilter().getStatusIndicator() );
 475         if ( rxStatusIndicator.is() )
 476             rxStatusIndicator->start( OUString(), 10000 );
 477
 478         try
 479         {
 480             int nPagesImported = 0;
 481             for (auto const& elem : aRangeEnumerator)
 482             {
 483                 if ( rxStatusIndicator.is() )
 484                     rxStatusIndicator->setValue((nPagesImported * 10000) / aRangeEnumerator.size());
 485
 486                 importSlide(elem, !nPagesImported, bImportNotesPages);
 487                 nPagesImported++;
 488             }
 489             ResolveTextFields( rFilter );
 490         }
 491         catch( uno::Exception& )
 492         {
 493             SAL_WARN( "oox", "oox::ppt::PresentationFragmentHandler::finalizeImport(), "
 494                         "exception caught: " << comphelper::anyToString( cppu::getCaughtException() ) );
 495         }
 496         // todo error handling;
 497         if ( rxStatusIndicator.is() )
 498             rxStatusIndicator->end();
 499     }
 500
 501     // open the VBA project storage
 502     OUString aVbaFragmentPath = getFragmentPathFromFirstType(CREATE_MSOFFICE_RELATION_TYPE("vbaProject"));
 503     if (!aVbaFragmentPath.isEmpty())
 504     {
 505         uno::Reference<io::XInputStream> xInStrm = getFilter().openInputStream(aVbaFragmentPath);
 506         if (xInStrm.is())
 507         {
 508             StorageRef xPrjStrg(new oox::ole::OleStorage(getFilter().getComponentContext(), xInStrm, false));
 509             getFilter().getVbaProject().importVbaProject(*xPrjStrg);
 510         }
 511     }
 512 }
 513
 514 // CT_Presentation
 515 ::oox::core::ContextHandlerRef PresentationFragmentHandler::onCreateContext( sal_Int32 aElementToken, const AttributeList& rAttribs )
 516 {
 517     switch( aElementToken )
 518     {
 519     case PPT_TOKEN( presentation ):
 520     case PPT_TOKEN( sldMasterIdLst ):
 521     case PPT_TOKEN( notesMasterIdLst ):
 522     case PPT_TOKEN( sldIdLst ):
 523         return this;
 524     case PPT_TOKEN( sldMasterId ):
 525         maSlideMasterVector.push_back( rAttribs.getString( R_TOKEN( id ), OUString() ) );
 526         return this;
 527     case PPT_TOKEN( sldId ):
 528         maSlidesVector.push_back( rAttribs.getString( R_TOKEN( id ), OUString() ) );
 529         return this;
 530     case PPT_TOKEN( notesMasterId ):
 531         maNotesMasterVector.push_back( rAttribs.getString( R_TOKEN( id ), OUString() ) );
 532         return this;
 533     case PPT_TOKEN( sldSz ):
 534         maSlideSize = GetSize2D( rAttribs.getFastAttributeList() );
 535         return this;
 536     case PPT_TOKEN( notesSz ):
 537         maNotesSize = GetSize2D( rAttribs.getFastAttributeList() );
 538         return this;
 539     case PPT_TOKEN( custShowLst ):
 540         return new CustomShowListContext( *this, maCustomShowList );
 541     case PPT_TOKEN( defaultTextStyle ):
 542         return new TextListStyleContext( *this, *mpTextListStyle );
 543     }
 544     return this;
 545 }
 546
 547 void PresentationFragmentHandler::importSlide( const FragmentHandlerRef& rxSlideFragmentHandler,
 548         const SlidePersistPtr& rSlidePersistPtr )
 549 {
 550     Reference< drawing::XDrawPage > xSlide( rSlidePersistPtr->getPage() );
 551     SlidePersistPtr pMasterPersistPtr( rSlidePersistPtr->getMasterPersist() );
 552     if ( pMasterPersistPtr.get() )
 553     {
 554         // Setting "Layout" property adds extra title and outliner preset shapes to the master slide
 555         Reference< drawing::XDrawPage > xMasterSlide(pMasterPersistPtr->getPage());
 556         const int nCount = xMasterSlide->getCount();
 557
 558         const OUString sLayout = "Layout";
 559         uno::Reference< beans::XPropertySet > xSet( xSlide, uno::UNO_QUERY_THROW );
 560         xSet->setPropertyValue( sLayout, Any( pMasterPersistPtr->getLayoutFromValueToken() ) );
 561
 562         while( nCount < xMasterSlide->getCount())
 563         {
 564             Reference< drawing::XShape > xShape;
 565             xMasterSlide->getByIndex(xMasterSlide->getCount()-1) >>= xShape;
 566             xMasterSlide->remove(xShape);
 567         }
 568     }
 569     while( xSlide->getCount() )
 570     {
 571         Reference< drawing::XShape > xShape;
 572         xSlide->getByIndex(0) >>= xShape;
 573         xSlide->remove( xShape );
 574     }
 575
 576     Reference< XPropertySet > xPropertySet( xSlide, UNO_QUERY );
 577     if ( xPropertySet.is() )
 578     {
 579         awt::Size& rPageSize( rSlidePersistPtr->isNotesPage() ? maNotesSize : maSlideSize );
 580         xPropertySet->setPropertyValue( "Width", Any( rPageSize.Width ) );
 581         xPropertySet->setPropertyValue( "Height", Any( rPageSize.Height ) );
 582
 583         oox::ppt::HeaderFooter aHeaderFooter( rSlidePersistPtr->getHeaderFooter() );
 584         if ( !rSlidePersistPtr->isMasterPage() )
 585             aHeaderFooter.mbSlideNumber = aHeaderFooter.mbHeader = aHeaderFooter.mbFooter = aHeaderFooter.mbDateTime = false;
 586         try
 587         {
 588             if ( rSlidePersistPtr->isNotesPage() )
 589                 xPropertySet->setPropertyValue( "IsHeaderVisible", Any( aHeaderFooter.mbHeader ) );
 590             xPropertySet->setPropertyValue( "IsFooterVisible", Any( aHeaderFooter.mbFooter ) );
 591             xPropertySet->setPropertyValue( "IsDateTimeVisible", Any( aHeaderFooter.mbDateTime ) );
 592             xPropertySet->setPropertyValue( "IsPageNumberVisible", Any( aHeaderFooter.mbSlideNumber ) );
 593         }
 594         catch( uno::Exception& )
 595         {
 596         }
 597     }
 598     rSlidePersistPtr->setPath( rxSlideFragmentHandler->getFragmentPath() );
 599     getFilter().importFragment( rxSlideFragmentHandler );
 600 }
 601
 602 } }
 603
 604 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */