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