1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sd.hxx"
26 #include <osl/endian.h>
27 #include <eppt.hxx>
28 #include "epptdef.hxx"
29 #ifndef _PptEscherEx_HXX
30 #include "escherex.hxx"
31 #endif
32 #include <tools/poly.hxx>
33 #include <vcl/bmpacc.hxx>
34 #include <vcl/gradient.hxx>
35 #include <vcl/gfxlink.hxx>
36 #include <tools/stream.hxx>
37 #include <sot/storage.hxx>
38 #include <vcl/outdev.hxx>
39 #include <vcl/virdev.hxx>
40 #include <vcl/gradient.hxx>
41 #include <sfx2/app.hxx>
42 #include <svl/languageoptions.hxx>
43 //#ifndef _SVX_XIT_HXX
44 //#include <svx/xit.hxx>
45 //#endif
46 #include <editeng/svxenum.hxx>
47 #include <svx/unoapi.hxx>
48 #include <svx/svdoashp.hxx>
49 #include <com/sun/star/style/VerticalAlignment.hpp>
50 #include <com/sun/star/container/XIndexReplace.hpp>
51 #include <com/sun/star/presentation/XPresentationPage.hpp>
52 #include <com/sun/star/awt/XFont.hpp>
53 #ifndef _COM_SUN_STAR_AWT_XFONTWEIGHT_HPP_
54 #include <com/sun/star/awt/FontWeight.hpp>
55 #endif
56 #ifndef _COM_SUN_STAR_AWT_XFONTUNDERLINE_HPP_
57 #include <com/sun/star/awt/FontUnderline.hpp>
58 #endif
59 #include <com/sun/star/style/ParagraphAdjust.hpp>
60 #include <com/sun/star/style/LineSpacing.hpp>
61 #include <com/sun/star/style/LineSpacingMode.hpp>
62 #ifndef _COM_SUN_STAR_STYLE_XSTYLEFAMILIESSUPPLIER_PP_
63 #include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
64 #endif
65 #include <com/sun/star/style/XStyle.hpp>
66 #include <com/sun/star/drawing/PointSequence.hpp>
67 #include <com/sun/star/drawing/FlagSequence.hpp>
68 #include <com/sun/star/drawing/PolygonFlags.hpp>
69 #include <com/sun/star/beans/PropertyValue.hpp>
70 #include <com/sun/star/drawing/XControlShape.hpp>
71 #include <comphelper/processfactory.hxx>
72 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
73 #include <com/sun/star/i18n/XBreakIterator.hpp>
74 #include <com/sun/star/i18n/XScriptTypeDetector.hpp>
75 #include <com/sun/star/i18n/ScriptType.hpp>
76 #include <com/sun/star/i18n/ScriptDirection.hpp>
77 #include <com/sun/star/embed/Aspects.hpp>
78 #include <vcl/cvtgrf.hxx>
79 #include <tools/urlobj.hxx>
80 #ifndef _CPPUHELPER_EXTRACT_HXX_
81 #include <comphelper/extract.hxx>
82 #endif
83 #ifndef _CPPUHELPER_PROPTYPEHLP_HXX_
84 #include <cppuhelper/proptypehlp.hxx>
85 #endif
86 #ifndef _UCBHELPER_CONTENT_HXX_
87 #include <ucbhelper/content.hxx>
88 #endif
89 #ifndef _UCBHELPER_CONTENTBROKER_HXX_
90 #include <ucbhelper/contentbroker.hxx>
91 #endif
92 #ifndef _TOOLKIT_UNOHLP_HXX
93 #include <toolkit/helper/vclunohelper.hxx>
94 #endif
95 #include <rtl/crc.h>
96 #include <sot/clsids.hxx>
97 #include <unotools/ucbstreamhelper.hxx>
98 #include <com/sun/star/text/FontRelief.hpp>
99 #include <editeng/frmdiritem.hxx>
100 /*
101 #include <editeng/outliner.hxx>
102 #include <editeng/outlobj.hxx>
103 #include <svx/svdmodel.hxx>
104 */
105 #include <svtools/fltcall.hxx>
106 #include <com/sun/star/table/XTable.hpp>
107 #include <com/sun/star/table/XMergeableCell.hpp>
108 #include <com/sun/star/table/BorderLine.hpp>
109 #include <set>
110
111 //#include <svx/xbtmpit.hxx>
112
113 #include "i18npool/mslangid.hxx"
114
115 #include <vos/xception.hxx>
116 using namespace vos;
117
118 using namespace ::com::sun::star;
119
120 ////////////////////////////////////////////////////////////////////////////////////////////////////
121
122 #define ANSI_CHARSET 0
123 #define DEFAULT_CHARSET 1
124 #define SYMBOL_CHARSET 2
125 #define SHIFTJIS_CHARSET 128
126 #define HANGEUL_CHARSET 129
127 #define CHINESEBIG5_CHARSET 136
128 #define OEM_CHARSET 255
129
130 ////////////////////////////////////////////////////////////////////////////////////////////////////
131
132 /* Font Families */
133 #define FF_DONTCARE 0x00
134 #define FF_ROMAN 0x10
135 #define FF_SWISS 0x20
136 #define FF_MODERN 0x30
137 #define FF_SCRIPT 0x40
138 #define FF_DECORATIVE 0x50
139
140 ////////////////////////////////////////////////////////////////////////////////////////////////////
141
142 #define DEFAULT_PITCH 0x00
143 #define FIXED_PITCH 0x01
144 #define VARIABLE_PITCH 0x02
145
146 // ---------------------------------------------------------------------------------------------
147
148 com::sun::star::uno::Reference< com::sun::star::i18n::XBreakIterator > xPPTBreakIter;
149 com::sun::star::uno::Reference< com::sun::star::i18n::XScriptTypeDetector > xScriptTypeDetector;
150
PPTExBulletProvider()151 PPTExBulletProvider::PPTExBulletProvider()
152 {
153 pGraphicProv = new EscherGraphicProvider( _E_GRAPH_PROV_USE_INSTANCES | _E_GRAPH_PROV_DO_NOT_ROTATE_METAFILES );
154 }
155
~PPTExBulletProvider()156 PPTExBulletProvider::~PPTExBulletProvider()
157 {
158 delete pGraphicProv;
159 }
160
GetId(const ByteString & rUniqueId,Size & rGraphicSize)161 sal_uInt16 PPTExBulletProvider::GetId( const ByteString& rUniqueId, Size& rGraphicSize )
162 {
163 sal_uInt16 nRetValue = 0xffff;
164 sal_uInt32 nId = 0;
165
166 if ( rUniqueId.Len() )
167 {
168 Rectangle aRect;
169 GraphicObject aGraphicObject( rUniqueId );
170 Graphic aMappedGraphic, aGraphic( aGraphicObject.GetGraphic() );
171 Size aPrefSize( aGraphic.GetPrefSize() );
172 BitmapEx aBmpEx( aGraphic.GetBitmapEx() );
173
174 if ( rGraphicSize.Width() && rGraphicSize.Height() )
175 {
176 double fQ1 = ( (double)aPrefSize.Width() / (double)aPrefSize.Height() );
177 double fQ2 = ( (double)rGraphicSize.Width() / (double)rGraphicSize.Height() );
178 double fXScale = 1;
179 double fYScale = 1;
180
181 if ( fQ1 > fQ2 )
182 fYScale = fQ1 / fQ2;
183 else if ( fQ1 < fQ2 )
184 fXScale = fQ2 / fQ1;
185
186 if ( ( fXScale != 1.0 ) || ( fYScale != 1.0 ) )
187 {
188 aBmpEx.Scale( fXScale, fYScale );
189 Size aNewSize( (sal_Int32)((double)rGraphicSize.Width() / fXScale + 0.5 ),
190 (sal_Int32)((double)rGraphicSize.Height() / fYScale + 0.5 ) );
191
192 rGraphicSize = aNewSize;
193
194 aMappedGraphic = Graphic( aBmpEx );
195 aGraphicObject = GraphicObject( aMappedGraphic );
196 }
197 }
198
199 nId = pGraphicProv->GetBlibID( aBuExPictureStream, aGraphicObject.GetUniqueID(), aRect, NULL, NULL );
200
201 if ( nId && ( nId < 0x10000 ) )
202 nRetValue = (sal_uInt16)nId - 1;
203 }
204 return nRetValue;
205 }
206
207 // ---------------------------------------------------------------------------------------------
208
GroupTable()209 GroupTable::GroupTable() :
210 mnCurrentGroupEntry ( 0 ),
211 mnMaxGroupEntry ( 0 ),
212 mnGroupsClosed ( 0 ),
213 mpGroupEntry ( NULL )
214 {
215 ImplResizeGroupTable( 32 );
216 }
217
218 // ---------------------------------------------------------------------------------------------
219
~GroupTable()220 GroupTable::~GroupTable()
221 {
222 for ( sal_uInt32 i = 0; i < mnCurrentGroupEntry; delete mpGroupEntry[ i++ ] ) ;
223 delete[] mpGroupEntry;
224 }
225
226 // ---------------------------------------------------------------------------------------------
227
ImplResizeGroupTable(sal_uInt32 nEntrys)228 void GroupTable::ImplResizeGroupTable( sal_uInt32 nEntrys )
229 {
230 if ( nEntrys > mnMaxGroupEntry )
231 {
232 mnMaxGroupEntry = nEntrys;
233 GroupEntry** pTemp = new GroupEntry*[ nEntrys ];
234 for ( sal_uInt32 i = 0; i < mnCurrentGroupEntry; i++ )
235 pTemp[ i ] = mpGroupEntry[ i ];
236 if ( mpGroupEntry )
237 delete[] mpGroupEntry;
238 mpGroupEntry = pTemp;
239 }
240 }
241
242 // ---------------------------------------------------------------------------------------------
243
EnterGroup(::com::sun::star::uno::Reference<::com::sun::star::container::XIndexAccess> & rXIndexAccessRef)244 sal_Bool GroupTable::EnterGroup( ::com::sun::star::uno::Reference< ::com::sun::star::container::XIndexAccess >& rXIndexAccessRef )
245 {
246 sal_Bool bRet = sal_False;
247 if ( rXIndexAccessRef.is() )
248 {
249 GroupEntry* pNewGroup = new GroupEntry( rXIndexAccessRef );
250 if ( pNewGroup->mnCount )
251 {
252 if ( mnMaxGroupEntry == mnCurrentGroupEntry )
253 ImplResizeGroupTable( mnMaxGroupEntry + 8 );
254 mpGroupEntry[ mnCurrentGroupEntry++ ] = pNewGroup;
255 bRet = sal_True;
256 }
257 else
258 delete pNewGroup;
259 }
260 return bRet;
261 }
262
263 // ---------------------------------------------------------------------------------------------
264
GetGroupsClosed()265 sal_uInt32 GroupTable::GetGroupsClosed()
266 {
267 sal_uInt32 nRet = mnGroupsClosed;
268 mnGroupsClosed = 0;
269 return nRet;
270 }
271
272 // ---------------------------------------------------------------------------------------------
273
ClearGroupTable()274 void GroupTable::ClearGroupTable()
275 {
276 for ( sal_uInt32 i = 0; i < mnCurrentGroupEntry; i++, delete mpGroupEntry[ i ] ) ;
277 mnCurrentGroupEntry = 0;
278 }
279
280 // ---------------------------------------------------------------------------------------------
281
ResetGroupTable(sal_uInt32 nCount)282 void GroupTable::ResetGroupTable( sal_uInt32 nCount )
283 {
284 ClearGroupTable();
285 mpGroupEntry[ mnCurrentGroupEntry++ ] = new GroupEntry( nCount );
286 }
287
288 // ---------------------------------------------------------------------------------------------
289
GetNextGroupEntry()290 sal_Bool GroupTable::GetNextGroupEntry()
291 {
292 while ( mnCurrentGroupEntry )
293 {
294 mnIndex = mpGroupEntry[ mnCurrentGroupEntry - 1 ]->mnCurrentPos++;
295
296 if ( mpGroupEntry[ mnCurrentGroupEntry - 1 ]->mnCount > mnIndex )
297 return sal_True;
298
299 delete ( mpGroupEntry[ --mnCurrentGroupEntry ] );
300
301 if ( mnCurrentGroupEntry )
302 mnGroupsClosed++;
303 }
304 return sal_False;
305 }
306
307 // ---------------------------------------------------------------------------------------------
308
~FontCollectionEntry()309 FontCollectionEntry::~FontCollectionEntry()
310 {
311 }
312
313 // ---------------------------------------------------------------------------------------------
314
ImplInit(const String & rName)315 void FontCollectionEntry::ImplInit( const String& rName )
316 {
317 String aSubstName( GetSubsFontName( rName, SUBSFONT_ONLYONE | SUBSFONT_MS ) );
318 if ( aSubstName.Len() )
319 {
320 Name = aSubstName;
321 bIsConverted = sal_True;
322 }
323 else
324 {
325 Name = rName;
326 bIsConverted = sal_False;
327 }
328 }
329
~FontCollection()330 FontCollection::~FontCollection()
331 {
332 for( void* pStr = List::First(); pStr; pStr = List::Next() )
333 delete (FontCollectionEntry*)pStr;
334 delete pVDev;
335 xPPTBreakIter = NULL;
336 xScriptTypeDetector = NULL;
337 }
338
FontCollection()339 FontCollection::FontCollection() :
340 pVDev ( NULL )
341 {
342 com::sun::star::uno::Reference< com::sun::star::lang::XMultiServiceFactory >
343 xMSF = ::comphelper::getProcessServiceFactory();
344 com::sun::star::uno::Reference< com::sun::star::uno::XInterface >
345 xInterface = xMSF->createInstance( rtl::OUString::createFromAscii( "com.sun.star.i18n.BreakIterator" ) );
346 if ( xInterface.is() )
347 xPPTBreakIter = com::sun::star::uno::Reference< com::sun::star::i18n::XBreakIterator >
348 ( xInterface, com::sun::star::uno::UNO_QUERY );
349
350 xInterface = xMSF->createInstance( rtl::OUString::createFromAscii( "com.sun.star.i18n.ScriptTypeDetector" ) );
351 if ( xInterface.is() )
352 xScriptTypeDetector = com::sun::star::uno::Reference< com::sun::star::i18n::XScriptTypeDetector >
353 ( xInterface, com::sun::star::uno::UNO_QUERY );
354 }
355
GetScriptDirection(const String & rString) const356 short FontCollection::GetScriptDirection( const String& rString ) const
357 {
358 short nRet = com::sun::star::i18n::ScriptDirection::NEUTRAL;
359 if ( xScriptTypeDetector.is() )
360 {
361 const rtl::OUString sT( rString );
362 nRet = xScriptTypeDetector->getScriptDirection( sT, 0, com::sun::star::i18n::ScriptDirection::NEUTRAL );
363 }
364 return nRet;
365 }
366
GetId(FontCollectionEntry & rEntry)367 sal_uInt32 FontCollection::GetId( FontCollectionEntry& rEntry )
368 {
369 if( rEntry.Name.Len() )
370 {
371 const sal_uInt32 nFonts = GetCount();
372
373 for( sal_uInt32 i = 0; i < nFonts; i++ )
374 {
375 const FontCollectionEntry* pEntry = GetById( i );
376 if( pEntry->Name == rEntry.Name )
377 return i;
378 }
379 Font aFont;
380 aFont.SetCharSet( rEntry.CharSet );
381 aFont.SetName( rEntry.Original );
382 // aFont.SetFamily( rEntry.Family );
383 // aFont.SetPitch( rEntry.Pitch );
384 aFont.SetHeight( 100 );
385
386 if ( !pVDev )
387 pVDev = new VirtualDevice;
388
389 pVDev->SetFont( aFont );
390 FontMetric aMetric( pVDev->GetFontMetric() );
391
392 sal_uInt16 nTxtHeight = (sal_uInt16)aMetric.GetAscent() + (sal_uInt16)aMetric.GetDescent();
393
394 if ( nTxtHeight )
395 {
396 double fScaling = (double)nTxtHeight / 120.0;
397 if ( ( fScaling > 0.50 ) && ( fScaling < 1.5 ) )
398 rEntry.Scaling = fScaling;
399 }
400
401 List::Insert( new FontCollectionEntry( rEntry ), LIST_APPEND );
402 return nFonts;
403 }
404 return 0;
405 }
406
GetById(sal_uInt32 nId)407 const FontCollectionEntry* FontCollection::GetById( sal_uInt32 nId )
408 {
409 return (FontCollectionEntry*)List::GetObject( nId );
410 }
411
412 // ---------------------------------------------------------------------------------------------
413
ImplVBAInfoContainer(SvStream * pStrm)414 sal_uInt32 PPTWriter::ImplVBAInfoContainer( SvStream* pStrm )
415 {
416 sal_uInt32 nSize = 28;
417 if ( pStrm )
418 {
419 *pStrm << (sal_uInt32)( 0x1f | ( EPP_VBAInfo << 16 ) )
420 << (sal_uInt32)( nSize - 8 )
421 << (sal_uInt32)( 2 | ( EPP_VBAInfoAtom << 16 ) )
422 << (sal_uInt32)12;
423 mpPptEscherEx->InsertPersistOffset( EPP_Persist_VBAInfoAtom, pStrm->Tell() );
424 *pStrm << (sal_uInt32)0
425 << (sal_uInt32)0
426 << (sal_uInt32)1;
427 }
428 return nSize;
429 }
430
431 // ---------------------------------------------------------------------------------------------
432
ImplSlideViewInfoContainer(sal_uInt32 nInstance,SvStream * pStrm)433 sal_uInt32 PPTWriter::ImplSlideViewInfoContainer( sal_uInt32 nInstance, SvStream* pStrm )
434 {
435 sal_uInt32 nSize = 111;
436 if ( pStrm )
437 {
438 sal_uInt8 bShowGuides = 0;
439 sal_uInt8 bSnapToGrid = 1;
440 sal_uInt8 bSnapToShape = 0;
441
442 sal_Int32 nScaling = 85;
443 sal_Int32 nMasterCoordinate = 0xdda;
444 sal_Int32 nXOrigin = -780;
445 sal_Int32 nYOrigin = -84;
446
447 sal_Int32 nPosition1 = 0x870;
448 sal_Int32 nPosition2 = 0xb40;
449
450 if ( nInstance )
451 {
452 bShowGuides = 1;
453 nScaling = 0x3b;
454 nMasterCoordinate = 0xf0c;
455 nXOrigin = -1752;
456 nYOrigin = -72;
457 nPosition1 = 0xb40;
458 nPosition2 = 0x870;
459 }
460 *pStrm << (sal_uInt32)( 0xf | ( EPP_SlideViewInfo << 16 ) | ( nInstance << 4 ) )
461 << (sal_uInt32)( nSize - 8 )
462 << (sal_uInt32)( EPP_SlideViewInfoAtom << 16 ) << (sal_uInt32)3
463 << bShowGuides << bSnapToGrid << bSnapToShape
464 << (sal_uInt32)( EPP_ViewInfoAtom << 16 ) << (sal_uInt32)52
465 << nScaling << (sal_Int32)100 << nScaling << (sal_Int32)100 // scaling atom - Keeps the current scale
466 << nScaling << (sal_Int32)100 << nScaling << (sal_Int32)100 // scaling atom - Keeps the previous scale
467 << (sal_Int32)0x17ac << nMasterCoordinate// Origin - Keeps the origin in master coordinates
468 << nXOrigin << nYOrigin // Origin
469 << (sal_uInt8)1 // Bool1 varScale - Set if zoom to fit is set
470 << (sal_uInt8)0 // bool1 draftMode - Not used
471 << (sal_uInt16)0 // padword
472 << (sal_uInt32)( ( 7 << 4 ) | ( EPP_GuideAtom << 16 ) ) << (sal_uInt32)8
473 << (sal_uInt32)0 // Type of the guide. If the guide is horizontal this value is zero. If it's vertical, it's one.
474 << nPosition1 // Position of the guide in master coordinates. X coordinate if it's vertical, and Y coordinate if it's horizontal.
475 << (sal_uInt32)( ( 7 << 4 ) | ( EPP_GuideAtom << 16 ) ) << (sal_uInt32)8
476 << (sal_Int32)1 // Type of the guide. If the guide is horizontal this value is zero. If it's vertical, it's one.
477 << nPosition2; // Position of the guide in master coordinates. X coordinate if it's vertical, and Y coordinate if it's horizontal.
478 }
479 return nSize;
480 }
481
482 // ---------------------------------------------------------------------------------------------
483
ImplOutlineViewInfoContainer(SvStream * pStrm)484 sal_uInt32 PPTWriter::ImplOutlineViewInfoContainer( SvStream* pStrm )
485 {
486 sal_uInt32 nSize = 68;
487 if ( pStrm )
488 {
489 *pStrm << (sal_uInt32)( 0xf | ( EPP_OutlineViewInfo << 16 ) ) << (sal_uInt32)( nSize - 8 )
490 << (sal_uInt32)( EPP_ViewInfoAtom << 16 ) << (sal_uInt32)52
491 << (sal_Int32)170 << (sal_Int32)200 << (sal_Int32)170 << (sal_Int32)200 // scaling atom - Keeps the current scale
492 << (sal_Int32)170 << (sal_Int32)200 << (sal_Int32)170 << (sal_Int32)200 // scaling atom - Keeps the previous scale
493 << (sal_Int32)0x17ac << 0xdda // Origin - Keeps the origin in master coordinates
494 << (sal_Int32)-780 << (sal_Int32)-84 // Origin
495 << (sal_uInt8)1 // bool1 varScale - Set if zoom to fit is set
496 << (sal_uInt8)0 // bool1 draftMode - Not used
497 << (sal_uInt16)0; // padword
498 }
499 return nSize;
500 }
501
502 // ---------------------------------------------------------------------------------------------
503
ImplProgBinaryTag(SvStream * pStrm)504 sal_uInt32 PPTWriter::ImplProgBinaryTag( SvStream* pStrm )
505 {
506 sal_uInt32 nPictureStreamSize, nOutlineStreamSize, nSize = 8;
507
508 nPictureStreamSize = aBuExPictureStream.Tell();
509 if ( nPictureStreamSize )
510 nSize += nPictureStreamSize + 8;
511
512 nOutlineStreamSize = aBuExOutlineStream.Tell();
513 if ( nOutlineStreamSize )
514 nSize += nOutlineStreamSize + 8;
515
516 if ( pStrm )
517 {
518 *pStrm << (sal_uInt32)( EPP_BinaryTagData << 16 ) << (sal_uInt32)( nSize - 8 );
519 if ( nPictureStreamSize )
520 {
521 *pStrm << (sal_uInt32)( 0xf | ( EPP_PST_ExtendedBuGraContainer << 16 ) ) << nPictureStreamSize;
522 pStrm->Write( aBuExPictureStream.GetData(), nPictureStreamSize );
523 }
524 if ( nOutlineStreamSize )
525 {
526 *pStrm << (sal_uInt32)( 0xf | ( EPP_PST_ExtendedPresRuleContainer << 16 ) ) << nOutlineStreamSize;
527 pStrm->Write( aBuExOutlineStream.GetData(), nOutlineStreamSize );
528 }
529 }
530 return nSize;
531 }
532
533 // ---------------------------------------------------------------------------------------------
534
ImplProgBinaryTagContainer(SvStream * pStrm,SvMemoryStream * pBinTagStrm)535 sal_uInt32 PPTWriter::ImplProgBinaryTagContainer( SvStream* pStrm, SvMemoryStream* pBinTagStrm )
536 {
537 sal_uInt32 nSize = 8 + 8 + 14;
538 if ( pStrm )
539 {
540 *pStrm << (sal_uInt32)( 0xf | ( EPP_ProgBinaryTag << 16 ) ) << (sal_uInt32)0
541 << (sal_uInt32)( EPP_CString << 16 ) << (sal_uInt32)14
542 << (sal_uInt32)0x5f005f << (sal_uInt32)0x50005f
543 << (sal_uInt32)0x540050 << (sal_uInt16)0x39;
544 }
545 if ( pBinTagStrm )
546 {
547 sal_uInt32 nLen = pBinTagStrm->Tell();
548 nSize += nLen + 8;
549 *pStrm << (sal_uInt32)( EPP_BinaryTagData << 16 ) << nLen;
550 pStrm->Write( pBinTagStrm->GetData(), nLen );
551 }
552 else
553 nSize += ImplProgBinaryTag( pStrm );
554
555 if ( pStrm )
556 {
557 pStrm->SeekRel( - ( (sal_Int32)nSize - 4 ) );
558 *pStrm << (sal_uInt32)( nSize - 8 );
559 pStrm->SeekRel( nSize - 8 );
560 }
561 return nSize;
562 }
563
564 // ---------------------------------------------------------------------------------------------
565
ImplProgTagContainer(SvStream * pStrm,SvMemoryStream * pBinTagStrm)566 sal_uInt32 PPTWriter::ImplProgTagContainer( SvStream* pStrm, SvMemoryStream* pBinTagStrm )
567 {
568 sal_uInt32 nSize = 0;
569 if ( aBuExPictureStream.Tell() || aBuExOutlineStream.Tell() || pBinTagStrm )
570 {
571 nSize = 8;
572 if ( pStrm )
573 {
574 *pStrm << (sal_uInt32)( 0xf | ( EPP_ProgTags << 16 ) ) << (sal_uInt32)0;
575 }
576 nSize += ImplProgBinaryTagContainer( pStrm, pBinTagStrm );
577 if ( pStrm )
578 {
579 pStrm->SeekRel( - ( (sal_Int32)nSize - 4 ) );
580 *pStrm << (sal_uInt32)( nSize - 8 );
581 pStrm->SeekRel( nSize - 8 );
582 }
583 }
584 return nSize;
585 }
586
587 // ---------------------------------------------------------------------------------------------
588
ImplDocumentListContainer(SvStream * pStrm)589 sal_uInt32 PPTWriter::ImplDocumentListContainer( SvStream* pStrm )
590 {
591 sal_uInt32 nSize = 8;
592 if ( pStrm )
593 {
594 *pStrm << (sal_uInt32)( ( EPP_List << 16 ) | 0xf ) << (sal_uInt32)0;
595 }
596
597 nSize += ImplVBAInfoContainer( pStrm );
598 nSize += ImplSlideViewInfoContainer( 0, pStrm );
599 nSize += ImplOutlineViewInfoContainer( pStrm );
600 nSize += ImplSlideViewInfoContainer( 1, pStrm );
601 nSize += ImplProgTagContainer( pStrm );
602
603 if ( pStrm )
604 {
605 pStrm->SeekRel( - ( (sal_Int32)nSize - 4 ) );
606 *pStrm << (sal_uInt32)( nSize - 8 );
607 pStrm->SeekRel( nSize - 8 );
608 }
609 return nSize;
610 }
611
612 // ---------------------------------------------------------------------------------------------
613
ImplMasterSlideListContainer(SvStream * pStrm)614 sal_uInt32 PPTWriter::ImplMasterSlideListContainer( SvStream* pStrm )
615 {
616 sal_uInt32 i, nSize = 28 * mnMasterPages + 8;
617 if ( pStrm )
618 {
619 *pStrm << (sal_uInt32)( 0x1f | ( EPP_SlideListWithText << 16 ) ) << (sal_uInt32)( nSize - 8 );
620
621 for ( i = 0; i < mnMasterPages; i++ )
622 {
623 *pStrm << (sal_uInt32)( EPP_SlidePersistAtom << 16 ) << (sal_uInt32)20;
624 mpPptEscherEx->InsertPersistOffset( EPP_MAINMASTER_PERSIST_KEY | i, pStrm->Tell() );
625 *pStrm << (sal_uInt32)0 // psrReference - logical reference to the slide persist object ( EPP_MAINMASTER_PERSIST_KEY )
626 << (sal_uInt32)0 // flags - only bit 3 used, if set then slide contains shapes other than placeholders
627 << (sal_Int32)0 // numberTexts - number of placeholder texts stored with the persist object. Allows to display outline view without loading the slide persist objects
628 << (sal_Int32)( 0x80000000 | i ) // slideId - Unique slide identifier, used for OLE link monikers for example
629 << (sal_uInt32)0; // reserved, usually 0
630 }
631 }
632 return nSize;
633 }
634
635 // ---------------------------------------------------------------------------------------------
636
ImplInsertBookmarkURL(const String & rBookmarkURL,const sal_uInt32 nType,const String & rStringVer0,const String & rStringVer1,const String & rStringVer2,const String & rStringVer3)637 sal_uInt32 PPTWriter::ImplInsertBookmarkURL( const String& rBookmarkURL, const sal_uInt32 nType,
638 const String& rStringVer0, const String& rStringVer1, const String& rStringVer2, const String& rStringVer3 )
639 {
640 sal_uInt32 nHyperId = ++mnExEmbed;
641
642 rtl::OUString sBookmarkURL( rBookmarkURL );
643 INetURLObject aBaseURI( maBaseURI );
644 INetURLObject aBookmarkURI( rBookmarkURL );
645 if( aBaseURI.GetProtocol() == aBookmarkURI.GetProtocol() )
646 {
647 rtl::OUString aRelUrl( INetURLObject::GetRelURL( maBaseURI, rBookmarkURL,
648 INetURLObject::WAS_ENCODED, INetURLObject::DECODE_TO_IURI, RTL_TEXTENCODING_UTF8, INetURLObject::FSYS_DETECT ) );
649 if ( aRelUrl.getLength() )
650 sBookmarkURL = aRelUrl;
651 }
652 maHyperlink.Insert( new EPPTHyperlink( sBookmarkURL, nType ), LIST_APPEND );
653
654 *mpExEmbed << (sal_uInt16)0xf
655 << (sal_uInt16)EPP_ExHyperlink
656 << (sal_uInt32)0;
657 sal_uInt32 nHyperSize, nHyperStart = mpExEmbed->Tell();
658 *mpExEmbed << (sal_uInt16)0
659 << (sal_uInt16)EPP_ExHyperlinkAtom
660 << (sal_uInt32)4
661 << nHyperId;
662
663 sal_uInt16 i, nStringLen;
664 nStringLen = rStringVer0.Len();
665 if ( nStringLen )
666 {
667 *mpExEmbed << (sal_uInt32)( EPP_CString << 16 ) << (sal_uInt32)( nStringLen * 2 );
668 for ( i = 0; i < nStringLen; i++ )
669 {
670 *mpExEmbed << rStringVer0.GetChar( i );
671 }
672 }
673 nStringLen = rStringVer1.Len();
674 if ( nStringLen )
675 {
676 *mpExEmbed << (sal_uInt32)( ( EPP_CString << 16 ) | 0x10 ) << (sal_uInt32)( nStringLen * 2 );
677 for ( i = 0; i < nStringLen; i++ )
678 {
679 *mpExEmbed << rStringVer1.GetChar( i );
680 }
681 }
682 nStringLen = rStringVer2.Len();
683 if ( nStringLen )
684 {
685 *mpExEmbed << (sal_uInt32)( ( EPP_CString << 16 ) | 0x20 ) << (sal_uInt32)( nStringLen * 2 );
686 for ( i = 0; i < nStringLen; i++ )
687 {
688 *mpExEmbed << rStringVer2.GetChar( i );
689 }
690 }
691 nStringLen = rStringVer3.Len();
692 if ( nStringLen )
693 {
694 *mpExEmbed << (sal_uInt32)( ( EPP_CString << 16 ) | 0x30 ) << (sal_uInt32)( nStringLen * 2 );
695 for ( i = 0; i < nStringLen; i++ )
696 {
697 *mpExEmbed << rStringVer3.GetChar( i );
698 }
699 }
700 nHyperSize = mpExEmbed->Tell() - nHyperStart;
701 mpExEmbed->SeekRel( - ( (sal_Int32)nHyperSize + 4 ) );
702 *mpExEmbed << nHyperSize;
703 mpExEmbed->SeekRel( nHyperSize );
704 return nHyperId;
705 }
706
707 // ---------------------------------------------------------------------------------------------
708
ImplCloseDocument()709 sal_Bool PPTWriter::ImplCloseDocument()
710 {
711 sal_uInt32 nOfs = mpPptEscherEx->PtGetOffsetByID( EPP_Persist_Document );
712 if ( nOfs )
713 {
714 mpPptEscherEx->PtReplaceOrInsert( EPP_Persist_CurrentPos, mpStrm->Tell() );
715 mpStrm->Seek( nOfs );
716
717 // creating the TxMasterStyleAtom
718 SvMemoryStream aTxMasterStyleAtomStrm( 0x200, 0x200 );
719 {
720 EscherExAtom aTxMasterStyleAtom( aTxMasterStyleAtomStrm, EPP_TxMasterStyleAtom, EPP_TEXTTYPE_Other );
721 aTxMasterStyleAtomStrm << (sal_uInt16)5; // paragraph count
722 sal_uInt16 nLev;
723 sal_Bool bFirst = sal_True;
724 for ( nLev = 0; nLev < 5; nLev++ )
725 {
726 mpStyleSheet->mpParaSheet[ EPP_TEXTTYPE_Other ]->Write( aTxMasterStyleAtomStrm, mpPptEscherEx, nLev, bFirst, sal_False, mXPagePropSet );
727 mpStyleSheet->mpCharSheet[ EPP_TEXTTYPE_Other ]->Write( aTxMasterStyleAtomStrm, mpPptEscherEx, nLev, bFirst, sal_False, mXPagePropSet );
728 bFirst = sal_False;
729 }
730 }
731
732 mpExEmbed->Seek( STREAM_SEEK_TO_END );
733 sal_uInt32 nExEmbedSize = mpExEmbed->Tell();
734
735 // nEnviroment : Gesamtgroesse des Environment Containers
736 sal_uInt32 nEnvironment = maFontCollection.GetCount() * 76 // 68 bytes pro Fontenityatom und je 8 Bytes fuer die Header
737 + 8 // 1 FontCollection Container
738 + 20 // SrKinsoku Container
739 + 18 // 1 TxSiStyleAtom
740 + aTxMasterStyleAtomStrm.Tell() // 1 TxMasterStyleAtom;
741 + mpStyleSheet->SizeOfTxCFStyleAtom();
742
743 sal_uInt32 nBytesToInsert = nEnvironment + 8;
744
745 if ( nExEmbedSize )
746 nBytesToInsert += nExEmbedSize + 8 + 12;
747
748 nBytesToInsert += maSoundCollection.GetSize();
749 nBytesToInsert += mpPptEscherEx->DrawingGroupContainerSize();
750 nBytesToInsert += ImplMasterSlideListContainer( NULL );
751 nBytesToInsert += ImplDocumentListContainer( NULL );
752
753 // nBytes im Stream einfuegen, und abhaengige Container anpassen
754 mpPptEscherEx->InsertAtCurrentPos( nBytesToInsert, false );
755
756 // CREATE HYPERLINK CONTAINER
757 if ( nExEmbedSize )
758 {
759 *mpStrm << (sal_uInt16)0xf
760 << (sal_uInt16)EPP_ExObjList
761 << (sal_uInt32)( nExEmbedSize + 12 )
762 << (sal_uInt16)0
763 << (sal_uInt16)EPP_ExObjListAtom
764 << (sal_uInt32)4
765 << (sal_uInt32)mnExEmbed;
766 mpPptEscherEx->InsertPersistOffset( EPP_Persist_ExObj, mpStrm->Tell() );
767 mpStrm->Write( mpExEmbed->GetData(), nExEmbedSize );
768 }
769
770 // CREATE ENVIRONMENT
771 *mpStrm << (sal_uInt16)0xf << (sal_uInt16)EPP_Environment << (sal_uInt32)nEnvironment;
772
773 // Open Container ( EPP_SrKinsoku )
774 *mpStrm << (sal_uInt16)0x2f << (sal_uInt16)EPP_SrKinsoku << (sal_uInt32)12;
775 mpPptEscherEx->AddAtom( 4, EPP_SrKinsokuAtom, 0, 3 );
776 *mpStrm << (sal_Int32)0; // SrKinsoku Level 0
777
778 // Open Container ( EPP_FontCollection )
779 *mpStrm << (sal_uInt16)0xf << (sal_uInt16)EPP_FontCollection << (sal_uInt32)maFontCollection.GetCount() * 76;
780
781 for ( sal_uInt32 i = 0; i < maFontCollection.GetCount(); i++ )
782 {
783 mpPptEscherEx->AddAtom( 68, EPP_FontEnityAtom, 0, i );
784 const FontCollectionEntry* pDesc = maFontCollection.GetById( i );
785 sal_uInt32 nFontLen = pDesc->Name.Len();
786 if ( nFontLen > 31 )
787 nFontLen = 31;
788 for ( sal_uInt16 n = 0; n < 32; n++ )
789 {
790 sal_Unicode nUniCode = 0;
791 if ( n < nFontLen )
792 nUniCode = pDesc->Name.GetChar( n );
793 *mpStrm << nUniCode;
794 }
795 sal_uInt8 lfCharSet = ANSI_CHARSET;
796 sal_uInt8 lfClipPrecision = 0;
797 sal_uInt8 lfQuality = 6;
798 sal_uInt8 lfPitchAndFamily = 0;
799
800 if ( pDesc->CharSet == RTL_TEXTENCODING_SYMBOL )
801 lfCharSet = SYMBOL_CHARSET;
802
803 switch( pDesc->Family )
804 {
805 case ::com::sun::star::awt::FontFamily::ROMAN :
806 lfPitchAndFamily |= FF_ROMAN;
807 break;
808
809 case ::com::sun::star::awt::FontFamily::SWISS :
810 lfPitchAndFamily |= FF_SWISS;
811 break;
812
813 case ::com::sun::star::awt::FontFamily::MODERN :
814 lfPitchAndFamily |= FF_MODERN;
815 break;
816
817 case ::com::sun::star::awt::FontFamily::SCRIPT:
818 lfPitchAndFamily |= FF_SCRIPT;
819 break;
820
821 case ::com::sun::star::awt::FontFamily::DECORATIVE:
822 lfPitchAndFamily |= FF_DECORATIVE;
823 break;
824
825 default:
826 lfPitchAndFamily |= FAMILY_DONTKNOW;
827 break;
828 }
829 switch( pDesc->Pitch )
830 {
831 case ::com::sun::star::awt::FontPitch::FIXED:
832 lfPitchAndFamily |= FIXED_PITCH;
833 break;
834
835 default:
836 lfPitchAndFamily |= DEFAULT_PITCH;
837 break;
838 }
839 *mpStrm << lfCharSet
840 << lfClipPrecision
841 << lfQuality
842 << lfPitchAndFamily;
843 }
844 mpStyleSheet->WriteTxCFStyleAtom( *mpStrm ); // create style that is used for new standard objects
845 mpPptEscherEx->AddAtom( 10, EPP_TxSIStyleAtom );
846 *mpStrm << (sal_uInt32)7 // ?
847 << (sal_Int16)2 // ?
848 << (sal_uInt8)9 // ?
849 << (sal_uInt8)8 // ?
850 << (sal_Int16)0; // ?
851
852 mpStrm->Write( aTxMasterStyleAtomStrm.GetData(), aTxMasterStyleAtomStrm.Tell() );
853 maSoundCollection.Write( *mpStrm );
854 mpPptEscherEx->WriteDrawingGroupContainer( *mpStrm );
855 ImplMasterSlideListContainer( mpStrm );
856 ImplDocumentListContainer( mpStrm );
857
858 sal_uInt32 nOldPos = mpPptEscherEx->PtGetOffsetByID( EPP_Persist_CurrentPos );
859 if ( nOldPos )
860 {
861 mpStrm->Seek( nOldPos );
862 return sal_True;
863 }
864 }
865 return sal_False;
866 }
867
868 // ---------------------------------------------------------------------------------------------
869
GetPropertyValue(::com::sun::star::uno::Any & rAny,const::com::sun::star::uno::Reference<::com::sun::star::beans::XPropertySet> & rXPropSet,const String & rString,sal_Bool bTestPropertyAvailability)870 sal_Bool PropValue::GetPropertyValue(
871 ::com::sun::star::uno::Any& rAny,
872 const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > & rXPropSet,
873 const String& rString,
874 sal_Bool bTestPropertyAvailability )
875 {
876 sal_Bool bRetValue = sal_True;
877 if ( bTestPropertyAvailability )
878 {
879 bRetValue = sal_False;
880 try
881 {
882 ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySetInfo >
883 aXPropSetInfo( rXPropSet->getPropertySetInfo() );
884 if ( aXPropSetInfo.is() )
885 bRetValue = aXPropSetInfo->hasPropertyByName( rString );
886 }
887 catch( ::com::sun::star::uno::Exception& )
888 {
889 bRetValue = sal_False;
890 }
891 }
892 if ( bRetValue )
893 {
894 try
895 {
896 rAny = rXPropSet->getPropertyValue( rString );
897 if ( !rAny.hasValue() )
898 bRetValue = sal_False;
899 }
900 catch( ::com::sun::star::uno::Exception& )
901 {
902 bRetValue = sal_False;
903 }
904 }
905 return bRetValue;
906 }
907
908 // ---------------------------------------------------------------------------------------------
909
GetPropertyState(const::com::sun::star::uno::Reference<::com::sun::star::beans::XPropertySet> & rXPropSet,const String & rPropertyName)910 ::com::sun::star::beans::PropertyState PropValue::GetPropertyState(
911 const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > & rXPropSet,
912 const String& rPropertyName )
913 {
914 ::com::sun::star::beans::PropertyState eRetValue = ::com::sun::star::beans::PropertyState_AMBIGUOUS_VALUE;
915 try
916 {
917 ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertyState > aXPropState
918 ( rXPropSet, ::com::sun::star::uno::UNO_QUERY );
919 if ( aXPropState.is() )
920 eRetValue = aXPropState->getPropertyState( rPropertyName );
921 }
922 catch( ::com::sun::star::uno::Exception& )
923 {
924 //...
925 }
926 return eRetValue;
927 }
928
929 // ---------------------------------------------------------------------------------------------
930
ImplGetPropertyValue(const String & rString)931 sal_Bool PropValue::ImplGetPropertyValue( const String& rString )
932 {
933 return GetPropertyValue( mAny, mXPropSet, rString );
934 }
935
936 // ---------------------------------------------------------------------------------------------
937
ImplGetPropertyValue(const::com::sun::star::uno::Reference<::com::sun::star::beans::XPropertySet> & aXPropSet,const String & rString)938 sal_Bool PropValue::ImplGetPropertyValue( const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > & aXPropSet, const String& rString )
939 {
940 return GetPropertyValue( mAny, aXPropSet, rString );
941 }
942
943 // ---------------------------------------------------------------------------------------------
944
ImplGetPropertyValue(const String & rString,sal_Bool bGetPropertyState)945 sal_Bool PropStateValue::ImplGetPropertyValue( const String& rString, sal_Bool bGetPropertyState )
946 {
947 ePropState = ::com::sun::star::beans::PropertyState_AMBIGUOUS_VALUE;
948 sal_Bool bRetValue = sal_True;
949 #ifdef UNX
950 ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySetInfo >
951 aXPropSetInfo( mXPropSet->getPropertySetInfo() );
952 if ( !aXPropSetInfo.is() )
953 return sal_False;
954 #endif
955 try
956 {
957 mAny = mXPropSet->getPropertyValue( rString );
958 if ( !mAny.hasValue() )
959 bRetValue = sal_False;
960 else if ( bGetPropertyState )
961 ePropState = mXPropState->getPropertyState( rString );
962 else
963 ePropState = ::com::sun::star::beans::PropertyState_DIRECT_VALUE;
964 }
965 catch( ::com::sun::star::uno::Exception& )
966 {
967 bRetValue = sal_False;
968 }
969 return bRetValue;
970 }
971
972 // ---------------------------------------------------------------------------------------------
973
ImplInitSOIface()974 sal_Bool PPTWriter::ImplInitSOIface()
975 {
976 while( sal_True )
977 {
978 mXDrawPagesSupplier = ::com::sun::star::uno::Reference<
979 ::com::sun::star::drawing::XDrawPagesSupplier >
980 ( mXModel, ::com::sun::star::uno::UNO_QUERY );
981 if ( !mXDrawPagesSupplier.is() )
982 break;
983
984 mXMasterPagesSupplier = ::com::sun::star::uno::Reference<
985 ::com::sun::star::drawing::XMasterPagesSupplier >
986 ( mXModel, ::com::sun::star::uno::UNO_QUERY );
987 if ( !mXMasterPagesSupplier.is() )
988 break;
989 mXDrawPages = mXMasterPagesSupplier->getMasterPages();
990 if ( !mXDrawPages.is() )
991 break;
992 mnMasterPages = mXDrawPages->getCount();
993 mXDrawPages = mXDrawPagesSupplier->getDrawPages();
994 if( !mXDrawPages.is() )
995 break;
996 mnPages = mXDrawPages->getCount();
997 if ( !ImplGetPageByIndex( 0, NORMAL ) )
998 break;
999
1000 return sal_True;
1001 }
1002 return sal_False;
1003 }
1004
1005 // ---------------------------------------------------------------------------------------------
1006
ImplSetCurrentStyleSheet(sal_uInt32 nPageNum)1007 sal_Bool PPTWriter::ImplSetCurrentStyleSheet( sal_uInt32 nPageNum )
1008 {
1009 sal_Bool bRet = sal_False;
1010 if ( nPageNum >= maStyleSheetList.size() )
1011 nPageNum = 0;
1012 else
1013 bRet = sal_True;
1014 mpStyleSheet = maStyleSheetList[ nPageNum ];
1015 return bRet;
1016 }
1017
1018 // ---------------------------------------------------------------------------------------------
1019
ImplGetPageByIndex(sal_uInt32 nIndex,PageType ePageType)1020 sal_Bool PPTWriter::ImplGetPageByIndex( sal_uInt32 nIndex, PageType ePageType )
1021 {
1022 while( sal_True )
1023 {
1024 if ( ePageType != meLatestPageType )
1025 {
1026 switch( ePageType )
1027 {
1028 case NORMAL :
1029 case NOTICE :
1030 {
1031 mXDrawPages = mXDrawPagesSupplier->getDrawPages();
1032 if( !mXDrawPages.is() )
1033 return sal_False;
1034 }
1035 break;
1036
1037 case MASTER :
1038 {
1039 mXDrawPages = mXMasterPagesSupplier->getMasterPages();
1040 if( !mXDrawPages.is() )
1041 return sal_False;
1042 }
1043 break;
1044 default:
1045 break;
1046 }
1047 meLatestPageType = ePageType;
1048 }
1049 ::com::sun::star::uno::Any aAny( mXDrawPages->getByIndex( nIndex ) );
1050 aAny >>= mXDrawPage;
1051 if ( !mXDrawPage.is() )
1052 break;
1053 if ( ePageType == NOTICE )
1054 {
1055 ::com::sun::star::uno::Reference< ::com::sun::star::presentation::XPresentationPage >
1056 aXPresentationPage( mXDrawPage, ::com::sun::star::uno::UNO_QUERY );
1057 if ( !aXPresentationPage.is() )
1058 break;
1059 mXDrawPage = aXPresentationPage->getNotesPage();
1060 if ( !mXDrawPage.is() )
1061 break;
1062 }
1063 mXPagePropSet = ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >
1064 ( mXDrawPage, ::com::sun::star::uno::UNO_QUERY );
1065 if ( !mXPagePropSet.is() )
1066 break;
1067
1068 mXShapes = ::com::sun::star::uno::Reference<
1069 ::com::sun::star::drawing::XShapes >
1070 ( mXDrawPage, ::com::sun::star::uno::UNO_QUERY );
1071 if ( !mXShapes.is() )
1072 break;
1073
1074 /* try to get the "real" background PropertySet. If the normal page is not supporting this property, it is
1075 taken the property from the master */
1076 sal_Bool bHasBackground = GetPropertyValue( aAny, mXPagePropSet, String( RTL_CONSTASCII_USTRINGPARAM( "Background" ) ), sal_True );
1077 if ( bHasBackground )
1078 bHasBackground = ( aAny >>= mXBackgroundPropSet );
1079 if ( !bHasBackground )
1080 {
1081 ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XMasterPageTarget >
1082 aXMasterPageTarget( mXDrawPage, ::com::sun::star::uno::UNO_QUERY );
1083 if ( aXMasterPageTarget.is() )
1084 {
1085 ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XDrawPage > aXMasterDrawPage;
1086 aXMasterDrawPage = aXMasterPageTarget->getMasterPage();
1087 if ( aXMasterDrawPage.is() )
1088 {
1089 ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > aXMasterPagePropSet;
1090 aXMasterPagePropSet = ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >
1091 ( aXMasterDrawPage, ::com::sun::star::uno::UNO_QUERY );
1092 if ( aXMasterPagePropSet.is() )
1093 {
1094 sal_Bool bBackground = GetPropertyValue( aAny, aXMasterPagePropSet,
1095 String( RTL_CONSTASCII_USTRINGPARAM( "Background" ) ) );
1096 if ( bBackground )
1097 {
1098 aAny >>= mXBackgroundPropSet;
1099 }
1100 }
1101 }
1102 }
1103 }
1104 return sal_True;
1105 }
1106 return sal_False;
1107 }
1108
1109 // ---------------------------------------------------------------------------------------------
1110
ImplGetShapeByIndex(sal_uInt32 nIndex,sal_Bool bGroup)1111 sal_Bool PPTWriter::ImplGetShapeByIndex( sal_uInt32 nIndex, sal_Bool bGroup )
1112 {
1113 while(sal_True)
1114 {
1115 if ( ( bGroup == sal_False ) || ( GetCurrentGroupLevel() == 0 ) )
1116 {
1117 ::com::sun::star::uno::Any aAny( mXShapes->getByIndex( nIndex ) );
1118 aAny >>= mXShape;
1119 }
1120 else
1121 {
1122 ::com::sun::star::uno::Any aAny( GetCurrentGroupAccess()->getByIndex( GetCurrentGroupIndex() ) );
1123 aAny >>= mXShape;
1124 }
1125 if ( !mXShape.is() )
1126 break;
1127
1128 ::com::sun::star::uno::Any aAny( mXShape->queryInterface( ::getCppuType( (const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >*) 0 ) ));
1129 aAny >>= mXPropSet;
1130
1131 if ( !mXPropSet.is() )
1132 break;
1133 maPosition = ImplMapPoint( mXShape->getPosition() );
1134 maSize = ImplMapSize( mXShape->getSize() );
1135 maRect = Rectangle( Point( maPosition.X, maPosition.Y ), Size( maSize.Width, maSize.Height ) );
1136 mType = ByteString( String( mXShape->getShapeType() ), RTL_TEXTENCODING_UTF8 );
1137 mType.Erase( 0, 13 ); // "com.sun.star." entfernen
1138 sal_uInt16 nPos = mType.Search( (const char*)"Shape" );
1139 mType.Erase( nPos, 5 );
1140
1141 mbPresObj = mbEmptyPresObj = sal_False;
1142 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "IsPresentationObject" ) ) ) )
1143 mAny >>= mbPresObj;
1144
1145 if ( mbPresObj && ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "IsEmptyPresentationObject" ) ) ) )
1146 mAny >>= mbEmptyPresObj;
1147
1148 mnAngle = ( PropValue::GetPropertyValue( aAny,
1149 mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "RotateAngle" ) ), sal_True ) )
1150 ? *((sal_Int32*)aAny.getValue() )
1151 : 0;
1152
1153 return sal_True;
1154 }
1155 return sal_False;
1156 }
1157
1158 // -----------------------------------------------------------------------
1159
ImplGetMasterIndex(PageType ePageType)1160 sal_uInt32 PPTWriter::ImplGetMasterIndex( PageType ePageType )
1161 {
1162 sal_uInt32 nRetValue = 0;
1163 ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XMasterPageTarget >
1164 aXMasterPageTarget( mXDrawPage, ::com::sun::star::uno::UNO_QUERY );
1165
1166 if ( aXMasterPageTarget.is() )
1167 {
1168 ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XDrawPage >
1169 aXDrawPage = aXMasterPageTarget->getMasterPage();
1170 if ( aXDrawPage.is() )
1171 {
1172 ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >
1173 aXPropertySet( aXDrawPage, ::com::sun::star::uno::UNO_QUERY );
1174
1175 if ( aXPropertySet.is() )
1176 {
1177 if ( ImplGetPropertyValue( aXPropertySet, String( RTL_CONSTASCII_USTRINGPARAM( "Number" ) ) ) )
1178 nRetValue |= *(sal_Int16*)mAny.getValue();
1179 if ( nRetValue & 0xffff ) // ueberlauf vermeiden
1180 nRetValue--;
1181 }
1182 }
1183 }
1184 if ( ePageType == NOTICE )
1185 nRetValue += mnMasterPages;
1186 return nRetValue;
1187 }
1188
1189 // -----------------------------------------------------------------------
1190
ImplGetStyleSheets()1191 sal_Bool PPTWriter::ImplGetStyleSheets()
1192 {
1193 int nInstance, nLevel;
1194 sal_Bool bRetValue = sal_False;
1195 sal_uInt32 nPageNum;
1196
1197 for ( nPageNum = 0; nPageNum < mnMasterPages; nPageNum++ )
1198 {
1199 ::com::sun::star::uno::Reference< ::com::sun::star::container::XNamed >
1200 aXNamed;
1201
1202 ::com::sun::star::uno::Reference< ::com::sun::star::container::XNameAccess >
1203 aXNameAccess;
1204
1205 ::com::sun::star::uno::Reference< ::com::sun::star::style::XStyleFamiliesSupplier >
1206 aXStyleFamiliesSupplier( mXModel, ::com::sun::star::uno::UNO_QUERY );
1207
1208 ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >
1209 aXPropSet( mXModel, ::com::sun::star::uno::UNO_QUERY );
1210
1211 sal_uInt16 nDefaultTab = ( aXPropSet.is() && ImplGetPropertyValue( aXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "TabStop" ) ) ) )
1212 ? (sal_uInt16)( *(sal_Int32*)mAny.getValue() / 4.40972 )
1213 : 1250;
1214
1215 maStyleSheetList.push_back( new PPTExStyleSheet( nDefaultTab, (PPTExBulletProvider&)*this ) );
1216 ImplSetCurrentStyleSheet( nPageNum );
1217 if ( ImplGetPageByIndex( nPageNum, MASTER ) )
1218 aXNamed = ::com::sun::star::uno::Reference< ::com::sun::star::container::XNamed >
1219 ( mXDrawPage, ::com::sun::star::uno::UNO_QUERY );
1220
1221 if ( aXStyleFamiliesSupplier.is() )
1222 aXNameAccess = aXStyleFamiliesSupplier->getStyleFamilies();
1223
1224 bRetValue = aXNamed.is() && aXNameAccess.is() && aXStyleFamiliesSupplier.is();
1225 if ( bRetValue )
1226 {
1227 for ( nInstance = EPP_TEXTTYPE_Title; nInstance <= EPP_TEXTTYPE_CenterTitle; nInstance++ )
1228 {
1229 String aStyle;
1230 String aFamily;
1231 switch ( nInstance )
1232 {
1233 case EPP_TEXTTYPE_CenterTitle :
1234 case EPP_TEXTTYPE_Title :
1235 {
1236 aStyle = String( RTL_CONSTASCII_USTRINGPARAM( "title" ) );
1237 aFamily = aXNamed->getName();
1238 }
1239 break;
1240 case EPP_TEXTTYPE_Body :
1241 {
1242 aStyle = String( RTL_CONSTASCII_USTRINGPARAM( "outline1" ) ); // SD_LT_SEPARATOR
1243 aFamily = aXNamed->getName();
1244 }
1245 break;
1246 case EPP_TEXTTYPE_Other :
1247 {
1248 aStyle = String( RTL_CONSTASCII_USTRINGPARAM( "standard" ) );
1249 aFamily = String( RTL_CONSTASCII_USTRINGPARAM( "graphics" ) );
1250 }
1251 break;
1252 case EPP_TEXTTYPE_CenterBody :
1253 {
1254 aStyle = String( RTL_CONSTASCII_USTRINGPARAM( "subtitle" ) );
1255 aFamily = aXNamed->getName();
1256 }
1257 break;
1258 }
1259 if ( aStyle.Len() && aFamily.Len() )
1260 {
1261 try
1262 {
1263 ::com::sun::star::uno::Reference< ::com::sun::star::container::XNameAccess >xNameAccess;
1264 if ( aXNameAccess->hasByName( aFamily ) )
1265 {
1266 ::com::sun::star::uno::Any aAny( aXNameAccess->getByName( aFamily ) );
1267 if( aAny.getValue() && ::cppu::extractInterface( xNameAccess, aAny ) )
1268 {
1269 ::com::sun::star::uno::Reference< ::com::sun::star::container::XNameAccess > aXFamily;
1270 if ( aAny >>= aXFamily )
1271 {
1272 if ( aXFamily->hasByName( aStyle ) )
1273 {
1274 ::com::sun::star::uno::Reference< ::com::sun::star::style::XStyle > xStyle;
1275 aAny = aXFamily->getByName( aStyle );
1276 if( aAny.getValue() && ::cppu::extractInterface( xStyle, aAny ) )
1277 {
1278 ::com::sun::star::uno::Reference< ::com::sun::star::style::XStyle > aXStyle;
1279 aAny >>= aXStyle;
1280 ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >
1281 xPropSet( aXStyle, ::com::sun::star::uno::UNO_QUERY );
1282 if( xPropSet.is() )
1283 mpStyleSheet->SetStyleSheet( xPropSet, maFontCollection, nInstance, 0 );
1284 for ( nLevel = 1; nLevel < 5; nLevel++ )
1285 {
1286 if ( nInstance == EPP_TEXTTYPE_Body )
1287 {
1288 sal_Unicode cTemp = aStyle.GetChar( aStyle.Len() - 1 );
1289 aStyle.SetChar( aStyle.Len() - 1, ++cTemp );
1290 if ( aXFamily->hasByName( aStyle ) )
1291 {
1292 aXFamily->getByName( aStyle ) >>= xStyle;
1293 if( xStyle.is() )
1294 {
1295 ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >
1296 xPropertySet( xStyle, ::com::sun::star::uno::UNO_QUERY );
1297 if ( xPropertySet.is() )
1298 mpStyleSheet->SetStyleSheet( xPropertySet, maFontCollection, nInstance, nLevel );
1299 }
1300 }
1301 }
1302 else
1303 mpStyleSheet->SetStyleSheet( xPropSet, maFontCollection, nInstance, nLevel );
1304 }
1305 }
1306 }
1307 }
1308 }
1309 }
1310 }
1311 catch( ::com::sun::star::uno::Exception& )
1312 {
1313 //
1314 }
1315 }
1316 }
1317 for ( ; nInstance <= EPP_TEXTTYPE_QuarterBody; nInstance++ )
1318 {
1319
1320 }
1321 }
1322 }
1323 return bRetValue;
1324 }
1325
1326 // -----------------------------------------------------------------------
1327
ImplWriteParagraphs(SvStream & rOut,TextObj & rTextObj)1328 void PPTWriter::ImplWriteParagraphs( SvStream& rOut, TextObj& rTextObj )
1329 {
1330 sal_Bool bFirstParagraph = sal_True;
1331 sal_uInt32 nCharCount;
1332 sal_uInt32 nPropertyFlags = 0;
1333 sal_uInt16 nDepth = 0;
1334 sal_Int16 nLineSpacing;
1335 int nInstance = rTextObj.GetInstance();
1336
1337 for ( ParagraphObj* pPara = rTextObj.First() ; pPara; pPara = rTextObj.Next(), bFirstParagraph = sal_False )
1338 {
1339 PortionObj* pPortion = (PortionObj*)pPara->First();
1340 nCharCount = pPara->Count();
1341
1342 nDepth = pPara->nDepth;
1343 if ( nDepth > 4)
1344 nDepth = 4;
1345
1346 if ( ( pPara->meTextAdjust == ::com::sun::star::beans::PropertyState_DIRECT_VALUE ) ||
1347 ( mpStyleSheet->IsHardAttribute( nInstance, pPara->nDepth, ParaAttr_Adjust, pPara->mnTextAdjust ) ) )
1348 nPropertyFlags |= 0x00000800;
1349 nLineSpacing = pPara->mnLineSpacing;
1350
1351 const FontCollectionEntry* pDesc = maFontCollection.GetById( pPortion->mnFont );
1352 sal_Int16 nNormalSpacing = 100;
1353 if ( !mbFontIndependentLineSpacing && pDesc )
1354 {
1355 double fN = 100.0;
1356 fN *= pDesc->Scaling;
1357 nNormalSpacing = (sal_Int16)( fN + 0.5 );
1358 }
1359 if ( !mbFontIndependentLineSpacing && bFirstParagraph && ( nLineSpacing > nNormalSpacing ) ) // sj: i28747, no replacement for fixed linespacing
1360 {
1361 nLineSpacing = nNormalSpacing;
1362 nPropertyFlags |= 0x00001000;
1363 }
1364 else
1365 {
1366 if ( nLineSpacing > 0 )
1367 {
1368 if ( !mbFontIndependentLineSpacing && pDesc )
1369 nLineSpacing = (sal_Int16)( (double)nLineSpacing * pDesc->Scaling + 0.5 );
1370 }
1371 else
1372 {
1373 if ( pPortion && pPortion->mnCharHeight > (sal_uInt16)( ((double)-nLineSpacing) * 0.001 * 72.0 / 2.54 ) ) // 1/100mm to point
1374 nLineSpacing = nNormalSpacing;
1375 else
1376 nLineSpacing = (sal_Int16)( (double)nLineSpacing / 4.40972 );
1377 }
1378 if ( ( pPara->meLineSpacing == ::com::sun::star::beans::PropertyState_DIRECT_VALUE ) ||
1379 ( mpStyleSheet->IsHardAttribute( nInstance, pPara->nDepth, ParaAttr_LineFeed, nLineSpacing ) ) )
1380 nPropertyFlags |= 0x00001000;
1381 }
1382 if ( ( pPara->meLineSpacingTop == ::com::sun::star::beans::PropertyState_DIRECT_VALUE ) ||
1383 ( mpStyleSheet->IsHardAttribute( nInstance, pPara->nDepth, ParaAttr_UpperDist, pPara->mnLineSpacingTop ) ) )
1384 nPropertyFlags |= 0x00002000;
1385 if ( ( pPara->meLineSpacingBottom == ::com::sun::star::beans::PropertyState_DIRECT_VALUE ) ||
1386 ( mpStyleSheet->IsHardAttribute( nInstance, pPara->nDepth, ParaAttr_LowerDist, pPara->mnLineSpacingBottom ) ) )
1387 nPropertyFlags |= 0x00004000;
1388 if ( ( pPara->meForbiddenRules == ::com::sun::star::beans::PropertyState_DIRECT_VALUE ) ||
1389 ( mpStyleSheet->IsHardAttribute( nInstance, pPara->nDepth, ParaAttr_UpperDist, pPara->mbForbiddenRules ) ) )
1390 nPropertyFlags |= 0x00020000;
1391 if ( ( pPara->meParagraphPunctation == ::com::sun::star::beans::PropertyState_DIRECT_VALUE ) ||
1392 ( mpStyleSheet->IsHardAttribute( nInstance, pPara->nDepth, ParaAttr_UpperDist, pPara->mbParagraphPunctation ) ) )
1393 nPropertyFlags |= 0x00080000;
1394 if ( ( pPara->meBiDi == ::com::sun::star::beans::PropertyState_DIRECT_VALUE ) ||
1395 ( mpStyleSheet->IsHardAttribute( nInstance, nDepth, ParaAttr_BiDi, pPara->mnBiDi ) ) )
1396 nPropertyFlags |= 0x00200000;
1397
1398
1399 sal_Int32 nBuRealSize = pPara->nBulletRealSize;
1400 sal_Int16 nBulletFlags = pPara->nBulletFlags;
1401
1402 if ( pPara->bExtendedParameters )
1403 nPropertyFlags |= pPara->nParaFlags;
1404 else
1405 {
1406 nPropertyFlags |= 1; // turn off bullet explicit
1407 nBulletFlags = 0;
1408 }
1409
1410 // Write nTextOfs and nBullets
1411 if ( mpStyleSheet->IsHardAttribute( nInstance, nDepth, ParaAttr_TextOfs, pPara->nTextOfs ) )
1412 nPropertyFlags |= 0x100;
1413 if ( mpStyleSheet->IsHardAttribute( nInstance, nDepth, ParaAttr_BulletOfs, pPara->nBulletOfs ))
1414 nPropertyFlags |= 0x400;
1415
1416 FontCollectionEntry aFontDescEntry( pPara->aFontDesc.Name, pPara->aFontDesc.Family, pPara->aFontDesc.Pitch, pPara->aFontDesc.CharSet );
1417 sal_uInt16 nFontId = (sal_uInt16)maFontCollection.GetId( aFontDescEntry );
1418
1419 rOut << nCharCount
1420 << nDepth // Level
1421 << (sal_uInt32)nPropertyFlags; // Paragraph Attribut Set
1422
1423 if ( nPropertyFlags & 0xf )
1424 rOut << nBulletFlags;
1425 if ( nPropertyFlags & 0x80 )
1426 rOut << (sal_uInt16)( pPara->cBulletId );
1427 if ( nPropertyFlags & 0x10 )
1428 rOut << nFontId;
1429 if ( nPropertyFlags & 0x40 )
1430 rOut << (sal_Int16)nBuRealSize;
1431 if ( nPropertyFlags & 0x20 )
1432 {
1433 sal_uInt32 nBulletColor = pPara->nBulletColor;
1434 if ( nBulletColor == COL_AUTO )
1435 {
1436 sal_Bool bIsDark = sal_False;
1437 ::com::sun::star::uno::Any aAny;
1438 if ( PropValue::GetPropertyValue( aAny, mXPagePropSet, String( RTL_CONSTASCII_USTRINGPARAM( "IsBackgroundDark" ) ), sal_True ) )
1439 aAny >>= bIsDark;
1440 nBulletColor = bIsDark ? 0xffffff : 0x000000;
1441 }
1442 nBulletColor &= 0xffffff;
1443 nBulletColor |= 0xfe000000;
1444 rOut << nBulletColor;
1445 }
1446 if ( nPropertyFlags & 0x00000800 )
1447 rOut << (sal_uInt16)( pPara->mnTextAdjust );
1448 if ( nPropertyFlags & 0x00001000 )
1449 rOut << (sal_uInt16)( nLineSpacing );
1450 if ( nPropertyFlags & 0x00002000 )
1451 rOut << (sal_uInt16)( pPara->mnLineSpacingTop );
1452 if ( nPropertyFlags & 0x00004000 )
1453 rOut << (sal_uInt16)( pPara->mnLineSpacingBottom );
1454 if ( nPropertyFlags & 0x100 )
1455 rOut << (sal_uInt16)(pPara->nTextOfs);
1456 if ( nPropertyFlags & 0x400 )
1457 rOut << (sal_uInt16)(pPara->nBulletOfs);
1458 if ( nPropertyFlags & 0x000e0000 )
1459 {
1460 sal_uInt16 nAsianSettings = 0;
1461 if ( pPara->mbForbiddenRules )
1462 nAsianSettings |= 1;
1463 if ( pPara->mbParagraphPunctation )
1464 nAsianSettings |= 4;
1465 rOut << nAsianSettings;
1466 }
1467 if ( nPropertyFlags & 0x200000 )
1468 rOut << pPara->mnBiDi;
1469 }
1470 }
1471
1472 // -----------------------------------------------------------------------
1473
ImplWritePortions(SvStream & rOut,TextObj & rTextObj)1474 void PPTWriter::ImplWritePortions( SvStream& rOut, TextObj& rTextObj )
1475 {
1476 sal_uInt32 nPropertyFlags, i = 0;
1477 int nInstance = rTextObj.GetInstance();
1478
1479 for ( ParagraphObj* pPara = rTextObj.First(); pPara; pPara = rTextObj.Next(), i++ )
1480 {
1481 for ( PortionObj* pPortion = (PortionObj*)pPara->First(); pPortion; pPortion = (PortionObj*)pPara->Next() )
1482 {
1483 nPropertyFlags = 0;
1484 sal_uInt32 nCharAttr = pPortion->mnCharAttr;
1485 sal_uInt32 nCharColor = pPortion->mnCharColor;
1486
1487 if ( nCharColor == COL_AUTO ) // nCharColor depends to the background color
1488 {
1489 sal_Bool bIsDark = sal_False;
1490 ::com::sun::star::uno::Any aAny;
1491 if ( PropValue::GetPropertyValue( aAny, mXPagePropSet, String( RTL_CONSTASCII_USTRINGPARAM( "IsBackgroundDark" ) ), sal_True ) )
1492 aAny >>= bIsDark;
1493 nCharColor = bIsDark ? 0xffffff : 0x000000;
1494 }
1495
1496 nCharColor &= 0xffffff;
1497
1498 /* the portion is using the embossed or engraved attribute, which we want to map to the relief feature of PPT.
1499 Because the relief feature of PPT is dependent to the background color, such a mapping can not always be used. */
1500 if ( nCharAttr & 0x200 )
1501 {
1502 sal_uInt32 nBackgroundColor = 0xffffff;
1503
1504 if ( !nCharColor ) // special threatment for
1505 nCharColor = 0xffffff; // black fontcolor
1506
1507 ::com::sun::star::uno::Any aAny;
1508 ::com::sun::star::drawing::FillStyle aFS( ::com::sun::star::drawing::FillStyle_NONE );
1509 if ( PropValue::GetPropertyValue( aAny, mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "FillStyle" ) ) ) )
1510 aAny >>= aFS;
1511 switch( aFS )
1512 {
1513 case ::com::sun::star::drawing::FillStyle_GRADIENT :
1514 {
1515 Point aEmptyPoint = Point();
1516 Rectangle aRect( aEmptyPoint, Size( 28000, 21000 ) );
1517 EscherPropertyContainer aPropOpt( mpPptEscherEx->GetGraphicProvider(), mpPicStrm, aRect );
1518 aPropOpt.CreateGradientProperties( mXPropSet );
1519 aPropOpt.GetOpt( ESCHER_Prop_fillColor, nBackgroundColor );
1520 }
1521 break;
1522 case ::com::sun::star::drawing::FillStyle_SOLID :
1523 {
1524 if ( PropValue::GetPropertyValue( aAny, mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "FillColor" ) ) ) )
1525 nBackgroundColor = mpPptEscherEx->GetColor( *((sal_uInt32*)aAny.getValue()) );
1526 }
1527 break;
1528 case ::com::sun::star::drawing::FillStyle_NONE :
1529 {
1530 ::com::sun::star::uno::Any aBackAny;
1531 ::com::sun::star::drawing::FillStyle aBackFS( ::com::sun::star::drawing::FillStyle_NONE );
1532 if ( PropValue::GetPropertyValue( aBackAny, mXBackgroundPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "FillStyle" ) ) ) )
1533 aBackAny >>= aBackFS;
1534 switch( aBackFS )
1535 {
1536 case ::com::sun::star::drawing::FillStyle_GRADIENT :
1537 {
1538 Point aEmptyPoint = Point();
1539 Rectangle aRect( aEmptyPoint, Size( 28000, 21000 ) );
1540 EscherPropertyContainer aPropOpt( mpPptEscherEx->GetGraphicProvider(), mpPicStrm, aRect );
1541 aPropOpt.CreateGradientProperties( mXBackgroundPropSet );
1542 aPropOpt.GetOpt( ESCHER_Prop_fillColor, nBackgroundColor );
1543 }
1544 break;
1545 case ::com::sun::star::drawing::FillStyle_SOLID :
1546 {
1547 if ( PropValue::GetPropertyValue( aAny, mXBackgroundPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "FillColor" ) ) ) )
1548 nBackgroundColor = mpPptEscherEx->GetColor( *((sal_uInt32*)aAny.getValue()) );
1549 }
1550 break;
1551 default:
1552 break;
1553 }
1554 }
1555 break;
1556 default:
1557 break;
1558 }
1559
1560 sal_Int32 nB = nBackgroundColor & 0xff;
1561 nB += (sal_uInt8)( nBackgroundColor >> 8 );
1562 nB += (sal_uInt8)( nBackgroundColor >> 16 );
1563 // if the background color is nearly black, relief can't been used, because the text would not be visible
1564 if ( nB < 0x60 || ( nBackgroundColor != nCharColor ) )
1565 {
1566 nCharAttr &=~ 0x200;
1567
1568 // now check if the text is part of a group, and if the previous object has the same color than the fontcolor
1569 // ( and if fillcolor is not available the background color ), it is sometimes
1570 // not possible to export the 'embossed' flag
1571 if ( ( GetCurrentGroupLevel() > 0 ) && ( GetCurrentGroupIndex() >= 1 ) )
1572 {
1573 ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XShape > aGroupedShape( GetCurrentGroupAccess()->getByIndex( GetCurrentGroupIndex() - 1 ), uno::UNO_QUERY );
1574 if( aGroupedShape.is() )
1575 {
1576 ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > aPropSetOfNextShape
1577 ( aGroupedShape, ::com::sun::star::uno::UNO_QUERY );
1578 if ( aPropSetOfNextShape.is() )
1579 {
1580 if ( PropValue::GetPropertyValue( aAny, aPropSetOfNextShape,
1581 String( RTL_CONSTASCII_USTRINGPARAM( "FillColor" ) ), sal_True ) )
1582 {
1583 if ( nCharColor == mpPptEscherEx->GetColor( *((sal_uInt32*)aAny.getValue()) ) )
1584 {
1585 nCharAttr |= 0x200;
1586 }
1587 }
1588 }
1589 }
1590 }
1591 }
1592 }
1593 nCharColor |= 0xfe000000;
1594 if ( nInstance == 4 ) // special handling for normal textobjects:
1595 nPropertyFlags |= nCharAttr & 0x217; // not all attributes ar inherited
1596 else
1597 {
1598 if ( /* ( pPortion->mnCharAttrHard & 1 ) || */
1599 ( mpStyleSheet->IsHardAttribute( nInstance, pPara->nDepth, CharAttr_Bold, nCharAttr ) ) )
1600 nPropertyFlags |= 1;
1601 if ( /* ( pPortion->mnCharAttrHard & 2 ) || */
1602 ( mpStyleSheet->IsHardAttribute( nInstance, pPara->nDepth, CharAttr_Italic, nCharAttr ) ) )
1603 nPropertyFlags |= 2;
1604 if ( /* ( pPortion->mnCharAttrHard & 4 ) || */
1605 ( mpStyleSheet->IsHardAttribute( nInstance, pPara->nDepth, CharAttr_Underline, nCharAttr ) ) )
1606 nPropertyFlags |= 4;
1607 if ( /* ( pPortion->mnCharAttrHard & 0x10 ) || */
1608 ( mpStyleSheet->IsHardAttribute( nInstance, pPara->nDepth, CharAttr_Shadow, nCharAttr ) ) )
1609 nPropertyFlags |= 0x10;
1610 if ( /* ( pPortion->mnCharAttrHard & 0x200 ) || */
1611 ( mpStyleSheet->IsHardAttribute( nInstance, pPara->nDepth, CharAttr_Embossed, nCharAttr ) ) )
1612 nPropertyFlags |= 512;
1613 }
1614 if ( rTextObj.HasExtendedBullets() )
1615 {
1616 nPropertyFlags |= ( i & 0x3f ) << 10 ;
1617 nCharAttr |= ( i & 0x3f ) << 10;
1618 }
1619 if ( ( pPortion->meFontName == ::com::sun::star::beans::PropertyState_DIRECT_VALUE ) ||
1620 ( mpStyleSheet->IsHardAttribute( nInstance, pPara->nDepth, CharAttr_Font, pPortion->mnFont ) ) )
1621 nPropertyFlags |= 0x00010000;
1622 if ( ( pPortion->meAsianOrComplexFont == ::com::sun::star::beans::PropertyState_DIRECT_VALUE ) ||
1623 ( mpStyleSheet->IsHardAttribute( nInstance, pPara->nDepth, CharAttr_AsianOrComplexFont, pPortion->mnAsianOrComplexFont ) ) )
1624 nPropertyFlags |= 0x00200000;
1625 if ( ( pPortion->meCharHeight == ::com::sun::star::beans::PropertyState_DIRECT_VALUE ) ||
1626 ( mpStyleSheet->IsHardAttribute( nInstance, pPara->nDepth, CharAttr_FontHeight, pPortion->mnCharHeight ) ) )
1627 nPropertyFlags |= 0x00020000;
1628 if ( ( pPortion->meCharColor == ::com::sun::star::beans::PropertyState_DIRECT_VALUE ) ||
1629 ( mpStyleSheet->IsHardAttribute( nInstance, pPara->nDepth, CharAttr_FontColor, nCharColor & 0xffffff ) ) )
1630 nPropertyFlags |= 0x00040000;
1631 if ( ( pPortion->meCharEscapement == ::com::sun::star::beans::PropertyState_DIRECT_VALUE ) ||
1632 ( mpStyleSheet->IsHardAttribute( nInstance, pPara->nDepth, CharAttr_Escapement, pPortion->mnCharEscapement ) ) )
1633 nPropertyFlags |= 0x00080000;
1634
1635 sal_uInt32 nCharCount = pPortion->Count();
1636
1637 rOut << nCharCount
1638 << nPropertyFlags; //PropertyFlags
1639
1640 if ( nPropertyFlags & 0xffff )
1641 rOut << (sal_uInt16)( nCharAttr );
1642 if ( nPropertyFlags & 0x00010000 )
1643 rOut << pPortion->mnFont;
1644 if ( nPropertyFlags & 0x00200000 )
1645 rOut << pPortion->mnAsianOrComplexFont;
1646 if ( nPropertyFlags & 0x00020000 )
1647 rOut << (sal_uInt16)( pPortion->mnCharHeight );
1648 if ( nPropertyFlags & 0x00040000 )
1649 rOut << (sal_uInt32)nCharColor;
1650 if ( nPropertyFlags & 0x00080000 )
1651 rOut << pPortion->mnCharEscapement;
1652 }
1653 }
1654 }
1655
1656 // ----------------------------------------------------------------------------------------
1657 // laedt und konvertiert text aus shape, ergebnis ist mnTextSize gespeichert;
ImplGetText()1658 sal_Bool PPTWriter::ImplGetText()
1659 {
1660 mnTextSize = 0;
1661 mbFontIndependentLineSpacing = sal_False;
1662 mXText = ::com::sun::star::uno::Reference<
1663 ::com::sun::star::text::XSimpleText >
1664 ( mXShape, ::com::sun::star::uno::UNO_QUERY );
1665
1666 if ( mXText.is() )
1667 {
1668 mnTextSize = mXText->getString().getLength();
1669 ::com::sun::star::uno::Any aAny;
1670 if ( GetPropertyValue( aAny, mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "FontIndependentLineSpacing" ) ) ), sal_True )
1671 aAny >>= mbFontIndependentLineSpacing;
1672 }
1673 return ( mnTextSize != 0 );
1674 }
1675
1676 // -----------------------------------------------------------------------
1677
ImplFlipBoundingBox(EscherPropertyContainer & rPropOpt)1678 void PPTWriter::ImplFlipBoundingBox( EscherPropertyContainer& rPropOpt )
1679 {
1680 if ( mnAngle < 0 )
1681 mnAngle = ( 36000 + mnAngle ) % 36000;
1682 else
1683 mnAngle = ( 36000 - ( mnAngle % 36000 ) );
1684
1685 double fCos = cos( (double)mnAngle * F_PI18000 );
1686 double fSin = sin( (double)mnAngle * F_PI18000 );
1687
1688 double fWidthHalf = maRect.GetWidth() / 2;
1689 double fHeightHalf = maRect.GetHeight() / 2;
1690
1691 double fXDiff = fCos * fWidthHalf + fSin * (-fHeightHalf);
1692 double fYDiff = - ( fSin * fWidthHalf - fCos * ( -fHeightHalf ) );
1693
1694 maRect.Move( (sal_Int32)( -( fWidthHalf - fXDiff ) ), (sal_Int32)( - ( fHeightHalf + fYDiff ) ) );
1695 mnAngle *= 655;
1696 mnAngle += 0x8000;
1697 mnAngle &=~0xffff; // nAngle auf volle Gradzahl runden
1698 rPropOpt.AddOpt( ESCHER_Prop_Rotation, mnAngle );
1699
1700 if ( ( mnAngle >= ( 45 << 16 ) && mnAngle < ( 135 << 16 ) ) ||
1701 ( mnAngle >= ( 225 << 16 ) && mnAngle < ( 315 << 16 ) ) )
1702 {
1703 // In diesen beiden Bereichen steht in PPT gemeinerweise die
1704 // BoundingBox bereits senkrecht. Daher muss diese VOR
1705 // DER ROTATION flachgelegt werden.
1706 ::com::sun::star::awt::Point
1707 aTopLeft( (sal_Int32)( maRect.Left() + fWidthHalf - fHeightHalf ), (sal_Int32)( maRect.Top() + fHeightHalf - fWidthHalf ) );
1708 Size aNewSize( maRect.GetHeight(), maRect.GetWidth() );
1709 maRect = Rectangle( Point( aTopLeft.X, aTopLeft.Y ), aNewSize );
1710 }
1711 }
1712
1713 // -----------------------------------------------------------------------
1714
1715 struct FieldEntry
1716 {
1717 sal_uInt32 nFieldType;
1718 sal_uInt32 nFieldStartPos;
1719 sal_uInt32 nFieldEndPos;
1720 String aRepresentation;
1721 String aFieldUrl;
1722
FieldEntryFieldEntry1723 FieldEntry( sal_uInt32 nType, sal_uInt32 nStart, sal_uInt32 nEnd )
1724 {
1725 nFieldType = nType;
1726 nFieldStartPos = nStart;
1727 nFieldEndPos = nEnd;
1728 }
1729 };
1730
1731 // -----------------------------------------------------------------------
1732
PortionObj(const::com::sun::star::uno::Reference<::com::sun::star::beans::XPropertySet> & rXPropSet,FontCollection & rFontCollection)1733 PortionObj::PortionObj( const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > & rXPropSet,
1734 FontCollection& rFontCollection ) :
1735 mnCharAttrHard ( 0 ),
1736 mnCharAttr ( 0 ),
1737 mnFont ( 0 ),
1738 mnAsianOrComplexFont( 0xffff ),
1739 mnTextSize ( 0 ),
1740 mbLastPortion ( sal_True ),
1741 mpText ( NULL ),
1742 mpFieldEntry ( NULL )
1743 {
1744 mXPropSet = rXPropSet;
1745
1746 ImplGetPortionValues( rFontCollection, sal_False );
1747 }
1748
PortionObj(::com::sun::star::uno::Reference<::com::sun::star::text::XTextRange> & rXTextRange,sal_Bool bLast,FontCollection & rFontCollection)1749 PortionObj::PortionObj( ::com::sun::star::uno::Reference< ::com::sun::star::text::XTextRange > & rXTextRange,
1750 sal_Bool bLast, FontCollection& rFontCollection ) :
1751 mnCharAttrHard ( 0 ),
1752 mnCharAttr ( 0 ),
1753 mnFont ( 0 ),
1754 mnAsianOrComplexFont ( 0xffff ),
1755 mbLastPortion ( bLast ),
1756 mpText ( NULL ),
1757 mpFieldEntry ( NULL )
1758 {
1759 String aString( rXTextRange->getString() );
1760 String aURL;
1761 sal_Bool bRTL_endingParen = sal_False;
1762
1763 mnTextSize = aString.Len();
1764 if ( bLast )
1765 mnTextSize++;
1766
1767 if ( mnTextSize )
1768 {
1769 mpFieldEntry = NULL;
1770 sal_uInt32 nFieldType = 0;
1771
1772 mXPropSet = ::com::sun::star::uno::Reference<
1773 ::com::sun::star::beans::XPropertySet >
1774 ( rXTextRange, ::com::sun::star::uno::UNO_QUERY );
1775 mXPropState = ::com::sun::star::uno::Reference<
1776 ::com::sun::star::beans::XPropertyState >
1777 ( rXTextRange, ::com::sun::star::uno::UNO_QUERY );
1778
1779 sal_Bool bPropSetsValid = ( mXPropSet.is() && mXPropState.is() );
1780 if ( bPropSetsValid )
1781 nFieldType = ImplGetTextField( rXTextRange, mXPropSet, aURL );
1782 if ( nFieldType )
1783 {
1784 mpFieldEntry = new FieldEntry( nFieldType, 0, mnTextSize );
1785 if ( ( nFieldType >> 28 == 4 ) )
1786 {
1787 mpFieldEntry->aRepresentation = aString;
1788 mpFieldEntry->aFieldUrl = aURL;
1789 }
1790 }
1791 sal_Bool bSymbol = sal_False;
1792
1793 if ( bPropSetsValid && ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharFontCharSet" ) ), sal_False ) )
1794 {
1795 sal_Int16 nCharset;
1796 mAny >>= nCharset;
1797 if ( nCharset == ::com::sun::star::awt::CharSet::SYMBOL )
1798 bSymbol = sal_True;
1799 }
1800 if ( mpFieldEntry && ( nFieldType & 0x800000 ) ) // placeholder ?
1801 {
1802 mnTextSize = 1;
1803 if ( bLast )
1804 mnTextSize++;
1805 mpText = new sal_uInt16[ mnTextSize ];
1806 mpText[ 0 ] = 0x2a;
1807 }
1808 else
1809 {
1810 const sal_Unicode* pText = aString.GetBuffer();
1811 // For i39516 - a closing parenthesis that ends an RTL string is displayed backwards by PPT
1812 // Solution: add a Unicode Right-to-Left Mark, following the method described in i18024
1813 if ( bLast && pText[ aString.Len() - 1 ] == sal_Unicode(')') && rFontCollection.GetScriptDirection( aString ) == com::sun::star::i18n::ScriptDirection::RIGHT_TO_LEFT )
1814 {
1815 mnTextSize++;
1816 bRTL_endingParen = sal_True;
1817 }
1818 mpText = new sal_uInt16[ mnTextSize ];
1819 sal_uInt16 nChar;
1820 for ( int i = 0; i < aString.Len(); i++ )
1821 {
1822 nChar = (sal_uInt16)pText[ i ];
1823 if ( nChar == 0xa )
1824 nChar++;
1825 else if ( !bSymbol )
1826 {
1827 switch ( nChar )
1828 {
1829 // Currency
1830 case 128: nChar = 0x20AC; break;
1831 // Punctuation and other
1832 case 130: nChar = 0x201A; break;// SINGLE LOW-9 QUOTATION MARK
1833 case 131: nChar = 0x0192; break;// LATIN SMALL LETTER F WITH HOOK
1834 case 132: nChar = 0x201E; break;// DOUBLE LOW-9 QUOTATION MARK
1835 // LOW DOUBLE PRIME QUOTATION MARK
1836 case 133: nChar = 0x2026; break;// HORIZONTAL ELLIPSES
1837 case 134: nChar = 0x2020; break;// DAGGER
1838 case 135: nChar = 0x2021; break;// DOUBLE DAGGER
1839 case 136: nChar = 0x02C6; break;// MODIFIER LETTER CIRCUMFLEX ACCENT
1840 case 137: nChar = 0x2030; break;// PER MILLE SIGN
1841 case 138: nChar = 0x0160; break;// LATIN CAPITAL LETTER S WITH CARON
1842 case 139: nChar = 0x2039; break;// SINGLE LEFT-POINTING ANGLE QUOTATION MARK
1843 case 140: nChar = 0x0152; break;// LATIN CAPITAL LIGATURE OE
1844 case 142: nChar = 0x017D; break;// LATIN CAPITAL LETTER Z WITH CARON
1845 case 145: nChar = 0x2018; break;// LEFT SINGLE QUOTATION MARK
1846 // MODIFIER LETTER TURNED COMMA
1847 case 146: nChar = 0x2019; break;// RIGHT SINGLE QUOTATION MARK
1848 // MODIFIER LETTER APOSTROPHE
1849 case 147: nChar = 0x201C; break;// LEFT DOUBLE QUOTATION MARK
1850 // REVERSED DOUBLE PRIME QUOTATION MARK
1851 case 148: nChar = 0x201D; break;// RIGHT DOUBLE QUOTATION MARK
1852 // REVERSED DOUBLE PRIME QUOTATION MARK
1853 case 149: nChar = 0x2022; break;// BULLET
1854 case 150: nChar = 0x2013; break;// EN DASH
1855 case 151: nChar = 0x2014; break;// EM DASH
1856 case 152: nChar = 0x02DC; break;// SMALL TILDE
1857 case 153: nChar = 0x2122; break;// TRADE MARK SIGN
1858 case 154: nChar = 0x0161; break;// LATIN SMALL LETTER S WITH CARON
1859 case 155: nChar = 0x203A; break;// SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
1860 case 156: nChar = 0x0153; break;// LATIN SMALL LIGATURE OE
1861 case 158: nChar = 0x017E; break;// LATIN SMALL LETTER Z WITH CARON
1862 case 159: nChar = 0x0178; break;// LATIN CAPITAL LETTER Y WITH DIAERESIS
1863 // case 222: nChar = 0x00B6; break;// PILCROW SIGN / PARAGRAPH SIGN
1864 }
1865 }
1866 mpText[ i ] = nChar;
1867 }
1868 }
1869 if ( bRTL_endingParen )
1870 mpText[ mnTextSize - 2 ] = 0x200F; // Unicode Right-to-Left mark
1871
1872 if ( bLast )
1873 mpText[ mnTextSize - 1 ] = 0xd;
1874
1875 if ( bPropSetsValid )
1876 ImplGetPortionValues( rFontCollection, sal_True );
1877 }
1878 }
1879
PortionObj(const PortionObj & rPortionObj)1880 PortionObj::PortionObj( const PortionObj& rPortionObj )
1881 : PropStateValue( rPortionObj )
1882 {
1883 ImplConstruct( rPortionObj );
1884 }
1885
~PortionObj()1886 PortionObj::~PortionObj()
1887 {
1888 ImplClear();
1889 }
1890
Write(SvStream * pStrm,sal_Bool bLast)1891 void PortionObj::Write( SvStream* pStrm, sal_Bool bLast )
1892 {
1893 sal_uInt32 nCount = mnTextSize;
1894 if ( bLast && mbLastPortion )
1895 nCount--;
1896 for ( sal_uInt32 i = 0; i < nCount; i++ )
1897 *pStrm << (sal_uInt16)mpText[ i ];
1898 }
1899
ImplGetPortionValues(FontCollection & rFontCollection,sal_Bool bGetPropStateValue)1900 void PortionObj::ImplGetPortionValues( FontCollection& rFontCollection, sal_Bool bGetPropStateValue )
1901 {
1902
1903 sal_Bool bOk = ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharFontName" ) ), bGetPropStateValue );
1904 meFontName = ePropState;
1905 if ( bOk )
1906 {
1907 FontCollectionEntry aFontDesc( *(::rtl::OUString*)mAny.getValue() );
1908 sal_uInt32 nCount = rFontCollection.GetCount();
1909 mnFont = (sal_uInt16)rFontCollection.GetId( aFontDesc );
1910 if ( mnFont == nCount )
1911 {
1912 FontCollectionEntry& rFontDesc = rFontCollection.GetLast();
1913 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharFontCharSet" ) ), sal_False ) )
1914 mAny >>= rFontDesc.CharSet;
1915 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharFontFamily" ) ), sal_False ) )
1916 mAny >>= rFontDesc.Family;
1917 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharFontPitch" ) ), sal_False ) )
1918 mAny >>= rFontDesc.Pitch;
1919 }
1920 }
1921
1922 sal_Int16 nScriptType = SvtLanguageOptions::GetScriptTypeOfLanguage( Application::GetSettings().GetLanguage() );
1923 if ( mpText && mnTextSize && xPPTBreakIter.is() )
1924 {
1925 rtl::OUString sT( mpText, mnTextSize );
1926 nScriptType = xPPTBreakIter->getScriptType( sT, 0 );
1927 }
1928 if ( nScriptType != com::sun::star::i18n::ScriptType::COMPLEX )
1929 {
1930 bOk = ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharFontNameAsian" ) ), bGetPropStateValue );
1931 meAsianOrComplexFont = ePropState;
1932 if ( bOk )
1933 {
1934 FontCollectionEntry aFontDesc( *(::rtl::OUString*)mAny.getValue() );
1935 sal_uInt32 nCount = rFontCollection.GetCount();
1936 mnAsianOrComplexFont = (sal_uInt16)rFontCollection.GetId( aFontDesc );
1937 if ( mnAsianOrComplexFont == nCount )
1938 {
1939 FontCollectionEntry& rFontDesc = rFontCollection.GetLast();
1940 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharFontCharSetAsian" ) ), sal_False ) )
1941 mAny >>= rFontDesc.CharSet;
1942 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharFontFamilyAsian" ) ), sal_False ) )
1943 mAny >>= rFontDesc.Family;
1944 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharFontPitchAsian" ) ), sal_False ) )
1945 mAny >>= rFontDesc.Pitch;
1946 }
1947 }
1948 }
1949 else
1950 {
1951 bOk = ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharFontNameComplex" ) ), bGetPropStateValue );
1952 meAsianOrComplexFont = ePropState;
1953 if ( bOk )
1954 {
1955 FontCollectionEntry aFontDesc( *(::rtl::OUString*)mAny.getValue() );
1956 sal_uInt32 nCount = rFontCollection.GetCount();
1957 mnAsianOrComplexFont = (sal_uInt16)rFontCollection.GetId( aFontDesc );
1958 if ( mnAsianOrComplexFont == nCount )
1959 {
1960 FontCollectionEntry& rFontDesc = rFontCollection.GetLast();
1961 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharFontCharSetComplex" ) ), sal_False ) )
1962 mAny >>= rFontDesc.CharSet;
1963 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharFontFamilyComplex" ) ), sal_False ) )
1964 mAny >>= rFontDesc.Family;
1965 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharFontPitchComplex" ) ), sal_False ) )
1966 mAny >>= rFontDesc.Pitch;
1967 }
1968 }
1969 }
1970
1971 rtl::OUString aCharHeightName, aCharWeightName, aCharLocaleName, aCharPostureName;
1972 switch( nScriptType )
1973 {
1974 case com::sun::star::i18n::ScriptType::ASIAN :
1975 {
1976 aCharHeightName = String( RTL_CONSTASCII_USTRINGPARAM( "CharHeightAsian" ) );
1977 aCharWeightName = String( RTL_CONSTASCII_USTRINGPARAM( "CharWeightAsian" ) );
1978 aCharLocaleName = String( RTL_CONSTASCII_USTRINGPARAM( "CharLocaleAsian" ) );
1979 aCharPostureName = String( RTL_CONSTASCII_USTRINGPARAM( "CharPostureAsian" ) );
1980 break;
1981 }
1982 case com::sun::star::i18n::ScriptType::COMPLEX :
1983 {
1984 aCharHeightName = String( RTL_CONSTASCII_USTRINGPARAM( "CharHeightComplex" ) );
1985 aCharWeightName = String( RTL_CONSTASCII_USTRINGPARAM( "CharWeightComplex" ) );
1986 aCharLocaleName = String( RTL_CONSTASCII_USTRINGPARAM( "CharLocaleComplex" ) );
1987 aCharPostureName = String( RTL_CONSTASCII_USTRINGPARAM( "CharPostureComplex" ) );
1988 break;
1989 }
1990 default:
1991 {
1992 aCharHeightName = String( RTL_CONSTASCII_USTRINGPARAM( "CharHeight" ) );
1993 aCharWeightName = String( RTL_CONSTASCII_USTRINGPARAM( "CharWeight" ) );
1994 aCharLocaleName = String( RTL_CONSTASCII_USTRINGPARAM( "CharLocale" ) );
1995 aCharPostureName = String( RTL_CONSTASCII_USTRINGPARAM( "CharPosture" ) );
1996 break;
1997 }
1998 }
1999
2000 mnCharHeight = 24;
2001 if ( GetPropertyValue( mAny, mXPropSet, aCharHeightName, sal_False ) )
2002 {
2003 float fVal(0.0);
2004 if ( mAny >>= fVal )
2005 {
2006 mnCharHeight = (sal_uInt16)( fVal + 0.5 );
2007 meCharHeight = GetPropertyState( mXPropSet, aCharHeightName );
2008 }
2009 }
2010 if ( GetPropertyValue( mAny, mXPropSet, aCharWeightName, sal_False ) )
2011 {
2012 float fFloat(0.0);
2013 if ( mAny >>= fFloat )
2014 {
2015 if ( fFloat >= ::com::sun::star::awt::FontWeight::SEMIBOLD )
2016 mnCharAttr |= 1;
2017 if ( GetPropertyState( mXPropSet, aCharWeightName ) == ::com::sun::star::beans::PropertyState_DIRECT_VALUE )
2018 mnCharAttrHard |= 1;
2019 }
2020 }
2021 if ( GetPropertyValue( mAny, mXPropSet, aCharLocaleName, sal_False ) )
2022 {
2023 com::sun::star::lang::Locale eLocale;
2024 if ( mAny >>= eLocale )
2025 meCharLocale = eLocale;
2026 }
2027 if ( GetPropertyValue( mAny, mXPropSet, aCharPostureName, sal_False ) )
2028 {
2029 ::com::sun::star::awt::FontSlant aFS;
2030 if ( mAny >>= aFS )
2031 {
2032 switch( aFS )
2033 {
2034 case ::com::sun::star::awt::FontSlant_OBLIQUE :
2035 case ::com::sun::star::awt::FontSlant_ITALIC :
2036 mnCharAttr |= 2;
2037 break;
2038 default:
2039 break;
2040 }
2041 if ( GetPropertyState( mXPropSet, aCharPostureName ) == ::com::sun::star::beans::PropertyState_DIRECT_VALUE )
2042 mnCharAttrHard |= 2;
2043 }
2044 }
2045
2046 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharUnderline" ) ), bGetPropStateValue ) )
2047 {
2048 sal_Int16 nVal(0);
2049 mAny >>= nVal;
2050 switch ( nVal )
2051 {
2052 case ::com::sun::star::awt::FontUnderline::SINGLE :
2053 case ::com::sun::star::awt::FontUnderline::DOUBLE :
2054 case ::com::sun::star::awt::FontUnderline::DOTTED :
2055 mnCharAttr |= 4;
2056 }
2057 }
2058 if ( ePropState == ::com::sun::star::beans::PropertyState_DIRECT_VALUE )
2059 mnCharAttrHard |= 4;
2060
2061 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharShadowed" ) ), bGetPropStateValue ) )
2062 {
2063 sal_Bool bBool(sal_False);
2064 mAny >>= bBool;
2065 if ( bBool )
2066 mnCharAttr |= 0x10;
2067 }
2068 if ( ePropState == ::com::sun::star::beans::PropertyState_DIRECT_VALUE )
2069 mnCharAttrHard |= 16;
2070
2071 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharRelief" ) ), bGetPropStateValue ) )
2072 {
2073 sal_Int16 nVal(0);
2074 mAny >>= nVal;
2075 if ( nVal != ::com::sun::star::text::FontRelief::NONE )
2076 mnCharAttr |= 512;
2077 }
2078 if ( ePropState == ::com::sun::star::beans::PropertyState_DIRECT_VALUE )
2079 mnCharAttrHard |= 512;
2080
2081 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharColor" ) ), bGetPropStateValue ) )
2082 {
2083 sal_uInt32 nSOColor = *( (sal_uInt32*)mAny.getValue() );
2084 mnCharColor = nSOColor & 0xff00ff00; // green and hibyte
2085 mnCharColor |= (sal_uInt8)( nSOColor ) << 16; // red and blue is switched
2086 mnCharColor |= (sal_uInt8)( nSOColor >> 16 );
2087 }
2088 meCharColor = ePropState;
2089
2090 mnCharEscapement = 0;
2091 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharEscapement" ) ), bGetPropStateValue ) )
2092 {
2093 mAny >>= mnCharEscapement;
2094 if ( mnCharEscapement > 100 )
2095 mnCharEscapement = 33;
2096 else if ( mnCharEscapement < -100 )
2097 mnCharEscapement = -33;
2098 }
2099 meCharEscapement = ePropState;
2100 }
2101
ImplClear()2102 void PortionObj::ImplClear()
2103 {
2104 delete (FieldEntry*)mpFieldEntry;
2105 delete[] mpText;
2106 }
2107
ImplConstruct(const PortionObj & rPortionObj)2108 void PortionObj::ImplConstruct( const PortionObj& rPortionObj )
2109 {
2110 mbLastPortion = rPortionObj.mbLastPortion;
2111 mnTextSize = rPortionObj.mnTextSize;
2112 mnCharColor = rPortionObj.mnCharColor;
2113 mnCharEscapement = rPortionObj.mnCharEscapement;
2114 mnCharAttr = rPortionObj.mnCharAttr;
2115 mnCharHeight = rPortionObj.mnCharHeight;
2116 mnFont = rPortionObj.mnFont;
2117 mnAsianOrComplexFont = rPortionObj.mnAsianOrComplexFont;
2118
2119 if ( rPortionObj.mpText )
2120 {
2121 mpText = new sal_uInt16[ mnTextSize ];
2122 memcpy( mpText, rPortionObj.mpText, mnTextSize << 1 );
2123 }
2124 else
2125 mpText = NULL;
2126
2127 if ( rPortionObj.mpFieldEntry )
2128 mpFieldEntry = new FieldEntry( *( rPortionObj.mpFieldEntry ) );
2129 else
2130 mpFieldEntry = NULL;
2131 }
2132
ImplCalculateTextPositions(sal_uInt32 nCurrentTextPosition)2133 sal_uInt32 PortionObj::ImplCalculateTextPositions( sal_uInt32 nCurrentTextPosition )
2134 {
2135 if ( mpFieldEntry && ( !mpFieldEntry->nFieldStartPos ) )
2136 {
2137 mpFieldEntry->nFieldStartPos += nCurrentTextPosition;
2138 mpFieldEntry->nFieldEndPos += nCurrentTextPosition;
2139 }
2140 return mnTextSize;
2141 }
2142
2143 // -----------------------------------------------------------------------
2144 // Rueckgabe: 0 = kein TextField
2145 // bit28->31 text field type :
2146 // 1 = Date
2147 // 2 = Time
2148 // 3 = SlideNumber
2149 // 4 = Url
2150 // 5 = DateTime
2151 // 6 = header
2152 // 7 = footer
2153 // bit24->27 text field sub type (optional)
2154 // 23-> PPT Textfield needs a placeholder
2155
ImplGetTextField(::com::sun::star::uno::Reference<::com::sun::star::text::XTextRange> &,const::com::sun::star::uno::Reference<::com::sun::star::beans::XPropertySet> & rXPropSet,String & rURL)2156 sal_uInt32 PortionObj::ImplGetTextField( ::com::sun::star::uno::Reference< ::com::sun::star::text::XTextRange > & ,
2157 const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > & rXPropSet, String& rURL )
2158 {
2159 sal_uInt32 nRetValue = 0;
2160 sal_Int32 nFormat;
2161 ::com::sun::star::uno::Any aAny;
2162 if ( GetPropertyValue( aAny, rXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "TextPortionType" ) ), sal_True ) )
2163 {
2164 String aTextFieldType( *(::rtl::OUString*)aAny.getValue() );
2165 if ( aTextFieldType == String( RTL_CONSTASCII_USTRINGPARAM( "TextField" ) ) )
2166 {
2167 if ( GetPropertyValue( aAny, rXPropSet, aTextFieldType, sal_True ) )
2168 {
2169 ::com::sun::star::uno::Reference< ::com::sun::star::text::XTextField > aXTextField;
2170 if ( aAny >>= aXTextField )
2171 {
2172 if ( aXTextField.is() )
2173 {
2174 ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >
2175 xFieldPropSet( aXTextField, ::com::sun::star::uno::UNO_QUERY );
2176 if ( xFieldPropSet.is() )
2177 {
2178 String aFieldKind( aXTextField->getPresentation( sal_True ) );
2179 if ( aFieldKind == String( RTL_CONSTASCII_USTRINGPARAM( "Date" ) ) )
2180 {
2181 if ( GetPropertyValue( aAny, xFieldPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "IsFix" ) ) ), sal_True )
2182 {
2183 sal_Bool bBool;
2184 aAny >>= bBool;
2185 if ( !bBool ) // Fixed DateFields gibt es in PPT nicht
2186 {
2187 if ( GetPropertyValue( aAny, xFieldPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "Format" ) ) ), sal_True )
2188 {
2189 nFormat = *(sal_Int32*)aAny.getValue();
2190 switch ( nFormat )
2191 {
2192 default:
2193 case 5 :
2194 case 4 :
2195 case 2 : nFormat = 0; break;
2196 case 8 :
2197 case 9 :
2198 case 3 : nFormat = 1; break;
2199 case 7 :
2200 case 6 : nFormat = 2; break;
2201 }
2202 nRetValue |= ( ( ( 1 << 4 ) | nFormat ) << 24 ) | 0x800000;
2203 }
2204 }
2205 }
2206 }
2207 else if ( aFieldKind == String( RTL_CONSTASCII_USTRINGPARAM( "URL" ) ) )
2208 {
2209 if ( GetPropertyValue( aAny, xFieldPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "URL" ) ) ), sal_True )
2210 rURL = String( *(::rtl::OUString*)aAny.getValue() );
2211 nRetValue = 4 << 28;
2212 }
2213 else if ( aFieldKind == String( RTL_CONSTASCII_USTRINGPARAM( "Page" ) ) )
2214 {
2215 nRetValue = 3 << 28 | 0x800000;
2216 }
2217 else if ( aFieldKind == String( RTL_CONSTASCII_USTRINGPARAM( "Pages" ) ) )
2218 {
2219
2220 }
2221 else if ( aFieldKind == String( RTL_CONSTASCII_USTRINGPARAM( "Time" ) ) )
2222 {
2223 if ( GetPropertyValue( aAny, xFieldPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "IsFix" ) ) ), sal_True )
2224 {
2225 sal_Bool bBool;
2226 aAny >>= bBool;
2227 if ( !bBool )
2228 {
2229 if ( GetPropertyValue( aAny, xFieldPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "IsFix" ) ) ), sal_True )
2230 {
2231 nFormat = *(sal_Int32*)aAny.getValue();
2232 nRetValue |= ( ( ( 2 << 4 ) | nFormat ) << 24 ) | 0x800000;
2233 }
2234 }
2235 }
2236 }
2237 else if ( aFieldKind == String( RTL_CONSTASCII_USTRINGPARAM( "File" ) ) )
2238 {
2239
2240 }
2241 else if ( aFieldKind == String( RTL_CONSTASCII_USTRINGPARAM( "Table" ) ) )
2242 {
2243
2244 }
2245 else if ( aFieldKind == String( RTL_CONSTASCII_USTRINGPARAM( "ExtTime" ) ) )
2246 {
2247 if ( GetPropertyValue( aAny, xFieldPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "IsFix" ) ) ), sal_True )
2248 {
2249 sal_Bool bBool;
2250 aAny >>= bBool;
2251 if ( !bBool )
2252 {
2253 if ( GetPropertyValue( aAny, xFieldPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "Format" ) ) ), sal_True )
2254 {
2255 nFormat = *(sal_Int32*)aAny.getValue();
2256 switch ( nFormat )
2257 {
2258 default:
2259 case 6 :
2260 case 7 :
2261 case 8 :
2262 case 2 : nFormat = 12; break;
2263 case 3 : nFormat = 9; break;
2264 case 5 :
2265 case 4 : nFormat = 10; break;
2266
2267 }
2268 nRetValue |= ( ( ( 2 << 4 ) | nFormat ) << 24 ) | 0x800000;
2269 }
2270 }
2271 }
2272 }
2273 else if ( aFieldKind == String( RTL_CONSTASCII_USTRINGPARAM( "ExtFile" ) ) )
2274 {
2275
2276 }
2277 else if ( aFieldKind == String( RTL_CONSTASCII_USTRINGPARAM( "Author" ) ) )
2278 {
2279
2280 }
2281 else if ( aFieldKind == String( RTL_CONSTASCII_USTRINGPARAM( "DateTime" ) ) )
2282 {
2283 nRetValue = 5 << 28 | 0x800000;
2284 }
2285 else if ( aFieldKind == String( RTL_CONSTASCII_USTRINGPARAM( "Header" ) ) )
2286 {
2287 nRetValue = 6 << 28 | 0x800000;
2288 }
2289 else if ( aFieldKind == String( RTL_CONSTASCII_USTRINGPARAM( "Footer" ) ) )
2290 {
2291 nRetValue = 7 << 28 | 0x800000;
2292 }
2293 }
2294 }
2295 }
2296 }
2297 }
2298 }
2299 return nRetValue;
2300 }
2301
operator =(const PortionObj & rPortionObj)2302 PortionObj& PortionObj::operator=( const PortionObj& rPortionObj )
2303 {
2304 if ( this != &rPortionObj )
2305 {
2306 ImplClear();
2307 ImplConstruct( rPortionObj );
2308 }
2309 return *this;
2310 }
2311
2312 // -----------------------------------------------------------------------
2313
ParagraphObj(const::com::sun::star::uno::Reference<::com::sun::star::beans::XPropertySet> & rXPropSet,PPTExBulletProvider & rProv)2314 ParagraphObj::ParagraphObj( const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > & rXPropSet,
2315 PPTExBulletProvider& rProv ) :
2316 maMapModeSrc ( MAP_100TH_MM ),
2317 maMapModeDest ( MAP_INCH, Point(), Fraction( 1, 576 ), Fraction( 1, 576 ) )
2318 {
2319 mXPropSet = rXPropSet;
2320
2321 bExtendedParameters = sal_False;
2322
2323 nDepth = 0;
2324 nBulletFlags = 0;
2325 nParaFlags = 0;
2326
2327 ImplGetParagraphValues( rProv, sal_False );
2328 }
2329
ParagraphObj(::com::sun::star::uno::Reference<::com::sun::star::text::XTextContent> & rXTextContent,ParaFlags aParaFlags,FontCollection & rFontCollection,PPTExBulletProvider & rProv)2330 ParagraphObj::ParagraphObj( ::com::sun::star::uno::Reference< ::com::sun::star::text::XTextContent > & rXTextContent,
2331 ParaFlags aParaFlags, FontCollection& rFontCollection, PPTExBulletProvider& rProv ) :
2332 maMapModeSrc ( MAP_100TH_MM ),
2333 maMapModeDest ( MAP_INCH, Point(), Fraction( 1, 576 ), Fraction( 1, 576 ) ),
2334 mbFirstParagraph ( aParaFlags.bFirstParagraph ),
2335 mbLastParagraph ( aParaFlags.bLastParagraph )
2336 {
2337 bExtendedParameters = sal_False;
2338
2339 nDepth = 0;
2340 nBulletFlags = 0;
2341 nParaFlags = 0;
2342
2343 mXPropSet = ::com::sun::star::uno::Reference<
2344 ::com::sun::star::beans::XPropertySet >
2345 ( rXTextContent, ::com::sun::star::uno::UNO_QUERY );
2346
2347 mXPropState = ::com::sun::star::uno::Reference<
2348 ::com::sun::star::beans::XPropertyState >
2349 ( rXTextContent, ::com::sun::star::uno::UNO_QUERY );
2350
2351 if ( mXPropSet.is() && mXPropState.is() )
2352 {
2353 ::com::sun::star::uno::Reference< ::com::sun::star::container::XEnumerationAccess >
2354 aXTextPortionEA( rXTextContent, ::com::sun::star::uno::UNO_QUERY );
2355 if ( aXTextPortionEA.is() )
2356 {
2357 ::com::sun::star::uno::Reference< ::com::sun::star::container::XEnumeration >
2358 aXTextPortionE( aXTextPortionEA->createEnumeration() );
2359 if ( aXTextPortionE.is() )
2360 {
2361 while ( aXTextPortionE->hasMoreElements() )
2362 {
2363 ::com::sun::star::uno::Reference< ::com::sun::star::text::XTextRange > aXCursorText;
2364 ::com::sun::star::uno::Any aAny( aXTextPortionE->nextElement() );
2365 if ( aAny >>= aXCursorText )
2366 {
2367 PortionObj* pPortionObj = new PortionObj( aXCursorText, !aXTextPortionE->hasMoreElements(), rFontCollection );
2368 if ( pPortionObj->Count() )
2369 Insert( pPortionObj, LIST_APPEND );
2370 else
2371 delete pPortionObj;
2372 }
2373 }
2374 }
2375 }
2376 ImplGetParagraphValues( rProv, sal_True );//
2377 }
2378 }
2379
ParagraphObj(const ParagraphObj & rObj)2380 ParagraphObj::ParagraphObj( const ParagraphObj& rObj )
2381 : List()
2382 , PropStateValue()
2383 , SOParagraph()
2384 {
2385 ImplConstruct( rObj );
2386 }
2387
~ParagraphObj()2388 ParagraphObj::~ParagraphObj()
2389 {
2390 ImplClear();
2391 }
2392
Write(SvStream * pStrm)2393 void ParagraphObj::Write( SvStream* pStrm )
2394 {
2395 for ( void* pPtr = First(); pPtr; pPtr = Next() )
2396 ((PortionObj*)pPtr)->Write( pStrm, mbLastParagraph );
2397 }
2398
ImplClear()2399 void ParagraphObj::ImplClear()
2400 {
2401 for ( void* pPtr = First(); pPtr; pPtr = Next() )
2402 delete (PortionObj*)pPtr;
2403 }
2404
CalculateGraphicBulletSize(sal_uInt16 nFontHeight)2405 void ParagraphObj::CalculateGraphicBulletSize( sal_uInt16 nFontHeight )
2406 {
2407 if ( ( (SvxExtNumType)nNumberingType == SVX_NUM_BITMAP ) && ( nBulletId != 0xffff ) )
2408 {
2409 // calculate the bulletrealsize for this grafik
2410 if ( aBuGraSize.Width() && aBuGraSize.Height() )
2411 {
2412 double fCharHeight = nFontHeight;
2413 double fLen = aBuGraSize.Height();
2414 fCharHeight = fCharHeight * 0.2540;
2415 double fQuo = fLen / fCharHeight;
2416 nBulletRealSize = (sal_Int16)( fQuo + 0.5 );
2417 if ( (sal_uInt16)nBulletRealSize > 400 )
2418 nBulletRealSize = 400;
2419 }
2420 }
2421 }
2422
2423 // from sw/source/filter/ww8/wrtw8num.cxx for default bullets to export to MS intact
lcl_SubstituteBullet(String & rNumStr,rtl_TextEncoding & rChrSet,String & rFontName)2424 static void lcl_SubstituteBullet(String& rNumStr, rtl_TextEncoding& rChrSet, String& rFontName)
2425 {
2426 sal_Unicode cChar = rNumStr.GetChar(0);
2427 StarSymbolToMSMultiFont *pConvert = CreateStarSymbolToMSMultiFont();
2428 String sFont = pConvert->ConvertChar(cChar);
2429 delete pConvert;
2430 if (sFont.Len())
2431 {
2432 rNumStr = static_cast< sal_Unicode >(cChar | 0xF000);
2433 rFontName = sFont;
2434 rChrSet = RTL_TEXTENCODING_SYMBOL;
2435 }
2436 else if ( (rNumStr.GetChar(0) < 0xE000 || rNumStr.GetChar(0) > 0xF8FF) )
2437 {
2438 /*
2439 Ok we can't fit into a known windows unicode font, but
2440 we are not in the private area, so we are a
2441 standardized symbol, so turn off the symbol bit and
2442 let words own font substitution kick in
2443 */
2444 rChrSet = RTL_TEXTENCODING_UNICODE;
2445 rFontName = ::GetFontToken(rFontName, 0);
2446 }
2447 else
2448 {
2449 /*
2450 Well we don't have an available substition, and we're
2451 in our private area, so give up and show a standard
2452 bullet symbol
2453 */
2454 rFontName.AssignAscii(RTL_CONSTASCII_STRINGPARAM("Wingdings"));
2455 rNumStr = static_cast< sal_Unicode >(0x6C);
2456 }
2457 }
2458
ImplGetNumberingLevel(PPTExBulletProvider & rBuProv,sal_Int16 nNumberingDepth,sal_Bool bIsBullet,sal_Bool bGetPropStateValue)2459 void ParagraphObj::ImplGetNumberingLevel( PPTExBulletProvider& rBuProv, sal_Int16 nNumberingDepth, sal_Bool bIsBullet, sal_Bool bGetPropStateValue )
2460 {
2461 ::com::sun::star::uno::Any aAny;
2462 if ( GetPropertyValue( aAny, mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "ParaLeftMargin" ) ) ) )
2463 {
2464 sal_Int32 nVal;
2465 if ( aAny >>= nVal )
2466 nTextOfs = static_cast< sal_Int16 >( nVal / ( 2540.0 / 576 ) + 0.5 ) ;
2467 }
2468 if ( GetPropertyValue( aAny, mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "ParaFirstLineIndent" ) ) ) )
2469 {
2470 if ( aAny >>= nBulletOfs )
2471 nBulletOfs = static_cast< sal_Int32 >( nBulletOfs / ( 2540.0 / 576 ) + 0.5 );
2472 }
2473 if ( GetPropertyValue( aAny, mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "NumberingIsNumber" ) ) ) )
2474 aAny >>= bNumberingIsNumber;
2475
2476 ::com::sun::star::uno::Reference< ::com::sun::star::container::XIndexReplace > aXIndexReplace;
2477
2478 if ( bIsBullet && ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "NumberingRules" ) ), bGetPropStateValue ) )
2479 {
2480 if ( ( mAny >>= aXIndexReplace ) && nNumberingDepth < aXIndexReplace->getCount() )
2481 {
2482 mAny <<= aXIndexReplace->getByIndex( nNumberingDepth );
2483 ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue>
2484 aPropertySequence( *( ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue>*)mAny.getValue() );
2485
2486 const ::com::sun::star::beans::PropertyValue* pPropValue = aPropertySequence.getArray();
2487
2488 sal_Int32 nPropertyCount = aPropertySequence.getLength();
2489 if ( nPropertyCount )
2490 {
2491 bExtendedParameters = sal_True;
2492 nBulletRealSize = 100;
2493 nMappedNumType = 0;
2494
2495 String aGraphicURL;
2496 for ( sal_Int32 i = 0; i < nPropertyCount; i++ )
2497 {
2498 const void* pValue = pPropValue[ i ].Value.getValue();
2499 if ( pValue )
2500 {
2501 ::rtl::OUString aPropName( pPropValue[ i ].Name );
2502 if ( aPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "NumberingType" ) ) )
2503 nNumberingType = *( (sal_Int16*)pValue );
2504 else if ( aPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Adjust" ) ) )
2505 nHorzAdjust = *( (sal_Int16*)pValue );
2506 else if ( aPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "BulletChar" ) ) )
2507 {
2508 String aString( *( (String*)pValue ) );
2509 if ( aString.Len() )
2510 cBulletId = aString.GetChar( 0 );
2511 }
2512 else if ( aPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "BulletFont" ) ) )
2513 {
2514 aFontDesc = *( (::com::sun::star::awt::FontDescriptor*)pValue );
2515
2516 // Our numbullet dialog has set the wrong textencoding for our "StarSymbol" font,
2517 // instead of a Unicode encoding the encoding RTL_TEXTENCODING_SYMBOL was used.
2518 // Because there might exist a lot of damaged documemts I added this two lines
2519 // which fixes the bullet problem for the export.
2520 if ( aFontDesc.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "StarSymbol" ) ) )
2521 aFontDesc.CharSet = RTL_TEXTENCODING_MS_1252;
2522
2523 }
2524 else if ( aPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "GraphicURL" ) ) )
2525 aGraphicURL = ( *(::rtl::OUString*)pValue );
2526 else if ( aPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "GraphicSize" ) ) )
2527 {
2528 if ( pPropValue[ i ].Value.getValueType() == ::getCppuType( (::com::sun::star::awt::Size*)0) )
2529 {
2530 // don't cast awt::Size to Size as on 64-bits they are not the same.
2531 ::com::sun::star::awt::Size aSize;
2532 pPropValue[ i ].Value >>= aSize;
2533 aBuGraSize.nA = aSize.Width;
2534 aBuGraSize.nB = aSize.Height;
2535 }
2536 }
2537 else if ( aPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "StartWith" ) ) )
2538 nStartWith = *( (sal_Int16*)pValue );
2539 else if ( aPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "LeftMargin" ) ) )
2540 nTextOfs = nTextOfs + static_cast< sal_Int16 >( *( (sal_Int32*)pValue ) / ( 2540.0 / 576 ) );
2541 else if ( aPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "FirstLineOffset" ) ) )
2542 nBulletOfs += (sal_Int16)( *( (sal_Int32*)pValue ) / ( 2540.0 / 576 ) );
2543 else if ( aPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "BulletColor" ) ) )
2544 {
2545 sal_uInt32 nSOColor = *( (sal_uInt32*)pValue );
2546 nBulletColor = nSOColor & 0xff00ff00; // green and hibyte
2547 nBulletColor |= (sal_uInt8)( nSOColor ) << 16; // red
2548 nBulletColor |= (sal_uInt8)( nSOColor >> 16 ) | 0xfe000000; // blue
2549 }
2550 else if ( aPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "BulletRelSize" ) ) )
2551 {
2552 nBulletRealSize = *( (sal_Int16*)pValue );
2553 nParaFlags |= 0x40;
2554 nBulletFlags |= 8;
2555 }
2556 else if ( aPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Prefix" ) ) )
2557 sPrefix = ( *(::rtl::OUString*)pValue );
2558 else if ( aPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Suffix" ) ) )
2559 sSuffix = ( *(::rtl::OUString*)pValue );
2560 #ifdef DBG_UTIL
2561 else if ( ! (
2562 ( aPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "SymbolTextDistance" ) ) )
2563 || ( aPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Graphic" ) ) ) ) )
2564 {
2565 DBG_ERROR( "Unbekanntes Property" );
2566 }
2567 #endif
2568 }
2569 }
2570
2571 if ( aGraphicURL.Len() )
2572 {
2573 if ( aBuGraSize.Width() && aBuGraSize.Height() )
2574 {
2575 xub_StrLen nIndex = aGraphicURL.Search( (sal_Unicode)':', 0 );
2576 if ( nIndex != STRING_NOTFOUND )
2577 {
2578 nIndex++;
2579 if ( aGraphicURL.Len() > nIndex )
2580 {
2581 ByteString aUniqueId( aGraphicURL, nIndex, aGraphicURL.Len() - nIndex, RTL_TEXTENCODING_UTF8 );
2582 if ( aUniqueId.Len() )
2583 {
2584 nBulletId = rBuProv.GetId( aUniqueId, aBuGraSize );
2585 if ( nBulletId != 0xffff )
2586 bExtendedBulletsUsed = sal_True;
2587 }
2588 }
2589 }
2590 }
2591 else
2592 {
2593 nNumberingType = SVX_NUM_NUMBER_NONE;
2594 }
2595 }
2596
2597 PortionObj* pPortion = (PortionObj*)First();
2598 CalculateGraphicBulletSize( ( pPortion ) ? pPortion->mnCharHeight : 24 );
2599
2600 switch( (SvxExtNumType)nNumberingType )
2601 {
2602 case SVX_NUM_NUMBER_NONE : nParaFlags |= 0xf; break;
2603
2604 case SVX_NUM_CHAR_SPECIAL : // Bullet
2605 {
2606 if ( aFontDesc.Name.equalsIgnoreAsciiCaseAscii("starsymbol") ||
2607 aFontDesc.Name.equalsIgnoreAsciiCaseAscii("opensymbol") )
2608 {
2609 String sFontName = aFontDesc.Name;
2610 String sNumStr = cBulletId;
2611 rtl_TextEncoding eChrSet = aFontDesc.CharSet;
2612 lcl_SubstituteBullet(sNumStr,eChrSet,sFontName);
2613 aFontDesc.Name = sFontName;
2614 cBulletId = sNumStr.GetChar( 0 );
2615 aFontDesc.CharSet = eChrSet;
2616 }
2617
2618 if ( aFontDesc.Name.getLength() )
2619 {
2620 /*
2621 if ( aFontDesc.CharSet != ::com::sun::star::awt::CharSet::SYMBOL )
2622 {
2623 switch ( cBulletId )
2624 {
2625 // Currency
2626 case 128: cBulletId = 0x20AC; break;
2627 // Punctuation and other
2628 case 130: cBulletId = 0x201A; break;// SINGLE LOW-9 QUOTATION MARK
2629 case 131: cBulletId = 0x0192; break;// LATIN SMALL LETTER F WITH HOOK
2630 case 132: cBulletId = 0x201E; break;// DOUBLE LOW-9 QUOTATION MARK
2631 // LOW DOUBLE PRIME QUOTATION MARK
2632 case 133: cBulletId = 0x2026; break;// HORIZONTAL ELLIPSES
2633 case 134: cBulletId = 0x2020; break;// DAGGER
2634 case 135: cBulletId = 0x2021; break;// DOUBLE DAGGER
2635 case 136: cBulletId = 0x02C6; break;// MODIFIER LETTER CIRCUMFLEX ACCENT
2636 case 137: cBulletId = 0x2030; break;// PER MILLE SIGN
2637 case 138: cBulletId = 0x0160; break;// LATIN CAPITAL LETTER S WITH CARON
2638 case 139: cBulletId = 0x2039; break;// SINGLE LEFT-POINTING ANGLE QUOTATION MARK
2639 case 140: cBulletId = 0x0152; break;// LATIN CAPITAL LIGATURE OE
2640 case 142: cBulletId = 0x017D; break;// LATIN CAPITAL LETTER Z WITH CARON
2641 case 145: cBulletId = 0x2018; break;// LEFT SINGLE QUOTATION MARK
2642 // MODIFIER LETTER TURNED COMMA
2643 case 146: cBulletId = 0x2019; break;// RIGHT SINGLE QUOTATION MARK
2644 // MODIFIER LETTER APOSTROPHE
2645 case 147: cBulletId = 0x201C; break;// LEFT DOUBLE QUOTATION MARK
2646 // REVERSED DOUBLE PRIME QUOTATION MARK
2647 case 148: cBulletId = 0x201D; break;// RIGHT DOUBLE QUOTATION MARK
2648 // REVERSED DOUBLE PRIME QUOTATION MARK
2649 case 149: cBulletId = 0x2022; break;// BULLET
2650 case 150: cBulletId = 0x2013; break;// EN DASH
2651 case 151: cBulletId = 0x2014; break;// EM DASH
2652 case 152: cBulletId = 0x02DC; break;// SMALL TILDE
2653 case 153: cBulletId = 0x2122; break;// TRADE MARK SIGN
2654 case 154: cBulletId = 0x0161; break;// LATIN SMALL LETTER S WITH CARON
2655 case 155: cBulletId = 0x203A; break;// SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
2656 case 156: cBulletId = 0x0153; break;// LATIN SMALL LIGATURE OE
2657 case 158: cBulletId = 0x017E; break;// LATIN SMALL LETTER Z WITH CARON
2658 case 159: cBulletId = 0x0178; break;// LATIN CAPITAL LETTER Y WITH DIAERESIS
2659 // case 222: cBulletId = 0x00B6; break;// PILCROW SIGN / PARAGRAPH SIGN
2660 }
2661 }
2662 */
2663 nParaFlags |= 0x90; // wir geben den Font und den Charset vor
2664 }
2665 }
2666 case SVX_NUM_CHARS_UPPER_LETTER : // zaehlt von a-z, aa - az, ba - bz, ...
2667 case SVX_NUM_CHARS_LOWER_LETTER :
2668 case SVX_NUM_ROMAN_UPPER :
2669 case SVX_NUM_ROMAN_LOWER :
2670 case SVX_NUM_ARABIC :
2671 case SVX_NUM_PAGEDESC : // Numerierung aus der Seitenvorlage
2672 case SVX_NUM_BITMAP :
2673 case SVX_NUM_CHARS_UPPER_LETTER_N : // zaehlt von a-z, aa-zz, aaa-zzz
2674 case SVX_NUM_CHARS_LOWER_LETTER_N :
2675 case SVX_NUM_NUMBER_UPPER_ZH:
2676 case SVX_NUM_CIRCLE_NUMBER:
2677 case SVX_NUM_NUMBER_UPPER_ZH_TW:
2678 case SVX_NUM_NUMBER_LOWER_ZH:
2679 case SVX_NUM_FULL_WIDTH_ARABIC:
2680 {
2681 if ( nNumberingType != SVX_NUM_CHAR_SPECIAL )
2682 {
2683 bExtendedBulletsUsed = sal_True;
2684 if ( nNumberingDepth & 1 )
2685 cBulletId = 0x2013; // defaulting bullet characters for ppt97
2686 else if ( nNumberingDepth == 4 )
2687 cBulletId = 0xbb;
2688 else
2689 cBulletId = 0x2022;
2690
2691 switch( (SvxExtNumType)nNumberingType )
2692 {
2693 case SVX_NUM_CHARS_UPPER_LETTER :
2694 case SVX_NUM_CHARS_UPPER_LETTER_N :
2695 {
2696 if ( sSuffix == String( RTL_CONSTASCII_USTRINGPARAM( ")" ) ) )
2697 {
2698 if ( sPrefix == String( RTL_CONSTASCII_USTRINGPARAM( "(" ) ) )
2699 nMappedNumType = 0xa0001; // (A)
2700 else
2701 nMappedNumType = 0xb0001; // A)
2702 }
2703 else
2704 nMappedNumType = 0x10001; // A.
2705 }
2706 break;
2707 case SVX_NUM_CHARS_LOWER_LETTER :
2708 case SVX_NUM_CHARS_LOWER_LETTER_N :
2709 {
2710 if ( sSuffix == String( RTL_CONSTASCII_USTRINGPARAM( ")" ) ) )
2711 {
2712 if ( sPrefix == String( RTL_CONSTASCII_USTRINGPARAM( "(" ) ) )
2713 nMappedNumType = 0x80001; // (a)
2714 else
2715 nMappedNumType = 0x90001; // a)
2716 }
2717 else
2718 nMappedNumType = 0x00001; // a.
2719 }
2720 break;
2721 case SVX_NUM_ROMAN_UPPER :
2722 {
2723 if ( sSuffix == String( RTL_CONSTASCII_USTRINGPARAM( ")" ) ) )
2724 {
2725 if ( sPrefix == String( RTL_CONSTASCII_USTRINGPARAM( "(" ) ) )
2726 nMappedNumType = 0xe0001; // (I)
2727 else
2728 nMappedNumType = 0xf0001; // I)
2729 }
2730 else
2731 nMappedNumType = 0x70001; // I.
2732 }
2733 break;
2734 case SVX_NUM_ROMAN_LOWER :
2735 {
2736 if ( sSuffix == String( RTL_CONSTASCII_USTRINGPARAM( ")" ) ) )
2737 {
2738 if ( sPrefix == String( RTL_CONSTASCII_USTRINGPARAM( "(" ) ) )
2739 nMappedNumType = 0x40001; // (i)
2740 else
2741 nMappedNumType = 0x50001; // i)
2742 }
2743 else
2744 nMappedNumType = 0x60001; // i.
2745 }
2746 break;
2747 case SVX_NUM_ARABIC :
2748 {
2749 if ( sSuffix == String( RTL_CONSTASCII_USTRINGPARAM( ")" ) ) )
2750 {
2751 if ( sPrefix == String( RTL_CONSTASCII_USTRINGPARAM( "(" ) ) )
2752 nMappedNumType = 0xc0001; // (1)
2753 else
2754 nMappedNumType = 0x20001; // 1)
2755 }
2756 else
2757 {
2758 if ( ! ( sSuffix.Len() + sPrefix.Len() ) )
2759 nMappedNumType = 0xd0001; // 1
2760 else
2761 nMappedNumType = 0x30001; // 1.
2762 }
2763 }
2764 break;
2765 case SVX_NUM_NUMBER_UPPER_ZH :
2766 {
2767 if ( sSuffix.Len() )
2768 nMappedNumType = 0x110001; // Simplified Chinese with single-byte period.
2769 else
2770 nMappedNumType = 0x100001; // Simplified Chinese.
2771 }
2772 break;
2773 case SVX_NUM_CIRCLE_NUMBER :
2774 {
2775 nMappedNumType = 0x120001; // Double byte circle numbers.
2776 }
2777 break;
2778 case SVX_NUM_NUMBER_UPPER_ZH_TW :
2779 {
2780 if ( sSuffix.Len() )
2781 nMappedNumType = 0x160001; // Traditional Chinese with single-byte period.
2782 else
2783 nMappedNumType = 0x150001; // Traditional Chinese.
2784 }
2785 break;
2786 case SVX_NUM_NUMBER_LOWER_ZH :
2787 {
2788 if ( sSuffix == String( sal_Unicode(0xff0e)) )
2789 nMappedNumType = 0x260001; // Japanese with double-byte period.
2790 else if ( sSuffix.Len() )
2791 nMappedNumType = 0x1B0001; // Japanese/Korean with single-byte period.
2792 else
2793 nMappedNumType = 0x1A0001; // Japanese/Korean.
2794 }
2795 break;
2796 case SVX_NUM_FULL_WIDTH_ARABIC :
2797 {
2798 if ( sSuffix.Len() )
2799 nMappedNumType = 0x1D0001; // Double-byte Arabic numbers with double-byte period.
2800 else
2801 nMappedNumType = 0x1C0001; // Double-byte Arabic numbers.
2802 }
2803 break;
2804 default:
2805 break;
2806 }
2807 }
2808 nParaFlags |= 0x2f;
2809 nBulletFlags |= 6;
2810 if ( mbIsBullet && bNumberingIsNumber )
2811 nBulletFlags |= 1;
2812 }
2813 default: break;
2814 }
2815 }
2816 }
2817 }
2818 nBulletOfs = nTextOfs + nBulletOfs;
2819 if ( nBulletOfs < 0 )
2820 nBulletOfs = 0;
2821 }
2822
ImplGetParagraphValues(PPTExBulletProvider & rBuProv,sal_Bool bGetPropStateValue)2823 void ParagraphObj::ImplGetParagraphValues( PPTExBulletProvider& rBuProv, sal_Bool bGetPropStateValue )
2824 {
2825 static String sNumberingLevel ( RTL_CONSTASCII_USTRINGPARAM( "NumberingLevel" ) );
2826
2827 ::com::sun::star::uno::Any aAny;
2828 if ( GetPropertyValue( aAny, mXPropSet, sNumberingLevel, sal_True ) )
2829 {
2830 if ( bGetPropStateValue )
2831 meBullet = GetPropertyState( mXPropSet, sNumberingLevel );
2832 nDepth = *( (sal_Int16*)aAny.getValue() );
2833
2834 if ( nDepth < 0 )
2835 {
2836 mbIsBullet = sal_False;
2837 nDepth = 0;
2838 }
2839 else
2840 {
2841 if ( nDepth > 4 )
2842 nDepth = 4;
2843 mbIsBullet = sal_True;
2844 }
2845 }
2846 else
2847 {
2848 nDepth = 0;
2849 mbIsBullet = sal_False;
2850 }
2851 ImplGetNumberingLevel( rBuProv, nDepth, mbIsBullet, bGetPropStateValue );
2852
2853 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "ParaTabStops" ) ), bGetPropStateValue ) )
2854 maTabStop = *( ::com::sun::star::uno::Sequence< ::com::sun::star::style::TabStop>*)mAny.getValue();
2855 sal_Int16 eTextAdjust( ::com::sun::star::style::ParagraphAdjust_LEFT );
2856 if ( GetPropertyValue( aAny, mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "ParaAdjust" ) ), bGetPropStateValue ) )
2857 aAny >>= eTextAdjust;
2858 switch ( (::com::sun::star::style::ParagraphAdjust)eTextAdjust )
2859 {
2860 case ::com::sun::star::style::ParagraphAdjust_CENTER :
2861 mnTextAdjust = 1;
2862 break;
2863 case ::com::sun::star::style::ParagraphAdjust_RIGHT :
2864 mnTextAdjust = 2;
2865 break;
2866 case ::com::sun::star::style::ParagraphAdjust_BLOCK :
2867 mnTextAdjust = 3;
2868 break;
2869 default :
2870 case ::com::sun::star::style::ParagraphAdjust_LEFT :
2871 mnTextAdjust = 0;
2872 break;
2873 }
2874 meTextAdjust = ePropState;
2875
2876 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "ParaLineSpacing" ) ), bGetPropStateValue ) )
2877 {
2878 ::com::sun::star::style::LineSpacing aLineSpacing
2879 = *( (::com::sun::star::style::LineSpacing*)mAny.getValue() );
2880 switch ( aLineSpacing.Mode )
2881 {
2882 case ::com::sun::star::style::LineSpacingMode::MINIMUM :
2883 case ::com::sun::star::style::LineSpacingMode::LEADING :
2884 case ::com::sun::star::style::LineSpacingMode::FIX :
2885 mnLineSpacing = (sal_Int16)(-( aLineSpacing.Height ) );
2886 break;
2887
2888 case ::com::sun::star::style::LineSpacingMode::PROP :
2889 default:
2890 mnLineSpacing = (sal_Int16)( aLineSpacing.Height );
2891 break;
2892 }
2893 }
2894 meLineSpacing = ePropState;
2895
2896 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "ParaBottomMargin" ) ), bGetPropStateValue ) )
2897 {
2898 double fSpacing = *( (sal_uInt32*)mAny.getValue() ) + ( 2540.0 / 576.0 ) - 1;
2899 mnLineSpacingBottom = (sal_Int16)(-( fSpacing * 576.0 / 2540.0 ) );
2900 }
2901 meLineSpacingBottom = ePropState;
2902
2903 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "ParaTopMargin" ) ), bGetPropStateValue ) )
2904 {
2905 double fSpacing = *( (sal_uInt32*)mAny.getValue() ) + ( 2540.0 / 576.0 ) - 1;
2906 mnLineSpacingTop = (sal_Int16)(-( fSpacing * 576.0 / 2540.0 ) );
2907 }
2908 meLineSpacingTop = ePropState;
2909
2910 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "ParaIsForbiddenRules" ) ), bGetPropStateValue ) )
2911 mAny >>= mbForbiddenRules;
2912 meForbiddenRules = ePropState;
2913
2914 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "ParaIsHangingPunctuation" ) ), bGetPropStateValue ) )
2915 mAny >>= mbParagraphPunctation;
2916 meParagraphPunctation = ePropState;
2917
2918 mnBiDi = 0;
2919 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "WritingMode" ) ), bGetPropStateValue ) )
2920 {
2921 sal_Int16 nWritingMode;
2922 mAny >>= nWritingMode;
2923
2924 SvxFrameDirection eWritingMode( (SvxFrameDirection)nWritingMode );
2925 if ( ( eWritingMode == FRMDIR_HORI_RIGHT_TOP )
2926 || ( eWritingMode == FRMDIR_VERT_TOP_RIGHT ) )
2927 {
2928 mnBiDi = 1;
2929 }
2930 }
2931 meBiDi = ePropState;
2932 }
2933
ImplConstruct(const ParagraphObj & rParagraphObj)2934 void ParagraphObj::ImplConstruct( const ParagraphObj& rParagraphObj )
2935 {
2936 mnTextSize = rParagraphObj.mnTextSize;
2937 mnTextAdjust = rParagraphObj.mnTextAdjust;
2938 mnLineSpacing = rParagraphObj.mnLineSpacing;
2939 mnLineSpacingTop = rParagraphObj.mnLineSpacingTop;
2940 mnLineSpacingBottom = rParagraphObj.mnLineSpacingBottom;
2941 mbFirstParagraph = rParagraphObj.mbFirstParagraph;
2942 mbLastParagraph = rParagraphObj.mbLastParagraph;
2943 mbParagraphPunctation = rParagraphObj.mbParagraphPunctation;
2944 mbForbiddenRules = rParagraphObj.mbForbiddenRules;
2945 mnBiDi = rParagraphObj.mnBiDi;
2946
2947 ParagraphObj& rOther = const_cast<ParagraphObj&>(rParagraphObj);
2948 for ( const void* pPtr = rOther.First(); pPtr; pPtr = rOther.Next() )
2949 Insert( new PortionObj( *(const PortionObj*)pPtr ), LIST_APPEND );
2950
2951 maTabStop = rParagraphObj.maTabStop;
2952 bExtendedParameters = rParagraphObj.bExtendedParameters;
2953 nParaFlags = rParagraphObj.nParaFlags;
2954 nBulletFlags = rParagraphObj.nBulletFlags;
2955 sPrefix = rParagraphObj.sPrefix;
2956 sSuffix = rParagraphObj.sSuffix;
2957 sGraphicUrl = rParagraphObj.sGraphicUrl; // String auf eine Graphic
2958 aBuGraSize = rParagraphObj.aBuGraSize;
2959 nNumberingType = rParagraphObj.nNumberingType; // in wirlichkeit ist dies ein SvxEnum
2960 nHorzAdjust = rParagraphObj.nHorzAdjust;
2961 nBulletColor = rParagraphObj.nBulletColor;
2962 nBulletOfs = rParagraphObj.nBulletOfs;
2963 nStartWith = rParagraphObj.nStartWith; // Start der nummerierung
2964 nTextOfs = rParagraphObj.nTextOfs;
2965 nBulletRealSize = rParagraphObj.nBulletRealSize; // GroessenVerhaeltnis in Proz
2966 nDepth = rParagraphObj.nDepth; // aktuelle tiefe
2967 cBulletId = rParagraphObj.cBulletId; // wenn Numbering Type == CharSpecial
2968 aFontDesc = rParagraphObj.aFontDesc;
2969
2970 bExtendedBulletsUsed = rParagraphObj.bExtendedBulletsUsed;
2971 nBulletId = rParagraphObj.nBulletId;
2972 }
2973
ImplCalculateTextPositions(sal_uInt32 nCurrentTextPosition)2974 sal_uInt32 ParagraphObj::ImplCalculateTextPositions( sal_uInt32 nCurrentTextPosition )
2975 {
2976 mnTextSize = 0;
2977 for ( void* pPtr = First(); pPtr; pPtr = Next() )
2978 mnTextSize += ((PortionObj*)pPtr)->ImplCalculateTextPositions( nCurrentTextPosition + mnTextSize );
2979 return mnTextSize;
2980 }
2981
operator =(const ParagraphObj & rParagraphObj)2982 ParagraphObj& ParagraphObj::operator=( const ParagraphObj& rParagraphObj )
2983 {
2984 if ( this != &rParagraphObj )
2985 {
2986 ImplClear();
2987 ImplConstruct( rParagraphObj );
2988 }
2989 return *this;
2990 }
2991
2992 // -----------------------------------------------------------------------
2993
ImplTextObj(int nInstance)2994 ImplTextObj::ImplTextObj( int nInstance )
2995 {
2996 mnRefCount = 1;
2997 mnTextSize = 0;
2998 mnInstance = nInstance;
2999 mpList = new List;
3000 mbHasExtendedBullets = sal_False;
3001 mbFixedCellHeightUsed = sal_False;
3002 }
3003
~ImplTextObj()3004 ImplTextObj::~ImplTextObj()
3005 {
3006 for ( ParagraphObj* pPtr = (ParagraphObj*)mpList->First(); pPtr; pPtr = (ParagraphObj*)mpList->Next() )
3007 delete pPtr;
3008 delete mpList;
3009 }
3010
TextObj(::com::sun::star::uno::Reference<::com::sun::star::text::XSimpleText> & rXTextRef,int nInstance,FontCollection & rFontCollection,PPTExBulletProvider & rProv)3011 TextObj::TextObj( ::com::sun::star::uno::Reference< ::com::sun::star::text::XSimpleText > & rXTextRef,
3012 int nInstance, FontCollection& rFontCollection, PPTExBulletProvider& rProv )
3013 {
3014 mpImplTextObj = new ImplTextObj( nInstance );
3015
3016 ::com::sun::star::uno::Reference< ::com::sun::star::container::XEnumerationAccess >
3017 aXTextParagraphEA( rXTextRef, ::com::sun::star::uno::UNO_QUERY );
3018
3019 if ( aXTextParagraphEA.is() )
3020 {
3021 ::com::sun::star::uno::Reference< ::com::sun::star::container::XEnumeration >
3022 aXTextParagraphE( aXTextParagraphEA->createEnumeration() );
3023 if ( aXTextParagraphE.is() )
3024 {
3025 ParaFlags aParaFlags;
3026 while ( aXTextParagraphE->hasMoreElements() )
3027 {
3028 ::com::sun::star::uno::Reference< ::com::sun::star::text::XTextContent > aXParagraph;
3029 ::com::sun::star::uno::Any aAny( aXTextParagraphE->nextElement() );
3030 if ( aAny >>= aXParagraph )
3031 {
3032 if ( !aXTextParagraphE->hasMoreElements() )
3033 aParaFlags.bLastParagraph = sal_True;
3034 ParagraphObj* pPara = new ParagraphObj( aXParagraph, aParaFlags, rFontCollection, rProv );
3035 mpImplTextObj->mbHasExtendedBullets |= pPara->bExtendedBulletsUsed;
3036 mpImplTextObj->mpList->Insert( pPara, LIST_APPEND );
3037 aParaFlags.bFirstParagraph = sal_False;
3038 }
3039 }
3040 }
3041 }
3042 ImplCalculateTextPositions();
3043 }
3044
TextObj(const TextObj & rTextObj)3045 TextObj::TextObj( const TextObj& rTextObj )
3046 {
3047 mpImplTextObj = rTextObj.mpImplTextObj;
3048 mpImplTextObj->mnRefCount++;
3049 }
3050
~TextObj()3051 TextObj::~TextObj()
3052 {
3053 if ( ! ( --mpImplTextObj->mnRefCount ) )
3054 delete mpImplTextObj;
3055 }
3056
Write(SvStream * pStrm)3057 void TextObj::Write( SvStream* pStrm )
3058 {
3059 sal_uInt32 nSize, nPos = pStrm->Tell();
3060 *pStrm << (sal_uInt32)( EPP_TextCharsAtom << 16 ) << (sal_uInt32)0;
3061 for ( void* pPtr = First(); pPtr; pPtr = Next() )
3062 ((ParagraphObj*)pPtr)->Write( pStrm );
3063 nSize = pStrm->Tell() - nPos;
3064 pStrm->SeekRel( - ( (sal_Int32)nSize - 4 ) );
3065 *pStrm << (sal_uInt32)( nSize - 8 );
3066 pStrm->SeekRel( nSize - 8 );
3067 }
3068
ImplCalculateTextPositions()3069 void TextObj::ImplCalculateTextPositions()
3070 {
3071 mpImplTextObj->mnTextSize = 0;
3072 for ( void* pPtr = First(); pPtr; pPtr = Next() )
3073 mpImplTextObj->mnTextSize += ((ParagraphObj*)pPtr)->ImplCalculateTextPositions( mpImplTextObj->mnTextSize );
3074 }
3075
operator =(TextObj & rTextObj)3076 TextObj& TextObj::operator=( TextObj& rTextObj )
3077 {
3078 if ( this != &rTextObj )
3079 {
3080 if ( ! ( --mpImplTextObj->mnRefCount ) )
3081 delete mpImplTextObj;
3082 mpImplTextObj = rTextObj.mpImplTextObj;
3083 mpImplTextObj->mnRefCount++;
3084 }
3085 return *this;
3086 }
3087
WriteTextSpecInfo(SvStream * pStrm)3088 void TextObj::WriteTextSpecInfo( SvStream* pStrm )
3089 {
3090 sal_uInt32 nCharactersLeft( Count() );
3091 if ( nCharactersLeft >= 1 )
3092 {
3093 EscherExAtom aAnimationInfoAtom( *pStrm, EPP_TextSpecInfoAtom, 0, 0 );
3094 for ( ParagraphObj* pPtr = static_cast < ParagraphObj * >( First() ); nCharactersLeft && pPtr; pPtr = static_cast< ParagraphObj* >( Next() ) )
3095 {
3096 for ( PortionObj* pPortion = static_cast< PortionObj* >( pPtr->First() ); nCharactersLeft && pPortion; pPortion = static_cast< PortionObj* >( pPtr->Next() ) )
3097 {
3098 sal_Int32 nPortionSize = pPortion->mnTextSize >= nCharactersLeft ? nCharactersLeft : pPortion->mnTextSize;
3099 sal_Int32 nFlags = 7;
3100 nCharactersLeft -= nPortionSize;
3101 *pStrm << static_cast< sal_uInt32 >( nPortionSize )
3102 << nFlags
3103 << static_cast< sal_Int16 >( 1 ) // spellinfo -> needs rechecking
3104 << static_cast< sal_Int16 >( MsLangId::convertLocaleToLanguageWithFallback( pPortion->meCharLocale ) )
3105 << static_cast< sal_Int16 >( 0 ); // alt language
3106 }
3107 }
3108 if ( nCharactersLeft )
3109 *pStrm << nCharactersLeft << static_cast< sal_Int32 >( 1 ) << static_cast< sal_Int16 >( 1 );
3110
3111 }
3112 }
3113
3114 // -----------------------------------------------------------------------
3115
ImplAdjustFirstLineLineSpacing(TextObj & rTextObj,EscherPropertyContainer & rPropOpt)3116 void PPTWriter::ImplAdjustFirstLineLineSpacing( TextObj& rTextObj, EscherPropertyContainer& rPropOpt )
3117 {
3118 if ( !mbFontIndependentLineSpacing )
3119 {
3120 ParagraphObj* pPara = rTextObj.First();
3121 if ( pPara )
3122 {
3123 PortionObj* pPortion = (PortionObj*)pPara->First();
3124 if ( pPortion )
3125 {
3126 sal_Int16 nLineSpacing = pPara->mnLineSpacing;
3127 const FontCollectionEntry* pDesc = maFontCollection.GetById( pPortion->mnFont );
3128 if ( pDesc )
3129 nLineSpacing = (sal_Int16)( (double)nLineSpacing * pDesc->Scaling + 0.5 );
3130
3131 if ( ( nLineSpacing > 0 ) && ( nLineSpacing < 100 ) )
3132 {
3133 /*
3134 if ( rxText.is() )
3135 {
3136 ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XShape > xShape( rxText, ::com::sun::star::uno::UNO_QUERY );
3137 if ( xShape.is() )
3138 {
3139 SdrObject* pObj = GetSdrObjectFromXShape( mXShape );
3140 if ( pObj )
3141 {
3142 const OutlinerParaObject* pParaObj = pObj->GetOutlinerParaObject();
3143 if ( pParaObj )
3144 {
3145 SdrModel* pModel = pObj->GetModel();
3146 if ( pModel )
3147 {
3148 Outliner aOutliner( &pModel->GetItemPool(), pParaObj->GetOutlinerMode() );
3149 aOutliner.SetText( *pParaObj );
3150 sal_uLong nTextHeight = aOutliner.GetLineHeight( 0, 0 );
3151 if ( nTextHeight )
3152 {
3153 }
3154 }
3155 }
3156 }
3157 }
3158 }
3159 */
3160 double fCharHeight = pPortion->mnCharHeight;
3161 fCharHeight *= 2540 / 72;
3162 fCharHeight *= 100 - nLineSpacing;
3163 fCharHeight /= 100;
3164
3165 sal_uInt32 nUpperDistance = 0;
3166 rPropOpt.GetOpt( ESCHER_Prop_dyTextTop, nUpperDistance );
3167 nUpperDistance += static_cast< sal_uInt32 >( fCharHeight * 360.0 );
3168 rPropOpt.AddOpt( ESCHER_Prop_dyTextTop, nUpperDistance );
3169 }
3170 }
3171 }
3172 }
3173 }
3174
3175 // -----------------------------------------------------------------------
3176
ImplWriteTextStyleAtom(SvStream & rOut,int nTextInstance,sal_uInt32 nAtomInstance,TextRuleEntry * pTextRule,SvStream & rExtBuStr,EscherPropertyContainer * pPropOpt)3177 void PPTWriter::ImplWriteTextStyleAtom( SvStream& rOut, int nTextInstance, sal_uInt32 nAtomInstance,
3178 TextRuleEntry* pTextRule, SvStream& rExtBuStr, EscherPropertyContainer* pPropOpt )
3179 {
3180 PPTExParaSheet& rParaSheet = mpStyleSheet->GetParaSheet( nTextInstance );
3181
3182 rOut << (sal_uInt32)( ( EPP_TextHeaderAtom << 16 ) | ( nAtomInstance << 4 ) ) << (sal_uInt32)4
3183 << nTextInstance;
3184
3185 if ( mbEmptyPresObj )
3186 mnTextSize = 0;
3187 if ( !mbEmptyPresObj )
3188 {
3189 ParagraphObj* pPara;
3190 TextObj aTextObj( mXText, nTextInstance, maFontCollection, (PPTExBulletProvider&)*this );
3191
3192 // leaving out EPP_TextCharsAtom w/o text - still write out
3193 // attribute info though
3194 if ( mnTextSize )
3195 aTextObj.Write( &rOut );
3196
3197 if ( pPropOpt )
3198 ImplAdjustFirstLineLineSpacing( aTextObj, *pPropOpt );
3199
3200 sal_uInt32 nSize, nPos = rOut.Tell();
3201
3202 rOut << (sal_uInt32)( EPP_StyleTextPropAtom << 16 ) << (sal_uInt32)0;
3203 ImplWriteParagraphs( rOut, aTextObj );
3204 ImplWritePortions( rOut, aTextObj );
3205 nSize = rOut.Tell() - nPos;
3206 rOut.SeekRel( - ( (sal_Int32)nSize - 4 ) );
3207 rOut << (sal_uInt32)( nSize - 8 );
3208 rOut.SeekRel( nSize - 8 );
3209
3210 for ( pPara = aTextObj.First(); pPara; pPara = aTextObj.Next() )
3211 {
3212 for ( PortionObj* pPortion = (PortionObj*)pPara->First(); pPortion; pPortion = (PortionObj*)pPara->Next() )
3213 {
3214 if ( pPortion->mpFieldEntry )
3215 {
3216 const FieldEntry* pFieldEntry = pPortion->mpFieldEntry;
3217
3218 switch ( pFieldEntry->nFieldType >> 28 )
3219 {
3220 case 1 :
3221 case 2 :
3222 {
3223 rOut << (sal_uInt32)( EPP_DateTimeMCAtom << 16 ) << (sal_uInt32)8
3224 << (sal_uInt32)( pFieldEntry->nFieldStartPos ) // TxtOffset auf TxtField;
3225 << (sal_uInt8)( pFieldEntry->nFieldType & 0xff ) // Type
3226 << (sal_uInt8)0 << (sal_uInt16)0; // PadBytes
3227 }
3228 break;
3229 case 3 :
3230 {
3231 rOut << (sal_uInt32)( EPP_SlideNumberMCAtom << 16 ) << (sal_uInt32 ) 4
3232 << (sal_uInt32)( pFieldEntry->nFieldStartPos );
3233 }
3234 break;
3235 case 4 :
3236 {
3237 sal_uInt32 nPageIndex = 0;
3238 String aPageUrl;
3239 String aEmpty;
3240 String aFile( pFieldEntry->aFieldUrl );
3241 INetURLObject aUrl( pFieldEntry->aFieldUrl );
3242 if ( INET_PROT_FILE == aUrl.GetProtocol() )
3243 aFile = aUrl.PathToFileName();
3244 else if ( pFieldEntry->aFieldUrl.GetChar( 0 ) == '#' )
3245 {
3246 String aPage( INetURLObject::decode( pFieldEntry->aFieldUrl, '%', INetURLObject::DECODE_WITH_CHARSET ) );
3247 aPage.Erase( 0, 1 );
3248 for ( String* pStr = (String*)maSlideNameList.First(); pStr; pStr = (String*)maSlideNameList.Next(), nPageIndex++ )
3249 {
3250 if ( *pStr == aPage )
3251 {
3252 aPageUrl = UniString::CreateFromInt32( 256 + nPageIndex );
3253 aPageUrl.Append( String( RTL_CONSTASCII_USTRINGPARAM( "," ) ) );
3254 aPageUrl.Append( String::CreateFromInt32( nPageIndex + 1 ) );
3255 aPageUrl.Append( String( RTL_CONSTASCII_USTRINGPARAM( ",Slide " ) ) );
3256 aPageUrl.Append( String::CreateFromInt32( nPageIndex + 1 ) );
3257 }
3258 }
3259 }
3260 sal_uInt32 nHyperId;
3261 if ( aPageUrl.Len() )
3262 nHyperId = ImplInsertBookmarkURL( aPageUrl, 1 | ( nPageIndex << 8 ) | ( 1 << 31 ), pFieldEntry->aRepresentation, aEmpty, aEmpty, aPageUrl );
3263 else
3264 nHyperId = ImplInsertBookmarkURL( pFieldEntry->aFieldUrl, 2 | ( nHyperId << 8 ), aFile, pFieldEntry->aFieldUrl, aEmpty, aEmpty );
3265
3266 rOut << (sal_uInt32)( ( EPP_InteractiveInfo << 16 ) | 0xf ) << (sal_uInt32)24
3267 << (sal_uInt32)( EPP_InteractiveInfoAtom << 16 ) << (sal_uInt32)16
3268 << (sal_uInt32)0 // soundref
3269 << nHyperId // hyperlink id
3270 << (sal_uInt8)4 // hyperlink action
3271 << (sal_uInt8)0 // ole verb
3272 << (sal_uInt8)0 // jump
3273 << (sal_uInt8)0 // flags
3274 << (sal_uInt8)8 // hyperlink type ?
3275 << (sal_uInt8)0 << (sal_uInt8)0 << (sal_uInt8)0
3276 << (sal_uInt32)( EPP_TxInteractiveInfoAtom << 16 ) << (sal_uInt32)8
3277 << (sal_uInt32)( pFieldEntry->nFieldStartPos )
3278 << (sal_uInt32)( pFieldEntry->nFieldEndPos );
3279 }
3280 break;
3281 case 5 :
3282 {
3283 rOut << (sal_uInt32)( EPP_GenericDateMCAtom << 16 ) << (sal_uInt32)4
3284 << (sal_uInt32)( pFieldEntry->nFieldStartPos );
3285 }
3286 break;
3287 case 6 :
3288 {
3289 rOut << (sal_uInt32)( EPP_HeaderMCAtom << 16 ) << (sal_uInt32 ) 4
3290 << (sal_uInt32)( pFieldEntry->nFieldStartPos );
3291 }
3292 break;
3293 case 7 :
3294 {
3295 rOut << (sal_uInt32)( EPP_FooterMCAtom << 16 ) << (sal_uInt32 ) 4
3296 << (sal_uInt32)( pFieldEntry->nFieldStartPos );
3297 }
3298 break;
3299 default:
3300 break;
3301 }
3302 }
3303 }
3304 }
3305
3306 aTextObj.WriteTextSpecInfo( &rOut );
3307
3308 // Star Office Default TabSizes schreiben ( wenn noetig )
3309 pPara = aTextObj.First();
3310 if ( pPara )
3311 {
3312 sal_uInt32 nParaFlags = 0x1f;
3313 sal_Int16 nDepth, nMask, nNumberingRule[ 10 ];
3314 sal_uInt32 nTextOfs = pPara->nTextOfs;
3315 sal_uInt32 nTabs = pPara->maTabStop.getLength();
3316 const ::com::sun::star::style::TabStop* pTabStop = ( const ::com::sun::star::style::TabStop* )pPara->maTabStop.getConstArray();
3317
3318 for ( ; pPara; pPara = aTextObj.Next() )
3319 {
3320 if ( pPara->bExtendedParameters )
3321 {
3322 nDepth = pPara->nDepth;
3323 if ( nDepth < 5 )
3324 {
3325 nMask = 1 << nDepth;
3326 if ( nParaFlags & nMask )
3327 {
3328 nParaFlags &=~ nMask;
3329 if ( ( rParaSheet.maParaLevel[ nDepth ].mnTextOfs != pPara->nTextOfs ) ||
3330 ( rParaSheet.maParaLevel[ nDepth ].mnBulletOfs != pPara->nBulletOfs ) )
3331 {
3332 nParaFlags |= nMask << 16;
3333 nNumberingRule[ nDepth << 1 ] = pPara->nTextOfs;
3334 nNumberingRule[ ( nDepth << 1 ) + 1 ] = (sal_Int16)pPara->nBulletOfs;
3335 }
3336 }
3337 }
3338 }
3339 }
3340 nParaFlags >>= 16;
3341
3342 sal_uInt32 nDefaultTabSize = ImplMapSize( ::com::sun::star::awt::Size( 2011, 1 ) ).Width;
3343 sal_uInt32 nDefaultTabs = abs( maRect.GetWidth() ) / nDefaultTabSize;
3344 if ( nTabs )
3345 nDefaultTabs -= (sal_Int32)( ( ( pTabStop[ nTabs - 1 ].Position / 4.40972 ) + nTextOfs ) / nDefaultTabSize );
3346 if ( (sal_Int32)nDefaultTabs < 0 )
3347 nDefaultTabs = 0;
3348
3349 sal_uInt32 nTabCount = nTabs + nDefaultTabs;
3350 sal_uInt32 i, nTextRulerAtomFlags = 0;
3351
3352 if ( nTabCount )
3353 nTextRulerAtomFlags |= 4;
3354 if ( nParaFlags )
3355 nTextRulerAtomFlags |= ( ( nParaFlags << 3 ) | ( nParaFlags << 8 ) );
3356
3357 if ( nTextRulerAtomFlags )
3358 {
3359 SvStream* pRuleOut = &rOut;
3360 if ( pTextRule )
3361 pRuleOut = pTextRule->pOut = new SvMemoryStream( 0x100, 0x100 );
3362
3363 sal_uInt32 nRulePos = pRuleOut->Tell();
3364 *pRuleOut << (sal_uInt32)( EPP_TextRulerAtom << 16 ) << (sal_uInt32)0;
3365 *pRuleOut << nTextRulerAtomFlags;
3366 if ( nTextRulerAtomFlags & 4 )
3367 {
3368 *pRuleOut << (sal_uInt16)nTabCount;
3369 for ( i = 0; i < nTabs; i++ )
3370 {
3371 sal_uInt16 nPosition = (sal_uInt16)( ( pTabStop[ i ].Position / 4.40972 ) + nTextOfs );
3372 sal_uInt16 nType;
3373 switch ( pTabStop[ i ].Alignment )
3374 {
3375 case ::com::sun::star::style::TabAlign_DECIMAL : nType = 3; break;
3376 case ::com::sun::star::style::TabAlign_RIGHT : nType = 2; break;
3377 case ::com::sun::star::style::TabAlign_CENTER : nType = 1; break;
3378
3379 case ::com::sun::star::style::TabAlign_LEFT :
3380 default: nType = 0;
3381 };
3382 *pRuleOut << nPosition
3383 << nType;
3384 }
3385
3386 sal_uInt32 nWidth = 1;
3387 if ( nTabs )
3388 nWidth += (sal_Int32)( ( ( pTabStop[ nTabs - 1 ].Position / 4.40972 + nTextOfs ) / nDefaultTabSize ) );
3389 nWidth *= nDefaultTabSize;
3390 for ( i = 0; i < nDefaultTabs; i++, nWidth += nDefaultTabSize )
3391 *pRuleOut << nWidth;
3392 }
3393 for ( i = 0; i < 5; i++ )
3394 {
3395 if ( nTextRulerAtomFlags & ( 8 << i ) )
3396 *pRuleOut << nNumberingRule[ i << 1 ];
3397 if ( nTextRulerAtomFlags & ( 256 << i ) )
3398 *pRuleOut << nNumberingRule[ ( i << 1 ) + 1 ];
3399 }
3400 sal_uInt32 nBufSize = pRuleOut->Tell() - nRulePos;
3401 pRuleOut->SeekRel( - ( (sal_Int32)nBufSize - 4 ) );
3402 *pRuleOut << (sal_uInt32)( nBufSize - 8 );
3403 pRuleOut->SeekRel( nBufSize - 8 );
3404 }
3405 }
3406 if ( aTextObj.HasExtendedBullets() )
3407 {
3408 ParagraphObj* pBulletPara = aTextObj.First();
3409 if ( pBulletPara )
3410 {
3411 sal_uInt32 nBulletFlags = 0;
3412 sal_uInt32 nNumberingType = 0, nPos2 = rExtBuStr.Tell();
3413
3414 rExtBuStr << (sal_uInt32)( EPP_PST_ExtendedParagraphAtom << 16 ) << (sal_uInt32)0;
3415
3416 for ( ; pBulletPara; pBulletPara = aTextObj.Next() )
3417 {
3418 nBulletFlags = 0;
3419 sal_uInt16 nBulletId = pBulletPara->nBulletId;
3420 if ( pBulletPara->bExtendedBulletsUsed )
3421 {
3422 nBulletFlags = 0x800000;
3423 if ( pBulletPara->nNumberingType != SVX_NUM_BITMAP )
3424 nBulletFlags = 0x3000000;
3425 }
3426 rExtBuStr << (sal_uInt32)nBulletFlags;
3427
3428 if ( nBulletFlags & 0x800000 )
3429 rExtBuStr << nBulletId;
3430 if ( nBulletFlags & 0x1000000 )
3431 {
3432 switch( pBulletPara->nNumberingType )
3433 {
3434 case SVX_NUM_NUMBER_NONE :
3435 case SVX_NUM_CHAR_SPECIAL :
3436 nNumberingType = 0;
3437 break;
3438 case SVX_NUM_CHARS_UPPER_LETTER :
3439 case SVX_NUM_CHARS_UPPER_LETTER_N :
3440 case SVX_NUM_CHARS_LOWER_LETTER :
3441 case SVX_NUM_CHARS_LOWER_LETTER_N :
3442 case SVX_NUM_ROMAN_UPPER :
3443 case SVX_NUM_ROMAN_LOWER :
3444 case SVX_NUM_ARABIC :
3445 case SVX_NUM_NUMBER_UPPER_ZH:
3446 case SVX_NUM_CIRCLE_NUMBER:
3447 case SVX_NUM_NUMBER_UPPER_ZH_TW:
3448 case SVX_NUM_NUMBER_LOWER_ZH:
3449 case SVX_NUM_FULL_WIDTH_ARABIC:
3450 nNumberingType = pBulletPara->nMappedNumType;
3451 break;
3452
3453 // case SVX_NUM_PAGEDESC :
3454 case SVX_NUM_BITMAP :
3455 nNumberingType = 0;
3456 break;
3457
3458 }
3459 rExtBuStr << (sal_uInt32)nNumberingType;
3460 }
3461 if ( nBulletFlags & 0x2000000 )
3462 rExtBuStr << (sal_uInt16)pBulletPara->nStartWith;
3463 rExtBuStr << (sal_uInt32)0 << (sal_uInt32)0;
3464 }
3465 sal_uInt32 nBulletSize = ( rExtBuStr.Tell() - nPos2 ) - 8;
3466 rExtBuStr.SeekRel( - ( (sal_Int32)nBulletSize + 4 ) );
3467 rExtBuStr << nBulletSize;
3468 rExtBuStr.SeekRel( nBulletSize );
3469 }
3470 }
3471 }
3472 }
3473
3474 // -----------------------------------------------------------------------
3475
ImplWriteObjectEffect(SvStream & rSt,::com::sun::star::presentation::AnimationEffect eAe,::com::sun::star::presentation::AnimationEffect eTe,sal_uInt16 nOrder)3476 void PPTWriter::ImplWriteObjectEffect( SvStream& rSt,
3477 ::com::sun::star::presentation::AnimationEffect eAe,
3478 ::com::sun::star::presentation::AnimationEffect eTe,
3479 sal_uInt16 nOrder )
3480 {
3481 EscherExContainer aAnimationInfo( rSt, EPP_AnimationInfo );
3482 EscherExAtom aAnimationInfoAtom( rSt, EPP_AnimationInfoAtom, 0, 1 );
3483 sal_uInt32 nDimColor = 0x7000000; // color to use for dimming
3484 sal_uInt32 nFlags = 0x4400; // set of flags that determine type of build
3485 sal_uInt32 nSoundRef = 0; // 0 if storage is from clipboard. Otherwise index(ID) in SoundCollection list.
3486 sal_uInt32 nDelayTime = 0; // delay before playing object
3487 sal_uInt16 nSlideCount = 1; // number of slides to play object
3488 sal_uInt8 nBuildType = 1; // type of build
3489 sal_uInt8 nFlyMethod = 0; // animation effect( fly, zoom, appear, etc )
3490 sal_uInt8 nFlyDirection = 0; // Animation direction( left, right, up, down, etc )
3491 sal_uInt8 nAfterEffect = 0; // what to do after build
3492 sal_uInt8 nSubEffect = 0; // build by word or letter
3493 sal_uInt8 nOleVerb = 0; // Determines object's class (sound, video, other)
3494
3495 if ( eAe == ::com::sun::star::presentation::AnimationEffect_NONE )
3496 {
3497 nBuildType = 0;
3498 eAe = eTe;
3499 }
3500 switch ( eAe )
3501 {
3502 case ::com::sun::star::presentation::AnimationEffect_NONE :
3503 break;
3504 case ::com::sun::star::presentation::AnimationEffect_FADE_FROM_LEFT :
3505 {
3506 nFlyDirection = 2;
3507 nFlyMethod = 10;
3508 }
3509 break;
3510 case ::com::sun::star::presentation::AnimationEffect_FADE_FROM_TOP :
3511 {
3512 nFlyDirection = 3;
3513 nFlyMethod = 10;
3514 }
3515 break;
3516 case ::com::sun::star::presentation::AnimationEffect_FADE_FROM_RIGHT :
3517 {
3518 nFlyDirection = 0;
3519 nFlyMethod = 10;
3520 }
3521 break;
3522 case ::com::sun::star::presentation::AnimationEffect_FADE_FROM_BOTTOM :
3523 {
3524 nFlyDirection = 1;
3525 nFlyMethod = 10;
3526 }
3527 break;
3528 case ::com::sun::star::presentation::AnimationEffect_FADE_TO_CENTER :
3529 {
3530 nFlyDirection = 1;
3531 nFlyMethod = 11;
3532 }
3533 break;
3534 case ::com::sun::star::presentation::AnimationEffect_FADE_FROM_CENTER :
3535 {
3536 nFlyDirection = 0;
3537 nFlyMethod = 11;
3538 }
3539 break;
3540 case ::com::sun::star::presentation::AnimationEffect_MOVE_FROM_LEFT :
3541 {
3542 nFlyDirection = 0;
3543 nFlyMethod = 12;
3544 }
3545 break;
3546 case ::com::sun::star::presentation::AnimationEffect_MOVE_FROM_TOP :
3547 {
3548 nFlyDirection = 1;
3549 nFlyMethod = 12;
3550 }
3551 break;
3552 case ::com::sun::star::presentation::AnimationEffect_MOVE_FROM_RIGHT :
3553 {
3554 nFlyDirection = 2;
3555 nFlyMethod = 12;
3556 }
3557 break;
3558 case ::com::sun::star::presentation::AnimationEffect_MOVE_FROM_BOTTOM :
3559 {
3560 nFlyDirection = 3;
3561 nFlyMethod = 12;
3562 }
3563 break;
3564 case ::com::sun::star::presentation::AnimationEffect_VERTICAL_STRIPES :
3565 {
3566 nFlyDirection = 0;
3567 nFlyMethod = 2;
3568 }
3569 break;
3570 case ::com::sun::star::presentation::AnimationEffect_HORIZONTAL_STRIPES :
3571 {
3572 nFlyDirection = 1;
3573 nFlyMethod = 2;
3574 }
3575 break;
3576 case ::com::sun::star::presentation::AnimationEffect_CLOCKWISE :
3577 {
3578 nFlyDirection = 1;
3579 nFlyMethod = 3;
3580 }
3581 break;
3582 case ::com::sun::star::presentation::AnimationEffect_COUNTERCLOCKWISE :
3583 {
3584 nFlyDirection = 0;
3585 nFlyMethod = 3;
3586 }
3587 break;
3588 case ::com::sun::star::presentation::AnimationEffect_FADE_FROM_UPPERLEFT :
3589 {
3590 nFlyDirection = 7;
3591 nFlyMethod = 9;
3592 }
3593 break;
3594 case ::com::sun::star::presentation::AnimationEffect_FADE_FROM_UPPERRIGHT :
3595 {
3596 nFlyDirection = 6;
3597 nFlyMethod = 9;
3598 }
3599 break;
3600 case ::com::sun::star::presentation::AnimationEffect_FADE_FROM_LOWERLEFT :
3601 {
3602 nFlyDirection = 5;
3603 nFlyMethod = 9;
3604 }
3605 break;
3606 case ::com::sun::star::presentation::AnimationEffect_FADE_FROM_LOWERRIGHT :
3607 {
3608 nFlyDirection = 4;
3609 nFlyMethod = 9;
3610 }
3611 break;
3612 case ::com::sun::star::presentation::AnimationEffect_CLOSE_VERTICAL :
3613 {
3614 nFlyDirection = 1;
3615 nFlyMethod = 13;
3616 }
3617 break;
3618 case ::com::sun::star::presentation::AnimationEffect_CLOSE_HORIZONTAL :
3619 {
3620 nFlyDirection = 3;
3621 nFlyMethod = 13;
3622 }
3623 break;
3624 case ::com::sun::star::presentation::AnimationEffect_OPEN_VERTICAL :
3625 {
3626 nFlyDirection = 0;
3627 nFlyMethod = 13;
3628 }
3629 break;
3630 case ::com::sun::star::presentation::AnimationEffect_OPEN_HORIZONTAL :
3631 {
3632 nFlyDirection = 2;
3633 nFlyMethod = 13;
3634 }
3635 break;
3636 case ::com::sun::star::presentation::AnimationEffect_PATH :
3637 {
3638 nFlyDirection = 28;
3639 nFlyMethod = 12;
3640 }
3641 break;
3642 case ::com::sun::star::presentation::AnimationEffect_MOVE_TO_LEFT :
3643 {
3644 nFlyDirection = 0;
3645 nFlyMethod = 1;
3646 }
3647 break;
3648 case ::com::sun::star::presentation::AnimationEffect_MOVE_TO_TOP :
3649 {
3650 nFlyDirection = 0;
3651 nFlyMethod = 1;
3652 }
3653 break;
3654 case ::com::sun::star::presentation::AnimationEffect_MOVE_TO_RIGHT :
3655 {
3656 nFlyDirection = 0;
3657 nFlyMethod = 1;
3658 }
3659 break;
3660 case ::com::sun::star::presentation::AnimationEffect_MOVE_TO_BOTTOM :
3661 {
3662 nFlyDirection = 0;
3663 nFlyMethod = 1;
3664 }
3665 break;
3666 case ::com::sun::star::presentation::AnimationEffect_SPIRALIN_LEFT :
3667 case ::com::sun::star::presentation::AnimationEffect_SPIRALIN_RIGHT :
3668 case ::com::sun::star::presentation::AnimationEffect_SPIRALOUT_LEFT :
3669 case ::com::sun::star::presentation::AnimationEffect_SPIRALOUT_RIGHT :
3670 {
3671 nFlyDirection = 0x1c;
3672 nFlyMethod = 0xc;
3673 }
3674 break;
3675 case ::com::sun::star::presentation::AnimationEffect_DISSOLVE :
3676 {
3677 nFlyDirection = 0;
3678 nFlyMethod = 5;
3679 }
3680 break;
3681 case ::com::sun::star::presentation::AnimationEffect_WAVYLINE_FROM_LEFT :
3682 {
3683 nFlyDirection = 2;
3684 nFlyMethod = 10;
3685 }
3686 break;
3687 case ::com::sun::star::presentation::AnimationEffect_WAVYLINE_FROM_TOP :
3688 {
3689 nFlyDirection = 3;
3690 nFlyMethod = 10;
3691 }
3692 break;
3693 case ::com::sun::star::presentation::AnimationEffect_WAVYLINE_FROM_RIGHT :
3694 {
3695 nFlyDirection = 0;
3696 nFlyMethod = 10;
3697 }
3698 break;
3699 case ::com::sun::star::presentation::AnimationEffect_WAVYLINE_FROM_BOTTOM :
3700 {
3701 nFlyDirection = 1;
3702 nFlyMethod = 10;
3703 }
3704 break;
3705 case ::com::sun::star::presentation::AnimationEffect_RANDOM :
3706 {
3707 nFlyDirection = 0;
3708 nFlyMethod = 1;
3709 }
3710 break;
3711 case ::com::sun::star::presentation::AnimationEffect_VERTICAL_LINES :
3712 {
3713 nFlyDirection = 1;
3714 nFlyMethod = 8;
3715 }
3716 break;
3717 case ::com::sun::star::presentation::AnimationEffect_HORIZONTAL_LINES :
3718 {
3719 nFlyDirection = 0;
3720 nFlyMethod = 8;
3721 }
3722 break;
3723 case ::com::sun::star::presentation::AnimationEffect_LASER_FROM_LEFT :
3724 {
3725 nFlyDirection = 2;
3726 nFlyMethod = 10;
3727 }
3728 break;
3729 case ::com::sun::star::presentation::AnimationEffect_LASER_FROM_TOP :
3730 {
3731 nFlyDirection = 3;
3732 nFlyMethod = 10;
3733 }
3734 break;
3735 case ::com::sun::star::presentation::AnimationEffect_LASER_FROM_RIGHT :
3736 {
3737 nFlyDirection = 0;
3738 nFlyMethod = 10;
3739 }
3740 break;
3741 case ::com::sun::star::presentation::AnimationEffect_LASER_FROM_BOTTOM :
3742 {
3743 nFlyDirection = 1;
3744 nFlyMethod = 10;
3745 }
3746 break;
3747 case ::com::sun::star::presentation::AnimationEffect_LASER_FROM_UPPERLEFT :
3748 {
3749 nFlyDirection = 7;
3750 nFlyMethod = 9;
3751 }
3752 break;
3753 case ::com::sun::star::presentation::AnimationEffect_LASER_FROM_UPPERRIGHT :
3754 {
3755 nFlyDirection = 6;
3756 nFlyMethod = 9;
3757 }
3758 break;
3759 case ::com::sun::star::presentation::AnimationEffect_LASER_FROM_LOWERLEFT :
3760 {
3761 nFlyDirection = 5;
3762 nFlyMethod = 9;
3763 }
3764 break;
3765 case ::com::sun::star::presentation::AnimationEffect_LASER_FROM_LOWERRIGHT :
3766 {
3767 nFlyDirection = 4;
3768 nFlyMethod = 9;
3769 }
3770 break;
3771 case ::com::sun::star::presentation::AnimationEffect_APPEAR :
3772 break;
3773 case ::com::sun::star::presentation::AnimationEffect_HIDE :
3774 {
3775 nFlyDirection = 0;
3776 nFlyMethod = 1;
3777 }
3778 break;
3779 case ::com::sun::star::presentation::AnimationEffect_MOVE_FROM_UPPERLEFT :
3780 {
3781 nFlyDirection = 4;
3782 nFlyMethod = 12;
3783 }
3784 break;
3785 case ::com::sun::star::presentation::AnimationEffect_MOVE_FROM_UPPERRIGHT :
3786 {
3787 nFlyDirection = 5;
3788 nFlyMethod = 12;
3789 }
3790 break;
3791 case ::com::sun::star::presentation::AnimationEffect_MOVE_FROM_LOWERRIGHT :
3792 {
3793 nFlyDirection = 7;
3794 nFlyMethod = 12;
3795 }
3796 break;
3797 case ::com::sun::star::presentation::AnimationEffect_MOVE_FROM_LOWERLEFT :
3798 {
3799 nFlyDirection = 6;
3800 nFlyMethod = 12;
3801 }
3802 break;
3803 case ::com::sun::star::presentation::AnimationEffect_MOVE_TO_UPPERLEFT :
3804 case ::com::sun::star::presentation::AnimationEffect_MOVE_TO_UPPERRIGHT :
3805 case ::com::sun::star::presentation::AnimationEffect_MOVE_TO_LOWERRIGHT :
3806 case ::com::sun::star::presentation::AnimationEffect_MOVE_TO_LOWERLEFT :
3807 nAfterEffect |= 2;
3808 break;
3809 case ::com::sun::star::presentation::AnimationEffect_MOVE_SHORT_FROM_LEFT :
3810 case ::com::sun::star::presentation::AnimationEffect_MOVE_SHORT_FROM_UPPERLEFT :
3811 {
3812 nFlyDirection = 8;
3813 nFlyMethod = 12;
3814 }
3815 break;
3816 case ::com::sun::star::presentation::AnimationEffect_MOVE_SHORT_FROM_TOP :
3817 case ::com::sun::star::presentation::AnimationEffect_MOVE_SHORT_FROM_UPPERRIGHT :
3818 {
3819 nFlyDirection = 11;
3820 nFlyMethod = 12;
3821 }
3822 break;
3823 case ::com::sun::star::presentation::AnimationEffect_MOVE_SHORT_FROM_RIGHT :
3824 case ::com::sun::star::presentation::AnimationEffect_MOVE_SHORT_FROM_LOWERRIGHT :
3825 {
3826 nFlyDirection = 10;
3827 nFlyMethod = 12;
3828 }
3829 break;
3830 case ::com::sun::star::presentation::AnimationEffect_MOVE_SHORT_FROM_BOTTOM :
3831 case ::com::sun::star::presentation::AnimationEffect_MOVE_SHORT_FROM_LOWERLEFT :
3832 {
3833 nFlyDirection = 9;
3834 nFlyMethod = 12;
3835 }
3836 break;
3837 case ::com::sun::star::presentation::AnimationEffect_MOVE_SHORT_TO_LEFT :
3838 case ::com::sun::star::presentation::AnimationEffect_MOVE_SHORT_TO_UPPERLEFT :
3839 case ::com::sun::star::presentation::AnimationEffect_MOVE_SHORT_TO_TOP :
3840 case ::com::sun::star::presentation::AnimationEffect_MOVE_SHORT_TO_UPPERRIGHT :
3841 case ::com::sun::star::presentation::AnimationEffect_MOVE_SHORT_TO_RIGHT :
3842 case ::com::sun::star::presentation::AnimationEffect_MOVE_SHORT_TO_LOWERRIGHT :
3843 case ::com::sun::star::presentation::AnimationEffect_MOVE_SHORT_TO_BOTTOM :
3844 case ::com::sun::star::presentation::AnimationEffect_MOVE_SHORT_TO_LOWERLEFT :
3845 nAfterEffect |= 2;
3846 break;
3847 case ::com::sun::star::presentation::AnimationEffect_VERTICAL_CHECKERBOARD :
3848 {
3849 nFlyDirection = 1;
3850 nFlyMethod = 3;
3851 }
3852 break;
3853 case ::com::sun::star::presentation::AnimationEffect_HORIZONTAL_CHECKERBOARD :
3854 {
3855 nFlyDirection = 0;
3856 nFlyMethod = 3;
3857 }
3858 break;
3859 case ::com::sun::star::presentation::AnimationEffect_HORIZONTAL_ROTATE :
3860 case ::com::sun::star::presentation::AnimationEffect_VERTICAL_ROTATE :
3861 {
3862 nFlyDirection = 27;
3863 nFlyMethod = 12;
3864 }
3865 break;
3866 case ::com::sun::star::presentation::AnimationEffect_HORIZONTAL_STRETCH :
3867 case ::com::sun::star::presentation::AnimationEffect_VERTICAL_STRETCH :
3868 {
3869 nFlyDirection = 22;
3870 nFlyMethod = 12;
3871 }
3872 break;
3873 case ::com::sun::star::presentation::AnimationEffect_STRETCH_FROM_LEFT :
3874 case ::com::sun::star::presentation::AnimationEffect_STRETCH_FROM_UPPERLEFT :
3875 {
3876 nFlyDirection = 23;
3877 nFlyMethod = 12;
3878 }
3879 break;
3880 case ::com::sun::star::presentation::AnimationEffect_STRETCH_FROM_TOP :
3881 case ::com::sun::star::presentation::AnimationEffect_STRETCH_FROM_UPPERRIGHT :
3882 {
3883 nFlyDirection = 24;
3884 nFlyMethod = 12;
3885 }
3886 break;
3887 case ::com::sun::star::presentation::AnimationEffect_STRETCH_FROM_RIGHT :
3888 case ::com::sun::star::presentation::AnimationEffect_STRETCH_FROM_LOWERRIGHT :
3889 {
3890 nFlyDirection = 25;
3891 nFlyMethod = 12;
3892 }
3893 break;
3894 case ::com::sun::star::presentation::AnimationEffect_STRETCH_FROM_BOTTOM :
3895 case ::com::sun::star::presentation::AnimationEffect_STRETCH_FROM_LOWERLEFT :
3896 {
3897 nFlyDirection = 26;
3898 nFlyMethod = 12;
3899 }
3900 break;
3901 case ::com::sun::star::presentation::AnimationEffect_ZOOM_IN :
3902 {
3903 nFlyDirection = 16;
3904 nFlyMethod = 12;
3905 }
3906 break;
3907 case ::com::sun::star::presentation::AnimationEffect_ZOOM_IN_SMALL :
3908 case ::com::sun::star::presentation::AnimationEffect_ZOOM_IN_SPIRAL :
3909 {
3910 nFlyDirection = 17;
3911 nFlyMethod = 12;
3912 }
3913 break;
3914 case ::com::sun::star::presentation::AnimationEffect_ZOOM_OUT :
3915 {
3916 nFlyDirection = 18;
3917 nFlyMethod = 12;
3918 }
3919 break;
3920 case ::com::sun::star::presentation::AnimationEffect_ZOOM_OUT_SMALL :
3921 case ::com::sun::star::presentation::AnimationEffect_ZOOM_OUT_SPIRAL :
3922 {
3923 nFlyDirection = 19;
3924 nFlyMethod = 12;
3925 }
3926 break;
3927 case ::com::sun::star::presentation::AnimationEffect_ZOOM_IN_FROM_LEFT :
3928 case ::com::sun::star::presentation::AnimationEffect_ZOOM_IN_FROM_UPPERLEFT :
3929 case ::com::sun::star::presentation::AnimationEffect_ZOOM_IN_FROM_TOP :
3930 case ::com::sun::star::presentation::AnimationEffect_ZOOM_IN_FROM_UPPERRIGHT :
3931 case ::com::sun::star::presentation::AnimationEffect_ZOOM_IN_FROM_RIGHT :
3932 case ::com::sun::star::presentation::AnimationEffect_ZOOM_IN_FROM_LOWERRIGHT :
3933 case ::com::sun::star::presentation::AnimationEffect_ZOOM_IN_FROM_BOTTOM :
3934 case ::com::sun::star::presentation::AnimationEffect_ZOOM_IN_FROM_LOWERLEFT :
3935 case ::com::sun::star::presentation::AnimationEffect_ZOOM_IN_FROM_CENTER :
3936 {
3937 nFlyDirection = 16;
3938 nFlyMethod = 12;
3939 }
3940 break;
3941 case ::com::sun::star::presentation::AnimationEffect_ZOOM_OUT_FROM_LEFT :
3942 case ::com::sun::star::presentation::AnimationEffect_ZOOM_OUT_FROM_UPPERLEFT :
3943 case ::com::sun::star::presentation::AnimationEffect_ZOOM_OUT_FROM_TOP :
3944 case ::com::sun::star::presentation::AnimationEffect_ZOOM_OUT_FROM_UPPERRIGHT :
3945 case ::com::sun::star::presentation::AnimationEffect_ZOOM_OUT_FROM_RIGHT :
3946 case ::com::sun::star::presentation::AnimationEffect_ZOOM_OUT_FROM_LOWERRIGHT :
3947 case ::com::sun::star::presentation::AnimationEffect_ZOOM_OUT_FROM_BOTTOM :
3948 case ::com::sun::star::presentation::AnimationEffect_ZOOM_OUT_FROM_LOWERLEFT :
3949 case ::com::sun::star::presentation::AnimationEffect_ZOOM_OUT_FROM_CENTER :
3950 nAfterEffect |= 2;
3951 break;
3952 default:
3953 break;
3954 }
3955 if ( mnDiaMode >= 1 )
3956 nFlags |= 4;
3957 if ( eTe != ::com::sun::star::presentation::AnimationEffect_NONE )
3958 nBuildType = 2;
3959 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "SoundOn" ) ) ) )
3960 {
3961 sal_Bool bBool;
3962 mAny >>= bBool;
3963 if ( bBool )
3964 {
3965 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "Sound" ) ) ) )
3966 {
3967 nSoundRef = maSoundCollection.GetId( *(::rtl::OUString*)mAny.getValue() );
3968 if ( nSoundRef )
3969 nFlags |= 0x10;
3970 }
3971 }
3972 }
3973 sal_Bool bDimHide = sal_False;
3974 sal_Bool bDimPrevious = sal_False;
3975 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "DimHide" ) ) ) )
3976 mAny >>= bDimHide;
3977 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "DimPrevious" ) ) ) )
3978 mAny >>= bDimPrevious;
3979 if ( bDimPrevious )
3980 nAfterEffect |= 1;
3981 if ( bDimHide )
3982 nAfterEffect |= 2;
3983 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "DimColor" ) ) ) )
3984 nDimColor = mpPptEscherEx->GetColor( *((sal_uInt32*)mAny.getValue()) ) | 0xfe000000;
3985
3986 rSt << nDimColor << nFlags << nSoundRef << nDelayTime
3987 << nOrder // order of build ( 1.. )
3988 << nSlideCount << nBuildType << nFlyMethod << nFlyDirection
3989 << nAfterEffect << nSubEffect << nOleVerb
3990 << (sal_uInt16)0; // PadWord
3991 }
3992
3993 // -----------------------------------------------------------------------
3994
ImplWriteClickAction(SvStream & rSt,::com::sun::star::presentation::ClickAction eCa,sal_Bool bMediaClickAction)3995 void PPTWriter::ImplWriteClickAction( SvStream& rSt, ::com::sun::star::presentation::ClickAction eCa, sal_Bool bMediaClickAction )
3996 {
3997 sal_uInt32 nSoundRef = 0; // a reference to a sound in the sound collection, or NULL.
3998 sal_uInt32 nHyperLinkID = 0;// a persistent unique identifier to an external hyperlink object (only valid when action == HyperlinkAction).
3999 sal_uInt8 nAction = 0; // Action See Action Table
4000 sal_uInt8 nOleVerb = 0; // OleVerb Only valid when action == OLEAction. OLE verb to use, 0 = first verb, 1 = second verb, etc.
4001 sal_uInt8 nJump = 0; // Jump See Jump Table
4002 sal_uInt8 nFlags = 0; // Bit 1: Animated. If 1, then button is animated
4003 // Bit 2: Stop sound. If 1, then stop current sound when button is pressed.
4004 // Bit 3: CustomShowReturn. If 1, and this is a jump to custom show, then return to this slide after custom show.
4005 sal_uInt8 nHyperLinkType = 0;// HyperlinkType a value from the LinkTo enum, such as LT_URL (only valid when action == HyperlinkAction).
4006
4007 String aFile;
4008
4009 /*
4010 Action Table: Action Value
4011 NoAction 0
4012 MacroAction 1
4013 RunProgramAction 2
4014 JumpAction 3
4015 HyperlinkAction 4
4016 OLEAction 5
4017 MediaAction 6
4018 CustomShowAction 7
4019
4020 Jump Table: Jump Value
4021 NoJump 0
4022 NextSlide, 1
4023 PreviousSlide, 2
4024 FirstSlide, 3
4025 LastSlide, 4
4026 LastSlideViewed 5
4027 EndShow 6
4028 */
4029
4030 if ( bMediaClickAction )
4031 nAction = 6;
4032 else switch( eCa )
4033 {
4034 case ::com::sun::star::presentation::ClickAction_STOPPRESENTATION :
4035 nJump += 2;
4036 case ::com::sun::star::presentation::ClickAction_LASTPAGE :
4037 nJump++;
4038 case ::com::sun::star::presentation::ClickAction_FIRSTPAGE :
4039 nJump++;
4040 case ::com::sun::star::presentation::ClickAction_PREVPAGE :
4041 nJump++;
4042 case ::com::sun::star::presentation::ClickAction_NEXTPAGE :
4043 {
4044 nJump++;
4045 nAction = 3;
4046 }
4047 break;
4048 case ::com::sun::star::presentation::ClickAction_SOUND :
4049 {
4050 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "Bookmark" ) ) ) )
4051 nSoundRef = maSoundCollection.GetId( *(::rtl::OUString*)mAny.getValue() );
4052 }
4053 break;
4054 case ::com::sun::star::presentation::ClickAction_PROGRAM :
4055 {
4056 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "Bookmark" ) ) ) )
4057 {
4058 INetURLObject aUrl( *(::rtl::OUString*)mAny.getValue() );
4059 if ( INET_PROT_FILE == aUrl.GetProtocol() )
4060 {
4061 aFile = aUrl.PathToFileName();
4062 nAction = 2;
4063 }
4064 }
4065 }
4066 break;
4067
4068 case ::com::sun::star::presentation::ClickAction_BOOKMARK :
4069 {
4070 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "Bookmark" ) ) ) )
4071 {
4072 String aBookmark( *(::rtl::OUString*)mAny.getValue() );
4073 sal_uInt32 nIndex = 0;
4074 for ( String* pStr = (String*)maSlideNameList.First(); pStr; pStr = (String*)maSlideNameList.Next(), nIndex++ )
4075 {
4076 if ( *pStr == aBookmark )
4077 {
4078 // Bookmark ist ein link zu einer Dokumentseite
4079 nAction = 4;
4080 nHyperLinkType = 7;
4081
4082 String aEmpty;
4083 String aHyperString = UniString::CreateFromInt32( 256 + nIndex );
4084 aHyperString.Append( String( RTL_CONSTASCII_USTRINGPARAM( "," ) ) );
4085 aHyperString.Append( String::CreateFromInt32( nIndex + 1 ) );
4086 aHyperString.Append( String( RTL_CONSTASCII_USTRINGPARAM( ",Slide " ) ) );
4087 aHyperString.Append( String::CreateFromInt32( nIndex + 1 ) );
4088 nHyperLinkID = ImplInsertBookmarkURL( aHyperString, 1 | ( nIndex << 8 ) | ( 1 << 31 ), aBookmark, aEmpty, aEmpty, aHyperString );
4089 }
4090 }
4091 }
4092 }
4093 break;
4094
4095 case ::com::sun::star::presentation::ClickAction_DOCUMENT :
4096 {
4097 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "Bookmark" ) ) ) )
4098 {
4099 String aBookmark( *(::rtl::OUString*)mAny.getValue() );
4100 if ( aBookmark.Len() )
4101 {
4102 nAction = 4;
4103 nHyperLinkType = 8;
4104
4105 String aEmpty;
4106 String aBookmarkFile( aBookmark );
4107 INetURLObject aUrl( aBookmark );
4108 if ( INET_PROT_FILE == aUrl.GetProtocol() )
4109 aBookmarkFile = aUrl.PathToFileName();
4110 nHyperLinkID = ImplInsertBookmarkURL( aBookmark, (sal_uInt32)(2 | ( 1 << 31 )), aBookmarkFile, aBookmark, aEmpty, aEmpty );
4111 }
4112 }
4113 }
4114 break;
4115
4116 case ::com::sun::star::presentation::ClickAction_INVISIBLE :
4117 case ::com::sun::star::presentation::ClickAction_VERB :
4118 case ::com::sun::star::presentation::ClickAction_VANISH :
4119 case ::com::sun::star::presentation::ClickAction_MACRO :
4120 default :
4121 break;
4122 }
4123
4124 sal_uInt32 nContainerSize = 24;
4125 if ( nAction == 2 )
4126 nContainerSize += ( aFile.Len() * 2 ) + 8;
4127 rSt << (sal_uInt32)( ( EPP_InteractiveInfo << 16 ) | 0xf ) << (sal_uInt32)nContainerSize
4128 << (sal_uInt32)( EPP_InteractiveInfoAtom << 16 ) << (sal_uInt32)16
4129 << nSoundRef
4130 << nHyperLinkID
4131 << nAction
4132 << nOleVerb
4133 << nJump
4134 << nFlags
4135 << (sal_uInt32)nHyperLinkType;
4136
4137 if ( nAction == 2 ) // run program Action
4138 {
4139 sal_uInt16 i, nLen = aFile.Len();
4140 rSt << (sal_uInt32)( ( EPP_CString << 16 ) | 0x20 ) << (sal_uInt32)( nLen * 2 );
4141 for ( i = 0; i < nLen; i++ )
4142 rSt << aFile.GetChar( i );
4143 }
4144
4145 rSt << (sal_uInt32)( ( EPP_InteractiveInfo << 16 ) | 0x1f ) << (sal_uInt32)24 // Mouse Over Action
4146 << (sal_uInt32)( EPP_InteractiveInfo << 16 ) << (sal_uInt32)16;
4147 for ( int i = 0; i < 4; i++, rSt << (sal_uInt32)0 ) ;
4148 }
4149
4150 // -----------------------------------------------------------------------
4151
ImplGetEffect(const::com::sun::star::uno::Reference<::com::sun::star::beans::XPropertySet> & rPropSet,::com::sun::star::presentation::AnimationEffect & eEffect,::com::sun::star::presentation::AnimationEffect & eTextEffect,sal_Bool & bIsSound)4152 sal_Bool PPTWriter::ImplGetEffect( const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > & rPropSet,
4153 ::com::sun::star::presentation::AnimationEffect& eEffect,
4154 ::com::sun::star::presentation::AnimationEffect& eTextEffect,
4155 sal_Bool& bIsSound )
4156 {
4157 ::com::sun::star::uno::Any aAny;
4158 if ( GetPropertyValue( aAny, rPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "Effect" ) ) ) )
4159 aAny >>= eEffect;
4160 else
4161 eEffect = ::com::sun::star::presentation::AnimationEffect_NONE;
4162
4163 if ( GetPropertyValue( aAny, rPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "TextEffect" ) ) ) )
4164 aAny >>= eTextEffect;
4165 else
4166 eTextEffect = ::com::sun::star::presentation::AnimationEffect_NONE;
4167 if ( GetPropertyValue( aAny, rPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "SoundOn" ) ) ) )
4168 aAny >>= bIsSound;
4169 else
4170 bIsSound = sal_False;
4171
4172 sal_Bool bHasEffect = ( ( eEffect != ::com::sun::star::presentation::AnimationEffect_NONE )
4173 || ( eTextEffect != ::com::sun::star::presentation::AnimationEffect_NONE )
4174 || bIsSound );
4175 return bHasEffect;
4176 };
4177
4178 // -----------------------------------------------------------------------
4179
ImplCreatePresentationPlaceholder(const sal_Bool bMasterPage,const PageType,const sal_uInt32 nStyleInstance,const sal_uInt8 nPlaceHolderId)4180 sal_Bool PPTWriter::ImplCreatePresentationPlaceholder( const sal_Bool bMasterPage, const PageType /* ePageType */,
4181 const sal_uInt32 nStyleInstance, const sal_uInt8 nPlaceHolderId )
4182 {
4183 sal_Bool bRet = ImplGetText();
4184 if ( bRet && bMasterPage )
4185 {
4186 mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
4187 sal_uInt32 nPresShapeID = mpPptEscherEx->GenerateShapeId();
4188 mpPptEscherEx->AddShape( ESCHER_ShpInst_Rectangle, 0xa00, nPresShapeID );// Flags: HaveAnchor | HasSpt
4189 EscherPropertyContainer aPropOpt;
4190 aPropOpt.AddOpt( ESCHER_Prop_LockAgainstGrouping, 0x50001 );
4191 aPropOpt.AddOpt( ESCHER_Prop_lTxid, mnTxId += 0x60 );
4192 aPropOpt.AddOpt( ESCHER_Prop_AnchorText, ESCHER_AnchorMiddle );
4193 aPropOpt.AddOpt( ESCHER_Prop_fNoFillHitTest, 0x110001 );
4194 aPropOpt.AddOpt( ESCHER_Prop_lineColor, 0x8000001 );
4195 aPropOpt.AddOpt( ESCHER_Prop_shadowColor, 0x8000002 );
4196 aPropOpt.CreateFillProperties( mXPropSet, sal_True, mXShape );
4197 sal_uInt32 nLineFlags = 0x90001;
4198 if ( aPropOpt.GetOpt( ESCHER_Prop_fNoLineDrawDash, nLineFlags ) )
4199 nLineFlags |= 0x10001; // draw dashed line if no line
4200 aPropOpt.AddOpt( ESCHER_Prop_fNoLineDrawDash, nLineFlags );
4201
4202 SvMemoryStream aExtBu( 0x200, 0x200 );
4203 SvMemoryStream aClientTextBox( 0x200, 0x200 );
4204 ImplWriteTextStyleAtom( aClientTextBox, nStyleInstance, 0, NULL, aExtBu, &aPropOpt );
4205
4206 aPropOpt.CreateTextProperties( mXPropSet, mnTxId += 0x60, sal_False, sal_True );
4207 aPropOpt.CreateShapeProperties( mXShape );
4208 aPropOpt.Commit( *mpStrm );
4209 mpPptEscherEx->AddAtom( 8, ESCHER_ClientAnchor );
4210 *mpStrm << (sal_Int16)maRect.Top() << (sal_Int16)maRect.Left() << (sal_Int16)maRect.Right() << (sal_Int16)maRect.Bottom(); // oben, links, rechts, unten ????
4211 mpPptEscherEx->OpenContainer( ESCHER_ClientData );
4212 mpPptEscherEx->AddAtom( 8, EPP_OEPlaceholderAtom );
4213 *mpStrm << (sal_uInt32)0 // PlacementID
4214 << (sal_uInt8)nPlaceHolderId // PlaceHolderID
4215 << (sal_uInt8)0 // Size of PlaceHolder ( 0 = FULL, 1 = HALF, 2 = QUARTER )
4216 << (sal_uInt16)0; // padword
4217 mpPptEscherEx->CloseContainer(); // ESCHER_ClientData
4218 /*
4219 if ( aExtBu.Tell() )
4220 {
4221 if ( !pClientData )
4222 pClientData = new SvMemoryStream( 0x200, 0x200 );
4223 ImplProgTagContainer( pClientData, &aExtBu );
4224 }
4225 */
4226 if ( aClientTextBox.Tell() )
4227 {
4228 *mpStrm << (sal_uInt32)( ( ESCHER_ClientTextbox << 16 ) | 0xf )
4229 << (sal_uInt32)aClientTextBox.Tell();
4230
4231 mpStrm->Write( aClientTextBox.GetData(), aClientTextBox.Tell() );
4232 }
4233 mpPptEscherEx->CloseContainer(); // ESCHER_SpContainer
4234 }
4235 else
4236 bRet = sal_False;
4237 return bRet;
4238 }
4239
4240 // -----------------------------------------------------------------------
4241
ImplCreateShape(sal_uInt32 nType,sal_uInt32 nFlags,EscherSolverContainer & rSolver)4242 void PPTWriter::ImplCreateShape( sal_uInt32 nType, sal_uInt32 nFlags, EscherSolverContainer& rSolver )
4243 {
4244 sal_uInt32 nId = mpPptEscherEx->GenerateShapeId();
4245 mpPptEscherEx->AddShape( nType, nFlags, nId );
4246 rSolver.AddShape( mXShape, nId );
4247 }
4248
ImplCreateTextShape(EscherPropertyContainer & rPropOpt,EscherSolverContainer & rSolver,sal_Bool bFill)4249 void PPTWriter::ImplCreateTextShape( EscherPropertyContainer& rPropOpt, EscherSolverContainer& rSolver, sal_Bool bFill )
4250 {
4251 mnTextStyle = EPP_TEXTSTYLE_TEXT;
4252 mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
4253 ImplCreateShape( ESCHER_ShpInst_TextBox, 0xa00, rSolver );
4254 if ( bFill )
4255 rPropOpt.CreateFillProperties( mXPropSet, sal_True, mXShape );
4256 if ( ImplGetText() )
4257 rPropOpt.CreateTextProperties( mXPropSet, mnTxId += 0x60, sal_False, sal_True );
4258 }
4259
ImplWritePage(const PHLayout & rLayout,EscherSolverContainer & aSolverContainer,PageType ePageType,sal_Bool bMasterPage,int nPageNumber)4260 void PPTWriter::ImplWritePage( const PHLayout& rLayout, EscherSolverContainer& aSolverContainer, PageType ePageType, sal_Bool bMasterPage, int nPageNumber )
4261 {
4262 // #119551# PPT does not support groups of polygons and text (MS patch KB2289187)
4263 // sal_uInt32 nGroupLevel = 0;
4264
4265 sal_uInt32 nInstance, nGroups, nShapes, nShapeCount, nPer, nLastPer, nIndices, nOlePictureId;
4266 sal_uInt16 nEffectCount;
4267 ::com::sun::star::awt::Point aTextRefPoint;
4268
4269 ResetGroupTable( nShapes = mXShapes->getCount() );
4270
4271 nIndices = nInstance = nLastPer = nShapeCount = nEffectCount = 0;
4272
4273 sal_Bool bIsTitlePossible = sal_True; // bei mehr als einem title geht powerpoint in die knie
4274
4275 sal_uInt32 nOutlinerCount = 0; // die gliederungsobjekte muessen dem layout entsprechen,
4276 sal_uInt32 nPrevTextStyle = 0; // es darf nicht mehr als zwei geben
4277
4278 nOlePictureId = 0;
4279
4280 sal_Bool bAdditionalText = sal_False;
4281
4282 sal_Bool bSecOutl = sal_False;
4283 sal_uInt32 nPObjects = 0;
4284
4285 SvMemoryStream* pClientTextBox = NULL;
4286 SvMemoryStream* pClientData = NULL;
4287
4288 while( GetNextGroupEntry() )
4289 {
4290 nShapeCount++;
4291
4292 nPer = ( 5 * nShapeCount ) / nShapes;
4293 if ( nPer != nLastPer )
4294 {
4295 nLastPer = nPer;
4296 sal_uInt32 nValue = mnPagesWritten * 5 + nPer;
4297 if ( nValue > mnStatMaxValue )
4298 nValue = mnStatMaxValue;
4299 if ( mbStatusIndicator && ( nValue > mnLatestStatValue ) )
4300 {
4301 mXStatusIndicator->setValue( nValue );
4302 mnLatestStatValue = nValue;
4303 }
4304 }
4305 nGroups = GetGroupsClosed();
4306 for ( sal_uInt32 i = 0; i < nGroups; i++, mpPptEscherEx->LeaveGroup() ) ;
4307
4308 if ( ImplGetShapeByIndex( GetCurrentGroupIndex(), sal_True ) )
4309 {
4310 sal_Bool bIsSound;
4311 sal_Bool bMediaClickAction = sal_False;
4312 ::com::sun::star::presentation::AnimationEffect eAe;
4313 ::com::sun::star::presentation::AnimationEffect eTe;
4314
4315 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "PresentationOrder" ) ) ) )
4316 nEffectCount = *(sal_uInt16*)mAny.getValue();
4317
4318 sal_Bool bEffect = ImplGetEffect( mXPropSet, eAe, eTe, bIsSound );
4319 ::com::sun::star::presentation::ClickAction eCa = ::com::sun::star::presentation::ClickAction_NONE;
4320 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "OnClick" ) ) ) )
4321 mAny >>= eCa;
4322
4323 sal_Bool bGroup = mType == "drawing.Group";
4324 sal_Bool bOpenBezier = mType == "drawing.OpenBezier";
4325 sal_Bool bClosedBezier = mType == "drawing.ClosedBezier";
4326 sal_Bool bPolyPolygon = mType == "drawing.PolyPolygon";
4327 sal_Bool bPolyLine = mType == "drawing.PolyLine";
4328
4329 List aAdjustmentList;
4330 Rectangle aPolyBoundRect;
4331
4332 const ::com::sun::star::awt::Size aSize100thmm( mXShape->getSize() );
4333 const ::com::sun::star::awt::Point aPoint100thmm( mXShape->getPosition() );
4334 Rectangle aRect100thmm( Point( aPoint100thmm.X, aPoint100thmm.Y ), Size( aSize100thmm.Width, aSize100thmm.Height ) );
4335 EscherPropertyContainer aPropOpt( mpPptEscherEx->GetGraphicProvider(), mpPicStrm, aRect100thmm );
4336
4337 if ( bGroup )
4338 {
4339 SvMemoryStream* pTmp = NULL;
4340 ::com::sun::star::uno::Reference< ::com::sun::star::container::XIndexAccess >
4341 aXIndexAccess( mXShape, ::com::sun::star::uno::UNO_QUERY );
4342 if ( EnterGroup( aXIndexAccess ) )
4343 {
4344 if ( bEffect && !mbUseNewAnimations )
4345 {
4346 pTmp = new SvMemoryStream( 0x200, 0x200 );
4347 ImplWriteObjectEffect( *pTmp, eAe, eTe, ++nEffectCount );
4348 }
4349 if ( eCa != ::com::sun::star::presentation::ClickAction_NONE )
4350 {
4351 if ( !pTmp )
4352 pTmp = new SvMemoryStream( 0x200, 0x200 );
4353 ImplWriteClickAction( *pTmp, eCa, bMediaClickAction );
4354 }
4355 sal_uInt32 nShapeId = mpPptEscherEx->EnterGroup( &maRect, pTmp );
4356 aSolverContainer.AddShape( mXShape, nShapeId );
4357 delete pTmp;
4358 }
4359 }
4360 else
4361 {
4362 sal_Bool bIsFontwork = sal_False;
4363 sal_Bool bIsHatching = sal_False;
4364 ::com::sun::star::uno::Any aAny;
4365 ::com::sun::star::drawing::FillStyle eFS;
4366 if ( GetPropertyValue( aAny, mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "IsFontwork" ) ), sal_True ) )
4367 aAny >>= bIsFontwork;
4368 if ( GetPropertyValue( aAny, mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "FillStyle" ) ), sal_True ) )
4369 {
4370 aAny >>= eFS;
4371 bIsHatching = eFS == ::com::sun::star::drawing::FillStyle_HATCH;
4372 }
4373 if ( bIsHatching || bIsFontwork || ( mType == "drawing.Measure" ) || ( mType == "drawing.Caption" ) )
4374 {
4375 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "BoundRect" ) ) ) )
4376 {
4377 ::com::sun::star::awt::Rectangle aRect( *(::com::sun::star::awt::Rectangle*)mAny.getValue() );
4378 maPosition = ImplMapPoint( ::com::sun::star::awt::Point( aRect.X, aRect.Y ) );
4379 maSize = ImplMapSize( ::com::sun::star::awt::Size( aRect.Width, aRect.Height ) );
4380 maRect = Rectangle( Point( maPosition.X, maPosition.Y ), Size( maSize.Width, maSize.Height ) );
4381 }
4382 mType = "drawing.dontknow";
4383 }
4384 }
4385 sal_uInt8 nPlaceHolderAtom = EPP_PLACEHOLDER_NONE;
4386
4387 mnTextSize = 0;
4388 mnTextStyle = EPP_TEXTSTYLE_NORMAL;
4389
4390 if ( mType == "drawing.Custom" )
4391 {
4392 mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
4393 sal_uInt32 nMirrorFlags;
4394 rtl::OUString sCustomShapeType;
4395 MSO_SPT eShapeType = aPropOpt.GetCustomShapeType( mXShape, nMirrorFlags, sCustomShapeType );
4396 if ( sCustomShapeType.equalsAscii( "col-502ad400" ) || sCustomShapeType.equalsAscii( "col-60da8460" ) )
4397 { // sj: creating metafile for customshapes that can't be saved to ms format properly
4398 ImplCreateShape( ESCHER_ShpInst_PictureFrame, 0xa00, aSolverContainer );
4399 if ( aPropOpt.CreateGraphicProperties( mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "MetaFile" ) ), sal_False ) )
4400 {
4401 aPropOpt.AddOpt( ESCHER_Prop_LockAgainstGrouping, 0x800080 );
4402 SdrObject* pObj = GetSdrObjectFromXShape( mXShape );
4403 if ( pObj )
4404 {
4405 Rectangle aBound = pObj->GetCurrentBoundRect();
4406 maPosition = ImplMapPoint( ::com::sun::star::awt::Point( aBound.Left(), aBound.Top() ) );
4407 maSize = ImplMapSize( ::com::sun::star::awt::Size ( aBound.GetWidth(), aBound.GetHeight() ) );
4408 maRect = Rectangle( Point( maPosition.X, maPosition.Y ), Size( maSize.Width, maSize.Height ) );
4409 mnAngle = 0;
4410 }
4411 }
4412 }
4413 else
4414 {
4415 ImplCreateShape( eShapeType, nMirrorFlags | 0xa00, aSolverContainer );
4416 aPropOpt.CreateCustomShapeProperties( eShapeType, mXShape );
4417 aPropOpt.CreateFillProperties( mXPropSet, sal_True, mXShape);
4418 if ( ImplGetText() )
4419 {
4420 if ( !aPropOpt.IsFontWork() )
4421 aPropOpt.CreateTextProperties( mXPropSet, mnTxId += 0x60, sal_True, sal_True );
4422 }
4423 }
4424 }
4425 else if ( mType == "drawing.Rectangle" )
4426 {
4427 sal_Int32 nRadius = 0;
4428 mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
4429 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CornerRadius" ) ) ) )
4430 {
4431 mAny >>= nRadius;
4432 nRadius = ImplMapSize( ::com::sun::star::awt::Size( nRadius, 0 ) ).Width;
4433 }
4434 if ( nRadius )
4435 {
4436 ImplCreateShape( ESCHER_ShpInst_RoundRectangle, 0xa00, aSolverContainer ); // Flags: Connector | HasSpt
4437 sal_Int32 nLenght = maRect.GetWidth();
4438 if ( nLenght > maRect.GetHeight() )
4439 nLenght = maRect.GetHeight();
4440 nLenght >>= 1;
4441 if ( nRadius >= nLenght )
4442 nRadius = 0x2a30; // 0x2a30 ist PPTs maximum radius
4443 else
4444 nRadius = ( 0x2a30 * nRadius ) / nLenght;
4445 aPropOpt.AddOpt( ESCHER_Prop_adjustValue, nRadius );
4446 }
4447 else
4448 {
4449 ImplCreateShape( ESCHER_ShpInst_Rectangle, 0xa00, aSolverContainer ); // Flags: Connector | HasSpt
4450 }
4451 aPropOpt.CreateFillProperties( mXPropSet, sal_True, mXShape );
4452 if ( ImplGetText() )
4453 aPropOpt.CreateTextProperties( mXPropSet, mnTxId += 0x60, sal_False, sal_False );
4454 }
4455 else if ( mType == "drawing.Ellipse" )
4456 {
4457 ::com::sun::star::drawing::CircleKind eCircleKind( ::com::sun::star::drawing::CircleKind_FULL );
4458 PolyStyle ePolyKind = POLY_CHORD;
4459 if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CircleKind" ) ) ) )
4460 {
4461 mAny >>= eCircleKind;
4462 switch ( eCircleKind )
4463 {
4464 case ::com::sun::star::drawing::CircleKind_SECTION :
4465 {
4466 ePolyKind = POLY_PIE;
4467 }
4468 break;
4469 case ::com::sun::star::drawing::CircleKind_ARC :
4470 {
4471 ePolyKind = POLY_ARC;
4472 }
4473 break;
4474
4475 case ::com::sun::star::drawing::CircleKind_CUT :
4476 {
4477 ePolyKind = POLY_CHORD;
4478 }
4479 break;
4480
4481 default:
4482 eCircleKind = ::com::sun::star::drawing::CircleKind_FULL;
4483 }
4484 }
4485 if ( eCircleKind == ::com::sun::star::drawing::CircleKind_FULL )
4486 {
4487 mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
4488 ImplCreateShape( ESCHER_ShpInst_Ellipse, 0xa00, aSolverContainer ); // Flags: Connector | HasSpt
4489 aPropOpt.CreateFillProperties( mXPropSet, sal_True, mXShape );
4490 if ( ImplGetText() )
4491 aPropOpt.CreateTextProperties( mXPropSet, mnTxId += 0x60, sal_False, sal_False );
4492 }
4493 else
4494 {
4495 sal_Int32 nStartAngle, nEndAngle;
4496 if ( !ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CircleStartAngle" ) ) ) )
4497 continue;
4498 nStartAngle = *( (sal_Int32*)mAny.getValue() );
4499 if( !ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CircleEndAngle" ) ) ) )
4500 continue;
4501 nEndAngle = *( (sal_Int32*)mAny.getValue() );
4502 ::com::sun::star::awt::Point aPoint( mXShape->getPosition() );
4503 ::com::sun::star::awt::Size aSize( mXShape->getSize() );
4504 ::com::sun::star::awt::Point aStart, aEnd, aCenter;
4505 Rectangle aRect( Point( aPoint.X, aPoint.Y ), Size( aSize.Width, aSize.Height ) );
4506 aStart.X = (sal_Int32)( ( cos( (double)( nStartAngle * F_PI18000 ) ) * 100.0 ) );
4507 aStart.Y = - (sal_Int32)( ( sin( (double)( nStartAngle * F_PI18000 ) ) * 100.0 ) );
4508 aEnd.X = (sal_Int32)( ( cos( (double)( nEndAngle * F_PI18000 ) ) * 100.0 ) );
4509 aEnd.Y = - (sal_Int32)( ( sin( (double)( nEndAngle * F_PI18000 ) ) * 100.0 ) );
4510 aCenter.X = aPoint.X + ( aSize.Width / 2 );
4511 aCenter.Y = aPoint.Y + ( aSize.Height / 2 );
4512 aStart.X += aCenter.X;
4513 aStart.Y += aCenter.Y;
4514 aEnd.X += aCenter.X;
4515 aEnd.Y += aCenter.Y;
4516 Polygon aPolygon( aRect, Point( aStart.X, aStart.Y ), Point( aEnd.X, aEnd.Y ), ePolyKind );
4517 sal_Bool bNeedText = sal_True;
4518 if ( mnAngle )
4519 {
4520 aPolygon.Rotate( aRect.TopLeft(), (sal_uInt16)( mnAngle / 10 ) );
4521 if ( ImplGetText() )
4522 {
4523 // #119551# PPT does not support groups of polygons and text (MS patch KB2289187)
4524 // mpPptEscherEx->EnterGroup( 0,0 );
4525 // nGroupLevel = mpPptEscherEx->GetGroupLevel();
4526 bNeedText = sal_False;
4527 bAdditionalText = sal_True;
4528 mnTextSize = 0;
4529 }
4530 mnAngle = 0;
4531 }
4532 mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
4533 ImplCreateShape( ESCHER_ShpInst_NotPrimitive, 0xa00, aSolverContainer ); // Flags: Connector | HasSpt
4534 ::com::sun::star::awt::Rectangle aNewRect;
4535 switch ( ePolyKind )
4536 {
4537 case POLY_PIE :
4538 case POLY_CHORD :
4539 {
4540 if ( aPropOpt.CreatePolygonProperties( mXPropSet, ESCHER_CREATEPOLYGON_POLYPOLYGON, sal_False, aNewRect, &aPolygon ) )
4541 aPropOpt.CreateFillProperties( mXPropSet, sal_True , mXShape );
4542 }
4543 break;
4544
4545 case POLY_ARC :
4546 {
4547 if ( aPropOpt.CreatePolygonProperties( mXPropSet, ESCHER_CREATEPOLYGON_POLYLINE, sal_False, aNewRect, &aPolygon ) )
4548 aPropOpt.CreateLineProperties( mXPropSet, sal_False );
4549 }
4550 break;
4551 }
4552 maRect = ImplMapRectangle( aNewRect );
4553 maPosition = ::com::sun::star::awt::Point( maRect.Left(), maRect.Top() );
4554 maSize = ::com::sun::star::awt::Size( maRect.GetWidth(), maRect.GetHeight() );
4555 if ( bNeedText && ImplGetText() )
4556 aPropOpt.CreateTextProperties( mXPropSet, mnTxId += 0x60, sal_False, sal_False );
4557 }
4558 }
4559 else if ( mType == "drawing.Control" )
4560 {
4561 ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XControlShape >
4562 aXControlShape( mXShape, ::com::sun::star::uno::UNO_QUERY );
4563 if ( !aXControlShape.is() )
4564 continue;
4565 ::com::sun::star::uno::Reference< ::com::sun::star::awt::XControlModel >
4566 aXControlModel( aXControlShape->getControl() );
4567 if ( !aXControlModel.is() )
4568 continue;
4569
4570 sal_Int64 nAspect = ::com::sun::star::embed::Aspects::MSOLE_CONTENT;
4571 try
4572 {
4573 // try to get the aspect when available
4574 ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >
4575 xShapeProps( mXShape, ::com::sun::star::uno::UNO_QUERY_THROW );
4576 xShapeProps->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Aspect" ) ) ) >>= nAspect;
4577 }
4578 catch( ::com::sun::star::uno::Exception& )
4579 {}
4580
4581 *mpExEmbed << (sal_uInt32)( 0xf | ( EPP_ExControl << 16 ) )
4582 << (sal_uInt32)0; // Size of this container
4583
4584 sal_uInt32 nSize, nOldPos = mpExEmbed->Tell();
4585
4586 sal_uInt32 nPageId = nPageNumber;
4587 if ( ePageType == MASTER )
4588 nPageId |= 0x80000000;
4589 else
4590 nPageId += 0x100;
4591 *mpExEmbed << (sal_uInt32)( EPP_ExControlAtom << 16 )
4592 << (sal_uInt32)4
4593 << nPageId;
4594 PPTExOleObjEntry* pEntry = new PPTExOleObjEntry( OCX_CONTROL, mpExEmbed->Tell() );
4595 pEntry->xControlModel = aXControlModel;
4596 pEntry->xShape = mXShape;
4597 maExOleObj.Insert( pEntry );
4598
4599 mnExEmbed++;
4600
4601 *mpExEmbed << (sal_uInt32)( 1 | ( EPP_ExOleObjAtom << 16 ) )
4602 << (sal_uInt32)24
4603 << (sal_uInt32)nAspect
4604 << (sal_uInt32)2
4605 << (sal_uInt32)mnExEmbed
4606 << (sal_uInt32)0
4607 << (sal_uInt32)4 // index to the persist table
4608 << (sal_uInt32)0x0012de00;
4609
4610
4611 ::com::sun::star::awt::Size aSize;
4612 String aControlName;
4613 SvStorageRef xTemp( new SvStorage( new SvMemoryStream(), sal_True ) );
4614 if ( SvxMSConvertOCXControls::WriteOCXStream( xTemp, aXControlModel, aSize, aControlName ) )
4615 {
4616 String aUserName( xTemp->GetUserName() );
4617 String aOleIdentifier;
4618 if ( aUserName.Len() )
4619 {
4620 SvStorageStreamRef xCompObj = xTemp->OpenSotStream(
4621 String( RTL_CONSTASCII_USTRINGPARAM( "\1CompObj" ) ),
4622 STREAM_READ | STREAM_NOCREATE | STREAM_SHARE_DENYALL );
4623 xCompObj->Seek( STREAM_SEEK_TO_END );
4624 sal_uInt32 nStreamLen = xCompObj->Tell();
4625 xCompObj->Seek( 0 );
4626 sal_Int16 nVersion, nByteOrder;
4627 sal_Int32 nWinVersion, nVal, nStringLen;
4628 *xCompObj >> nVersion
4629 >> nByteOrder
4630 >> nWinVersion
4631 >> nVal;
4632 xCompObj->SeekRel( 16 ); // skipping clsid
4633 *xCompObj >> nStringLen;
4634 if ( ( xCompObj->Tell() + nStringLen ) < nStreamLen )
4635 {
4636 xCompObj->SeekRel( nStringLen ); // now skipping the UserName;
4637 *xCompObj >> nStringLen;
4638 if ( ( xCompObj->Tell() + nStringLen ) < nStreamLen )
4639 {
4640 xCompObj->SeekRel( nStringLen ); // now skipping the clipboard formatname
4641 *xCompObj >> nStringLen;
4642 if ( ( nStringLen > 1 ) && ( ( xCompObj->Tell() + nStringLen ) < nStreamLen ) )
4643 { // i think that the OleIdentifier will follow
4644 ByteString aTemp;
4645 sal_Char* p = aTemp.AllocBuffer( (sal_uInt16)(nStringLen - 1) );
4646 xCompObj->Read( p, nStringLen - 1 );
4647 aOleIdentifier = String( aTemp, gsl_getSystemTextEncoding() );
4648 }
4649 }
4650 }
4651 }
4652 if ( aControlName.Len() )
4653 PPTWriter::WriteCString( *mpExEmbed, aControlName, 1 );
4654 if ( aOleIdentifier.Len() )
4655 PPTWriter::WriteCString( *mpExEmbed, aOleIdentifier, 2 );
4656 if ( aUserName.Len() )
4657 PPTWriter::WriteCString( *mpExEmbed, aUserName, 3 );
4658 }
4659 nSize = mpExEmbed->Tell() - nOldPos;
4660 mpExEmbed->Seek( nOldPos - 4 );
4661 *mpExEmbed << nSize;
4662 mpExEmbed->Seek( STREAM_SEEK_TO_END );
4663 nOlePictureId = mnExEmbed;
4664
4665 mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
4666 sal_uInt32 nSpFlags = SHAPEFLAG_HAVESPT | SHAPEFLAG_HAVEANCHOR | SHAPEFLAG_OLESHAPE;
4667 ImplCreateShape( ESCHER_ShpInst_HostControl, nSpFlags, aSolverContainer );
4668 if ( aPropOpt.CreateGraphicProperties( mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "MetaFile" ) ), sal_False ) )
4669 aPropOpt.AddOpt( ESCHER_Prop_LockAgainstGrouping, 0x800080 );
4670 //export form control graphic
4671 else if ( aPropOpt.CreateBlipPropertiesforOLEControl(mXPropSet,mXShape))
4672 aPropOpt.AddOpt( ESCHER_Prop_LockAgainstGrouping, 0x800080 );
4673 aPropOpt.AddOpt( ESCHER_Prop_pictureId, mnExEmbed );
4674 aPropOpt.AddOpt( ESCHER_Prop_pictureActive, 0x10000 );
4675
4676 if ( aControlName.Len() )
4677 {
4678 sal_uInt16 i, nBufSize;
4679 nBufSize = ( aControlName.Len() + 1 ) << 1;
4680 sal_uInt8* pBuf = new sal_uInt8[ nBufSize ];
4681 sal_uInt8* pTmp = pBuf;
4682 for ( i = 0; i < aControlName.Len(); i++ )
4683 {
4684 sal_Unicode nUnicode = aControlName.GetChar( i );
4685 *pTmp++ = (sal_uInt8)nUnicode;
4686 *pTmp++ = (sal_uInt8)( nUnicode >> 8 );
4687 }
4688 *pTmp++ = 0;
4689 *pTmp = 0;
4690 aPropOpt.AddOpt( ESCHER_Prop_wzName, sal_True, nBufSize, pBuf, nBufSize );
4691 }
4692 }
4693 else if ( mType == "drawing.Connector" )
4694 {
4695 sal_uInt16 nSpType, nSpFlags;
4696 ::com::sun::star::awt::Rectangle aNewRect;
4697 if ( aPropOpt.CreateConnectorProperties( mXShape, aSolverContainer, aNewRect, nSpType, nSpFlags ) == sal_False )
4698 continue;
4699
4700 maRect = ImplMapRectangle( aNewRect );
4701 maPosition = ::com::sun::star::awt::Point( maRect.Left(), maRect.Top() );
4702 maSize = ::com::sun::star::awt::Size( maRect.GetWidth(), maRect.GetHeight() );
4703
4704 mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
4705 ImplCreateShape( nSpType, nSpFlags, aSolverContainer );
4706
4707 // #119459# for connector shape, the start point and end point is fixed, and should not be rotated.
4708 mnAngle = 0;
4709 }
4710 else if ( mType == "drawing.Measure" )
4711 {
4712 continue;
4713 }
4714 else if ( mType == "drawing.Line" )
4715 {
4716 ::com::sun::star::awt::Rectangle aNewRect;
4717 aPropOpt.CreatePolygonProperties( mXPropSet, ESCHER_CREATEPOLYGON_LINE, sal_False, aNewRect, NULL );
4718 maRect = ImplMapRectangle( aNewRect );
4719 maPosition = ::com::sun::star::awt::Point( maRect.Left(), maRect.Top() );
4720 maSize = ::com::sun::star::awt::Size( maRect.GetWidth(), maRect.GetHeight() );
4721 if ( ImplGetText() )
4722 {
4723 aTextRefPoint = ::com::sun::star::awt::Point( maRect.Left(), maRect.Top() );
4724 mnTextSize = 0;
4725 bAdditionalText = sal_True;
4726 // #119551# PPT does not support groups of polygons and text (MS patch KB2289187)
4727 // mpPptEscherEx->EnterGroup( &maRect,0 );
4728 }
4729 mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
4730 sal_uInt32 nFlags = 0xa00; // Flags: Connector | HasSpt
4731 if ( maRect.Top() > maRect.Bottom() )
4732 nFlags |= 0x80; // Flags: VertMirror
4733 if ( maRect.Left() > maRect.Right() )
4734 nFlags |= 0x40; // Flags: HorzMirror
4735
4736 ImplCreateShape( ESCHER_ShpInst_Line, nFlags, aSolverContainer );
4737 aPropOpt.AddOpt( ESCHER_Prop_shapePath, ESCHER_ShapeComplex );
4738 aPropOpt.CreateLineProperties( mXPropSet, sal_False );
4739 mnAngle = 0;
4740 }
4741 else if ( bPolyPolygon )
4742 {
4743 if ( ImplGetText() )
4744 {
4745 // #119551# PPT does not support groups of polygons and text (MS patch KB2289187)
4746 // mpPptEscherEx->EnterGroup( 0,0 );
4747 // nGroupLevel = mpPptEscherEx->GetGroupLevel();
4748 bAdditionalText = sal_True;
4749 mnTextSize = 0;
4750 }
4751 mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
4752 ImplCreateShape( ESCHER_ShpInst_NotPrimitive, 0xa00, aSolverContainer ); // Flags: Connector | HasSpt
4753 ::com::sun::star::awt::Rectangle aNewRect;
4754 aPropOpt.CreatePolygonProperties( mXPropSet, ESCHER_CREATEPOLYGON_POLYPOLYGON, sal_False, aNewRect, NULL );
4755 maRect = ImplMapRectangle( aNewRect );
4756 maPosition = ::com::sun::star::awt::Point( maRect.Left(), maRect.Top() );
4757 maSize = ::com::sun::star::awt::Size( maRect.GetWidth(), maRect.GetHeight() );
4758 aPropOpt.CreateFillProperties( mXPropSet, sal_True , mXShape );
4759 mnAngle = 0;
4760 }
4761 else if ( bPolyLine )
4762 {
4763 if ( ImplGetText() )
4764 {
4765 // #119551# PPT does not support groups of polygons and text (MS patch KB2289187)
4766 // mpPptEscherEx->EnterGroup( 0,0 );
4767 // nGroupLevel = mpPptEscherEx->GetGroupLevel();
4768 bAdditionalText = sal_True;
4769 mnTextSize = 0;
4770 }
4771 mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
4772 ImplCreateShape( ESCHER_ShpInst_NotPrimitive, 0xa00, aSolverContainer ); // Flags: Connector | HasSpt
4773 ::com::sun::star::awt::Rectangle aNewRect;
4774 aPropOpt.CreatePolygonProperties( mXPropSet, ESCHER_CREATEPOLYGON_POLYLINE, sal_False, aNewRect, NULL );
4775 maRect = ImplMapRectangle( aNewRect );
4776 maPosition = ::com::sun::star::awt::Point( maRect.Left(), maRect.Top() );
4777 maSize = ::com::sun::star::awt::Size( maRect.GetWidth(), maRect.GetHeight() );
4778 aPropOpt.CreateLineProperties( mXPropSet, sal_False );
4779 mnAngle = 0;
4780 }
4781 else if ( bOpenBezier )
4782 {
4783 if ( ImplGetText() )
4784 {
4785 // #119551# PPT does not support groups of polygons and text (MS patch KB2289187)
4786 // mpPptEscherEx->EnterGroup( 0,0 );
4787 // nGroupLevel = mpPptEscherEx->GetGroupLevel();
4788 bAdditionalText = sal_True;
4789 mnTextSize = 0;
4790 }
4791 mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
4792 ImplCreateShape( ESCHER_ShpInst_NotPrimitive, 0xa00, aSolverContainer ); // Flags: Connector | HasSpt
4793 ::com::sun::star::awt::Rectangle aNewRect;
4794 aPropOpt.CreatePolygonProperties( mXPropSet, ESCHER_CREATEPOLYGON_POLYLINE, sal_True, aNewRect, NULL );
4795 maRect = ImplMapRectangle( aNewRect );
4796 maPosition = ::com::sun::star::awt::Point( maRect.Left(), maRect.Top() );
4797 maSize = ::com::sun::star::awt::Size( maRect.GetWidth(), maRect.GetHeight() );
4798 aPropOpt.CreateLineProperties( mXPropSet, sal_False );
4799 mnAngle = 0;
4800 }
4801 else if ( bClosedBezier )
4802 {
4803 if ( ImplGetText() )
4804 {
4805 // #119551# PPT does not support groups of polygons and text (MS patch KB2289187)
4806 // mpPptEscherEx->EnterGroup( 0,0 );
4807 // nGroupLevel = mpPptEscherEx->GetGroupLevel();
4808 bAdditionalText = sal_True;
4809 mnTextSize = 0;
4810 }
4811 mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
4812 ImplCreateShape( ESCHER_ShpInst_NotPrimitive, 0xa00, aSolverContainer ); // Flags: Connector | HasSpt
4813 ::com::sun::star::awt::Rectangle aNewRect;
4814 aPropOpt.CreatePolygonProperties( mXPropSet, ESCHER_CREATEPOLYGON_POLYPOLYGON, sal_True, aNewRect, NULL );
4815 maRect = ImplMapRectangle( aNewRect );
4816 maPosition = ::com::sun::star::awt::Point( maRect.Left(), maRect.Top() );
4817 maSize = ::com::sun::star::awt::Size( maRect.GetWidth(), maRect.GetHeight() );
4818 aPropOpt.CreateFillProperties( mXPropSet, sal_True , mXShape );
4819 mnAngle = 0;
4820 }
4821 else if ( ( mType == "drawing.GraphicObject" ) || ( mType == "presentation.GraphicObject" ) )
4822 {
4823 mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
4824
4825 // ein GraphicObject kann auch ein ClickMe Element sein
4826 if ( mbEmptyPresObj && ( ePageType == NORMAL ) )
4827 {
4828 nPlaceHolderAtom = rLayout.nUsedObjectPlaceHolder;
4829 ImplCreateShape( ESCHER_ShpInst_Rectangle, 0x220, aSolverContainer ); // Flags: HaveAnchor | HaveMaster
4830 aPropOpt.AddOpt( ESCHER_Prop_lTxid, mnTxId += 0x60 );
4831 aPropOpt.AddOpt( ESCHER_Prop_fNoFillHitTest, 0x10001 );
4832 aPropOpt.AddOpt( ESCHER_Prop_fNoLineDrawDash, 0x10001 );
4833 aPropOpt.AddOpt( ESCHER_Prop_hspMaster, mnShapeMasterBody );
4834 }
4835 else
4836 {
4837 mXText = ::com::sun::star::uno::Reference<
4838 ::com::sun::star::text::XSimpleText >
4839 ( mXShape, ::com::sun::star::uno::UNO_QUERY );
4840
4841 if ( mXText.is() )
4842 mnTextSize = mXText->getString().getLength();
4843
4844 if ( mnTextSize ) // graphic object oder Flachenfuellung
4845 {
4846 /* SJ #i34951#: because M. documents are not allowing GraphicObjects containing text, we
4847 have to create a simpe Rectangle with fill bitmap instead (while not allowing BitmapMode_Repeat).
4848 */
4849 ImplCreateShape( ESCHER_ShpInst_Rectangle, 0xa00, aSolverContainer ); // Flags: Connector | HasSpt
4850 if ( aPropOpt.CreateGraphicProperties( mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "GraphicURL" ) ), sal_True, sal_True, sal_False ) )
4851 {
4852 aPropOpt.AddOpt( ESCHER_Prop_WrapText, ESCHER_WrapNone );
4853 aPropOpt.AddOpt( ESCHER_Prop_AnchorText, ESCHER_AnchorMiddle );
4854 aPropOpt.AddOpt( ESCHER_Prop_fNoFillHitTest, 0x140014 );
4855 aPropOpt.AddOpt( ESCHER_Prop_fillBackColor, 0x8000000 );
4856 aPropOpt.AddOpt( ESCHER_Prop_fNoLineDrawDash, 0x80000 );
4857 if ( ImplGetText() )
4858 aPropOpt.CreateTextProperties( mXPropSet, mnTxId += 0x60, sal_False, sal_False );
4859 }
4860 }
4861 else
4862 {
4863 ImplCreateShape( ESCHER_ShpInst_PictureFrame, 0xa00, aSolverContainer );
4864
4865 if ( aPropOpt.CreateGraphicProperties( mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "GraphicURL" ) ), sal_False, sal_True ) )
4866 {
4867 aPropOpt.AddOpt( ESCHER_Prop_LockAgainstGrouping, 0x800080 );
4868 }
4869 }
4870 }
4871 }
4872 else if ( ( mType == "drawing.Text" ) || ( mType == "presentation.Notes" ) )
4873 {
4874 if ( ( ePageType == NOTICE ) && mbPresObj )
4875 {
4876 if ( ImplCreatePresentationPlaceholder( bMasterPage, ePageType, EPP_TEXTTYPE_Notes, EPP_PLACEHOLDER_MASTERNOTESBODYIMAGE ) )
4877 continue;
4878 else
4879 nPlaceHolderAtom = EPP_PLACEHOLDER_NOTESBODY;
4880 }
4881 ImplCreateTextShape( aPropOpt, aSolverContainer, sal_True );
4882 }
4883 else if ( mType == "presentation.TitleText" )
4884 {
4885 if ( mbPresObj )
4886 {
4887 if ( ( ePageType == NOTICE ) && mbEmptyPresObj )
4888 {
4889 mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
4890 nPlaceHolderAtom = EPP_PLACEHOLDER_MASTERNOTESBODYIMAGE;
4891 ImplCreateShape( ESCHER_ShpInst_Rectangle, 0x200, aSolverContainer );
4892 aPropOpt.CreateLineProperties( mXPropSet, sal_False );
4893 aPropOpt.AddOpt( ESCHER_Prop_fNoFillHitTest, 0x10001 );
4894 }
4895 else if ( rLayout.bTitlePossible && bIsTitlePossible )
4896 {
4897 bIsTitlePossible = sal_False;
4898
4899 ImplGetText();
4900 TextObj aTextObj( mXText, EPP_TEXTTYPE_Title, maFontCollection, (PPTExBulletProvider&)*this );
4901 if ( ePageType == MASTER )
4902 {
4903 if ( mnTextSize )
4904 {
4905 ::rtl::OUString aUString( mXText->getString() );
4906 sal_uInt16 nChar;
4907
4908 mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
4909 mnShapeMasterTitle = mpPptEscherEx->GenerateShapeId();
4910 mpPptEscherEx->AddShape( ESCHER_ShpInst_Rectangle, 0xa00, mnShapeMasterTitle );// Flags: HaveAnchor | HasSpt
4911 EscherPropertyContainer aPropertyOptions;
4912 aPropertyOptions.AddOpt( ESCHER_Prop_LockAgainstGrouping, 0x50001 );
4913 aPropertyOptions.AddOpt( ESCHER_Prop_lTxid, mnTxId += 0x60 );
4914 aPropertyOptions.AddOpt( ESCHER_Prop_AnchorText, ESCHER_AnchorMiddle );
4915 // aPropertyOptions.AddOpt( ESCHER_Prop_fillColor, nFillColor );
4916 // aPropertyOptions.AddOpt( ESCHER_Prop_fillBackColor, nFillBackColor );
4917 aPropertyOptions.AddOpt( ESCHER_Prop_fNoFillHitTest, 0x110001 );
4918 aPropertyOptions.AddOpt( ESCHER_Prop_lineColor, 0x8000001 );
4919 aPropertyOptions.AddOpt( ESCHER_Prop_shadowColor, 0x8000002 );
4920 aPropertyOptions.CreateFillProperties( mXPropSet, sal_True, mXShape );
4921 sal_uInt32 nLineFlags = 0x90001;
4922 if ( aPropertyOptions.GetOpt( ESCHER_Prop_fNoLineDrawDash, nLineFlags ) )
4923 nLineFlags |= 0x10001; // draw dashed line if no line
4924 aPropertyOptions.AddOpt( ESCHER_Prop_fNoLineDrawDash, nLineFlags );
4925 aPropertyOptions.CreateTextProperties( mXPropSet, mnTxId += 0x60, sal_False, sal_True );
4926 ImplAdjustFirstLineLineSpacing( aTextObj, aPropOpt );
4927 aPropertyOptions.Commit( *mpStrm );
4928 mpPptEscherEx->AddAtom( 8, ESCHER_ClientAnchor );
4929 *mpStrm << (sal_Int16)maRect.Top() << (sal_Int16)maRect.Left() << (sal_Int16)maRect.Right() << (sal_Int16)maRect.Bottom(); // oben, links, rechts, unten ????
4930 mpPptEscherEx->OpenContainer( ESCHER_ClientData );
4931 mpPptEscherEx->AddAtom( 8, EPP_OEPlaceholderAtom );
4932 *mpStrm << (sal_uInt32)0 // PlacementID
4933 << (sal_uInt8)EPP_PLACEHOLDER_MASTERTITLE // PlaceHolderID
4934 << (sal_uInt8)0 // Size of PlaceHolder ( 0 = FULL, 1 = HALF, 2 = QUARTER )
4935 << (sal_uInt16)0; // padword
4936 mpPptEscherEx->CloseContainer(); // ESCHER_ClientData
4937 mpPptEscherEx->OpenContainer( ESCHER_ClientTextbox );
4938 mpPptEscherEx->AddAtom( 4, EPP_TextHeaderAtom );
4939 *mpStrm << (sal_uInt32)EPP_TEXTTYPE_Title;
4940 mpPptEscherEx->AddAtom( mnTextSize << 1, EPP_TextCharsAtom );
4941 const sal_Unicode* pString = aUString.getStr();
4942 for ( sal_uInt32 i = 0; i < mnTextSize; i++ )
4943 {
4944 nChar = pString[ i ]; // 0xa -> 0xb weicher Zeilenumbruch
4945 if ( nChar == 0xa )
4946 nChar++; // 0xd -> 0xd harter Zeilenumbruch
4947 *mpStrm << nChar;
4948 }
4949 mpPptEscherEx->AddAtom( 6, EPP_BaseTextPropAtom );
4950 *mpStrm << (sal_uInt32)( mnTextSize + 1 ) << (sal_uInt16)0;
4951 mpPptEscherEx->AddAtom( 10, EPP_TextSpecInfoAtom );
4952 *mpStrm << (sal_uInt32)( mnTextSize + 1 ) << (sal_uInt32)1 << (sal_uInt16)0;
4953 mpPptEscherEx->CloseContainer(); // ESCHER_ClientTextBox
4954 mpPptEscherEx->CloseContainer(); // ESCHER_SpContainer
4955 }
4956 continue;
4957 }
4958 else
4959 {
4960 mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
4961 mnTextStyle = EPP_TEXTSTYLE_TITLE;
4962 nPlaceHolderAtom = rLayout.nTypeOfTitle;
4963 ImplCreateShape( ESCHER_ShpInst_Rectangle, 0x220, aSolverContainer ); // Flags: HaveAnchor | HaveMaster
4964 aPropOpt.AddOpt( ESCHER_Prop_hspMaster, mnShapeMasterTitle );
4965 aPropOpt.CreateFillProperties( mXPropSet, sal_True, mXShape );
4966 aPropOpt.CreateTextProperties( mXPropSet, mnTxId += 0x60, sal_False, sal_True );
4967 ImplAdjustFirstLineLineSpacing( aTextObj, aPropOpt );
4968 if ( mbEmptyPresObj )
4969 {
4970 sal_uInt32 nNoLineDrawDash = 0;
4971 aPropOpt.GetOpt( ESCHER_Prop_fNoLineDrawDash, nNoLineDrawDash );
4972 nNoLineDrawDash |= 0x10001;
4973 aPropOpt.AddOpt( ESCHER_Prop_fNoLineDrawDash, nNoLineDrawDash );
4974 }
4975 }
4976 }
4977 else
4978 mbPresObj = sal_False;
4979 }
4980 if ( !mbPresObj )
4981 {
4982 mType = "drawing.Text";
4983 ImplCreateTextShape( aPropOpt, aSolverContainer, sal_True );
4984 }
4985 }
4986 else if ( ( mType == "presentation.Outliner" ) || ( mType == "presentation.Subtitle" ) )
4987 {
4988 if ( mbPresObj )
4989 {
4990 nOutlinerCount++;
4991 if ( (rLayout.bOutlinerPossible && ( nOutlinerCount == 1 )) ||
4992 (( rLayout.bSecOutlinerPossible && ( nOutlinerCount == 2 ) ) && ( nPrevTextStyle == EPP_TEXTSTYLE_BODY ))
4993 )
4994 {
4995 ImplGetText();
4996 TextObj aTextObj( mXText, EPP_TEXTTYPE_Body, maFontCollection, (PPTExBulletProvider&)*this );
4997 if ( ePageType == MASTER )
4998 {
4999 nPrevTextStyle = EPP_TEXTSTYLE_TITLE;
5000 if ( mnTextSize )
5001 {
5002 mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
5003 mnShapeMasterBody = mpPptEscherEx->GenerateShapeId();
5004 mpPptEscherEx->AddShape( ESCHER_ShpInst_Rectangle, 0xa00, mnShapeMasterBody ); // Flags: HaveAnchor | HasSpt
5005 EscherPropertyContainer aPropOpt2;
5006 aPropOpt2.AddOpt( ESCHER_Prop_LockAgainstGrouping, 0x50001 );
5007 aPropOpt2.AddOpt( ESCHER_Prop_lTxid, mnTxId += 0x60 );
5008 // aPropOpt2.AddOpt( ESCHER_Prop_fillColor, nFillColor );
5009 // aPropOpt2.AddOpt( ESCHER_Prop_fillBackColor, nFillBackColor );
5010 aPropOpt2.AddOpt( ESCHER_Prop_fNoFillHitTest, 0x110001 );
5011 aPropOpt2.AddOpt( ESCHER_Prop_lineColor, 0x8000001 );
5012 aPropOpt2.AddOpt( ESCHER_Prop_fNoLineDrawDash, 0x90001 );
5013 aPropOpt2.AddOpt( ESCHER_Prop_shadowColor, 0x8000002 );
5014 aPropOpt2.CreateFillProperties( mXPropSet, sal_True, mXShape );
5015 sal_uInt32 nLineFlags = 0x90001;
5016 if ( aPropOpt2.GetOpt( ESCHER_Prop_fNoLineDrawDash, nLineFlags ) )
5017 nLineFlags |= 0x10001; // draw dashed line if no line
5018 aPropOpt2.AddOpt( ESCHER_Prop_fNoLineDrawDash, nLineFlags );
5019 aPropOpt2.CreateTextProperties( mXPropSet, mnTxId += 0x60, sal_False, sal_True );
5020 ImplAdjustFirstLineLineSpacing( aTextObj, aPropOpt2 );
5021 aPropOpt2.Commit( *mpStrm );
5022 mpPptEscherEx->AddAtom( 8, ESCHER_ClientAnchor );
5023 *mpStrm << (sal_Int16)maRect.Top() << (sal_Int16)maRect.Left() << (sal_Int16)maRect.Right() << (sal_Int16)maRect.Bottom(); // oben, links, rechts, unten ????
5024 mpPptEscherEx->OpenContainer( ESCHER_ClientData );
5025 mpPptEscherEx->AddAtom( 8, EPP_OEPlaceholderAtom );
5026 sal_uInt8 PlaceHolderID = ( mType == "presentation.Subtitle") ? EPP_PLACEHOLDER_MASTERSUBTITLE:EPP_PLACEHOLDER_MASTERBODY;
5027 *mpStrm << (sal_uInt32)1 // PlacementID
5028 << PlaceHolderID/*(sal_uInt8)EPP_PLACEHOLDER_MASTERBODY */ // PlaceHolderID
5029 << (sal_uInt8)0 // Size of PlaceHolder ( 0 = FULL, 1 = HALF, 2 = QUARTER )
5030 << (sal_uInt16)0; // padword
5031 mpPptEscherEx->CloseContainer(); // ESCHER_ClientData
5032 mpPptEscherEx->OpenContainer( ESCHER_ClientTextbox ); // printf
5033 mpPptEscherEx->AddAtom( 4, EPP_TextHeaderAtom );
5034 if ( mType == "presentation.Subtitle")
5035 *mpStrm << (sal_uInt32)EPP_TEXTTYPE_CenterBody;
5036 else
5037 *mpStrm << (sal_uInt32)EPP_TEXTTYPE_Body;
5038 mnTextSize = aTextObj.Count();
5039 aTextObj.Write( mpStrm );
5040 mpPptEscherEx->BeginAtom();
5041 for ( ParagraphObj* pPara = aTextObj.First() ; pPara; pPara = aTextObj.Next() )
5042 {
5043 sal_uInt32 nCharCount = pPara->Count();
5044 sal_uInt16 nDepth = pPara->nDepth;
5045 if ( nDepth > 4)
5046 nDepth = 4;
5047
5048 *mpStrm << nCharCount
5049 << nDepth;
5050 }
5051 mpPptEscherEx->EndAtom( EPP_BaseTextPropAtom );
5052 mpPptEscherEx->AddAtom( 10, EPP_TextSpecInfoAtom );
5053 *mpStrm << (sal_uInt32)( mnTextSize ) << (sal_uInt32)1 << (sal_uInt16)0;
5054
5055 mpPptEscherEx->CloseContainer(); // ESCHER_ClientTextBox
5056 mpPptEscherEx->CloseContainer(); // ESCHER_SpContainer
5057 }
5058 continue;
5059 }
5060 else
5061 {
5062 mnTextStyle = EPP_TEXTSTYLE_BODY;
5063 nPlaceHolderAtom = rLayout.nTypeOfOutliner;
5064 mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
5065 ImplCreateShape( ESCHER_ShpInst_Rectangle, 0x220, aSolverContainer ); // Flags: HaveAnchor | HaveMaster
5066 aPropOpt.AddOpt( ESCHER_Prop_hspMaster, mnShapeMasterBody );
5067 aPropOpt.CreateFillProperties( mXPropSet, sal_True, mXShape );
5068 aPropOpt.CreateTextProperties( mXPropSet, mnTxId += 0x60, sal_False, sal_True );
5069 ImplAdjustFirstLineLineSpacing( aTextObj, aPropOpt );
5070 if ( mbEmptyPresObj )
5071 {
5072 sal_uInt32 nNoLineDrawDash = 0;
5073 aPropOpt.GetOpt( ESCHER_Prop_fNoLineDrawDash, nNoLineDrawDash );
5074 nNoLineDrawDash |= 0x10001;
5075 aPropOpt.AddOpt( ESCHER_Prop_fNoLineDrawDash, nNoLineDrawDash );
5076 }
5077 }
5078 }
5079 else
5080 mbPresObj = sal_False;
5081 }
5082 if ( !mbPresObj )
5083 {
5084 if (ePageType == MASTER )
5085 {
5086 SdrObject* pObj = GetSdrObjectFromXShape( mXShape );
5087 if (pObj && pObj->IsNotVisibleAsMaster())
5088 continue;
5089 }
5090
5091 mType = "drawing.Text";
5092 ImplCreateTextShape( aPropOpt, aSolverContainer, sal_True );
5093 }
5094 }
5095 else if ( ( mType == "drawing.Page" ) || ( mType == "presentation.Page" ) )
5096 {
5097 if ( ( ePageType == NOTICE ) && mbPresObj )
5098 {
5099 if ( ImplCreatePresentationPlaceholder( bMasterPage, ePageType, EPP_TEXTTYPE_Notes, EPP_PLACEHOLDER_MASTERNOTESSLIDEIMAGE ) )
5100 continue;
5101 else
5102 nPlaceHolderAtom = EPP_PLACEHOLDER_NOTESSLIDEIMAGE;
5103 }
5104 ImplCreateTextShape( aPropOpt, aSolverContainer, sal_True );
5105 }
5106 else if ( mType == "drawing.Frame" )
5107 {
5108 continue;
5109 }
5110 else if ( ( mType == "drawing.OLE2" ) || ( mType == "presentation.OLE2" )
5111 || ( mType == "presentation.Chart" ) || ( mType == "presentation.Calc" )
5112 || ( mType == "presentation.OrgChart" ) )
5113 {
5114 mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
5115 if ( mbEmptyPresObj && ( ePageType == NORMAL ) )
5116 {
5117 nPlaceHolderAtom = rLayout.nUsedObjectPlaceHolder;
5118 ImplCreateShape( ESCHER_ShpInst_Rectangle, 0x220, aSolverContainer ); // Flags: HaveAnchor | HaveMaster
5119 aPropOpt.AddOpt( ESCHER_Prop_lTxid, mnTxId += 0x60 );
5120 aPropOpt.AddOpt( ESCHER_Prop_fNoFillHitTest, 0x10001 );
5121 aPropOpt.AddOpt( ESCHER_Prop_fNoLineDrawDash, 0x10001 );
5122 aPropOpt.AddOpt( ESCHER_Prop_hspMaster, mnShapeMasterBody );
5123 }
5124 else
5125 {
5126 *mpExEmbed << (sal_uInt32)( 0xf | ( EPP_ExEmbed << 16 ) )
5127 << (sal_uInt32)0; // Size of this container
5128
5129 sal_uInt32 nSize, nOldPos = mpExEmbed->Tell();
5130
5131 *mpExEmbed << (sal_uInt32)( EPP_ExEmbedAtom << 16 )
5132 << (sal_uInt32)8
5133 << (sal_uInt32)0 // follow colorscheme : 0->do not follow
5134 // 1->follow collorscheme
5135 // 2->follow text and background scheme
5136 << (sal_uInt8)1 // (bool)set if embedded server can not be locked
5137 << (sal_uInt8)0 // (bool)do not need to send dimension
5138 << (sal_uInt8)0 // (bool)is object a world table
5139 << (sal_uInt8)0; // pad byte
5140
5141 PPTExOleObjEntry* pE = new PPTExOleObjEntry( NORMAL_OLE_OBJECT, mpExEmbed->Tell() );
5142 pE->xShape = mXShape;
5143 maExOleObj.Insert( pE );
5144
5145 mnExEmbed++;
5146
5147 sal_Int64 nAspect = ::com::sun::star::embed::Aspects::MSOLE_CONTENT;
5148 try
5149 {
5150 // try to get the aspect when available
5151 ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >
5152 xShapeProps( mXShape, ::com::sun::star::uno::UNO_QUERY_THROW );
5153 xShapeProps->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Aspect" ) ) ) >>= nAspect;
5154 }
5155 catch( ::com::sun::star::uno::Exception& )
5156 {}
5157
5158 *mpExEmbed << (sal_uInt32)( 1 | ( EPP_ExOleObjAtom << 16 ) )
5159 << (sal_uInt32)24
5160 << (sal_uInt32)nAspect // Aspect
5161 << (sal_uInt32)0
5162 << (sal_uInt32)mnExEmbed // index to the persist table
5163 << (sal_uInt32)0 // subtype
5164 << (sal_uInt32)0
5165 << (sal_uInt32)0x0012b600;
5166
5167 // PPTWriter::WriteCString( *mpExEmbed, "Photo Editor Photo", 1 );
5168 // PPTWriter::WriteCString( *mpExEmbed, "MSPhotoEd.3", 2 );
5169 // PPTWriter::WriteCString( *mpExEmbed, "Microsoft Photo Editor 3.0 Photo", 3 );
5170
5171 nSize = mpExEmbed->Tell() - nOldPos;
5172 mpExEmbed->Seek( nOldPos - 4 );
5173 *mpExEmbed << nSize;
5174 mpExEmbed->Seek( STREAM_SEEK_TO_END );
5175 nOlePictureId = mnExEmbed;
5176
5177 sal_uInt32 nSpFlags = 0xa00;
5178 if ( nOlePictureId )
5179 nSpFlags |= 0x10;
5180 ImplCreateShape( ESCHER_ShpInst_PictureFrame, nSpFlags, aSolverContainer );
5181 if ( aPropOpt.CreateOLEGraphicProperties( mXShape ) )
5182 aPropOpt.AddOpt( ESCHER_Prop_LockAgainstGrouping, 0x800080 );
5183 if ( nOlePictureId )
5184 aPropOpt.AddOpt( ESCHER_Prop_pictureId, nOlePictureId );
5185 }
5186 }
5187 else if ( mType == "presentation.Header" )
5188 {
5189 if ( ImplCreatePresentationPlaceholder( bMasterPage, ePageType, EPP_TEXTTYPE_Other, EPP_PLACEHOLDER_MASTERHEADER ) )
5190 continue;
5191 else
5192 {
5193 mbPresObj = sal_False;
5194 mType = "drawing.Text";
5195 ImplCreateTextShape( aPropOpt, aSolverContainer, sal_True );
5196 }
5197 }
5198 else if ( mType == "presentation.Footer" )
5199 {
5200 if ( ImplCreatePresentationPlaceholder( bMasterPage, ePageType, EPP_TEXTTYPE_Other, EPP_PLACEHOLDER_MASTERFOOTER ) )
5201 continue;
5202 else
5203 {
5204 mbPresObj = sal_False;
5205 mType = "drawing.Text";
5206 ImplCreateTextShape( aPropOpt, aSolverContainer, sal_True );
5207 }
5208 }
5209 else if ( mType == "presentation.DateTime" )
5210 {
5211 if ( ImplCreatePresentationPlaceholder( bMasterPage, ePageType, EPP_TEXTTYPE_Other, EPP_PLACEHOLDER_MASTERDATE ) )
5212 continue;
5213 else
5214 {
5215 mbPresObj = sal_False;
5216 mType = "drawing.Text";
5217 ImplCreateTextShape( aPropOpt, aSolverContainer, sal_True );
5218 }
5219 }
5220 else if ( mType == "presentation.SlideNumber" )
5221 {
5222 if ( ImplCreatePresentationPlaceholder( bMasterPage, ePageType, EPP_TEXTTYPE_Other, EPP_PLACEHOLDER_MASTERSLIDENUMBER ) )
5223 continue;
5224 else
5225 {
5226 mbPresObj = sal_False;
5227 mType = "drawing.Text";
5228 ImplCreateTextShape( aPropOpt, aSolverContainer, sal_True );
5229 }
5230 }
5231 else if ( ( (sal_Char)'3' == mType.GetChar( 8 ) ) && ( (char)'D' == mType.GetChar( 9 ) ) ) // drawing.3D
5232 {
5233 // SceneObject, CubeObject, SphereObject, LatheObject, ExtrudeObject, PolygonObject
5234 if ( !ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "Bitmap" ) ) ) )
5235 continue;
5236
5237 mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
5238 ImplCreateShape( ESCHER_ShpInst_PictureFrame, 0xa00, aSolverContainer );
5239
5240 if ( aPropOpt.CreateGraphicProperties( mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "Bitmap" ) ), sal_False ) )
5241 aPropOpt.AddOpt( ESCHER_Prop_LockAgainstGrouping, 0x800080 );
5242 }
5243 else if ( mType == "drawing.Media" )
5244 {
5245 mnAngle = 0;
5246 mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
5247 ImplCreateShape( ESCHER_ShpInst_PictureFrame, 0xa00, aSolverContainer );
5248 if ( aPropOpt.CreateMediaGraphicProperties( mXShape ) )
5249 aPropOpt.AddOpt( ESCHER_Prop_LockAgainstGrouping, 0x800080 );
5250 ::com::sun::star::uno::Any aAny;
5251 if ( PropValue::GetPropertyValue( aAny, mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "MediaURL" ) ), sal_True ) )
5252 {
5253 rtl::OUString aMediaURL;
5254 if ( (aAny >>= aMediaURL ) && aMediaURL.getLength() )
5255 {
5256 // SJ: creating the Media RefObj
5257 sal_uInt32 nRefId = ++mnExEmbed;
5258
5259 *mpExEmbed << (sal_uInt16)0xf
5260 << (sal_uInt16)EPP_ExMCIMovie // PPT_PST_ExAviMovie
5261 << (sal_uInt32)0;
5262 sal_uInt32 nSize, nStart = mpExEmbed->Tell();
5263 *mpExEmbed << (sal_uInt16)0
5264 << (sal_uInt16)EPP_ExObjRefAtom
5265 << (sal_uInt32)4
5266 << nRefId;
5267 *mpExEmbed << (sal_uInt16)0xf
5268 << (sal_uInt16)EPP_ExVideo
5269 << (sal_uInt32)0;
5270
5271 *mpExEmbed << (sal_uInt16)0
5272 << (sal_uInt16)EPP_ExMediaAtom
5273 << (sal_uInt32)8
5274 << nRefId
5275 << (sal_uInt16)0
5276 << (sal_uInt16)0x435;
5277
5278
5279 sal_uInt16 i, nStringLen = (sal_uInt16)aMediaURL.getLength();
5280 *mpExEmbed << (sal_uInt32)( EPP_CString << 16 ) << (sal_uInt32)( nStringLen * 2 );
5281 for ( i = 0; i < nStringLen; i++ )
5282 {
5283 sal_Unicode nChar = aMediaURL[ i ];
5284 *mpExEmbed << nChar;
5285 }
5286 nSize = mpExEmbed->Tell() - nStart;
5287 mpExEmbed->SeekRel( - ( (sal_Int32)nSize + 4 ) );
5288 *mpExEmbed << nSize; // size of PPT_PST_ExMCIMovie
5289 mpExEmbed->SeekRel( 0x10 );
5290 nSize -= 20;
5291 *mpExEmbed << nSize; // PPT_PST_ExMediaAtom
5292 mpExEmbed->SeekRel( nSize );
5293
5294 if ( !pClientData )
5295 pClientData = new SvMemoryStream( 0x200, 0x200 );
5296 *pClientData << (sal_uInt16)0
5297 << (sal_uInt16)EPP_ExObjRefAtom
5298 << (sal_uInt32)4
5299 << nRefId;
5300 // write EPP_InteractiveInfo container for no_action
5301 *pClientData << (sal_uInt32)( ( EPP_InteractiveInfo << 16 ) | 0xf ) << (sal_uInt32)24;
5302 *pClientData << (sal_uInt16)0
5303 << (sal_uInt16)EPP_InteractiveInfoAtom
5304 << (sal_uInt32)16
5305 << (sal_uInt32) 0
5306 << (sal_uInt32) 0
5307 << (sal_uInt8) 6
5308 << (sal_uInt8) 0
5309 << (sal_uInt8) 0
5310 << (sal_uInt8) 0
5311 << (sal_uInt32) 0;
5312 }
5313 }
5314 }
5315 else if ( (mType == "drawing.Table") || (mType == "presentation.Table") )
5316 {
5317 SvMemoryStream* pTmp = NULL;
5318 if ( bEffect && !mbUseNewAnimations )
5319 {
5320 pTmp = new SvMemoryStream( 0x200, 0x200 );
5321 ImplWriteObjectEffect( *pTmp, eAe, eTe, ++nEffectCount );
5322 }
5323 if ( eCa != ::com::sun::star::presentation::ClickAction_NONE )
5324 {
5325 if ( !pTmp )
5326 pTmp = new SvMemoryStream( 0x200, 0x200 );
5327 ImplWriteClickAction( *pTmp, eCa, bMediaClickAction );
5328 }
5329 ImplCreateTable( mXShape, aSolverContainer, aPropOpt );
5330 continue;
5331 }
5332 else if ( mType == "drawing.dontknow" )
5333 {
5334 mnAngle = 0;
5335 mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
5336 ImplCreateShape( ESCHER_ShpInst_PictureFrame, 0xa00, aSolverContainer );
5337 if ( aPropOpt.CreateGraphicProperties( mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "MetaFile" ) ), sal_False ) )
5338 aPropOpt.AddOpt( ESCHER_Prop_LockAgainstGrouping, 0x800080 );
5339 }
5340 else
5341 {
5342 continue;
5343 }
5344 sal_Int32 nPlacementID = -1;
5345
5346 sal_Bool bClientData = ( bEffect || ( eCa != ::com::sun::star::presentation::ClickAction_NONE ) ||
5347 nPlaceHolderAtom || nOlePictureId );
5348 if ( bClientData )
5349 {
5350 if ( nPlaceHolderAtom )
5351 {
5352 if ( ( mnTextStyle == EPP_TEXTSTYLE_TITLE ) || ( mnTextStyle == EPP_TEXTSTYLE_BODY ) )
5353 nPlacementID = nIndices++;
5354 else
5355 {
5356 switch ( nPlaceHolderAtom )
5357 {
5358 default :
5359 {
5360 if ( nPlaceHolderAtom < 19 )
5361 break;
5362 }
5363 case EPP_PLACEHOLDER_NOTESBODY :
5364 case EPP_PLACEHOLDER_MASTERDATE :
5365 case EPP_PLACEHOLDER_NOTESSLIDEIMAGE :
5366 case EPP_PLACEHOLDER_MASTERNOTESBODYIMAGE :
5367 nPlacementID = nIndices++;
5368 }
5369 }
5370 if ( !pClientData )
5371 pClientData = new SvMemoryStream( 0x200, 0x200 );
5372
5373 *pClientData << (sal_uInt32)( EPP_OEPlaceholderAtom << 16 ) << (sal_uInt32)8
5374 << nPlacementID // PlacementID
5375 << (sal_uInt8)nPlaceHolderAtom // PlaceHolderID
5376 << (sal_uInt8)0 // Size of PlaceHolder ( 0 = FULL, 1 = HALF, 2 = QUARTER )
5377 << (sal_uInt16)0; // padword
5378 }
5379 if ( nOlePictureId )
5380 {
5381 if ( !pClientData )
5382 pClientData = new SvMemoryStream( 0x200, 0x200 );
5383
5384 *pClientData << (sal_uInt32)( EPP_ExObjRefAtom << 16 ) << (sal_uInt32)4
5385 << nOlePictureId;
5386 nOlePictureId = 0;
5387 }
5388 if ( bEffect )
5389 {
5390 if ( !pClientData )
5391 pClientData = new SvMemoryStream( 0x200, 0x200 );
5392
5393 // check if it is sensible to replace the object effect with text effect,
5394 // because in Impress there is the possibility to use a compound effect,
5395 // e.g. the object effect is an AnimationEffect_FADE_FROM_LEFT and the
5396 // text effect is a AnimationEffect_FADE_FROM_TOP, in PowerPoint there
5397 // can be used only one effect
5398 if ( mnTextSize && ( eTe != ::com::sun::star::presentation::AnimationEffect_NONE )
5399 && ( eAe != ::com::sun::star::presentation::AnimationEffect_NONE )
5400 && ( eTe != eAe ) )
5401 {
5402 sal_uInt32 nFillStyleFlags, nLineStyleFlags;
5403 if ( aPropOpt.GetOpt( ESCHER_Prop_fNoFillHitTest, nFillStyleFlags )
5404 && aPropOpt.GetOpt( ESCHER_Prop_fNoLineDrawDash, nLineStyleFlags ) )
5405 {
5406 // there is no fillstyle and also no linestyle
5407 if ( ! ( ( nFillStyleFlags & 0x10 ) + ( nLineStyleFlags & 9 ) ) )
5408 eAe = eTe;
5409 }
5410 }
5411 if ( !mbUseNewAnimations )
5412 ImplWriteObjectEffect( *pClientData, eAe, eTe, ++nEffectCount );
5413 }
5414
5415 if ( eCa != ::com::sun::star::presentation::ClickAction_NONE )
5416 {
5417 if ( !pClientData )
5418 pClientData = new SvMemoryStream( 0x200, 0x200 );
5419 ImplWriteClickAction( *pClientData, eCa, bMediaClickAction );
5420 }
5421 }
5422 if ( ( mnTextStyle == EPP_TEXTSTYLE_TITLE ) || ( mnTextStyle == EPP_TEXTSTYLE_BODY ) )
5423 {
5424 if ( !pClientTextBox )
5425 pClientTextBox = new SvMemoryStream( 0x200, 0x200 );
5426
5427 if ( mbEmptyPresObj == sal_False )
5428 {
5429 if ( ( ePageType == NORMAL ) && ( bMasterPage == sal_False ) )
5430 {
5431 sal_uInt32 nTextType = EPP_TEXTTYPE_Body;
5432 if ( mnTextStyle == EPP_TEXTSTYLE_BODY )
5433 {
5434 if ( bSecOutl )
5435 nTextType = EPP_TEXTTYPE_HalfBody;
5436 else if ( mType == "presentation.Subtitle" )
5437 nTextType = EPP_TEXTTYPE_CenterBody;
5438 bSecOutl = sal_True;
5439 }
5440 else
5441 nTextType = EPP_TEXTTYPE_Title;
5442
5443 TextRuleEntry aTextRule( nPageNumber );
5444 SvMemoryStream aExtBu( 0x200, 0x200 );
5445 ImplGetText();
5446 ImplWriteTextStyleAtom( *pClientTextBox, nTextType, nPObjects, &aTextRule, aExtBu, NULL );
5447 ImplWriteExtParaHeader( aExtBu, nPObjects++, nTextType, nPageNumber + 0x100 );
5448 SvMemoryStream* pOut = aTextRule.pOut;
5449 if ( pOut )
5450 {
5451 pClientTextBox->Write( pOut->GetData(), pOut->Tell() );
5452 delete pOut, aTextRule.pOut = NULL;
5453 }
5454 if ( aExtBu.Tell() )
5455 {
5456 if ( !pClientData )
5457 pClientData = new SvMemoryStream( 0x200, 0x200 );
5458 ImplProgTagContainer( pClientData, &aExtBu );
5459 }
5460 }
5461 }
5462 }
5463 else
5464 {
5465 if ( !aPropOpt.IsFontWork() )
5466 {
5467 if ( mnTextSize || ( nPlaceHolderAtom == EPP_PLACEHOLDER_MASTERDATE ) || ( nPlaceHolderAtom == EPP_PLACEHOLDER_NOTESBODY ) )
5468 {
5469 int nInstance2;
5470 if ( ( nPlaceHolderAtom == EPP_PLACEHOLDER_MASTERDATE ) || ( nPlaceHolderAtom == EPP_PLACEHOLDER_NOTESBODY ) )
5471 nInstance2 = 2;
5472 else
5473 nInstance2 = EPP_TEXTTYPE_Other; // Text in a Shape
5474
5475 if ( !pClientTextBox )
5476 pClientTextBox = new SvMemoryStream( 0x200, 0x200 );
5477
5478 SvMemoryStream aExtBu( 0x200, 0x200 );
5479 ImplWriteTextStyleAtom( *pClientTextBox, nInstance2, 0, NULL, aExtBu, &aPropOpt );
5480 if ( aExtBu.Tell() )
5481 {
5482 if ( !pClientData )
5483 pClientData = new SvMemoryStream( 0x200, 0x200 );
5484 ImplProgTagContainer( pClientData, &aExtBu );
5485 }
5486 }
5487 else if ( nPlaceHolderAtom >= 19 )
5488 {
5489 if ( !pClientTextBox )
5490 pClientTextBox = new SvMemoryStream( 12 );
5491
5492 *pClientTextBox << (sal_uInt32)( EPP_TextHeaderAtom << 16 ) << (sal_uInt32)4
5493 << (sal_uInt32)7;
5494 }
5495 }
5496 }
5497
5498 aPropOpt.CreateShadowProperties( mXPropSet );
5499 maRect.Justify();
5500 if ( mnAngle )
5501 ImplFlipBoundingBox( aPropOpt );
5502 aPropOpt.CreateShapeProperties( mXShape );
5503 aPropOpt.Commit( *mpStrm );
5504 if ( GetCurrentGroupLevel() > 0 )
5505 mpPptEscherEx->AddChildAnchor( maRect );
5506 else
5507 mpPptEscherEx->AddClientAnchor( maRect );
5508
5509 if ( pClientData )
5510 {
5511 *mpStrm << (sal_uInt32)( ( ESCHER_ClientData << 16 ) | 0xf )
5512 << (sal_uInt32)pClientData->Tell();
5513
5514 mpStrm->Write( pClientData->GetData(), pClientData->Tell() );
5515 delete pClientData, pClientData = NULL;
5516 }
5517 if ( pClientTextBox )
5518 {
5519 *mpStrm << (sal_uInt32)( ( ESCHER_ClientTextbox << 16 ) | 0xf )
5520 << (sal_uInt32)pClientTextBox->Tell();
5521
5522 mpStrm->Write( pClientTextBox->GetData(), pClientTextBox->Tell() );
5523 delete pClientTextBox, pClientTextBox = NULL;
5524 }
5525 mpPptEscherEx->CloseContainer(); // ESCHER_SpContainer
5526 }
5527 nPrevTextStyle = mnTextStyle;
5528
5529 if ( bAdditionalText )
5530 {
5531 bAdditionalText = sal_False;
5532
5533 ::com::sun::star::uno::Any aAny;
5534 EscherPropertyContainer aPropOpt;
5535 mnAngle = ( PropValue::GetPropertyValue( aAny,
5536 mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "RotateAngle" ) ), sal_True ) )
5537 ? *((sal_Int32*)aAny.getValue() )
5538 : 0;
5539
5540 aPropOpt.AddOpt( ESCHER_Prop_fNoLineDrawDash, 0x90000 );
5541 aPropOpt.AddOpt( ESCHER_Prop_fNoFillHitTest, 0x100000 );
5542 if ( mType == "drawing.Line" )
5543 {
5544 double fDist = hypot( maRect.GetWidth(), maRect.GetHeight() );
5545 maRect = Rectangle( Point( aTextRefPoint.X, aTextRefPoint.Y ),
5546 Point( (sal_Int32)( aTextRefPoint.X + fDist ), aTextRefPoint.Y - 1 ) );
5547 ImplCreateTextShape( aPropOpt, aSolverContainer, sal_False );
5548 aPropOpt.AddOpt( ESCHER_Prop_FitTextToShape, 0x60006 ); // Size Shape To Fit Text
5549 if ( mnAngle < 0 )
5550 mnAngle = ( 36000 + mnAngle ) % 36000;
5551 if ( mnAngle )
5552 ImplFlipBoundingBox( aPropOpt );
5553 }
5554 else
5555 {
5556 ImplCreateTextShape( aPropOpt, aSolverContainer, sal_False );
5557 if ( mnAngle < 0 )
5558 mnAngle = ( 36000 + mnAngle ) % 36000;
5559 else
5560 mnAngle = ( 36000 - ( mnAngle % 36000 ) );
5561
5562 mnAngle *= 655;
5563 mnAngle += 0x8000;
5564 mnAngle &=~0xffff; // nAngle auf volle Gradzahl runden
5565 aPropOpt.AddOpt( ESCHER_Prop_Rotation, mnAngle );
5566
5567 // #119551# PPT does not support groups of polygons and text (MS patch KB2289187)
5568 // mpPptEscherEx->SetGroupSnapRect( nGroupLevel, maRect );
5569 // mpPptEscherEx->SetGroupLogicRect( nGroupLevel, maRect );
5570 }
5571 if ( !pClientTextBox )
5572 pClientTextBox = new SvMemoryStream( 0x200, 0x200 );
5573
5574 SvMemoryStream aExtBu( 0x200, 0x200 );
5575 ImplWriteTextStyleAtom( *pClientTextBox, EPP_TEXTTYPE_Other, 0, NULL, aExtBu, &aPropOpt );
5576
5577 aPropOpt.CreateShapeProperties( mXShape );
5578 aPropOpt.Commit( *mpStrm );
5579 if ( GetCurrentGroupLevel() > 0 )
5580 mpPptEscherEx->AddChildAnchor( maRect );
5581 else
5582 mpPptEscherEx->AddClientAnchor( maRect );
5583
5584 *mpStrm << (sal_uInt32)( ( ESCHER_ClientTextbox << 16 ) | 0xf )
5585 << (sal_uInt32)pClientTextBox->Tell();
5586
5587 mpStrm->Write( pClientTextBox->GetData(), pClientTextBox->Tell() );
5588 delete pClientTextBox, pClientTextBox = NULL;
5589
5590 mpPptEscherEx->CloseContainer(); // ESCHER_SpContainer
5591
5592 // #119551# PPT does not support groups of polygons and text (MS patch KB2289187)
5593 // mpPptEscherEx->LeaveGroup();
5594 }
5595 }
5596 ClearGroupTable(); // gruppierungen wegschreiben, sofern noch irgendwelche offen sind, was eigendlich nicht sein sollte
5597 nGroups = GetGroupsClosed();
5598 for ( sal_uInt32 i = 0; i < nGroups; i++, mpPptEscherEx->LeaveGroup() ) ;
5599 mnPagesWritten++;
5600 }
5601
5602 // -----------------------------------------------------------------------
5603
ImplMapPoint(const::com::sun::star::awt::Point & rPoint)5604 ::com::sun::star::awt::Point PPTWriter::ImplMapPoint( const ::com::sun::star::awt::Point& rPoint )
5605 {
5606 Point aRet( OutputDevice::LogicToLogic( Point( rPoint.X, rPoint.Y ), maMapModeSrc, maMapModeDest ) );
5607 return ::com::sun::star::awt::Point( aRet.X(), aRet.Y() );
5608 }
5609
5610 // -----------------------------------------------------------------------
5611
ImplMapSize(const::com::sun::star::awt::Size & rSize)5612 ::com::sun::star::awt::Size PPTWriter::ImplMapSize( const ::com::sun::star::awt::Size& rSize )
5613 {
5614 Size aRetSize( OutputDevice::LogicToLogic( Size( rSize.Width, rSize.Height ), maMapModeSrc, maMapModeDest ) );
5615
5616 if ( !aRetSize.Width() )
5617 aRetSize.Width()++;
5618 if ( !aRetSize.Height() )
5619 aRetSize.Height()++;
5620 return ::com::sun::star::awt::Size( aRetSize.Width(), aRetSize.Height() );
5621 }
5622
5623 // -----------------------------------------------------------------------
5624
ImplMapRectangle(const::com::sun::star::awt::Rectangle & rRect)5625 Rectangle PPTWriter::ImplMapRectangle( const ::com::sun::star::awt::Rectangle& rRect )
5626 {
5627 ::com::sun::star::awt::Point aPoint( rRect.X, rRect.Y );
5628 ::com::sun::star::awt::Size aSize( rRect.Width, rRect.Height );
5629 ::com::sun::star::awt::Point aP( ImplMapPoint( aPoint ) );
5630 ::com::sun::star::awt::Size aS( ImplMapSize( aSize ) );
5631 return Rectangle( Point( aP.X, aP.Y ), Size( aS.Width, aS.Height ) );
5632 }
5633
5634 // -----------------------------------------------------------------------
5635
5636 struct CellBorder
5637 {
5638 sal_Int32 mnPos; // specifies the distance to the top/left position of the table
5639 sal_Int32 mnLength;
5640 table::BorderLine maCellBorder;
5641
CellBorderCellBorder5642 CellBorder() : mnPos ( 0 ), mnLength( 0 ){};
5643 };
5644
ImplCreateCellBorder(const CellBorder * pCellBorder,sal_Int32 nX1,sal_Int32 nY1,sal_Int32 nX2,sal_Int32 nY2)5645 sal_Bool PPTWriter::ImplCreateCellBorder( const CellBorder* pCellBorder, sal_Int32 nX1, sal_Int32 nY1, sal_Int32 nX2, sal_Int32 nY2)
5646 {
5647 sal_Int32 nLineWidth = pCellBorder->maCellBorder.OuterLineWidth + pCellBorder->maCellBorder.InnerLineWidth;
5648 if ( nLineWidth )
5649 {
5650 nLineWidth *= 2;
5651 mnAngle = 0;
5652 mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
5653 EscherPropertyContainer aPropOptSp;
5654
5655 sal_uInt32 nId = mpPptEscherEx->GenerateShapeId();
5656 mpPptEscherEx->AddShape( ESCHER_ShpInst_Line, 0xa02, nId );
5657 aPropOptSp.AddOpt( ESCHER_Prop_shapePath, ESCHER_ShapeComplex );
5658 aPropOptSp.AddOpt( ESCHER_Prop_fNoLineDrawDash, 0xa0008 );
5659 aPropOptSp.AddOpt( ESCHER_Prop_fshadowObscured, 0x20000 );
5660
5661 sal_uInt32 nBorderColor = pCellBorder->maCellBorder.Color & 0xff00; // green
5662 nBorderColor |= static_cast< sal_uInt8 >( pCellBorder->maCellBorder.Color ) << 16; // red
5663 nBorderColor |= static_cast< sal_uInt8 >( pCellBorder->maCellBorder.Color >> 16 ); // blue
5664 aPropOptSp.AddOpt( ESCHER_Prop_lineColor, nBorderColor );
5665
5666 aPropOptSp.AddOpt( ESCHER_Prop_lineWidth, nLineWidth * 360 );
5667 aPropOptSp.AddOpt( ESCHER_Prop_fc3DLightFace, 0x80000 );
5668 aPropOptSp.Commit( *mpStrm );
5669 mpPptEscherEx->AddAtom( 16, ESCHER_ChildAnchor );
5670 *mpStrm << nX1
5671 << nY1
5672 << nX2
5673 << nY2;
5674 mpPptEscherEx->CloseContainer();
5675 return sal_True;
5676 }
5677 return sal_False;
5678 }
5679
5680 //get merged cell's width
GetCellRight(sal_Int32 nColumn,Rectangle & rect,std::vector<std::pair<sal_Int32,sal_Int32>> & aColumns,uno::Reference<table::XMergeableCell> & xCell)5681 sal_Int32 GetCellRight( sal_Int32 nColumn,
5682 Rectangle& rect,
5683 std::vector< std::pair< sal_Int32, sal_Int32 > >& aColumns,
5684 uno::Reference< table::XMergeableCell >& xCell )
5685 {
5686 sal_Int32 nRight = aColumns[ nColumn ].first + aColumns[ nColumn ].second;
5687 for ( sal_Int32 nColumnSpan = 1; nColumnSpan < xCell->getColumnSpan(); nColumnSpan++ )
5688 {
5689 sal_uInt32 nC = nColumnSpan + nColumn;
5690 if ( nC < aColumns.size() )
5691 nRight += aColumns[ nC ].second;
5692 else
5693 nRight = rect.Right();
5694 }
5695 return nRight;
5696 }
5697 //get merged cell's height
GetCellBottom(sal_Int32 nRow,Rectangle & rect,std::vector<std::pair<sal_Int32,sal_Int32>> & aRows,uno::Reference<table::XMergeableCell> & xCell)5698 sal_Int32 GetCellBottom( sal_Int32 nRow,
5699 Rectangle& rect,
5700 std::vector< std::pair< sal_Int32, sal_Int32 > >& aRows,
5701 uno::Reference< table::XMergeableCell >& xCell )
5702 {
5703 sal_Int32 nBottom = aRows[nRow].first + aRows[nRow].second;
5704 for ( sal_Int32 nRowSpan = 1; nRowSpan < xCell->getRowSpan(); nRowSpan++ )
5705 {
5706 sal_uInt32 nR = nRowSpan + nRow;
5707 if ( nR < aRows.size() )
5708 nBottom += aRows[ nR ].second;
5709 else
5710 nBottom = rect.Bottom();
5711 }
5712 return nBottom;
5713 }
5714
WriteCString(SvStream & rSt,const String & rString,sal_uInt32 nInstance)5715 void PPTWriter::WriteCString( SvStream& rSt, const String& rString, sal_uInt32 nInstance )
5716 {
5717 sal_uInt32 i, nLen = rString.Len();
5718 if ( nLen )
5719 {
5720 rSt << (sal_uInt32)( ( nInstance << 4 ) | ( EPP_CString << 16 ) )
5721 << (sal_uInt32)( nLen << 1 );
5722 for ( i = 0; i < nLen; i++ )
5723 rSt << rString.GetChar( (sal_uInt16)i );
5724 }
5725 }
5726
ImplCreateTable(uno::Reference<drawing::XShape> & rXShape,EscherSolverContainer & aSolverContainer,EscherPropertyContainer & aPropOpt)5727 void PPTWriter::ImplCreateTable( uno::Reference< drawing::XShape >& rXShape, EscherSolverContainer& aSolverContainer,
5728 EscherPropertyContainer& aPropOpt )
5729 {
5730 try
5731 {
5732 static const rtl::OUString sModel( RTL_CONSTASCII_USTRINGPARAM ( "Model" ) );
5733 static const rtl::OUString sWidth( RTL_CONSTASCII_USTRINGPARAM ( "Width" ) );
5734 static const rtl::OUString sHeight( RTL_CONSTASCII_USTRINGPARAM ( "Height" ) );
5735
5736 uno::Reference< table::XTable > xTable;
5737 if ( mXPropSet->getPropertyValue( sModel ) >>= xTable )
5738 {
5739 uno::Reference< table::XColumnRowRange > xColumnRowRange( xTable, uno::UNO_QUERY_THROW );
5740 uno::Reference< container::XIndexAccess > xColumns( xColumnRowRange->getColumns(), uno::UNO_QUERY_THROW );
5741 uno::Reference< container::XIndexAccess > xRows( xColumnRowRange->getRows(), uno::UNO_QUERY_THROW );
5742 sal_uInt16 nRowCount = static_cast< sal_uInt16 >( xRows->getCount() );
5743 sal_uInt16 nColumnCount = static_cast< sal_uInt16 >( xColumns->getCount() );
5744
5745 std::vector< std::pair< sal_Int32, sal_Int32 > > aColumns;
5746 std::vector< std::pair< sal_Int32, sal_Int32 > > aRows;
5747
5748 awt::Point aPosition( ImplMapPoint( rXShape->getPosition() ) );
5749 sal_Int32 nPosition = aPosition.X;
5750 for ( sal_Int32 x = 0; x < nColumnCount; x++ )
5751 {
5752 uno::Reference< beans::XPropertySet > xPropSet( xColumns->getByIndex( x ), uno::UNO_QUERY_THROW );
5753 awt::Size aS( 0, 0 );
5754 xPropSet->getPropertyValue( sWidth ) >>= aS.Width;
5755 awt::Size aM( ImplMapSize( aS ) );
5756 aColumns.push_back( std::pair< sal_Int32, sal_Int32 >( nPosition, aM.Width ) );
5757 nPosition += aM.Width;
5758 if ( x == nColumnCount - 1 && nPosition != maRect.Right() )
5759 maRect.Right() = nPosition;
5760 }
5761
5762 nPosition = aPosition.Y;
5763 for ( sal_Int32 y = 0; y < nRowCount; y++ )
5764 {
5765 uno::Reference< beans::XPropertySet > xPropSet( xRows->getByIndex( y ), uno::UNO_QUERY_THROW );
5766 awt::Size aS( 0, 0 );
5767 xPropSet->getPropertyValue( sHeight ) >>= aS.Height;
5768 awt::Size aM( ImplMapSize( aS ) );
5769 aRows.push_back( std::pair< sal_Int32, sal_Int32 >( nPosition, aM.Height ) );
5770 nPosition += aM.Height;
5771 if ( y == nRowCount - 1 && nPosition != maRect.Bottom())
5772 maRect.Bottom() = nPosition;
5773 }
5774 mpPptEscherEx->OpenContainer( ESCHER_SpgrContainer );
5775 mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
5776 mpPptEscherEx->AddAtom( 16, ESCHER_Spgr, 1 );
5777 *mpStrm << (sal_Int32)maRect.Left() // Bounding box fuer die Gruppierten shapes an die sie attached werden
5778 << (sal_Int32)maRect.Top()
5779 << (sal_Int32)maRect.Right()
5780 << (sal_Int32)maRect.Bottom();
5781
5782 sal_uInt32 nShapeId = mpPptEscherEx->GenerateShapeId();
5783 mpPptEscherEx->AddShape( ESCHER_ShpInst_Min, 0x201, nShapeId ); // Flags: Group | Patriarch
5784 aSolverContainer.AddShape( rXShape, nShapeId );
5785 EscherPropertyContainer aPropOpt2;
5786
5787 if ( nRowCount )
5788 {
5789 SvMemoryStream aMemStrm;
5790 aMemStrm.ObjectOwnsMemory( sal_False );
5791 aMemStrm << nRowCount
5792 << nRowCount
5793 << (sal_uInt16)4;
5794
5795 std::vector< std::pair< sal_Int32, sal_Int32 > >::const_iterator aIter( aRows.begin() );
5796 while( aIter != aRows.end() )
5797 aMemStrm << (*aIter++).second;
5798
5799 aPropOpt.AddOpt( ESCHER_Prop_LockAgainstGrouping, 0x1000100 );
5800 aPropOpt2.AddOpt( ESCHER_Prop_tableProperties, 1 );
5801 aPropOpt2.AddOpt( ESCHER_Prop_tableRowProperties, sal_True, aMemStrm.Tell(), static_cast< sal_uInt8* >( const_cast< void* >( aMemStrm.GetData() ) ), aMemStrm.Tell() );
5802 aPropOpt.CreateShapeProperties( rXShape );
5803 aPropOpt.Commit( *mpStrm );
5804 aPropOpt2.Commit( *mpStrm, 3, ESCHER_UDefProp );
5805 if ( GetCurrentGroupLevel() > 0 )
5806 mpPptEscherEx->AddChildAnchor( maRect );
5807 else
5808 mpPptEscherEx->AddClientAnchor( maRect );
5809 mpPptEscherEx->CloseContainer();
5810
5811
5812 uno::Reference< table::XCellRange > xCellRange( xTable, uno::UNO_QUERY_THROW );
5813 for( sal_Int32 nRow = 0; nRow < xRows->getCount(); nRow++ )
5814 {
5815 for( sal_Int32 nColumn = 0; nColumn < xColumns->getCount(); nColumn++ )
5816 {
5817 uno::Reference< table::XMergeableCell > xCell( xCellRange->getCellByPosition( nColumn, nRow ), uno::UNO_QUERY_THROW );
5818 if ( !xCell->isMerged() )
5819 {
5820 sal_Int32 nLeft = aColumns[ nColumn ].first;
5821 sal_Int32 nTop = aRows[ nRow ].first;
5822 sal_Int32 nRight = GetCellRight( nColumn, maRect,aColumns,xCell );
5823 sal_Int32 nBottom = GetCellBottom( nRow, maRect,aRows,xCell );
5824
5825 mbFontIndependentLineSpacing = sal_False;
5826 mXPropSet = uno::Reference< beans::XPropertySet >( xCell, uno::UNO_QUERY_THROW );
5827 mXText = uno::Reference< text::XSimpleText >( xCell, uno::UNO_QUERY_THROW );
5828 mnTextSize = mXText->getString().getLength();
5829
5830 ::com::sun::star::uno::Any aAny;
5831 if ( GetPropertyValue( aAny, mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "FontIndependentLineSpacing" ) ) ), sal_True )
5832 aAny >>= mbFontIndependentLineSpacing;
5833
5834 EscherPropertyContainer aPropOptSp;
5835 mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
5836 ImplCreateShape( ESCHER_ShpInst_Rectangle, 0xa02, aSolverContainer ); // Flags: Connector | HasSpt | Child
5837 aPropOptSp.CreateFillProperties( mXPropSet, sal_True );
5838 aPropOptSp.AddOpt( ESCHER_Prop_fNoLineDrawDash, 0x90000 );
5839 aPropOptSp.CreateTextProperties( mXPropSet, mnTxId += 0x60, sal_False, sal_True );
5840 aPropOptSp.AddOpt( ESCHER_Prop_WrapText, ESCHER_WrapSquare );
5841
5842 SvMemoryStream aClientTextBox( 0x200, 0x200 );
5843 SvMemoryStream aExtBu( 0x200, 0x200 );
5844
5845 ImplWriteTextStyleAtom( aClientTextBox, EPP_TEXTTYPE_Other, 0, NULL, aExtBu, &aPropOptSp );
5846
5847 // need write client data for extend bullet
5848 if ( aExtBu.Tell() )
5849 {
5850 SvMemoryStream* pClientData = new SvMemoryStream( 0x200, 0x200 );
5851 ImplProgTagContainer( pClientData, &aExtBu );
5852 *mpStrm << (sal_uInt32)( ( ESCHER_ClientData << 16 ) | 0xf )
5853 << (sal_uInt32)pClientData->Tell();
5854
5855 mpStrm->Write( pClientData->GetData(), pClientData->Tell() );
5856 delete pClientData, pClientData = NULL;
5857 }
5858
5859 aPropOptSp.Commit( *mpStrm );
5860 mpPptEscherEx->AddAtom( 16, ESCHER_ChildAnchor );
5861 *mpStrm << nLeft
5862 << nTop
5863 << nRight
5864 << nBottom;
5865
5866 *mpStrm << (sal_uInt32)( ( ESCHER_ClientTextbox << 16 ) | 0xf )
5867 << (sal_uInt32)aClientTextBox.Tell();
5868
5869 mpStrm->Write( aClientTextBox.GetData(), aClientTextBox.Tell() );
5870 mpPptEscherEx->CloseContainer();
5871 }
5872 }
5873 }
5874
5875 static const rtl::OUString sTopBorder( String( RTL_CONSTASCII_USTRINGPARAM( "TopBorder" ) ) );
5876 static const rtl::OUString sBottomBorder( String( RTL_CONSTASCII_USTRINGPARAM( "BottomBorder" ) ) );
5877 static const rtl::OUString sLeftBorder( String( RTL_CONSTASCII_USTRINGPARAM( "LeftBorder" ) ) );
5878 static const rtl::OUString sRightBorder( String( RTL_CONSTASCII_USTRINGPARAM( "RightBorder" ) ) );
5879 static const rtl::OUString sDiagonalTLBR( RTL_CONSTASCII_USTRINGPARAM ( "DiagonalTLBR" ) );
5880 static const rtl::OUString sDiagonalBLTR( RTL_CONSTASCII_USTRINGPARAM ( "DiagonalBLTR" ) );
5881
5882 // creating horz lines
5883 for( sal_Int32 nLine = 0; nLine < ( xRows->getCount() + 1 ); nLine++ )
5884 {
5885 for( sal_Int32 nColumn = 0; nColumn < xColumns->getCount(); nColumn++ )
5886 {
5887 CellBorder aCellBorder;
5888 aCellBorder.mnPos = aColumns[ nColumn ].first;
5889 aCellBorder.mnLength = aColumns[ nColumn ].second;
5890 sal_Bool bTop = sal_False;
5891 //write nLine*nColumn cell's top border
5892 if ( nLine < xRows->getCount() )
5893 { // top border
5894 uno::Reference< table::XMergeableCell > xCell( xCellRange->getCellByPosition( nColumn, nLine ), uno::UNO_QUERY_THROW );
5895 if ( !xCell->isMerged() )
5896 {
5897 uno::Reference< beans::XPropertySet > xPropSet2( xCell, uno::UNO_QUERY_THROW );
5898 table::BorderLine aBorderLine;
5899 if ( xPropSet2->getPropertyValue( sTopBorder ) >>= aBorderLine )
5900 aCellBorder.maCellBorder = aBorderLine;
5901 sal_Int32 nRight = GetCellRight( nColumn, maRect,aColumns,xCell );
5902 bTop = ImplCreateCellBorder( &aCellBorder, aCellBorder.mnPos,
5903 aRows[ nLine ].first, nRight, aRows[ nLine ].first );
5904 }
5905 }
5906
5907 //if nLine*nColumn cell's top border is empty, check (nLine-1)*nColumn cell's bottom border
5908 //and write the last row's bottom border
5909 if (( nLine && !bTop ) || (nLine == xRows->getCount()))
5910 { // bottom border
5911 sal_Int32 nRow = nLine;
5912
5913 while( nRow )
5914 { //find last no merged cell
5915 uno::Reference< table::XMergeableCell > xCell( xCellRange->getCellByPosition( nColumn, nRow - 1 ), uno::UNO_QUERY_THROW );
5916 if ( !xCell->isMerged() )
5917 {
5918 sal_Int32 nRight = GetCellRight( nColumn, maRect,aColumns,xCell );
5919 sal_Int32 nBottom = GetCellBottom( nRow - 1, maRect,aRows,xCell );
5920 if ( nBottom == ( aRows[ nLine-1 ].first + aRows[ nLine-1 ].second ) )
5921 {
5922 uno::Reference< table::XMergeableCell > xCellOwn( xCellRange->getCellByPosition( nColumn, nRow - 1 ), uno::UNO_QUERY_THROW );
5923 uno::Reference< beans::XPropertySet > xPropSet2( xCellOwn, uno::UNO_QUERY_THROW );
5924 table::BorderLine aBorderLine;
5925 if ( xPropSet2->getPropertyValue( sBottomBorder ) >>= aBorderLine )
5926 aCellBorder.maCellBorder = aBorderLine;
5927 ImplCreateCellBorder( &aCellBorder, aCellBorder.mnPos,
5928 nBottom, nRight, nBottom);
5929 }
5930 nRow=0;
5931 }
5932 else
5933 nRow--;
5934 }
5935 }
5936 }
5937 }
5938
5939 // creating vertical lines
5940 for( sal_Int32 nLine = 0; nLine < ( xColumns->getCount() + 1 ); nLine++ )
5941 {
5942 for( sal_Int32 nRow = 0; nRow < xRows->getCount(); nRow++ )
5943 {
5944
5945 CellBorder aCellBorder;
5946 aCellBorder.mnPos = aRows[ nRow].first;
5947 aCellBorder.mnLength = aRows[ nRow].second;
5948 sal_Bool bLeft = sal_False;
5949 if ( nLine < xColumns->getCount() )
5950 { // left border
5951 uno::Reference< table::XMergeableCell > xCell( xCellRange->getCellByPosition( nLine, nRow ), uno::UNO_QUERY_THROW );
5952 if (!xCell->isMerged() )
5953 {
5954 uno::Reference< beans::XPropertySet > xCellSet( xCell, uno::UNO_QUERY_THROW );
5955 table::BorderLine aBorderLine;
5956 if ( xCellSet->getPropertyValue( sLeftBorder ) >>= aBorderLine )
5957 aCellBorder.maCellBorder = aBorderLine;
5958 sal_Int32 nBottom = GetCellBottom( nRow, maRect, aRows,xCell );
5959 bLeft = ImplCreateCellBorder( &aCellBorder, aColumns[nLine].first, aCellBorder.mnPos,
5960 aColumns[nLine].first, nBottom );
5961 }
5962 }
5963 if ( ( nLine && !bLeft )||(nLine == xColumns->getCount()))
5964 { // right border
5965 sal_Int32 nColumn = nLine;
5966 while ( nColumn )
5967 {
5968 uno::Reference< table::XMergeableCell > xCell( xCellRange->getCellByPosition( nColumn - 1, nRow ), uno::UNO_QUERY_THROW );
5969 if (!xCell->isMerged() )
5970 {
5971 sal_Int32 nRight = GetCellRight( nColumn-1, maRect, aColumns,xCell );
5972 sal_Int32 nBottom = GetCellBottom( nRow, maRect, aRows, xCell );
5973 if ( nRight == (aColumns[nLine-1].first + aColumns[nLine-1].second) )
5974 {
5975 uno::Reference< table::XMergeableCell > xCellOwn( xCellRange->getCellByPosition( nColumn - 1, nRow ), uno::UNO_QUERY_THROW );
5976 uno::Reference< beans::XPropertySet > xCellSet( xCellOwn, uno::UNO_QUERY_THROW );
5977 table::BorderLine aBorderLine;
5978 if ( xCellSet->getPropertyValue( sRightBorder ) >>= aBorderLine )
5979 aCellBorder.maCellBorder = aBorderLine;
5980 ImplCreateCellBorder( &aCellBorder, nRight, aCellBorder.mnPos,
5981 nRight, nBottom );
5982 }
5983 nColumn = 0;
5984 }
5985 else
5986 nColumn --;
5987 }
5988 }
5989 }
5990 }
5991 }
5992 }
5993 }
5994 catch( uno::Exception& )
5995 {
5996 }
5997 mpPptEscherEx->CloseContainer();
5998 }
5999