?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
bump product version to 6.3.0.0.beta1
[LibreOffice.git] / sd / source / filter / eppt / eppt.cxx
blob92caecc4da3c9ca70a8caaaaa19c0062f50b9155
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 "eppt.hxx"
21 #include "epptdef.hxx"
22 #include "pptexanimations.hxx"
23 #include <o3tl/any.hxx>
24 #include <tools/globname.hxx>
25 #include <rtl/ustring.hxx>
26 #include <tools/stream.hxx>
27 #include <svx/unoapi.hxx>
28 #include <svx/svdobj.hxx>
29 #include <svx/svdoole2.hxx>
30 #include <com/sun/star/container/XIndexContainer.hpp>
31 #include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
32 #include <com/sun/star/office/XAnnotation.hpp>
33 #include <com/sun/star/office/XAnnotationAccess.hpp>
34 #include <com/sun/star/office/XAnnotationEnumeration.hpp>
35 #include <com/sun/star/presentation/AnimationSpeed.hpp>
36 #include <com/sun/star/presentation/XPresentationSupplier.hpp>
37 #include <com/sun/star/presentation/XCustomPresentationSupplier.hpp>
38 #include <com/sun/star/geometry/RealPoint2D.hpp>
39 #include <com/sun/star/util/DateTime.hpp>
40 #include <com/sun/star/task/XStatusIndicator.hpp>
41 #include <tools/zcodec.hxx>
42 #include <filter/msfilter/classids.hxx>
43 #include <filter/msfilter/msoleexp.hxx>
44 #include <filter/msfilter/msdffimp.hxx>
45 #include <filter/msfilter/svxmsbas.hxx>
46 #include <editeng/flditem.hxx>
47 #include <sfx2/docinf.hxx>
48 #include <oox/export/utils.hxx>
49 #include <oox/ole/olehelper.hxx>
50 #include <rtl/math.hxx>
51 #include <memory>
52
53 class SfxObjectShell;
54 // complete SfxObjectShell for SaveVBA under -fsanitize=function
55
56 using namespace com::sun::star;
57 using namespace ::com::sun::star::uno;
58 using namespace ::com::sun::star::presentation;
59
60 using ::com::sun::star::beans::XPropertySet;
61
62 //============================ PPTWriter ==================================
63
64 PPTWriter::PPTWriter( tools::SvRef<SotStorage> const & rSvStorage,
65 css::uno::Reference< css::frame::XModel > const & rXModel,
66 css::uno::Reference< css::task::XStatusIndicator > const & rXStatInd,
67 SvMemoryStream* pVBA, sal_uInt32 nCnvrtFlags ) :
68 PPTWriterBase ( rXModel, rXStatInd ),
69 mnCnvrtFlags ( nCnvrtFlags ),
70 mbStatus ( false ),
71 mnStatMaxValue ( 0 ),
72 mnLatestStatValue ( 0 ),
73 mnTextStyle( 0 ),
74 mbFontIndependentLineSpacing( false ),
75 mnTextSize( 0 ),
76 mrStg ( rSvStorage ),
77 mnVBAOleOfs ( 0 ),
78 mpVBA ( pVBA ),
79 mnExEmbed ( 0 ),
80 mpExEmbed ( new SvMemoryStream ),
81 mnPagesWritten ( 0 ),
82 mnTxId ( 0x7a2f64 ),
83 mnDiaMode ( 0 ),
84 mnShapeMasterTitle ( 0 ),
85 mnShapeMasterBody ( 0 )
86 {
87 }
88
89 void PPTWriter::exportPPTPre( const std::vector< css::beans::PropertyValue >& rMediaData )
90 {
91 if ( !mrStg.is() )
92 return;
93
94 if ( mXStatusIndicator.is() )
95 {
96 mbStatusIndicator = true;
97 mnStatMaxValue = ( mnPages + mnMasterPages ) * 5;
98 mXStatusIndicator->start( "PowerPoint Export", mnStatMaxValue + ( mnStatMaxValue >> 3 ) );
99 }
100
101 SvGlobalName aGName(MSO_PPT8_CLASSID);
102 mrStg->SetClass( aGName, SotClipboardFormatId::NONE, "MS PowerPoint 97" );
103
104 if ( !ImplCreateCurrentUserStream() )
105 return;
106
107 mpStrm.reset( mrStg->OpenSotStream( "PowerPoint Document" ) );
108 if ( !mpStrm )
109 return;
110
111 if ( !mpPicStrm )
112 mpPicStrm.reset( mrStg->OpenSotStream( "Pictures" ) );
113
114 auto aIter = std::find_if(rMediaData.begin(), rMediaData.end(),
115 [](const css::beans::PropertyValue& rProp) { return rProp.Name == "BaseURI"; });
116 if (aIter != rMediaData.end())
117 (*aIter).Value >>= maBaseURI;
118 mpPptEscherEx.reset( new PptEscherEx( *mpStrm, maBaseURI ) );
119 }
120
121 void PPTWriter::exportPPTPost( )
122 {
123 if ( !ImplCloseDocument() )
124 return;
125
126 if ( mbStatusIndicator )
127 {
128 mXStatusIndicator->setText( "PowerPoint Export" );
129 sal_uInt32 nValue = mnStatMaxValue + ( mnStatMaxValue >> 3 );
130 if ( nValue > mnLatestStatValue )
131 {
132 mXStatusIndicator->setValue( nValue );
133 mnLatestStatValue = nValue;
134 }
135 }
136
137 ImplWriteOLE();
138
139 ImplWriteVBA();
140
141 ImplWriteAtomEnding();
142
143 ImplCreateDocumentSummaryInformation();
144
145 mbStatus = true;
146 };
147
148 static void ImplExportComments( const uno::Reference< drawing::XDrawPage >& xPage, SvMemoryStream& rBinaryTagData10Atom );
149
150 void PPTWriter::ImplWriteSlide( sal_uInt32 nPageNum, sal_uInt32 nMasterNum, sal_uInt16 nMode,
151 bool bHasBackground, Reference< XPropertySet > const & aXBackgroundPropSet )
152 {
153 Any aAny;
154
155 const PHLayout& rLayout = GetLayout( mXPagePropSet );
156 mpPptEscherEx->PtReplaceOrInsert( EPP_Persist_Slide | nPageNum, mpStrm->Tell() );
157 mpPptEscherEx->OpenContainer( EPP_Slide );
158 mpPptEscherEx->AddAtom( 24, EPP_SlideAtom, 2 );
159 mpStrm->WriteInt32( static_cast<sal_Int32>(rLayout.nLayout) );
160 mpStrm->WriteBytes(rLayout.nPlaceHolder, 8); // placeholderIDs (8 parts)
161 mpStrm->WriteUInt32( nMasterNum | 0x80000000 ) // master ID (equals 0x80000000 on a master page)
162 .WriteUInt32( nPageNum + 0x100 ) // notes ID (equals null if no notes are present)
163 .WriteUInt16( nMode )
164 .WriteUInt16( 0 ); // padword
165
166 mnDiaMode = 0;
167 bool bVisible = true;
168 css::presentation::FadeEffect eFe = css::presentation::FadeEffect_NONE;
169
170 if ( GetPropertyValue( aAny, mXPagePropSet, "Visible" ) )
171 aAny >>= bVisible;
172 if ( GetPropertyValue( aAny, mXPagePropSet, "Change" ) )
173 {
174 switch ( *o3tl::doAccess<sal_Int32>(aAny) )
175 {
176 case 1 : // automatic
177 mnDiaMode++;
178 [[fallthrough]];
179 case 2 : // semi-automatic
180 mnDiaMode++;
181 break;
182 default :
183 case 0 : // manual
184 break;
185 }
186 }
187 if ( GetPropertyValue( aAny, mXPagePropSet, "Effect" ) )
188 aAny >>= eFe;
189
190 sal_uInt32 nSoundRef = 0;
191 bool bIsSound = false;
192 bool bStopSound = false;
193 bool bLoopSound = false;
194
195 if ( GetPropertyValue( aAny, mXPagePropSet, "Sound" ) )
196 {
197 OUString aSoundURL;
198 if ( aAny >>= aSoundURL )
199 {
200 nSoundRef = maSoundCollection.GetId( aSoundURL );
201 bIsSound = true;
202 }
203 else
204 aAny >>= bStopSound;
205 }
206 if ( GetPropertyValue( aAny, mXPagePropSet, "LoopSound" ) )
207 aAny >>= bLoopSound;
208
209 bool bNeedsSSSlideInfoAtom = !bVisible
210 || ( mnDiaMode == 2 )
211 || bIsSound
212 || bStopSound
213 || ( eFe != css::presentation::FadeEffect_NONE );
214 if ( bNeedsSSSlideInfoAtom )
215 {
216 sal_uInt8 nDirection = 0;
217 sal_uInt8 nTransitionType = 0;
218 sal_uInt16 nBuildFlags = 1; // advance by mouseclick
219 sal_Int32 nSlideTime = 0; // still has to !!!
220 sal_uInt8 nSpeed = 1;
221
222 if ( GetPropertyValue( aAny, mXPagePropSet, "TransitionDuration" ) )
223 {
224 css::presentation::AnimationSpeed aAs;
225 double fTransitionDuration = -1.0;
226 aAny >>= fTransitionDuration;
227
228 if (fTransitionDuration >= 0)
229 {
230 if (fTransitionDuration <= 0.5)
231 {
232 aAs = css::presentation::AnimationSpeed::AnimationSpeed_FAST;
233 }
234 else if (fTransitionDuration >= 1.0)
235 {
236 aAs = css::presentation::AnimationSpeed::AnimationSpeed_SLOW;
237 }
238 else
239 {
240 aAs = css::presentation::AnimationSpeed::AnimationSpeed_MEDIUM;
241 }
242 }
243 else
244 aAs = css::presentation::AnimationSpeed::AnimationSpeed_MEDIUM;
245
246 nSpeed = static_cast<sal_uInt8>(aAs);
247 }
248 sal_Int16 nTT = 0;
249 if ( GetPropertyValue( aAny, mXPagePropSet, "TransitionType" )
250 && ( aAny >>= nTT ) )
251 {
252 sal_Int16 nTST = 0;
253 if ( GetPropertyValue( aAny, mXPagePropSet, "TransitionSubtype" )
254 && ( aAny >>= nTST ) )
255 nTransitionType = GetTransition( nTT, nTST, eFe, nDirection );
256
257 }
258 if ( !nTransitionType )
259 nTransitionType = GetTransition( eFe, nDirection );
260 if ( mnDiaMode == 2 ) // automatic ?
261 nBuildFlags |= 0x400;
262 if ( !bVisible )
263 nBuildFlags |= 4;
264 if ( bIsSound )
265 nBuildFlags |= 16;
266 if ( bLoopSound )
267 nBuildFlags |= 64;
268 if ( bStopSound )
269 nBuildFlags |= 256;
270
271 if ( GetPropertyValue( aAny, mXPagePropSet, "Duration" ) )// duration of this slide
272 nSlideTime = *o3tl::doAccess<sal_Int32>(aAny) << 10; // in ticks
273
274 mpPptEscherEx->AddAtom( 16, EPP_SSSlideInfoAtom );
275 mpStrm->WriteInt32( nSlideTime ) // standtime in ticks
276 .WriteUInt32( nSoundRef )
277 .WriteUChar( nDirection )
278 .WriteUChar( nTransitionType )
279 .WriteUInt16( nBuildFlags )
280 .WriteUChar( nSpeed )
281 .WriteUChar( 0 ).WriteUChar( 0 ).WriteUChar( 0 );
282 }
283
284 ImplCreateHeaderFooters( mXPagePropSet );
285
286 EscherSolverContainer aSolverContainer;
287 mpPptEscherEx->OpenContainer( EPP_PPDrawing );
288 mpPptEscherEx->OpenContainer( ESCHER_DgContainer );
289 mpPptEscherEx->EnterGroup(nullptr,nullptr);
290 ImplWritePage( rLayout, aSolverContainer, NORMAL, false, nPageNum ); // the shapes of the pages are created in the PPT document
291 mpPptEscherEx->LeaveGroup();
292
293 if ( bHasBackground )
294 ImplWriteBackground( aXBackgroundPropSet );
295 else
296 {
297 mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
298 mpPptEscherEx->AddShape( ESCHER_ShpInst_Rectangle,
299 ShapeFlag::Background | ShapeFlag::HaveShapeProperty );
300 EscherPropertyContainer aPropOpt;
301 aPropOpt.AddOpt( ESCHER_Prop_fillRectRight, PPTtoEMU( maDestPageSize.Width ) );
302 aPropOpt.AddOpt( ESCHER_Prop_fillRectBottom, PPTtoEMU( maDestPageSize.Width ) );
303 aPropOpt.AddOpt( ESCHER_Prop_fNoFillHitTest, 0x120012 );
304 aPropOpt.AddOpt( ESCHER_Prop_fNoLineDrawDash, 0x80000 );
305 aPropOpt.AddOpt( ESCHER_Prop_bWMode, ESCHER_wDontShow );
306 aPropOpt.AddOpt( ESCHER_Prop_fBackground, 0x10001 ); // if true, this is the background shape
307 aPropOpt.Commit( *mpStrm );
308 mpPptEscherEx->CloseContainer(); // ESCHER_SpContainer
309 }
310
311 aSolverContainer.WriteSolver( *mpStrm );
312
313 mpPptEscherEx->CloseContainer(); // ESCHER_DgContainer
314 mpPptEscherEx->CloseContainer(); // EPP_Drawing
315 mpPptEscherEx->AddAtom( 32, EPP_ColorSchemeAtom, 0, 1 );
316 mpStrm->WriteUInt32( 0xffffff ).WriteUInt32( 0x000000 ).WriteUInt32( 0x808080 ).WriteUInt32( 0x000000 ).WriteUInt32( 0x99cc00 ).WriteUInt32( 0xcc3333 ).WriteUInt32( 0xffcccc ).WriteUInt32( 0xb2b2b2 );
317
318 SvMemoryStream aBinaryTagData10Atom;
319 ImplExportComments( mXDrawPage, aBinaryTagData10Atom );
320 SvMemoryStream amsofbtAnimGroup;
321 ppt::AnimationExporter aExporter( aSolverContainer, maSoundCollection );
322 aExporter.doexport( mXDrawPage, amsofbtAnimGroup );
323 sal_uInt32 nmsofbtAnimGroupSize = amsofbtAnimGroup.Tell();
324 if ( nmsofbtAnimGroupSize )
325 {
326 {
327 EscherExAtom aMagic2( aBinaryTagData10Atom, 0x2eeb );
328 aBinaryTagData10Atom.WriteUInt32( 0x01c45df9 )
329 .WriteUInt32( 0xe1471b30 );
330 }
331 {
332 EscherExAtom aMagic( aBinaryTagData10Atom, 0x2b00 );
333 aBinaryTagData10Atom.WriteUInt32( 0 );
334 }
335 aBinaryTagData10Atom.WriteBytes(amsofbtAnimGroup.GetData(), amsofbtAnimGroup.Tell());
336 {
337 EscherExContainer aMagic2( aBinaryTagData10Atom, 0x2b02 );
338 }
339 }
340 if ( aBinaryTagData10Atom.Tell() )
341 {
342 EscherExContainer aProgTags ( *mpStrm, EPP_ProgTags );
343 EscherExContainer aProgBinaryTag( *mpStrm, EPP_ProgBinaryTag );
344 {
345 EscherExAtom aCString( *mpStrm, EPP_CString );
346 mpStrm->WriteUInt32( 0x5f005f )
347 .WriteUInt32( 0x50005f )
348 .WriteUInt32( 0x540050 )
349 .WriteUInt16( 0x31 )
350 .WriteUInt16( 0x30 );
351 }
352 {
353 EscherExAtom aBinaryTagData( *mpStrm, EPP_BinaryTagData );
354 mpStrm->WriteBytes(aBinaryTagData10Atom.GetData(), aBinaryTagData10Atom.Tell());
355 }
356 }
357 mpPptEscherEx->CloseContainer(); // EPP_Slide
358 }
359
360 void PPTWriter::ImplWriteSlideMaster( sal_uInt32 nPageNum, Reference< XPropertySet > const & aXBackgroundPropSet )
361 {
362 mpPptEscherEx->PtReplaceOrInsert( EPP_Persist_MainMaster | nPageNum, mpStrm->Tell() );
363 mpPptEscherEx->OpenContainer( EPP_MainMaster );
364 mpPptEscherEx->AddAtom( 24, EPP_SlideAtom, 2 );
365 mpStrm->WriteInt32( static_cast<sal_Int32>(EppLayout::TITLEANDBODYSLIDE) ) // slide layout -> title and body slide
366 .WriteUChar( 1 ).WriteUChar( 2 ).WriteUChar( 0 ).WriteUChar( 0 ).WriteUChar( 0 ).WriteUChar( 0 ).WriteUChar( 0 ).WriteUChar( 0 ) // placeholderID
367 .WriteUInt32( 0 ) // master ID (equals null at a master page)
368 .WriteUInt32( 0 ) // notes ID (equals null if no notes are present)
369 .WriteUInt16( 0 ) // Bit 1: Follow master objects, Bit 2: Follow master scheme, Bit 3: Follow master background
370 .WriteUInt16( 0 ); // padword
371
372 mpPptEscherEx->AddAtom( 32, EPP_ColorSchemeAtom, 0, 6 );
373 mpStrm->WriteUInt32( 0xffffff ).WriteUInt32( 0x000000 ).WriteUInt32( 0x808080 ).WriteUInt32( 0x000000 ).WriteUInt32( 0x99cc00 ).WriteUInt32( 0xcc3333 ).WriteUInt32( 0xffcccc ).WriteUInt32( 0xb2b2b2 );
374 mpPptEscherEx->AddAtom( 32, EPP_ColorSchemeAtom, 0, 6 );
375 mpStrm->WriteUInt32( 0xff0000 ).WriteUInt32( 0xffffff ).WriteUInt32( 0x000000 ).WriteUInt32( 0x00ffff ).WriteUInt32( 0x0099ff ).WriteUInt32( 0xffff00 ).WriteUInt32( 0x0000ff ).WriteUInt32( 0x969696 );
376 mpPptEscherEx->AddAtom( 32, EPP_ColorSchemeAtom, 0, 6 );
377 mpStrm->WriteUInt32( 0xccffff ).WriteUInt32( 0x000000 ).WriteUInt32( 0x336666 ).WriteUInt32( 0x008080 ).WriteUInt32( 0x339933 ).WriteUInt32( 0x000080 ).WriteUInt32( 0xcc3300 ).WriteUInt32( 0x66ccff );
378 mpPptEscherEx->AddAtom( 32, EPP_ColorSchemeAtom, 0, 6 );
379 mpStrm->WriteUInt32( 0xffffff ).WriteUInt32( 0x000000 ).WriteUInt32( 0x333333 ).WriteUInt32( 0x000000 ).WriteUInt32( 0xdddddd ).WriteUInt32( 0x808080 ).WriteUInt32( 0x4d4d4d ).WriteUInt32( 0xeaeaea );
380 mpPptEscherEx->AddAtom( 32, EPP_ColorSchemeAtom, 0, 6 );
381 mpStrm->WriteUInt32( 0xffffff ).WriteUInt32( 0x000000 ).WriteUInt32( 0x808080 ).WriteUInt32( 0x000000 ).WriteUInt32( 0x66ccff ).WriteUInt32( 0xff0000 ).WriteUInt32( 0xcc00cc ).WriteUInt32( 0xc0c0c0 );
382 mpPptEscherEx->AddAtom( 32, EPP_ColorSchemeAtom, 0, 6 );
383 mpStrm->WriteUInt32( 0xffffff ).WriteUInt32( 0x000000 ).WriteUInt32( 0x808080 ).WriteUInt32( 0x000000 ).WriteUInt32( 0xc0c0c0 ).WriteUInt32( 0xff6600 ).WriteUInt32( 0x0000ff ).WriteUInt32( 0x009900 );
384 mpPptEscherEx->AddAtom( 32, EPP_ColorSchemeAtom, 0, 6 );
385 mpStrm->WriteUInt32( 0xffffff ).WriteUInt32( 0x000000 ).WriteUInt32( 0x808080 ).WriteUInt32( 0x000000 ).WriteUInt32( 0xff9933 ).WriteUInt32( 0xccff99 ).WriteUInt32( 0xcc00cc ).WriteUInt32( 0xb2b2b2 );
386
387 for ( int nInstance = EPP_TEXTTYPE_Title; nInstance <= EPP_TEXTTYPE_QuarterBody; nInstance++ )
388 {
389 if ( nInstance == EPP_TEXTTYPE_notUsed )
390 continue;
391
392 // the auto color is dependent to the page background,so we have to set a page that is in the right context
393 if ( nInstance == EPP_TEXTTYPE_Notes )
394 (void)GetPageByIndex(0, NOTICE);
395 else
396 (void)GetPageByIndex(0, MASTER);
397
398 mpPptEscherEx->BeginAtom();
399
400 bool bSimpleText = false;
401
402 mpStrm->WriteUInt16( 5 ); // paragraph count
403
404 for ( sal_uInt16 nLev = 0; nLev < 5; nLev++ )
405 {
406 if ( nInstance >= EPP_TEXTTYPE_CenterBody )
407 {
408 bSimpleText = true;
409 mpStrm->WriteUInt16( nLev );
410 }
411 mpStyleSheet->mpParaSheet[ nInstance ]->Write( *mpStrm, nLev, bSimpleText, mXPagePropSet );
412 mpStyleSheet->mpCharSheet[ nInstance ]->Write( *mpStrm, nLev, bSimpleText, mXPagePropSet );
413 }
414 mpPptEscherEx->EndAtom( EPP_TxMasterStyleAtom, 0, nInstance );
415 }
416 GetPageByIndex( nPageNum, MASTER );
417
418 EscherSolverContainer aSolverContainer;
419
420 mpPptEscherEx->OpenContainer( EPP_PPDrawing );
421 mpPptEscherEx->OpenContainer( ESCHER_DgContainer );
422
423 mpPptEscherEx->EnterGroup(nullptr,nullptr);
424 ImplWritePage( GetLayout( 0 ), aSolverContainer, MASTER, true ); // the shapes of the pages are created in the PPT document
425 mpPptEscherEx->LeaveGroup();
426
427 ImplWriteBackground( aXBackgroundPropSet );
428
429 aSolverContainer.WriteSolver( *mpStrm );
430
431 mpPptEscherEx->CloseContainer(); // ESCHER_DgContainer
432 mpPptEscherEx->CloseContainer(); // EPP_Drawing
433 mpPptEscherEx->AddAtom( 32, EPP_ColorSchemeAtom, 0, 1 );
434 mpStrm->WriteUInt32( 0xffffff ).WriteUInt32( 0x000000 ).WriteUInt32( 0x808080 ).WriteUInt32( 0x000000 ).WriteUInt32( 0x99cc00 ).WriteUInt32( 0xcc3333 ).WriteUInt32( 0xffcccc ).WriteUInt32( 0xb2b2b2 );
435
436 if ( aBuExMasterStream.Tell() )
437 {
438 ImplProgTagContainer( mpStrm.get(), &aBuExMasterStream );
439 }
440 mpPptEscherEx->CloseContainer(); // EPP_MainMaster
441 };
442
443 PPTWriter::~PPTWriter()
444 {
445 mpExEmbed.reset();
446 mpPptEscherEx.reset();
447 mpCurUserStrm.reset();
448 mpPicStrm.reset();
449 mpStrm.reset();
450 maStyleSheetList.clear();
451 maExOleObj.clear();
452 if ( mbStatusIndicator )
453 mXStatusIndicator->end();
454 }
455
456 bool PPTWriter::ImplCreateCurrentUserStream()
457 {
458 mpCurUserStrm.reset( mrStg->OpenSotStream( "Current User" ) );
459 if ( !mpCurUserStrm )
460 return false;
461 char pUserName[] = "Current User";
462 sal_uInt32 nLenOfUserName = strlen( pUserName );
463 sal_uInt32 nSizeOfRecord = 0x14 + ( ( nLenOfUserName + 4 ) & ~ 3 );
464
465 mpCurUserStrm->WriteUInt16( 0 ).WriteUInt16( EPP_CurrentUserAtom ).WriteUInt32( nSizeOfRecord );
466 mpCurUserStrm->WriteUInt32( 0x14 ) // Len
467 .WriteUInt32( 0xe391c05f ); // Magic
468
469 sal_uInt32 nEditPos = mpCurUserStrm->Tell();
470 mpCurUserStrm->WriteUInt32( 0x0 ) // OffsetToCurrentEdit;
471 .WriteUInt16( nLenOfUserName )
472 .WriteUInt16( 0x3f4 ) // DocFileVersion
473 .WriteUChar( 3 ) // MajorVersion
474 .WriteUChar( 0 ) // MinorVersion
475 .WriteUInt16( 0 ); // Pad Word
476 pUserName[ nLenOfUserName ] = 8;
477 mpCurUserStrm->WriteBytes(pUserName, nLenOfUserName + 1);
478 for ( sal_uInt32 i = 0x15 + nLenOfUserName; i < nSizeOfRecord; i++ )
479 {
480 mpCurUserStrm->WriteUChar( 0 ); // pad bytes
481 }
482 mpCurUserStrm->Seek( nEditPos );
483 return true;
484 };
485
486 void PPTWriter::ImplCreateDocumentSummaryInformation()
487 {
488 uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
489 mXModel, uno::UNO_QUERY_THROW);
490 uno::Reference<document::XDocumentProperties> xDocProps(
491 xDPS->getDocumentProperties());
492
493 if (!xDocProps.is())
494 return;
495
496 // no idea what this is...
497 static const sal_Int8 aGuid[ 0x52 ] =
498 {
499 0x4e, 0x00, 0x00, 0x00,
500 '{',0,'D',0,'B',0,'1',0,'A',0,'C',0,'9',0,'6',0,'4',0,'-',0,
501 'E',0,'3',0,'9',0,'C',0,'-',0,'1',0,'1',0,'D',0,'2',0,'-',0,
502 'A',0,'1',0,'E',0,'F',0,'-',0,'0',0,'0',0,'6',0,'0',0,'9',0,
503 '7',0,'D',0,'A',0,'5',0,'6',0,'8',0,'9',0,'}',0
504 };
505 uno::Sequence<sal_Int8> aGuidSeq(aGuid, 0x52);
506
507 SvMemoryStream aHyperBlob;
508 ImplCreateHyperBlob( aHyperBlob );
509
510 uno::Sequence<sal_Int8> aHyperSeq(aHyperBlob.Tell());
511 const sal_Int8* pBlob(
512 static_cast<const sal_Int8*>(aHyperBlob.GetData()));
513 for (sal_Int32 j = 0; j < aHyperSeq.getLength(); ++j) {
514 aHyperSeq[j] = pBlob[j];
515 }
516
517 if ( mnCnvrtFlags & 0x8000 )
518 {
519 uno::Sequence<sal_Int8> aThumbSeq;
520 if ( GetPageByIndex( 0, NORMAL ) && ImplGetPropertyValue( mXPagePropSet, "PreviewBitmap" ) )
521 {
522 aThumbSeq = *o3tl::doAccess<uno::Sequence<sal_Int8>>(mAny);
523 }
524 sfx2::SaveOlePropertySet( xDocProps, mrStg.get(),
525 &aThumbSeq, &aGuidSeq, &aHyperSeq);
526 }
527 else
528 {
529 sfx2::SaveOlePropertySet( xDocProps, mrStg.get(),
530 nullptr, &aGuidSeq, &aHyperSeq );
531 }
532 }
533
534 void PPTWriter::ImplWriteExtParaHeader( SvMemoryStream& rSt, sal_uInt32 nRef, sal_uInt32 nInstance, sal_uInt32 nSlideId )
535 {
536 if ( rSt.Tell() )
537 {
538 aBuExOutlineStream.WriteUInt32( ( EPP_PST_ExtendedParagraphHeaderAtom << 16 )
539 | ( nRef << 4 ) )
540 .WriteUInt32( 8 )
541 .WriteUInt32( nSlideId )
542 .WriteUInt32( nInstance );
543 aBuExOutlineStream.WriteBytes(rSt.GetData(), rSt.Tell());
544 }
545 }
546
547 void PPTWriter::ImplCreateHeaderFooterStrings( SvStream& rStrm, css::uno::Reference< css::beans::XPropertySet > const & rXPagePropSet )
548 {
549 if ( !rXPagePropSet.is() )
550 return;
551
552 OUString aString;
553 css::uno::Any aAny;
554 if ( PropValue::GetPropertyValue( aAny, rXPagePropSet, "HeaderText", true ) )
555 {
556 if ( aAny >>= aString )
557 PPTWriter::WriteCString( rStrm, aString, 1 );
558 }
559 if ( PropValue::GetPropertyValue( aAny, rXPagePropSet, "FooterText", true ) )
560 {
561 if ( aAny >>= aString )
562 PPTWriter::WriteCString( rStrm, aString, 2 );
563 }
564 if ( PropValue::GetPropertyValue( aAny, rXPagePropSet, "DateTimeText", true ) )
565 {
566 if ( aAny >>= aString )
567 PPTWriter::WriteCString( rStrm, aString );
568 }
569 }
570
571 void PPTWriter::ImplCreateHeaderFooters( css::uno::Reference< css::beans::XPropertySet > const & rXPagePropSet )
572 {
573 if ( !rXPagePropSet.is() )
574 return;
575
576 bool bVal = false;
577 sal_uInt32 nVal = 0;
578 css::uno::Any aAny;
579 if ( PropValue::GetPropertyValue( aAny, rXPagePropSet, "IsHeaderVisible", true ) )
580 {
581 if ( ( aAny >>= bVal ) && bVal )
582 nVal |= 0x100000;
583 }
584 if ( PropValue::GetPropertyValue( aAny, rXPagePropSet, "IsFooterVisible", true ) )
585 {
586 if ( ( aAny >>= bVal ) && bVal )
587 nVal |= 0x200000;
588 }
589 if ( PropValue::GetPropertyValue( aAny, rXPagePropSet, "IsDateTimeVisible", true ) )
590 {
591 if ( ( aAny >>= bVal ) && bVal )
592 nVal |= 0x010000;
593 }
594 if ( PropValue::GetPropertyValue( aAny, rXPagePropSet, "IsPageNumberVisible", true ) )
595 {
596 if ( ( aAny >>= bVal ) && bVal )
597 nVal |= 0x080000;
598 }
599 if ( PropValue::GetPropertyValue( aAny, rXPagePropSet, "IsDateTimeFixed", true ) )
600 {
601 if ( ( aAny >>= bVal ) && !bVal )
602 nVal |= 0x20000;
603 else
604 nVal |= 0x40000;
605 }
606 if ( PropValue::GetPropertyValue( aAny, rXPagePropSet, "DateTimeFormat", true ) )
607 {
608 sal_Int32 nFormat = *o3tl::doAccess<sal_Int32>(aAny);
609 SvxDateFormat eDateFormat = static_cast<SvxDateFormat>( nFormat & 0xf );
610 SvxTimeFormat eTimeFormat = static_cast<SvxTimeFormat>( ( nFormat >> 4 ) & 0xf );
611 switch( eDateFormat )
612 {
613 case SvxDateFormat::F :
614 nFormat = 1;
615 break;
616 case SvxDateFormat::D :
617 nFormat = 2;
618 break;
619 case SvxDateFormat::C :
620 nFormat = 4;
621 break;
622 default:
623 case SvxDateFormat::A :
624 nFormat = 0;
625 }
626 switch( eTimeFormat )
627 {
628 case SvxTimeFormat::HH24_MM :
629 nFormat = 9;
630 break;
631 case SvxTimeFormat::HH12_MM :
632 nFormat = 11;
633 break;
634 case SvxTimeFormat::HH24_MM_SS :
635 nFormat = 10;
636 break;
637 case SvxTimeFormat::HH12_MM_SS :
638 nFormat = 12;
639 break;
640 default:
641 break;
642 }
643 nVal |= nFormat;
644 }
645
646 mpPptEscherEx->OpenContainer( EPP_HeadersFooters );
647 mpPptEscherEx->AddAtom( 4, EPP_HeadersFootersAtom );
648 mpStrm->WriteUInt32( nVal );
649 ImplCreateHeaderFooterStrings( *mpStrm, rXPagePropSet );
650 mpPptEscherEx->CloseContainer();
651 }
652
653 bool PPTWriter::ImplCreateDocument()
654 {
655 sal_uInt32 i;
656 sal_uInt16 nSlideType = EPP_SLIDESIZE_TYPECUSTOM;
657
658 sal_uInt32 nWidth = maDestPageSize.Width;
659 sal_uInt32 nHeight = maDestPageSize.Height;
660
661 if ( ( nWidth == 0x1680 ) && ( nHeight == 0x10e0 ) )
662 nSlideType = EPP_SLIDESIZE_TYPEONSCREEN;
663 else if ( ( nWidth == 0x1200 ) && ( nHeight == 0x240 ) )
664 nSlideType = EPP_SLIDESIZE_TYPEBANNER;
665 else if ( ( nWidth == 0x1950 ) && ( nHeight == 0x10e0 ) )
666 nSlideType = EPP_SLIDESIZE_TYPE35MM;
667 else if ( ( nWidth == 0x1860 ) && ( nHeight == 0x10e0 ) )
668 nSlideType = EPP_SLIDESIZE_TYPEA4PAPER;
669
670 mpPptEscherEx->OpenContainer( EPP_Document );
671 // CREATE DOCUMENT ATOM
672 mpPptEscherEx->AddAtom( 40, EPP_DocumentAtom, 1 );
673 mpStrm->WriteUInt32( nWidth ) // Slide Size in Master coordinates X
674 .WriteUInt32( nHeight ) // " " " " " Y
675 .WriteInt32( maNotesPageSize.Width ) // Notes Page Size X
676 .WriteInt32( maNotesPageSize.Height ) // " " " Y
677 .WriteInt32( 1 ).WriteInt32( 2 ); // the scale used when the Powerpoint document is embedded. the default is 1:2
678 mpPptEscherEx->InsertPersistOffset( EPP_MAINNOTESMASTER_PERSIST_KEY, mpStrm->Tell() );
679 mpStrm->WriteUInt32( 0 ) // Reference to NotesMaster ( 0 if none );
680 .WriteUInt32( 0 ) // Reference to HandoutMaster ( 0 if none );
681 .WriteInt16( 1 ) // Number of the first slide;
682 .WriteUInt16( nSlideType ) // Size of the document slides ( default: EPP_SLIDESIZETYPEONSCREEN )
683 .WriteUChar( 0 ) // bool1 indicates if document was saved with embedded true type fonts
684 .WriteUChar( 0 ) // bool1 indicates if the placeholders on the title slide are omitted
685 .WriteUChar( 0 ) // bool1 right to left ( flag for Bidi version )
686 .WriteUChar( 1 ); // bool1 visibility of comments shapes
687
688 mpPptEscherEx->PtInsert( EPP_Persist_Document, mpStrm->Tell() );
689
690 mpPptEscherEx->OpenContainer( EPP_HeadersFooters, 3 ); //Master footer (default)
691 mpPptEscherEx->AddAtom( 4, EPP_HeadersFootersAtom );
692 mpStrm->WriteUInt32( 0x25000d );
693 if ( GetPageByIndex( 0, MASTER ) )
694 ImplCreateHeaderFooterStrings( *mpStrm, mXPagePropSet );
695 mpPptEscherEx->CloseContainer();
696 mpPptEscherEx->OpenContainer( EPP_HeadersFooters, 4 ); //NotesMaster footer (default)
697 mpPptEscherEx->AddAtom( 4, EPP_HeadersFootersAtom );
698 mpStrm->WriteUInt32( 0x3d000d );
699 if ( GetPageByIndex( 0, NOTICE ) )
700 ImplCreateHeaderFooterStrings( *mpStrm, mXPagePropSet );
701 mpPptEscherEx->CloseContainer();
702
703 mpPptEscherEx->OpenContainer( EPP_SlideListWithText ); // animation information for the slides
704
705 for ( i = 0; i < mnPages; i++ )
706 {
707 mpPptEscherEx->AddAtom( 20, EPP_SlidePersistAtom );
708 mpPptEscherEx->InsertPersistOffset( EPP_MAINSLIDE_PERSIST_KEY | i, mpStrm->Tell() );
709 mpStrm->WriteUInt32( 0 ) // psrReference - logical reference to the slide persist object ( EPP_MAINSLIDE_PERSIST_KEY )
710 .WriteUInt32( 4 ) // flags - only bit 3 used, if set then slide contains shapes other than placeholders
711 .WriteInt32( 0 ) // numberTexts - number of placeholder texts stored with the persist object. Allows to display outline view without loading the slide persist objects
712 .WriteInt32( i + 0x100 ) // slideId - Unique slide identifier, used for OLE link monikers for example
713 .WriteUInt32( 0 ); // reserved, usually 0
714
715 if ( !GetPageByIndex( i, NORMAL ) ) // very exciting: once again through all pages
716 return false;
717 SetCurrentStyleSheet( GetMasterIndex( NORMAL ) );
718
719 css::uno::Reference< css::container::XNamed >
720 aXName( mXDrawPage, css::uno::UNO_QUERY );
721
722 if ( aXName.is() )
723 maSlideNameList.push_back( aXName->getName() );
724 else
725 maSlideNameList.emplace_back( );
726 }
727 mpPptEscherEx->CloseContainer(); // EPP_SlideListWithText
728
729 mpPptEscherEx->OpenContainer( EPP_SlideListWithText, 2 ); // animation information for the notes
730 for( i = 0; i < mnPages; i++ )
731 {
732 mpPptEscherEx->AddAtom( 20, EPP_SlidePersistAtom );
733 mpPptEscherEx->InsertPersistOffset( EPP_MAINNOTES_PERSIST_KEY | i, mpStrm->Tell() );
734 mpStrm->WriteUInt32( 0 )
735 .WriteUInt32( 4 )
736 .WriteInt32( 0 )
737 .WriteInt32( i + 0x100 )
738 .WriteUInt32( 0 );
739 }
740 mpPptEscherEx->CloseContainer(); // EPP_SlideListWithText
741
742 css::uno::Reference< css::presentation::XPresentationSupplier >
743 aXPresSupplier( mXModel, css::uno::UNO_QUERY );
744 if ( aXPresSupplier.is() )
745 {
746 css::uno::Reference< css::presentation::XPresentation > aXPresentation( aXPresSupplier->getPresentation() );
747 if ( aXPresentation.is() )
748 {
749 mXPropSet.set( aXPresentation, css::uno::UNO_QUERY );
750 if ( mXPropSet.is() )
751 {
752 OUString aCustomShow;
753 sal_uInt32 const nPenColor = 0x1000000;
754 sal_Int32 const nRestartTime = 0x7fffffff;
755 sal_Int16 nStartSlide = 0;
756 sal_Int16 nEndSlide = 0;
757 sal_uInt32 nFlags = 0; // Bit 0: Auto advance
758 // Bit 1 Skip builds ( do not allow slide effects )
759 // Bit 2 Use slide range
760 // Bit 3 Use named show
761 // Bit 4 Browse mode on
762 // Bit 5 Kiosk mode on
763 // Bit 7 loop continuously
764 // Bit ? show scrollbar
765
766 if ( ImplGetPropertyValue( "CustomShow" ) )
767 {
768 aCustomShow = *o3tl::doAccess<OUString>(mAny);
769 if ( !aCustomShow.isEmpty() )
770 {
771 nFlags |= 8;
772 }
773 }
774 if ( ( nFlags & 8 ) == 0 )
775 {
776 if ( ImplGetPropertyValue( "FirstPage" ) )
777 {
778 auto aSlideName = o3tl::doAccess<OUString>(mAny);
779
780 std::vector<OUString>::const_iterator pIter = std::find(
781 maSlideNameList.begin(),maSlideNameList.end(), *aSlideName);
782
783 if (pIter != maSlideNameList.end())
784 {
785 nStartSlide = pIter - maSlideNameList.begin() + 1;
786 nFlags |= 4;
787 nEndSlide = static_cast<sal_uInt16>(mnPages);
788 }
789 }
790 }
791
792 if ( ImplGetPropertyValue( "IsAutomatic" ) )
793 {
794 bool bBool = false;
795 mAny >>= bBool;
796 if ( !bBool )
797 nFlags |= 1;
798 }
799
800 if ( ImplGetPropertyValue( "IsEndless" ) ) // the correct name would be IsNotEndless: WTF?
801 {
802 bool bBool = false;
803 mAny >>= bBool;
804 if ( bBool )
805 nFlags |= 0x80;
806 }
807 if ( ImplGetPropertyValue( "IsFullScreen" ) )
808 {
809 bool bBool = false;
810 mAny >>= bBool;
811 if ( !bBool )
812 nFlags |= 0x11;
813 }
814
815 mpPptEscherEx->AddAtom( 80, EPP_SSDocInfoAtom, 1 );
816 mpStrm->WriteUInt32( nPenColor ).WriteInt32( nRestartTime ).WriteInt16( nStartSlide ).WriteInt16( nEndSlide );
817
818 sal_uInt32 nCustomShowNameLen = aCustomShow.getLength();
819 if ( nCustomShowNameLen > 31 )
820 nCustomShowNameLen = 31;
821 if ( nCustomShowNameLen ) // named show identifier
822 {
823 const sal_Unicode* pCustomShow = aCustomShow.getStr();
824 for ( i = 0; i < nCustomShowNameLen; i++ )
825 {
826 mpStrm->WriteUInt16( pCustomShow[ i ] );
827 }
828 }
829 for ( i = nCustomShowNameLen; i < 32; i++, mpStrm->WriteUInt16( 0 ) ) ;
830
831 mpStrm->WriteUInt32( nFlags );
832 css::uno::Reference< css::presentation::XCustomPresentationSupplier > aXCPSup( mXModel, css::uno::UNO_QUERY );
833 if ( aXCPSup.is() )
834 {
835 css::uno::Reference< css::container::XNameContainer > aXCont( aXCPSup->getCustomPresentations() );
836 if ( aXCont.is() )
837 {
838 css::uno::Sequence< OUString> aNameSeq( aXCont->getElementNames() );
839 if ( aNameSeq.hasElements() )
840 {
841 mpPptEscherEx->OpenContainer( EPP_NamedShows );
842 sal_uInt32 nCustomShowIndex = 0;
843 for( OUString const & customShowName : aNameSeq )
844 {
845 if ( !customShowName.isEmpty() )
846 {
847 mpPptEscherEx->OpenContainer( EPP_NamedShow, nCustomShowIndex++ );
848
849 sal_uInt32 nNamedShowLen = customShowName.getLength();
850 if ( nNamedShowLen > 31 )
851 nNamedShowLen = 31;
852 mpPptEscherEx->AddAtom( nNamedShowLen << 1, EPP_CString );
853 const sal_Unicode* pCustomShowName = customShowName.getStr();
854 for ( sal_uInt32 k = 0; k < nNamedShowLen; ++k )
855 mpStrm->WriteUInt16( pCustomShowName[ k ] );
856 mAny = aXCont->getByName( customShowName );
857 css::uno::Reference< css::container::XIndexContainer > aXIC;
858 if ( mAny >>= aXIC )
859 {
860 mpPptEscherEx->BeginAtom();
861
862 sal_Int32 nSlideCount = aXIC->getCount();
863 for ( sal_Int32 j = 0; j < nSlideCount; j++ ) // number of slides
864 {
865 mAny = aXIC->getByIndex( j );
866 css::uno::Reference< css::drawing::XDrawPage > aXDrawPage;
867 if ( mAny >>= aXDrawPage )
868 {
869 css::uno::Reference< css::container::XNamed > aXName( aXDrawPage, css::uno::UNO_QUERY );
870 if ( aXName.is() )
871 {
872 OUString aSlideName( aXName->getName() );
873 std::vector<OUString>::const_iterator pIter = std::find(
874 maSlideNameList.begin(),maSlideNameList.end(),aSlideName);
875
876 if (pIter != maSlideNameList.end())
877 {
878 sal_uInt32 nPageNumber = pIter - maSlideNameList.begin();
879 mpStrm->WriteUInt32( nPageNumber + 0x100 ); // unique slide id
880 }
881 }
882 }
883 }
884 mpPptEscherEx->EndAtom( EPP_NamedShowSlides );
885 }
886 mpPptEscherEx->CloseContainer(); // EPP_NamedShow
887 }
888 }
889 mpPptEscherEx->CloseContainer(); // EPP_NamedShows
890 }
891 }
892 }
893 }
894 }
895 }
896 mpPptEscherEx->AddAtom( 0, EPP_EndDocument );
897 mpPptEscherEx->CloseContainer(); // EPP_Document
898 return true;
899 };
900
901 void PPTWriter::ImplCreateHyperBlob( SvMemoryStream& rStrm )
902 {
903 sal_uInt32 nCurrentOfs, nParaOfs, nParaCount = 0;
904
905 nParaOfs = rStrm.Tell();
906 rStrm.WriteUInt32( 0 ); // property size
907 rStrm.WriteUInt32( 0 ); // property count
908
909 for ( const auto& rHyperlink : maHyperlink )
910 {
911 nParaCount += 6;
912 rStrm .WriteUInt32( 3 ) // Type VT_I4
913 .WriteUInt32( 7 ) // (VTI4 - Private1)
914 .WriteUInt32( 3 ) // Type VT_I4
915 .WriteUInt32( 6 ) // (VTI4 - Private2)
916 .WriteUInt32( 3 ) // Type VT_I4
917 .WriteUInt32( 0 ); // (VTI4 - Private3)
918
919 // INFO
920 // HIWORD: = 0 : do not change anything
921 // = 1 : replace the hyperlink with the target and subaddress in the following two VTLPWSTR
922 // = 2 : delete the hyperlink
923 // LOWORD: = 0 : graphic shown as background (link)
924 // = 1 : graphic shown as shape (link)
925 // = 2 : graphic is used to fill a shape
926 // = 3 : graphic used to fill a shape outline (future use)
927 // = 4 : hyperlink attached to a shape
928 // = 5 : " " " " (Word) field
929 // = 6 : " " " " (Excel) range
930 // = 7 : " " " " (PPT) text range
931 // = 8 : " " " " (Project) task
932
933 sal_Int32 nUrlLen = rHyperlink.aURL.getLength();
934 const OUString& rUrl = rHyperlink.aURL;
935
936 sal_uInt32 const nInfo = 7;
937
938 rStrm .WriteUInt32( 3 ) // Type VT_I4
939 .WriteUInt32( nInfo ); // Info
940
941 switch( rHyperlink.nType & 0xff )
942 {
943 case 1 : // click action to slidenumber
944 {
945 rStrm.WriteUInt32( 0x1f ).WriteUInt32( 1 ).WriteUInt32( 0 ); // path
946 rStrm.WriteUInt32( 0x1f ).WriteUInt32( nUrlLen + 1 );
947 for ( sal_Int32 i = 0; i < nUrlLen; i++ )
948 {
949 rStrm.WriteUInt16( rUrl[ i ] );
950 }
951 rStrm.WriteUInt16( 0 );
952 }
953 break;
954 case 2 :
955 {
956 sal_Int32 i;
957
958 rStrm .WriteUInt32( 0x1f )
959 .WriteUInt32( nUrlLen + 1 );
960 for ( i = 0; i < nUrlLen; i++ )
961 {
962 rStrm.WriteUInt16( rUrl[ i ] );
963 }
964 if ( ! ( i & 1 ) )
965 rStrm.WriteUInt16( 0 );
966 rStrm .WriteUInt16( 0 )
967 .WriteUInt32( 0x1f )
968 .WriteUInt32( 1 )
969 .WriteUInt32( 0 );
970 }
971 break;
972 }
973 }
974 nCurrentOfs = rStrm.Tell();
975 rStrm.Seek( nParaOfs );
976 rStrm.WriteUInt32( nCurrentOfs - ( nParaOfs + 4 ) );
977 rStrm.WriteUInt32( nParaCount );
978 rStrm.Seek( nCurrentOfs );
979 }
980
981 bool PPTWriter::ImplCreateMainNotes()
982 {
983 EscherSolverContainer aSolverContainer;
984
985 mpPptEscherEx->PtReplaceOrInsert( EPP_Persist_MainNotes, mpStrm->Tell() );
986 mpPptEscherEx->OpenContainer( EPP_Notes );
987 mpPptEscherEx->AddAtom( 8, EPP_NotesAtom, 1 );
988 mpStrm->WriteUInt32( 0x80000001 ) // Number that identifies this slide
989 .WriteUInt32( 0 ); // follow nothing
990 mpPptEscherEx->OpenContainer( EPP_PPDrawing );
991 mpPptEscherEx->OpenContainer( ESCHER_DgContainer );
992 mpPptEscherEx->EnterGroup(nullptr,nullptr);
993
994 ImplWritePage( GetLayout( 20 ), aSolverContainer, NOTICE, true );
995
996 mpPptEscherEx->LeaveGroup();
997 mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
998 mpPptEscherEx->AddShape( ESCHER_ShpInst_Rectangle, ShapeFlag::Background | ShapeFlag::HaveShapeProperty );
999 EscherPropertyContainer aPropOpt;
1000 aPropOpt.AddOpt( ESCHER_Prop_fillColor, 0xffffff ); // stock valued fill color
1001 aPropOpt.AddOpt( ESCHER_Prop_fillBackColor, 0 );
1002 aPropOpt.AddOpt( ESCHER_Prop_fillRectRight, 0x68bdde );
1003 aPropOpt.AddOpt( ESCHER_Prop_fillRectBottom, 0x8b9f8e );
1004 aPropOpt.AddOpt( ESCHER_Prop_fNoFillHitTest, 0x120012 );
1005 aPropOpt.AddOpt( ESCHER_Prop_fNoLineDrawDash, 0 );
1006 aPropOpt.AddOpt( ESCHER_Prop_bWMode, ESCHER_wDontShow );
1007 aPropOpt.AddOpt( ESCHER_Prop_fBackground, 0x10001 ); // if true, this is the background shape
1008 aPropOpt.Commit( *mpStrm );
1009 mpPptEscherEx->CloseContainer(); // ESCHER_SpContainer
1010
1011 aSolverContainer.WriteSolver( *mpStrm );
1012
1013 mpPptEscherEx->CloseContainer(); // ESCHER_DgContainer
1014 mpPptEscherEx->CloseContainer(); // EPP_Drawing
1015 mpPptEscherEx->AddAtom( 32, EPP_ColorSchemeAtom, 0, 1 );
1016 mpStrm->WriteUInt32( 0xffffff ).WriteUInt32( 0x000000 ).WriteUInt32( 0x808080 ).WriteUInt32( 0x000000 ).WriteUInt32( 0x99cc00 ).WriteUInt32( 0xcc3333 ).WriteUInt32( 0xffcccc ).WriteUInt32( 0xb2b2b2 );
1017 mpPptEscherEx->CloseContainer(); // EPP_Notes
1018 return true;
1019 }
1020
1021 static OUString getInitials( const OUString& rName )
1022 {
1023 OUStringBuffer sInitials;
1024
1025 const sal_Unicode * pStr = rName.getStr();
1026 sal_Int32 nLength = rName.getLength();
1027
1028 while( nLength )
1029 {
1030 // skip whitespace
1031 while( nLength && (*pStr <= ' ') )
1032 {
1033 nLength--; pStr++;
1034 }
1035
1036 // take letter
1037 if( nLength )
1038 {
1039 sInitials.append( *pStr );
1040 nLength--; pStr++;
1041 }
1042
1043 // skip letters until whitespace
1044 while( nLength && (*pStr > ' ') )
1045 {
1046 nLength--; pStr++;
1047 }
1048 }
1049
1050 return sInitials.makeStringAndClear();
1051 }
1052
1053 void ImplExportComments( const uno::Reference< drawing::XDrawPage >& xPage, SvMemoryStream& rBinaryTagData10Atom )
1054 {
1055 try
1056 {
1057 uno::Reference< office::XAnnotationAccess > xAnnotationAccess( xPage, uno::UNO_QUERY_THROW );
1058 uno::Reference< office::XAnnotationEnumeration > xAnnotationEnumeration( xAnnotationAccess->createAnnotationEnumeration() );
1059
1060 sal_Int32 nIndex = 1;
1061
1062 while( xAnnotationEnumeration->hasMoreElements() )
1063 {
1064 EscherExContainer aComment10( rBinaryTagData10Atom, EPP_Comment10 );
1065 {
1066 uno::Reference< office::XAnnotation > xAnnotation( xAnnotationEnumeration->nextElement() );
1067
1068 geometry::RealPoint2D aRealPoint2D( xAnnotation->getPosition() );
1069 MapMode aMapDest( MapUnit::MapInch, Point(), Fraction( 1, 576 ), Fraction( 1, 576 ) );
1070 Point aPoint( OutputDevice::LogicToLogic( Point( static_cast< sal_Int32 >( aRealPoint2D.X * 100.0 ),
1071 static_cast<sal_Int32>(aRealPoint2D.Y * 100.0)), MapMode(MapUnit::Map100thMM), aMapDest));
1072
1073 OUString sAuthor( xAnnotation->getAuthor() );
1074 uno::Reference< text::XText > xText( xAnnotation->getTextRange() );
1075 OUString sText( xText->getString() );
1076 OUString sInitials( getInitials( sAuthor ) );
1077 util::DateTime aDateTime( xAnnotation->getDateTime() );
1078 if ( !sAuthor.isEmpty() )
1079 PPTWriter::WriteCString( rBinaryTagData10Atom, sAuthor );
1080 if ( !sText.isEmpty() )
1081 PPTWriter::WriteCString( rBinaryTagData10Atom, sText, 1 );
1082 if ( !sInitials.isEmpty() )
1083 PPTWriter::WriteCString( rBinaryTagData10Atom, sInitials, 2 );
1084
1085 sal_Int16 nMilliSeconds = static_cast<sal_Int16>(::rtl::math::round(static_cast<double>(aDateTime.NanoSeconds) / 1000000000.0));
1086 EscherExAtom aCommentAtom10( rBinaryTagData10Atom, EPP_CommentAtom10 );
1087 rBinaryTagData10Atom.WriteInt32( nIndex++ )
1088 .WriteInt16( aDateTime.Year )
1089 .WriteUInt16( aDateTime.Month )
1090 .WriteUInt16( aDateTime.Day ) // todo: day of week
1091 .WriteUInt16( aDateTime.Day )
1092 .WriteUInt16( aDateTime.Hours )
1093 .WriteUInt16( aDateTime.Minutes )
1094 .WriteUInt16( aDateTime.Seconds )
1095 .WriteInt16( nMilliSeconds )
1096 .WriteInt32( aPoint.X() )
1097 .WriteInt32( aPoint.Y() );
1098 }
1099 }
1100 }
1101 catch ( uno::Exception& )
1102 {
1103 }
1104 }
1105
1106 void PPTWriter::ImplWriteNotes( sal_uInt32 nPageNum )
1107 {
1108 mpPptEscherEx->PtReplaceOrInsert( EPP_Persist_Notes | nPageNum, mpStrm->Tell() );
1109 mpPptEscherEx->OpenContainer( EPP_Notes );
1110 mpPptEscherEx->AddAtom( 8, EPP_NotesAtom, 1 );
1111 mpStrm->WriteUInt32( nPageNum + 0x100 )
1112 .WriteUInt16( 3 ) // follow master ....
1113 .WriteUInt16( 0 );
1114
1115 ImplCreateHeaderFooters( mXPagePropSet );
1116
1117 EscherSolverContainer aSolverContainer;
1118
1119 mpPptEscherEx->OpenContainer( EPP_PPDrawing );
1120 mpPptEscherEx->OpenContainer( ESCHER_DgContainer );
1121 mpPptEscherEx->EnterGroup(nullptr,nullptr);
1122
1123 ImplWritePage( GetLayout( 20 ), aSolverContainer, NOTICE, false ); // the shapes of the pages are created in the PPT document
1124
1125 mpPptEscherEx->LeaveGroup();
1126 mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
1127 mpPptEscherEx->AddShape( ESCHER_ShpInst_Rectangle, ShapeFlag::Background | ShapeFlag::HaveShapeProperty );
1128 EscherPropertyContainer aPropOpt;
1129 aPropOpt.AddOpt( ESCHER_Prop_fillColor, 0xffffff ); // stock valued fill color
1130 aPropOpt.AddOpt( ESCHER_Prop_fillBackColor, 0 );
1131 aPropOpt.AddOpt( ESCHER_Prop_fillRectRight, 0x8b9f8e );
1132 aPropOpt.AddOpt( ESCHER_Prop_fillRectBottom, 0x68bdde );
1133 aPropOpt.AddOpt( ESCHER_Prop_fNoFillHitTest, 0x120012 );
1134 aPropOpt.AddOpt( ESCHER_Prop_fNoLineDrawDash, 0x80000 );
1135 aPropOpt.AddOpt( ESCHER_Prop_bWMode, ESCHER_wDontShow );
1136 aPropOpt.AddOpt( ESCHER_Prop_fBackground, 0x10001 );
1137 aPropOpt.Commit( *mpStrm );
1138 mpPptEscherEx->CloseContainer(); // ESCHER_SpContainer
1139
1140 aSolverContainer.WriteSolver( *mpStrm );
1141
1142 mpPptEscherEx->CloseContainer(); // ESCHER_DgContainer
1143 mpPptEscherEx->CloseContainer(); // EPP_Drawing
1144 mpPptEscherEx->AddAtom( 32, EPP_ColorSchemeAtom, 0, 1 );
1145 mpStrm->WriteUInt32( 0xffffff ).WriteUInt32( 0x000000 ).WriteUInt32( 0x808080 ).WriteUInt32( 0x000000 ).WriteUInt32( 0x99cc00 ).WriteUInt32( 0xcc3333 ).WriteUInt32( 0xffcccc ).WriteUInt32( 0xb2b2b2 );
1146 mpPptEscherEx->CloseContainer(); // EPP_Notes
1147 };
1148
1149 void PPTWriter::ImplWriteBackground( css::uno::Reference< css::beans::XPropertySet > const & rXPropSet )
1150 {
1151 //************************ ******
1152 //** DEFAULT BACKGROUND SHAPE **
1153
1154 sal_uInt32 nFillColor = 0xffffff;
1155 sal_uInt32 nFillBackColor = 0;
1156
1157 mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
1158 mpPptEscherEx->AddShape( ESCHER_ShpInst_Rectangle, ShapeFlag::Background | ShapeFlag::HaveShapeProperty );
1159
1160 // #i121183# Use real PageSize in 100th mm
1161 ::tools::Rectangle aRect(Point(0, 0), Size(maPageSize.Width, maPageSize.Height));
1162
1163 EscherPropertyContainer aPropOpt( mpPptEscherEx->GetGraphicProvider(), mpPicStrm.get(), aRect );
1164 aPropOpt.AddOpt( ESCHER_Prop_fillType, ESCHER_FillSolid );
1165 css::drawing::FillStyle aFS( css::drawing::FillStyle_NONE );
1166 if ( ImplGetPropertyValue( rXPropSet, "FillStyle" ) )
1167 mAny >>= aFS;
1168
1169 switch( aFS )
1170 {
1171 case css::drawing::FillStyle_GRADIENT :
1172 {
1173 aPropOpt.CreateGradientProperties( rXPropSet );
1174 aPropOpt.AddOpt( ESCHER_Prop_fNoFillHitTest, 0x1f001e );
1175 aPropOpt.GetOpt( ESCHER_Prop_fillColor, nFillColor );
1176 aPropOpt.GetOpt( ESCHER_Prop_fillBackColor, nFillBackColor );
1177 }
1178 break;
1179
1180 case css::drawing::FillStyle_BITMAP :
1181 aPropOpt.CreateGraphicProperties( rXPropSet, "FillBitmap", true );
1182 break;
1183
1184 case css::drawing::FillStyle_HATCH :
1185 aPropOpt.CreateGraphicProperties( rXPropSet, "FillHatch", true );
1186 break;
1187
1188 case css::drawing::FillStyle_SOLID :
1189 {
1190 if ( ImplGetPropertyValue( rXPropSet, "FillColor" ) )
1191 {
1192 nFillColor = EscherEx::GetColor( *o3tl::doAccess<sal_uInt32>(mAny) );
1193 nFillBackColor = nFillColor ^ 0xffffff;
1194 }
1195 [[fallthrough]];
1196 }
1197 case css::drawing::FillStyle_NONE :
1198 default:
1199 aPropOpt.AddOpt( ESCHER_Prop_fNoFillHitTest, 0x120012 );
1200 break;
1201 }
1202 aPropOpt.AddOpt( ESCHER_Prop_fillColor, nFillColor );
1203 aPropOpt.AddOpt( ESCHER_Prop_fillBackColor, nFillBackColor );
1204 aPropOpt.AddOpt( ESCHER_Prop_fillRectRight, PPTtoEMU( maDestPageSize.Width ) );
1205 aPropOpt.AddOpt( ESCHER_Prop_fillRectBottom, PPTtoEMU( maDestPageSize.Height ) );
1206 aPropOpt.AddOpt( ESCHER_Prop_fNoLineDrawDash, 0x80000 );
1207 aPropOpt.AddOpt( ESCHER_Prop_bWMode, ESCHER_bwWhite );
1208 aPropOpt.AddOpt( ESCHER_Prop_fBackground, 0x10001 );
1209 aPropOpt.Commit( *mpStrm );
1210 mpPptEscherEx->CloseContainer(); // ESCHER_SpContainer
1211 }
1212
1213 void PPTWriter::ImplWriteVBA()
1214 {
1215 if ( mpVBA )
1216 {
1217 sal_uInt32 nLen = mpVBA->TellEnd();
1218 if ( nLen > 8 )
1219 {
1220 nLen -= 8;
1221 mnVBAOleOfs = mpStrm->Tell();
1222 mpPptEscherEx->BeginAtom();
1223 mpStrm->WriteBytes(static_cast<sal_Int8 const *>(mpVBA->GetData()) + 8, nLen);
1224 mpPptEscherEx->EndAtom( EPP_ExOleObjStg, 0, 1 );
1225 }
1226 }
1227 }
1228
1229 void PPTWriter::ImplWriteOLE( )
1230 {
1231
1232 SvxMSExportOLEObjects aOleExport( mnCnvrtFlags );
1233
1234 for ( auto& rxExOleObjEntry : maExOleObj )
1235 {
1236 PPTExOleObjEntry* pPtr = rxExOleObjEntry.get();
1237 std::unique_ptr<SvMemoryStream> pStrm;
1238 pPtr->nOfsB = mpStrm->Tell();
1239 switch ( pPtr->eType )
1240 {
1241 case NORMAL_OLE_OBJECT :
1242 {
1243 SdrObject* pSdrObj = GetSdrObjectFromXShape( pPtr->xShape );
1244 if ( auto pSdrOle2Obj = dynamic_cast< SdrOle2Obj* >(pSdrObj) )
1245 {
1246 const ::uno::Reference < embed::XEmbeddedObject >& xObj( pSdrOle2Obj->GetObjRef() );
1247 if( xObj.is() )
1248 {
1249 tools::SvRef<SotStorage> xTempStorage( new SotStorage( new SvMemoryStream(), true ) );
1250 aOleExport.ExportOLEObject( xObj, *xTempStorage );
1251
1252 //TODO/MBA: testing
1253 SvMemoryStream aStream;
1254 tools::SvRef<SotStorage> xCleanStorage( new SotStorage( false, aStream ) );
1255 xTempStorage->CopyTo( xCleanStorage.get() );
1256 // create a dummy content stream, the dummy content is necessary for ppt, but not for
1257 // doc files, so we can't share code.
1258 tools::SvRef<SotStorageStream> xStm = xCleanStorage->OpenSotStream( SVEXT_PERSIST_STREAM );
1259 xStm->WriteUInt32( 0 ) // no ClipboardId
1260 .WriteUInt32( 4 ) // no target device
1261 .WriteUInt32( 1 ) // aspect ratio
1262 .WriteInt32( -1 ) // L-Index
1263 .WriteUInt32( 0 ) // Advanced Flags
1264 .WriteUInt32( 0 ) // compression
1265 .WriteUInt32( 0 ) // Size
1266 .WriteUInt32( 0 ) // "
1267 .WriteUInt32( 0 );
1268 pStrm = xCleanStorage->CreateMemoryStream();
1269 }
1270 }
1271 }
1272 break;
1273
1274 case OCX_CONTROL :
1275 {
1276 if ( pPtr->xControlModel.is() )
1277 {
1278 OUString aName;
1279 //Initialize the graphic size which will be used on export
1280 css::awt::Size aSize( pPtr->xShape->getSize() );
1281 tools::SvRef<SotStorage> xDest( new SotStorage( new SvMemoryStream(), true ) );
1282 bool bOk = oox::ole::MSConvertOCXControls::WriteOCXStream( mXModel, xDest, pPtr->xControlModel, aSize, aName );
1283 if ( bOk )
1284 pStrm = xDest->CreateMemoryStream();
1285 }
1286 }
1287 }
1288 if ( pStrm )
1289 {
1290 mpPptEscherEx->BeginAtom();
1291 pStrm->Seek( STREAM_SEEK_TO_END );
1292 sal_uInt32 npStrmSize = pStrm->Tell();
1293 mpStrm->WriteUInt32( npStrmSize ); // uncompressed size
1294
1295 pStrm->Seek( 0 );
1296 ZCodec aZCodec( 0x8000, 0x8000 );
1297 aZCodec.BeginCompression();
1298 aZCodec.Compress( *pStrm, *mpStrm );
1299 aZCodec.EndCompression();
1300 pStrm.reset();
1301 mpPptEscherEx->EndAtom( EPP_ExOleObjStg, 0, 1 );
1302 }
1303 }
1304 }
1305
1306 // write PersistantTable and UserEditAtom
1307
1308 void PPTWriter::ImplWriteAtomEnding()
1309 {
1310
1311 #define EPP_LastViewTypeSlideView 1
1312
1313 sal_uInt32 i, nPos, nOfs, nPersistOfs = mpStrm->Tell();
1314 sal_uInt32 nPersistEntrys = 0;
1315 mpStrm->WriteUInt32( 0 ).WriteUInt32( 0 ).WriteUInt32( 0 ); // skip record header and first entry
1316
1317 // write document persist
1318 nPersistEntrys++;
1319 mpStrm->WriteUInt32( 0 );
1320 // write MasterPages persists
1321 for ( i = 0; i < mnMasterPages; i++ )
1322 {
1323 nOfs = mpPptEscherEx->PtGetOffsetByID( EPP_Persist_MainMaster | i );
1324 if ( nOfs )
1325 {
1326 mpStrm->WriteUInt32( nOfs );
1327 mpPptEscherEx->InsertAtPersistOffset( EPP_MAINMASTER_PERSIST_KEY | i, ++nPersistEntrys );
1328 }
1329 }
1330 // write MainNotesMaster persist
1331 nOfs = mpPptEscherEx->PtGetOffsetByID( EPP_Persist_MainNotes );
1332 if ( nOfs )
1333 {
1334 mpStrm->WriteUInt32( nOfs );
1335 mpPptEscherEx->InsertAtPersistOffset( EPP_MAINNOTESMASTER_PERSIST_KEY, ++nPersistEntrys );
1336 }
1337 // write slide persists -> we have to write a valid value into EPP_SlidePersistAtome too
1338 for ( i = 0; i < mnPages; i++ )
1339 {
1340 nOfs = mpPptEscherEx->PtGetOffsetByID( EPP_Persist_Slide | i );
1341 if ( nOfs )
1342 {
1343 mpStrm->WriteUInt32( nOfs );
1344 mpPptEscherEx->InsertAtPersistOffset( EPP_MAINSLIDE_PERSIST_KEY | i, ++nPersistEntrys );
1345 }
1346 }
1347 // write Notes persists
1348 for ( i = 0; i < mnPages; i++ )
1349 {
1350 nOfs = mpPptEscherEx->PtGetOffsetByID( EPP_Persist_Notes | i );
1351 if ( nOfs )
1352 {
1353 mpStrm->WriteUInt32( nOfs );
1354 mpPptEscherEx->InsertAtPersistOffset( EPP_MAINNOTES_PERSIST_KEY | i, ++nPersistEntrys );
1355 }
1356 }
1357 // Ole persists
1358 for ( auto& rxExOleObjEntry : maExOleObj )
1359 {
1360 PPTExOleObjEntry* pPtr = rxExOleObjEntry.get();
1361 nOfs = mpPptEscherEx->PtGetOffsetByID( EPP_Persist_ExObj );
1362 if ( nOfs )
1363 {
1364 nPersistEntrys++;
1365 mpStrm->WriteUInt32( pPtr->nOfsB );
1366 sal_uInt32 nOldPos, nPersOfs = nOfs + pPtr->nOfsA + 16 + 8; // 8 bytes atom header, +16 to the persist entry
1367 nOldPos = mpStrm->Tell();
1368 mpStrm->Seek( nPersOfs );
1369 mpStrm->WriteUInt32( nPersistEntrys );
1370 mpStrm->Seek( nOldPos );
1371 }
1372 }
1373 // VB persist
1374 if ( mnVBAOleOfs && mpVBA )
1375 {
1376 nOfs = mpPptEscherEx->PtGetOffsetByID( EPP_Persist_VBAInfoAtom );
1377 if ( nOfs )
1378 {
1379 nPersistEntrys++;
1380 sal_uInt32 n1, n2;
1381
1382 mpVBA->Seek( 0 );
1383 mpVBA->ReadUInt32( n1 )
1384 .ReadUInt32( n2 );
1385
1386 mpStrm->WriteUInt32( mnVBAOleOfs );
1387 sal_uInt32 nOldPos = mpStrm->Tell();
1388 mpStrm->Seek( nOfs ); // Fill the VBAInfoAtom with the correct index to the persisttable
1389 mpStrm->WriteUInt32( nPersistEntrys )
1390 .WriteUInt32( n1 )
1391 .WriteInt32( 2 );
1392 mpStrm->Seek( nOldPos );
1393
1394 }
1395 }
1396 nPos = mpStrm->Tell();
1397 mpStrm->Seek( nPersistOfs );
1398 mpPptEscherEx->AddAtom( ( nPersistEntrys + 1 ) << 2, EPP_PersistPtrIncrementalBlock ); // insert Record Header
1399 mpStrm->WriteUInt32( ( nPersistEntrys << 20 ) | 1 );
1400 mpStrm->Seek( nPos );
1401
1402 mpCurUserStrm->WriteUInt32( nPos ); // set offset to current edit
1403 mpPptEscherEx->AddAtom( 28, EPP_UserEditAtom );
1404 mpStrm->WriteInt32( 0x100 ) // last slide ID
1405 .WriteUInt32( 0x03000dbc ) // minor and major app version that did the save
1406 .WriteUInt32( 0 ) // offset last save, 0 after a full save
1407 .WriteUInt32( nPersistOfs ) // File offset to persist pointers for this save operation
1408 .WriteUInt32( 1 ) // Persist reference to the document persist object
1409 .WriteUInt32( nPersistEntrys ) // max persists written, Seed value for persist object id management
1410 .WriteInt16( EPP_LastViewTypeSlideView ) // last view type
1411 .WriteInt16( 0x12 ); // padword
1412 }
1413
1414 // - exported function -
1415
1416 extern "C" SAL_DLLPUBLIC_EXPORT sal_Bool ExportPPT( const std::vector< css::beans::PropertyValue >& rMediaData,
1417 tools::SvRef<SotStorage> const & rSvStorage,
1418 css::uno::Reference< css::frame::XModel > const & rXModel,
1419 css::uno::Reference< css::task::XStatusIndicator > const & rXStatInd,
1420 SvMemoryStream* pVBA,
1421 sal_uInt32 nCnvrtFlags )
1422 {
1423 std::unique_ptr<PPTWriter> pPPTWriter(new PPTWriter( rSvStorage, rXModel, rXStatInd, pVBA, nCnvrtFlags ));
1424 pPPTWriter->exportPPT(rMediaData);
1425 bool bStatus = pPPTWriter->IsValid();
1426 return bStatus;
1427 }
1428
1429 extern "C" SAL_DLLPUBLIC_EXPORT sal_Bool SaveVBA( SfxObjectShell& rDocShell, SvMemoryStream*& pBas )
1430 {
1431 tools::SvRef<SotStorage> xDest( new SotStorage( new SvMemoryStream(), true ) );
1432 SvxImportMSVBasic aMSVBas( rDocShell, *xDest );
1433 aMSVBas.SaveOrDelMSVBAStorage( true, "_MS_VBA_Overhead" );
1434
1435 tools::SvRef<SotStorage> xOverhead = xDest->OpenSotStorage( "_MS_VBA_Overhead" );
1436 if ( xOverhead.is() && ( xOverhead->GetError() == ERRCODE_NONE ) )
1437 {
1438 tools::SvRef<SotStorage> xOverhead2 = xOverhead->OpenSotStorage( "_MS_VBA_Overhead" );
1439 if ( xOverhead2.is() && ( xOverhead2->GetError() == ERRCODE_NONE ) )
1440 {
1441 tools::SvRef<SotStorageStream> xTemp = xOverhead2->OpenSotStream( "_MS_VBA_Overhead2" );
1442 if ( xTemp.is() && ( xTemp->GetError() == ERRCODE_NONE ) )
1443 {
1444 sal_uInt32 nLen = xTemp->GetSize();
1445 if ( nLen )
1446 {
1447 char* pTemp = new char[ nLen ];
1448 xTemp->Seek( STREAM_SEEK_TO_BEGIN );
1449 xTemp->ReadBytes(pTemp, nLen);
1450 pBas = new SvMemoryStream( pTemp, nLen, StreamMode::READ );
1451 pBas->ObjectOwnsMemory( true );
1452 return true;
1453 }
1454 }
1455 }
1456 }
1457
1458 return false;
1459 }
1460
1461 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE